We Keep Coding

How to loop through timer class for delayed time?

I want run timer for about 30000 ms and up to 8 or more times each so here is my loop but it runs all timers at once after 30000ms
public void repeatTimerTask() {
repeat = 8; // need to run 30 sec timer for 8 times but one after one
startTimer(30000); // firsat timer for 30 sec
Handler handler = new Handler();
for (int a = 1; a<=repeat; a++) {
final int finalA = a;
handler.postDelayed(new Runnable() {
#Override
public void run() {
startTimer(30000);
}
}, 30000); // delay until to finish first timer for 30 sec
}
}

To run a timer for n seconds you can use CountDownTimer
Declare two varibales globbaly. One for number of times you want to repeat. and one to keep the count of repetaion.
private int NUM_REPEAT = 4;
private int REPEAT_COUNT = 0;
Then call this method wherever you want. One thing to note if you want to run this loop 5 times you have to give number of repeation 4. Cause to satrt this function you have to call it so that will not come in count.
private void startTimer() {
new CountDownTimer(3000, 1000) {
int secondsLeft = 0;
public void onTick(long ms) {
if (Math.round((float) ms / 1000.0f) != secondsLeft) {
secondsLeft = Math.round((float) ms / 1000.0f);
// resend_timer is a textview
resend_timer.setText("remaining time is "+secondsLeft);
;
}
}
public void onFinish() {
Log.d(TAG, "timer finished "+REPEAT_COUNT);
if (REPEAT_COUNT <= NUM_REPEAT) {
startTimer();
REPEAT_COUNT++;
}
}
}.start();
}

Please try the below code, and call 'startTimer' method where you first want to start your timer :
private int startTimerCount = 1, repeat = 8;
private void startTimer(){
// if startTimerCount is less than 8 than the handle will be created
if(startTimerCount <= repeat){
// this will create a handler which invokes startTimer method after 30 seconds
new Handler().postDelayed(new Runnable() {
#Override
public void run() {
startTimer();
}
}, 30000);
// do what you want
Toast.makeText(this, "startTimer " + startTimerCount, Toast.LENGTH_SHORT).show();
}
startTimerCount++;
}

Update CountDownTimer with new Time - Android [duplicate]

The CountDownTimer default Constructor takes the values millisInFuture and countDownInterval.
If the user stops the timer, changes his settings to a different millisInFuture length, how would I go about changing the millisInFuture value without creating a new CountDownTimer object?
I've tried making a getMillisInFuture method in the override CountDownTimer class to no avail.
Would I have to override the onStart method, or what?

This class will not let you do much by itself.
You can create a class that contains a CountDownTimer timer field and a method update(time, tick) that hides the implementation. You would still need to call timer.cancel() and create a new CountDownTimer with the new values. Either that, or create your countdown timer from scratch using a Handler and postDelayed(...)
Take a look at an example of the second approach in my answer here

I needed it too, here's the code
public class DynamicCountdownTimer {
private CountDownTimer timer = null;
private double negativeBias = 0.00;
private double addingBias = 0.00;
private int minutes = 0;
private int ticks = 0;
private boolean supressFinish = false;
public DynamicCountdownTimer(int minutes, int ticks){
setTimer(minutes, ticks);
}
public void updateMinutes(int minutes){
if (timer != null){
this.supressFinish = true;
this.timer.cancel();
this.timer = null;
this.minutes = minutes;
this.addingBias = this.negativeBias + this.addingBias;
setTimer(this.minutes, this.ticks);
Start();
}
}
public void setTimer(int minutes, int ticks){
this.minutes = minutes;
this.ticks = ticks;
timer = new CountDownTimer((minutes * 60 * 1000), ticks) {
#Override
public void onTick(long l) {
negativeBias = (minutes * 60 * 1000) - l;
long calculatedTime = l - (long)addingBias;
if (calculatedTime <= 0){
onFinish();
}else{
callback.onTick(calculatedTime);
}
}
#Override
public void onFinish() {
if (!supressFinish){
callback.onFinish();
}
supressFinish = false;
}
};
}
public void Start(){
if (timer != null){
timer.start();
}
}
public void Cancel(){
if (timer != null){
timer.cancel();
}
}
public DynamicCountdownCallback callback = null;
public void setDynamicCountdownCallback(DynamicCountdownCallback c){
callback = c;
}
public interface DynamicCountdownCallback {
void onTick(long l);
void onFinish();
}
}
Here is how to use it:
DynamicCountdownTimer pCountDownTimer = null;
public void initializeTimer(int minutes){
pCountDownTimer = new DynamicCountdownTimer(minutes, 1000);
pCountDownTimer.setDynamicCountdownCallback(new DynamicCountdownTimer.DynamicCountdownCallback() {
#Override
public void onTick(long l) {
double progress = (double)( l) / (double)(minutes * 60 * 1000);
}
#Override
public void onFinish() {
// do something
}
});
pCountDownTimer.Start();
}
Then you can update it like this:
public void updateTimer(int minutes){
pCountDownTimer.updateMinutes(minutes);
}
After updating, the timer will simply carry on. It also carries over the already passed time.
This means, if the time was originally set to 30min and you update it to 45min after 10min, the remaining countdown time will be 35min.
It does it by recreating a new Timer when the update function is called. And at onTick, the already passed time (before the update) is calculated into the new progress.
You can change it to ms instead of min if you need it simply by replacing
(double)(minutes * 60 * 1000) -> ms
then
int minutes -> long ms

Handler.postDelayed causes lag

I created an application that can call using our SIP server. Now I want to do is to show the user how long his call has been on going. My script is actually working but I noticed that the longer the call, the laggy my app becomes. Here's the snippet of my code
Handler h = new Handler(Looper.getMainLooper());
_isOnCall = true;
long time = 0;
int x = 0;
while(_isOnCall) {
if (_isOnCall){
final int counter = 1 + x;
time += 1000;
h.postDelayed(new Runnable() {
#Override
public void run() {
(TargetDetailsActivity.this).runOnUiThread(new Runnable() {
#Override
public void run() {
final int seconds = counter % 60;
final int minutes = (counter % 3600) / 60;
final int hours = counter / 3600;
callcounter.post(new Runnable() {
#Override
public void run() {
callcounter.setText(String.format("%02d:%02d:%02d", hours, minutes, seconds));
}
});
}
});
}
}, time);
x++;
}else{
break;
}
}
Basically what the code does is just to count the seconds/minutes/hour he's been on the phone. When he hangs up, I call the code below:
_isOnCall = false;
h.removeCallbacksAndMessages(null);
I'm not sure what causes the lag. Help! Thanks.
UPDATE
I was able to make this working by utilizing galvan's suggestion using Timer. Here's my code for future reference:
private Timer myTimer;
private int counter_time=0;
public void onCallEstablished() {
myTimer = new Timer();
myTimer.schedule(new TimerTask() {
#Override
public void run() {
TimerMethod();
}
}, 0, 1000);
}
private void TimerMethod()
{
this.runOnUiThread(Timer_Tick);
}
private Runnable Timer_Tick = new Runnable() {
public void run() {
counter_time++;
int seconds = counter_time % 60;
int minutes = (counter_time % 3600) / 60;
int hours = counter_time / 3600;
callcounter.setText(String.format("%02d:%02d:%02d", hours, minutes, seconds));
}
};
public void releaseCall(){
if(myTimer != null){
myTimer.cancel();
myTimer.purge();
counter_time = 0;
}
}

It looks like every Runnable saves a reference to his parent object, a nested Runnable in this case. Try to take an heap snapshot for detecting a memory issues to see if this is the case here.
You can also make a repeat task with time interval, and stop the loop when the call ends.
Timer timer = new Timer();
TimerTask myTask = new TimerTask() {
#Override
public void run() {
// whatever you need to do every 2 seconds
}
};
timer.scheduleAtFixedRate(myTask,
firstTime,
period);
for more info about timer you can take a look at the docs

How to implement a Timer class in Java?

Recently, I have been developing some android apps and I found that android.os.Handler class is very suitable for implementing a .NET Timer (By that I mean System.Windows.Forms.Timer and System.Timers.Timer).
If you don't know what a .NET timer is, it's a timer that can be stopped, started at any time and its interval can be changed any time.
So I did the following:
import android.os.Handler;
public class Timer {
private Handler handler;
private boolean paused;
private int interval;
private Runnable task = new Runnable () {
#Override
public void run() {
if (!paused) {
runnable.run ();
Timer.this.handler.postDelayed (this, interval);
}
}
};
private Runnable runnable;
public int getInterval() {
return interval;
}
public void setInterval(int interval) {
this.interval = interval;
}
public void startTimer () {
paused = false;
handler.postDelayed (task, interval);
}
public void stopTimer () {
paused = true;
}
public Timer (Runnable runnable, int interval, boolean started) {
handler = new Handler ();
this.runnable = runnable;
this.interval = interval;
if (started)
startTimer ();
}
}
And it came out ok. Also, this one runs on the UI thread which means that I can use this to change graphical stuff. (I mainly use timers for those stuff)
However, this only works for android though. If I want to make a "traditional" java program, I have to use the stuff in the JDK. So I tried the following:
import java.util.Timer;
import java.util.TimerTask;
public class DotNetTimer {
private Timer timer;
private boolean paused;
private int interval;
private TimerTask task = new TimerTask () {
#Override
public void run() {
if (!paused)
runnable.run();
}
};
public Runnable runnable;
public int getInterval() {
return interval;
}
public void setInterval(int interval) {
this.interval = interval;
if (!paused) {
timer.cancel();
timer.scheduleAtFixedRate(task, interval, interval);
}
}
public void startTimer () {
timer.cancel();
timer.scheduleAtFixedRate(task, 0, interval);
}
public void stopTimer () {
paused = true;
}
public DotNetTimer (Runnable runnable, int interval, boolean started) {
timer = new Timer ();
this.runnable = runnable;
this.interval = interval;
if (started) {
paused = false;
startTimer ();
}
}
}
And I use this code to test it:
import static java.lang.System.out;
public class MyTestingClass {
static DotNetTimer timer;
public static void main(String[] args) {
Runnable r = new Runnable () {
int count = 0;
#Override
public void run() {
if (count < 5) {
count++;
out.println("Hello" + count);
} else {
timer.stopTimer();
}
}
};
timer = new DotNetTimer (r, 2000, true);
}
}
However, an IllegalStateException was thrown in the start timer method. I did some research on that and I found that java.util.Timer cannot be restarted after cancel(). And I know what you're saying, "why do you call cancel() in the startTimer() method?" If I don't call cancel(), the timer would have 2 tasks running when I call startTimer() when the timer is already started.
Any help will be appreciated.

From cancel() method in Timer class
Terminates this timer, discarding any currently scheduled tasks. Does
not interfere with a currently executing task (if it exists). Once a
timer has been terminated, its execution thread terminates gracefully,
and no more tasks may be scheduled on it.
Note that calling this method from within the run method of a timer
task that was invoked by this timer absolutely guarantees that the
ongoing task execution is the last task execution that will ever be
performed by this timer.
This method may be called repeatedly; the second and subsequent calls
have no effect.
so, internal thread of Timer is one-shot, you need to instantiate a new Timer object
You can check original source code of Timer class to understand (or replicate as you wish) how it really works
http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Timer.java

I found out that there is a class in Android called Handler which can execute code with a delay. So I made use of this class to create a timer!
import android.os.Handler;
import android.support.annotation.NonNull;
import android.widget.TextView;
public class Timer implements Comparable<Timer> {
private Handler handler;
private boolean paused;
private TextView text;
private int minutes;
private int seconds;
private final Runnable timerTask = new Runnable () {
#Override
public void run() {
if (!paused) {
seconds++;
if (seconds >= 60) {
seconds = 0;
minutes++;
}
text.setText (Timer.this.toString ());
Timer.this.handler.postDelayed (this, 1000);
}
}
};
#Override
public String toString () {
if (Integer.toString (seconds).length () == 1) {
return minutes + ":0" + seconds;
} else {
return minutes + ":" + seconds;
}
}
public void startTimer () {
paused = false;
handler.postDelayed (timerTask, 1000);
}
public void stopTimer () {
paused = true;
}
public void resetTimer () {
stopTimer ();
minutes = 0;
seconds = 0;
text.setText (toString ());
}
public Timer (TextView text) {
this.text = text;
handler = new Handler ();
}
public Timer (TextView text, String parseString) {
this (text);
String[] splitString = parseString.split (":");
minutes = Integer.parseInt (splitString[0]);
seconds = Integer.parseInt (splitString[1]);
}
#Override
public int compareTo(#NonNull Timer another) {
int numberOfSeconds = seconds + minutes * 60;
int anotherNumberOfSeconds = another.seconds + another.minutes * 60;
return ((Integer)numberOfSeconds).compareTo (anotherNumberOfSeconds);
}
}
And it has a really simple interface. Very easy to use.

Java StopWatch Suspend and Resume timer not working

The purpose of below code is to test the StopWatch for reset, start, suspend and resume. It should be possible to suspend a stopwatch at a given point in time and resume it later. In this case the elapse time is the cumulative total of all suspend and resume events when the timer is eventually stopped. The code works fine if i remove timer.suspend() and timer.resume(). When i run the code, thread goes to sleep for 2.3 seconds and give elapsed time 2300 in output. However, with suspend and resume method, it sleeps for 2.3 seconds but give output of 0.
Can you please suggest/advice what is wrong in the code?
Thank you.
interface StopWatch {
public void reset();
public void start();
public void stop();
public void suspend();
public void resume();
public long getElapsedTime();
public int getState();
public static final int RESET = 0, RUNNING =1, STOPPED =2, SUSPENDED = 3, RESUME = 0;}
Timer Class
class Timer implements StopWatch{
private long startTime;
private long elaspedTime;
private int state;
public Timer(){reset();}
public void reset(){
state = RESET;
elaspedTime = 0;
}
public void start(){
if(state==RESET){
startTime = System.currentTimeMillis();
state = RUNNING;
}
}
public void stop(){
if(state == RUNNING){
elaspedTime = System.currentTimeMillis() - startTime;
state = STOPPED;
}
}
public void suspend() {
if(state == RUNNING){
elaspedTime = System.currentTimeMillis() - startTime;
state = SUSPENDED;
}
}
public void resume(){
if(state == RUNNING){
elaspedTime = System.currentTimeMillis() - startTime;
state = RESUME;
}
}
public long getElapsedTime() {
if(state == RUNNING){
long elasped = System.currentTimeMillis() - startTime;
return elasped;
}
else if (state == STOPPED)
return elaspedTime;
else if (state == RESUME)
return elaspedTime;
return 0;
}
public int getState(){
return state;
}}
StopWatch Test
public class StopWatchTest {
public static void main (String[] args){
Timer timer = new Timer();
timer.start();
try{
Thread.sleep(2300);
timer.suspend();
timer.resume();
}catch (InterruptedException e){}
timer.stop();
long duration = timer.getElapsedTime();
System.out.println(duration);
}}

if(state == RUNNING){
elaspedTime = System.currentTimeMillis() - startTime;
state = RESUME;
}
In the resume method you are checking if the stopwatch is running, how can you resume an already running stopwatch?
Change RUNNING to SUSPENDED in your resume method.