Android: CountDownTimer überspringt den letzten onTick ()!

Ich weiß nicht, warum der Letzte tick nicht funktioniert, aber Sie können erstellen Sie Ihre eigenen timer mit Lauffähige , zum Beispiel.

class MyCountDownTimer {
    private long millisInFuture;
    private long countDownInterval;
    public MyCountDownTimer(long pMillisInFuture, long pCountDownInterval) {
            this.millisInFuture = pMillisInFuture;
            this.countDownInterval = pCountDownInterval;
        }
    public void Start() 
    {
        final Handler handler = new Handler();
        Log.v("status", "starting");
        final Runnable counter = new Runnable(){

            public void run(){
                if(millisInFuture <= 0) {
                    Log.v("status", "done");
                } else {
                    long sec = millisInFuture/1000;
                    Log.v("status", Long.toString(sec) + " seconds remain");
                    millisInFuture -= countDownInterval;
                    handler.postDelayed(this, countDownInterval);
                }
            }
        };

        handler.postDelayed(counter, countDownInterval);
    }
}

und starten Sie es,

new MyCountDownTimer(10000, 2000).Start();

BEARBEITEN FÜR DOOF FRAGE

sollten Sie eine variable für Zähler-status (boolean) . dann schreiben Sie eine Stop () - Methode wie Start().

BEARBEITEN-2 FÜR DOOF FRAGE

eigentlich ist es kein Fehler auf den beenden Schalter aber es ist ein Fehler auf der Startseite wieder nach dem stoppen(fortsetzen).

Schreibe ich eine neue, aktualisierte vollständige code, ich hatte gerade versucht und es funktioniert. Es ist eine einfache Zähler, der die Zeit anzeigen auf dem Bildschirm mit start-und stop-button.

Klasse für counter

public class MyCountDownTimer {
    private long millisInFuture;
    private long countDownInterval;
    private boolean status;
    public MyCountDownTimer(long pMillisInFuture, long pCountDownInterval) {
            this.millisInFuture = pMillisInFuture;
            this.countDownInterval = pCountDownInterval;
            status = false;
            Initialize();
    }

    public void Stop() {
        status = false;
    }

    public long getCurrentTime() {
        return millisInFuture;
    }

    public void Start() {
        status = true;
    }
    public void Initialize() 
    {
        final Handler handler = new Handler();
        Log.v("status", "starting");
        final Runnable counter = new Runnable(){

            public void run(){
                long sec = millisInFuture/1000;
                if(status) {
                    if(millisInFuture <= 0) {
                        Log.v("status", "done");
                    } else {
                        Log.v("status", Long.toString(sec) + " seconds remain");
                        millisInFuture -= countDownInterval;
                        handler.postDelayed(this, countDownInterval);
                    }
                } else {
                    Log.v("status", Long.toString(sec) + " seconds remain and timer has stopped!");
                    handler.postDelayed(this, countDownInterval);
                }
            }
        };

        handler.postDelayed(counter, countDownInterval);
    }
}

Aktivität Klasse

public class CounterActivity extends Activity {
    /** Called when the activity is first created. */
    TextView timeText;
    Button startBut;
    Button stopBut;
    MyCountDownTimer mycounter;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        timeText = (TextView) findViewById(R.id.time);
        startBut = (Button) findViewById(R.id.start);
        stopBut = (Button) findViewById(R.id.stop);
        mycounter = new MyCountDownTimer(20000, 1000);
        RefreshTimer();
    }

    public void StartTimer(View v) {
        Log.v("startbutton", "saymaya basladi");
        mycounter.Start();
    }

    public void StopTimer(View v) {
        Log.v("stopbutton", "durdu");
        mycounter.Stop();
    }

    public void RefreshTimer() 
    {
        final Handler handler = new Handler();
        final Runnable counter = new Runnable(){

            public void run(){
                timeText.setText(Long.toString(mycounter.getCurrentTime()));
                handler.postDelayed(this, 100);
            }
        };

        handler.postDelayed(counter, 100);
    }
}

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:weightSum="1">
    <TextView android:textAppearance="?android:attr/textAppearanceLarge" 
              android:text="TextView" android:layout_height="wrap_content" 
              android:layout_width="wrap_content" 
              android:id="@+id/time">
    </TextView>
    <Button android:text="Start" 
            android:id="@+id/start" 
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:onClick="StartTimer">
    </Button>
    <Button android:text="Stop" 
            android:id="@+id/stop" 
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:onClick="StopTimer">
    </Button>
</LinearLayout>

InformationsquelleAutor der Antwort ocanal

Die einfachste Lösung, die ich verwende, ist wie folgt. Beachten Sie, dass es nur funktioniert, wenn du eine einfache Anzeige mit einem Sekunden-countdown.

mTimer = new CountDownTimer(5000, 100){
            public void onTick(long millisUntilFinished) {
                mTimerView.setText(Long.toString(millisUntilFinished/1000));                
             }

             public void onFinish() {
                 mTimerView.setText("Expired");
             }
        };

        mTimer.start();

In den obigen code die onTick() aufgerufen wird alle 100 Millisekunden, aber optisch nur Sekunden angezeigt.

InformationsquelleAutor der Antwort Zzokk

Während die Lösung vor gültig ist, es kann noch weiter verbessert werden. Es unnötig ist, einen Thread in einer anderen Klasse (die können schon behandelt werden auf eigenen). Also einfach eine Klasse erstellen, reicht ein thread (oder lauffähig ist).

    class MyTimer extends Thread {
      private long millisInFuture;
      private long countDownInterval;
      final Handler mHandler = new Handler();

      public MyTimer(long pMillisInFuture, long pCountDownInterval) {
        this.millisInFuture = pMillisInFuture;
        this.countDownInterval = pCountDownInterval;
      }

      public void run() {
        if(millisInFuture <= 0) {
          Log.v("status", "done");
        } else {
          millisInFuture -= countDownInterval;
          mHandler.postDelayed(this, countDownInterval);
        }
      }
    }

InformationsquelleAutor der Antwort Mike Welsh

So, ich denke, ich ging ein wenig über Bord, weil mein timer läuft in einem eigenen thread statt mit postDelay-Handler, obwohl es immer posts zurück auf den thread, in der es erstellt wurde. Ich wusste auch, dass ich nur kümmerte sich um Sekunden, so dass die vereinfachten rund um diese Idee. Sie können auch Abbrechen und neu starten. Ich habe nicht anhalten gebaut, weil das nicht meine Bedürfnisse.

/**
* Created by MinceMan on 8/2/2014.
*/
public abstract class SecondCountDownTimer {

private final int seconds;
private TimerThread timer;
private final Handler handler;

/**
 * @param secondsToCountDown Total time in seconds you wish this timer to count down.
 */
public SecondCountDownTimer(int secondsToCountDown) {
    seconds = secondsToCountDown;
    handler = new Handler();
    timer = new TimerThread(secondsToCountDown);
}

/** This will cancel your current timer and start a new one.
 *  This call will override your timer duration only one time. **/
public SecondCountDownTimer start(int secondsToCountDown) {
    if (timer.getState() != State.NEW) {
        timer.interrupt();
        timer = new TimerThread(secondsToCountDown);
    }
    timer.start();
    return this;
}

/** This will cancel your current timer and start a new one. **/
public SecondCountDownTimer start() {
    return start(seconds);
}

public void cancel() {
    if (timer.isAlive()) timer.interrupt();
    timer = new TimerThread(seconds);
}

public abstract void onTick(int secondsUntilFinished);
private Runnable getOnTickRunnable(final int second) {
    return new Runnable() {
        @Override
        public void run() {
            onTick(second);
        }
    };
}

public abstract void onFinish();
private Runnable getFinishedRunnable() {
    return new Runnable() {
        @Override
        public void run() {
            onFinish();
        }
    };
}

private class TimerThread extends Thread {

    private int count;

    private TimerThread(int count) {
        this.count = count;
    }

    @Override
    public void run() {
        try {
            while (count != 0) {
                handler.post(getOnTickRunnable(count--));
                sleep(1000);
            }
        } catch (InterruptedException e) { }
        if (!isInterrupted()) {
            handler.post(getFinishedRunnable());
        }
    }
}

}

InformationsquelleAutor der Antwort MinceMan

Erweitern Nantoka Antwort. Hier ist mein code, um die Ansicht wird korrekt aktualisiert:

countDownTimer = new CountDownTimer(countDownMsec, 500) 
{
    public void onTick(long millisUntilFinished)
    {
        if(millisUntilFinished!=countDownMsec)
        {
            completedTick+=1;
            if(completedTick%2==0)      //1 second has passed
            {
                //UPDATE VIEW HERE based on "seconds = completedTick/2"
            }
            countDownMsec = millisUntilFinished;  //store in case of pause
        }
    }

    public void onFinish()
    {
        countDownMsec = 0;
        completedTick+=2;       //the final 2 ticks arrive together
        countDownTimer = null;

        //FINAL UPDATE TO VIEW HERE based on seconds = completedTick/2 == countDownMsec/1000
    }
}

InformationsquelleAutor der Antwort Simon Huckett

Ich auch vor dem gleichen Problem mit CountDownTimer und ich habe versucht, verschiedene Ansätze.
So ist eine der einfachsten Möglichkeiten ist, die in Lösung zur Verfügung gestellt von @Nantoca - er schlägt vor, die doppelte Frequenz von 1000ms, um 500ms. Aber ich weiß nicht, wie diese Lösung denn es macht mehr Arbeit, verbrauchen einige extra-Akku-Ressourcen.

Also beschloss ich, @ocanal ist soultion nutzen und das schreiben meiner eigenen einfache CustomCountDownTimer.

Aber ich fand paar Fehler in seinem code:

1. Es ist ein wenig ineffizient (erstellen von zweiten hf Resultate zu veröffentlichen)

2. Beginnt es zu veröffentlichen, die erste Folge mit einer Verzögerung. (Sie müssen post() Methode eher als postDelayed() während der ersten Initialisierung)

3. seltsam aussehende. Methoden mit Großbuchstaben, status anstelle der klassischen isCanceled boolean und einige andere.

So, ich gereinigt es ein bisschen und hier ist die allgemeinere version von seinem Ansatz:

private class CustomCountDownTimer {

    private Handler mHandler;
    private long millisUntilFinished;
    private long countDownInterval;
    private boolean isCanceled = false;

    public CustomCountDownTimer(long millisUntilFinished, long countDownInterval) {
        this.millisUntilFinished = millisUntilFinished;
        this.countDownInterval = countDownInterval;
        mHandler = new Handler();
    }

    public synchronized void cancel() {
        isCanceled = true;
        mHandler.removeCallbacksAndMessages(null);
    }

    public long getRemainingTime() {
        return millisUntilFinished;
    }

    public void start() {

        final Runnable counter = new Runnable() {

            public void run() {

                if (isCanceled) {
                    publishUpdate(0);
                } else {

                    //time is out
                    if(millisUntilFinished <= 0){
                        publishUpdate(0);
                        return;
                    }

                    //update UI:
                    publishUpdate(millisUntilFinished);

                    millisUntilFinished -= countDownInterval;
                    mHandler.postDelayed(this, countDownInterval);
                }
            }
        };

        mHandler.post(counter);
    }
}

InformationsquelleAutor der Antwort Kirill Karmazin