在另一个运行时暂停 CountDownTimer - Android

Question

我的程序中有两个倒数计时器，一个较长的（120 秒）和一个较短的（3.5 秒）。我希望在 3.5 秒计时器为运行时暂停 120 秒计时器，并且当 3.5 秒计时器不是运行时，较长的计时器继续运行。所以程序从剩余的 120 秒开始，而 3.5 秒运行，然后当 3.5 秒运行 120 秒时，程序将开始，只有当 3.5 秒再次运行时才暂停（一旦用户按回车键。）我该怎么做这个？

final CountDownTimer loop = new CountDownTimer(3500, 1000) {
                @Override
                public void onTick(long millisUntilFinished) {
                }
                @Override
                public void onFinish() {
                    number.setVisibility(View.GONE);
                    final TextView prompt = (TextView) findViewById(R.id.prompt);
                    prompt.setVisibility(View.VISIBLE);
                    prompt.setText(" Enter the number");
                    final EditText input = (EditText) findViewById(R.id.enterAnswer);
                    input.setVisibility(View.VISIBLE);
                    input.setOnKeyListener(new View.OnKeyListener() {
                        @Override
                        public boolean onKey(View v, int keyCode, KeyEvent event) {
                            if (event.getAction() == KeyEvent.ACTION_DOWN) {
                                switch (keyCode) {
                                    case KeyEvent.KEYCODE_ENTER:
                                        Editable answer = input.getText();
                                        int finalAnswer = Integer.parseInt(String.valueOf(answer));
                                        int finalLoadG1 = Integer.parseInt(String.valueOf(number.getText()));
                                        input.setVisibility(View.GONE);
                                        prompt.setVisibility(View.GONE);
                                        if (finalAnswer == finalLoadG1) {
                                            score++;
                                        }

                                        number.setVisibility(View.VISIBLE);

                                        if (score>=0 && score<=2){
                                            int loadG1 = generateG1.nextInt(89999)+10000;
                                            number.setText(""+loadG1);
                                        }

                                        else if (score>=3 && score<=5){
                                            int loadG1 = generateG1.nextInt(899999)+100000;
                                            number.setText(""+loadG1);
                                        }

                                        else if (score>=6 && score<=9){
                                            int loadG1 = generateG1.nextInt(8999999)+1000000;
                                            number.setText(""+loadG1);
                                        }

                                        else if (score>=10 && score<=14){
                                            int loadG1 = generateG1.nextInt(89999999)+10000000;
                                            number.setText(""+loadG1);
                                        }

                                        else if (score>=15 && score<=20){
                                            int loadG1 = generateG1.nextInt(899999999)+100000000;
                                            number.setText(""+loadG1);
                                        }

                                        else if (score>=21) {
                                            int loadG1 = generateG1.nextInt((int) 8999999999L)+1000000000;
                                            number.setText(""+loadG1);
                                        }

                                        input.getText().clear();

                                        start();

                                        return true;
                                    default:
                                }
                            }
                            return false;
                        }
                    });
                }
            }.start();

            new CountDownTimer(120000, 1000) {
                @Override
                public void onTick (long millisUntilFinished) {
                }
                @Override
                public void onFinish() {
                    TextView result = (TextView) findViewById(R.id.outcome);
                    result.setText("Score: "+ score);
                    TextView prompt = (TextView) findViewById(R.id.prompt);
                    prompt.setVisibility(View.GONE);
                    final EditText input = (EditText) findViewById(R.id.enterAnswer);
                    input.setVisibility(View.GONE);
                    loop.cancel();
                    number.setVisibility(View.GONE);
                }
            }.start();

我以前问过这个问题，但不幸的是没有得到有效的答案。如果有人能够回答这个问题，将不胜感激。请随意插入任何有助于解释您的答案的代码。非常感谢。

Answer 1

你可以这样试试（我没有测试过，但希望它能起作用）

public class MainActivity extends BaseActivity {

    private long remainingTimeForTimer = 0;

    private CountDownTimer mCountDownTimer

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Start first timer
        test1(120 * 1000);

        // now on the basis of remaining timer you can cancel current timer and after that second timer you can start that timer with remaining time

        if(remainingTimeForTimer > 0)
        {
            test1(remainingTimeForTimer);
        }


    }



    private void test1(long totalTimerTime)
    {

        mCountDownTimer = new CountDownTimer(totalTimerTime, 1000) {

            @Override
            public void onTick(long millisUntilFinished) {

                remainingTimeForTimer = millisUntilFinished;

            }

            @Override
            public void onFinish() {


                //trialCount = 0;

            }
        };

        mCountDownTimer.start();

    }



    @Override
    protected void onDestroy() {
        if (mCountDownTimer != null) {
            mCountDownTimer.cancel();
        }
        super.onDestroy();
    }
}

Answer 2

好的，我会尝试举个例子，但不能保证这正是您所需要的：

创建一个全局变量和 CountDownTimer 个对象：

Long remainingTime = 120000L;
ThreePointFiveSecondsTimer mThreePointFiveSecondsTimer;
HundredTwentySecondsTimer mHundredTwentySecondsTimer;

创建 120 秒计时器：

public class HundredTwentySecondsTimer extends CountDownTimer {

        public HundredTwentySecondsTimer(long millisInFuture, long countDownInterval) {
            super(millisInFuture, countDownInterval);
        }

        @Override
        public void onTick(long millisUntilFinished) {


        }

        @Override
        public void onFinish() {

        }
    }

创建 3.5 秒计时器：

  public class ThreePointFiveSecondsTimer extends CountDownTimer {

            public ThreePointFiveSecondsTimer(long millisInFuture, long countDownInterval) {
                super(millisInFuture, countDownInterval);
            }

            @Override
            public void onTick(long millisUntilFinished) {

              remainingTime = millisUntilFinished;//set the remaining time
            }

            @Override
            public void onFinish() {

//start the 120 second countdowntimer again
    mHundredTwentySecondsTimer  = new MyCountDownTimer(remainingTime, 1000);
    mHundredTwentySecondsTimer.start();
            }
        }

启动 120 秒计时器：

mHundredTwentySecondsTimer  = new MyCountDownTimer(remainingTime, 1000);
mHundredTwentySecondsTimer.start();

然后，您随时决定启动 3.5 计时器：

mThreePointFiveSecondsTimer   = new ThreePointFiveSecondsTimer (3500, 1000);
mThreePointFiveSecondsTimer.start();
mHundredTwentySecondsTimer.cancel();
mHundredTwentySecondsTimer = null;

这只是背后的想法，但您必须根据自己的需要进行调整。对不起，但不能给你所有你需要的东西，那将超出框架。

Answer 3

已解决

经过多次尝试，我已经解决了这个问题。我最终将较大的计时器放在较短的计时器的 onFinish 中，并将较长计时器的初始时间设置为 millisUntilFinished。然后我在用户按下回车键时取消长计时器，只要显示 EditText 框，它就会自动以更新的时间开始。

在另一个运行时暂停 CountDownTimer - Android

Pausing a CountDownTimer whilst another one runs - Android

java

android

countdowntimer

android-studio

pause