Androidスタジオの別のタイマーを使用してタイマーを開始するには

Question

私はJavaの初心者です（3ヶ月未満の経験）、私が作業しているプロジェクトではタイマーを作成する必要があります。 私はこれまでこれをやったことがありますが、私は1つのことをする方法を知らない。

2番目のタイマーが終了すると、タイマーを開始します。つまり、開始/停止ボタンを使用してタイマーを開始するのではなく、最初のタイマーがいつ開始されるのかを決定する2番目のタイマー（3秒で開始）を設定します。例えば、最初のタイマーが30秒であれば、2番目のタイマーが3-0からカウントダウンを終了するとカウントダウンを開始します。

これを行うには他のクラスまたはメソッド/リスナーが必要であることは知っていますが、これまでに述べたように、これまでJava（通常はC++を使用）で作業しています。

これを達成するためのヘルプ/ガイダンス/コードはすばらしいでしょう。これを試してこれを達成するために私が周りを歩いていたコードはここにあります。

のJava

import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.Button; 
import android.widget.TextView; 
import android.os.CountDownTimer; 

public class Timer extends AppCompatActivity 
{ 
TextView timer; 
TextView timerStart; 
Button multi; 
int track; 
int seconds; 
CountDownTimer countDownTimer; 
CountDownTimer start; 

View.OnClickListener btnListen = new View.OnClickListener(){ 
    @Override 
    public void onClick(View v) 
    { 
     switch(v.getId()) 
     { 
      case R.id.multi : start(); 
       break; 
     } 
    } 

}; 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_timer); 
    timer = (TextView) findViewById(R.id.timer); 
    timerStart = (TextView) findViewById(R.id.timerStart); 
    multi = (Button) findViewById(R.id.multi); 
    multi.setOnClickListener(btnListen); 

    multi.setText("Start"); 
} 

public void start_timer() 
{ 
    track = 3; 
    start = new CountDownTimer(3*1000,1000) { 
     @Override 
     public void onTick(long millisUntilFinished) { 
      timerStart.setText("" + millisUntilFinished/1000); 
     } 

     @Override 
     public void onFinish() { 
      timerStart.setText("Begin"); 
      track = 0; 
     } 
    }.start(); 
    seconds = 30; 
    if (timerStart.getText().equals("Begin")) 
    { 
     start.cancel(); 
     countDownTimer = new CountDownTimer(30 * 1000, 1000) { 
      @Override 
      public void onTick(long millisUntilFinished) { 
       timer.setText("" + millisUntilFinished/1000); 
      } 

      @Override 
      public void onFinish() { 
       timer.setText("BEEP"); 
      } 
     }.start(); 
    } 
    else 
    { 
     System.out.println("Nothing"); 
    } 
} 
public void start() 
{ 
    start_timer(); 
    /*seconds = 30; 
    if (timerStart.getText().equals("Begin")) 
    { 
     countDownTimer = new CountDownTimer(seconds * 1000, 1000) { 
      @Override 
      public void onTick(long millisUntilFinished) { 
       timer.setText("" + millisUntilFinished/1000); 
      } 

      @Override 
      public void onFinish() { 
       timer.setText("BEEP"); 
      } 
     }.start(); 
    }*/ 

} 
} 

繰り返しますが、これは私が周りいじるてるだけのものです。これを行う別の方法がある場合（RunnableまたはHandlerを使用する場合のように）、私はそれを開いています。私の目標はJavaを学ぶことです。

Answer 1

これはいかがですか？私はCountDownTimerを変更して連鎖できるようにしました。

public abstract class ChainedCountDownTimer { 

    /** 
    * Millis since epoch when alarm should stop. 
    */ 
    private final long mMillisInFuture; 

    /** 
    * The interval in millis that the user receives callbacks 
    */ 
    private final long mCountdownInterval; 

    private long mStopTimeInFuture; 

    /** 
    * boolean representing if the timer was cancelled 
    */ 
    private boolean mCancelled = false; 

    /** 
    * First timer in chaining 
    */ 
    private ChainedCountDownTimer first; 

    /** 
    * Next timer 
    */ 
    private ChainedCountDownTimer next; 

    /** 
    * @param millisInFuture The number of millis in the future from the call 
    * to {@link #start()} until the countdown is done and {@link #onFinish()} 
    * is called. 
    * @param countDownInterval The interval along the way to receive 
    * {@link #onTick(long)} callbacks. 
    */ 
    public ChainedCountDownTimer(long millisInFuture, long countDownInterval) { 
     mMillisInFuture = millisInFuture; 
     mCountdownInterval = countDownInterval; 
     first = this; 
    } 

    /** 
    * Cancel the countdown. 
    */ 
    public synchronized final void cancel() { 
     first.mCancelled = true; 
     mHandler.removeMessages(MSG); 
    } 

    public void start() { 
     first.startInternal(); 
    } 

    /** 
    * Start the countdown. 
    */ 
    public synchronized final ChainedCountDownTimer startInternal() { 
     mCancelled = false; 
     if (mMillisInFuture <= 0) { 
      onFinish(); 

      if (next != null) { 
       next.startInternal(); 
      } 

      return this; 
     } 
     mStopTimeInFuture = SystemClock.elapsedRealtime() + mMillisInFuture; 
     mHandler.sendMessage(mHandler.obtainMessage(MSG)); 
     return this; 
    } 


    /** 
    * Callback fired on regular interval. 
    * @param millisUntilFinished The amount of time until finished. 
    */ 
    public abstract void onTick(long millisUntilFinished); 

    /** 
    * Callback fired when the time is up. 
    */ 
    public abstract void onFinish(); 

    public ChainedCountDownTimer setNext(ChainedCountDownTimer next) { 
     this.next = next; 
     next.first = this.first; 

     return this.next; 
    } 

    private static final int MSG = 1; 


    // handles counting down 
    private Handler mHandler = new Handler() { 

     @Override 
     public void handleMessage(Message msg) { 

      synchronized (ChainedCountDownTimer.this) { 
       if (first.mCancelled) { 
        return; 
       } 

       final long millisLeft = mStopTimeInFuture - SystemClock.elapsedRealtime(); 

       if (millisLeft <= 0) { 
        onFinish(); 

        if (next != null) { 
         next.startInternal(); 
        } 

       } else if (millisLeft < mCountdownInterval) { 
        // no tick, just delay until done 
        sendMessageDelayed(obtainMessage(MSG), millisLeft); 
       } else { 
        long lastTickStart = SystemClock.elapsedRealtime(); 
        onTick(millisLeft); 

        // take into account user's onTick taking time to execute 
        long delay = lastTickStart + mCountdownInterval - SystemClock.elapsedRealtime(); 

        // special case: user's onTick took more than interval to 
        // complete, skip to next interval 
        while (delay < 0) delay += mCountdownInterval; 

        sendMessageDelayed(obtainMessage(MSG), delay); 
       } 
      } 
     } 
    }; 
} 

このように使用できます。

ChainedCountDownTimer timer1 = new ChainedCountDownTimer(3 * 1000, 1000) { 
    @Override 
    public void onTick(long millisUntilFinished) { 
     Log.d(TAG, "timer1 onTick"); 
    } 

    @Override 
    public void onFinish() { 
     Log.d(TAG, "timer1 onFinish"); 
    } 
}; 

ChainedCountDownTimer timer2 = new ChainedCountDownTimer(30 * 1000, 1000) { 
    @Override 
    public void onTick(long millisUntilFinished) { 
     Log.d(TAG, "timer2 onTick"); 
    } 

    @Override 
    public void onFinish() { 
     Log.d(TAG, "timer2 onFinish"); 
    } 
}; 

timer1.setNext(timer2).start();