Java 完成时重新启动倒计时比使用按钮重置慢

我有一个计时器，我想在它达到0时立即循环

在onFinish（）中重置计时器似乎比通过计时器的重置按钮手动重置计时器慢

当计时器完成时，它不会重新启动，直到“0”显示了一秒钟（可能在刻度结束时），有效地为计时器添加了我不想要的额外一秒钟

当显示“0”时，如何使计时器重新启动

导入和片段

package com.example.datacollector;

import android.content.Context;
import android.content.SharedPreferences;
import android.media.AudioManager;
import android.media.ToneGenerator;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.TextView;
import android.widget.EditText;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;

import java.util.Locale;

public class fragmentdro extends Fragment {
    private EditText session_edit_text;
    private EditText dro_edit_text;
    private TextView session_text_view;
    private TextView dro_text_view;
    private Button session_start_button;
    private Button dro_start_button;
    private Button session_reset_button;
    private Button dro_reset_button;
    private Button session_set_button;
    private Button dro_set_button;
    private CountDownTimer sessionTimer;
    private CountDownTimer droTimer;
    private boolean SessionTimerRunning;
    private boolean DROTimerRunning;
    private long SessionStartTimeInMillis;
    private long DROStartTimeInMillis;
    private long SessionTimeLeftInMillis = SessionStartTimeInMillis;
    private long DROTimeLeftInMillis = DROStartTimeInMillis;
    private long SessionEndTime;
    private long DROEndTime;
    View View;

    public View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container, @NonNull Bundle savedInstanceState) {
        View = inflater.inflate(R.layout.dro_fragment, container, false);

        session_edit_text = View.findViewById(R.id.session_edit_text);
        dro_edit_text = View.findViewById(R.id.dro_edit_text);
        session_text_view = View.findViewById(R.id.session_text_view);
        dro_text_view = View.findViewById(R.id.dro_text_view);
        session_start_button = View.findViewById(R.id.session_start_button);
        dro_start_button = View.findViewById(R.id.dro_start_button);
        session_reset_button = View.findViewById(R.id.session_reset_button);
        dro_reset_button = View.findViewById(R.id.dro_reset_button);
        session_set_button = View.findViewById(R.id.session_set_button);
        dro_set_button = View.findViewById(R.id.dro_set_button);
        InputMethodManager imm = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        ToneGenerator toneGenerator = new ToneGenerator(AudioManager.STREAM_ALARM, 100);

按钮

dro_set_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(android.view.View view) {
                String DROinput = dro_edit_text.getText().toString();
                if (DROinput.length() == 0) {
                    Toast.makeText(getActivity(), "Fill it in", Toast.LENGTH_SHORT).show();
                    return;
                }
                long millisInput = Long.parseLong(DROinput) * 1000;
                if (millisInput == 0) {
                    Toast.makeText(getActivity(), "Please enter a positive number", Toast.LENGTH_SHORT).show();
                    return;
                }
                setDROTime(millisInput);
                dro_edit_text.setText("");
                imm.hideSoftInputFromWindow(getView().getWindowToken(), 0);
            }
        });

        dro_start_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(android.view.View view) {
                if (DROTimerRunning) {
                    pauseDROTimer();
                } else {
                    startDROTimer();
                }
            }
        });

        dro_reset_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(android.view.View view) {
                if (DROTimerRunning) {
                    resetDROTimer();
                } else {
                    resetDROTimer();
                }
            }
        });

        return View;
    }

计时器

public void setDROTime(long milliseconds) {
        DROStartTimeInMillis = milliseconds;
        resetDROTimer();
    }

    public void startDROTimer() {
        DROEndTime = System.currentTimeMillis() + DROTimeLeftInMillis;
        final int[] secondsLeft = {0};
        droTimer = new CountDownTimer(DROTimeLeftInMillis, 100) {
            @Override
            public void onTick(long ms) {
                if (Math.round((float)ms/1000.0f) != secondsLeft[0])
                {
                    secondsLeft[0] = (int) (Math.round((float)ms)/1000.0f);
                }
                DROTimeLeftInMillis = ms;
                updateDROText();
            }

            @Override
            public void onFinish() {
                dro_text_view.setText("0");
                DROTimerRunning = false;
                DROTimeLeftInMillis = DROStartTimeInMillis + 1000;
                updateDROText();
                updateDROInterface();
                startDROTimer();
            }
        }.start();

        DROTimerRunning = true;
        dro_start_button.setText("Pause");
    }

    public void pauseDROTimer() {
        droTimer.cancel();
        DROTimerRunning = false;
        dro_start_button.setText("Start");
        updateDROText();
    }

    public void resetDROTimer() {
        if (DROTimerRunning) {
            droTimer.cancel();
            DROTimeLeftInMillis = (DROStartTimeInMillis + 1000);
            updateDROInterface();
            startDROTimer();
        } else {
            DROTimeLeftInMillis = (DROStartTimeInMillis);
            updateDROText();
            updateDROInterface();
            dro_reset_button.setVisibility(android.view.View.VISIBLE);
            dro_start_button.setVisibility(android.view.View.VISIBLE);
        }
    }

    public void updateDROText() {
        int seconds = (int) (DROTimeLeftInMillis/1000)%60;

        String timeLeftFormatted = String.format(Locale.getDefault(),
                timeLeftFormatted = String.format(Locale.getDefault(), ":%02d", seconds));
        dro_text_view.setText(timeLeftFormatted);
    }

    public void updateDROInterface() {
        if (DROTimerRunning) {
            dro_edit_text.setVisibility(android.view.View.INVISIBLE);
            dro_set_button.setVisibility(android.view.View.INVISIBLE);
            dro_reset_button.setVisibility(android.view.View.VISIBLE);
            dro_start_button.setText("Pause");
        } else {
            dro_edit_text.setVisibility(android.view.View.VISIBLE);
            dro_set_button.setVisibility(android.view.View.VISIBLE);
            dro_reset_button.setVisibility(android.view.View.VISIBLE);
            dro_start_button.setText("Start");
        }
    }

Prefs

@Override
    public void onStop() {
        super.onStop();

        SharedPreferences preferences = this.getActivity().getSharedPreferences("prefs", Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = preferences.edit();

        editor.putLong("SessionStartTimeInMillis", SessionStartTimeInMillis);
        editor.putLong("DROStartTimeInMillis", DROStartTimeInMillis);
        editor.putLong("MillisLeft", SessionTimeLeftInMillis);
        editor.putLong("DROMillisLeft", DROTimeLeftInMillis);
        editor.putBoolean("TimerRunning", SessionTimerRunning);
        editor.putBoolean("DROTimerRunning", DROTimerRunning);
        editor.putLong("EndTime", SessionEndTime);
        editor.putLong("DROEndTime", DROEndTime);

        if (sessionTimer !=null); {
            sessionTimer.cancel();
        }
    }

    @Override
    public void onStart() {
        super.onStart();

        SharedPreferences preferences = this.getActivity().getSharedPreferences("prefs", Context.MODE_PRIVATE);

        SessionStartTimeInMillis = preferences.getLong("SessionStartTimeInMillis", 0);
        SessionTimeLeftInMillis = preferences.getLong("MillisLeft", SessionTimeLeftInMillis);
        SessionTimerRunning = preferences.getBoolean("TimerRunning", false);

        DROStartTimeInMillis = preferences.getLong("DROStartTimeInMillis", 0);
        DROTimeLeftInMillis = preferences.getLong("DROMillisLeft", DROTimeLeftInMillis);
        DROTimerRunning = preferences.getBoolean("DROTimerRunning", false);

        updateSessionText();
        updateSessionInterface();
        updateDROText();
        updateDROInterface();

        if (SessionTimerRunning) {
            SessionEndTime = preferences.getLong("EndTime", 0);
            SessionTimeLeftInMillis = SessionEndTime - System.currentTimeMillis();

            if (SessionTimeLeftInMillis <0) {
                SessionTimeLeftInMillis = 0;
                SessionTimerRunning = false;
            } else {
                startSessionTimer();
            }
        }

        if (DROTimerRunning) {
            DROEndTime = preferences.getLong("EndTime", 0);
            DROTimeLeftInMillis = DROEndTime - System.currentTimeMillis();

            if (DROTimeLeftInMillis <0) {
                DROTimeLeftInMillis = 0;
                ToneGenerator toneGenerator = new ToneGenerator(AudioManager.STREAM_ALARM, 200);
                toneGenerator.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 100);
                DROTimerRunning = false;
            } else {
                startDROTimer();
            }
        }
    }
}

@覆盖
公共void onStop（）{
super.onStop（）；
SharedReferences首选项=this.getActivity（）.getSharedReferences（“prefs”，Context.MODE\u PRIVATE）；
SharedReferences.Editor=首选项.edit（）；
编辑器.putLong（“SessionStartTimeInMillis”，SessionStartTimeInMillis）；
编辑：普特隆（“DROStartTimeInMillis”，DROStartTimeInMillis）；
编辑：putLong（“MillisLeft”，SessionTimeLeftInMillis）；
普特隆编辑（DROMillisLeft，DROTimeLeftInMillis）；
putBoolean（“TimerRunning”，SessionTimerRunning）；
编辑器.putBoolean（“DROTimerRunning”，DROTimerRunning）；
editor.putLong（“EndTime”，sessionedtime）；
编者：普特隆（dronedtime，dronedtime）；
if（sessionTimer！=null）{
sessionTimer.cancel（）；
}
}
@凌驾
public void onStart（）{
super.onStart（）；
SharedReferences首选项=this.getActivity（）.getSharedReferences（“prefs”，Context.MODE\u PRIVATE）；
SessionStartTimeInMillis=preferences.getLong（“SessionStartTimeInMillis”，0）；
SessionTimeLeftInMillis=preferences.getLong（“MillisLeft”，SessionTimeLeftInMillis）；
SessionTimerRunning=preferences.getBoolean（“TimerRunning”，false）；
DROStartTimeInMillis=preferences.getLong（“DROStartTimeInMillis”，0）；
DROTimeLeftInMillis=preferences.getLong（“DROMillisLeft”，DROTimeLeftInMillis）；
DROTimerRunning=preferences.getBoolean（“DROTimerRunning”，false）；
updateSessionText（）；
updateSessionInterface（）；
updateDROText（）；
UpdatedPointerface（）；
if（SessionTimerRunning）{
sessionedtime=preferences.getLong（“EndTime”，0）；
SessionTimeLeftInMillis=SessionEndTime-System.currentTimeMillis（）；
如果（SessionTimeLeftInMillis您可以在DROTimeLeftInMillis中额外添加100毫秒

所以它应该看起来像：新的倒计时（DROTimeLeftInMillis+100100）{

由于onTick方法不会立即调用，它会在几毫秒后调用，因此通过添加100毫秒，它应该能够处理延迟，并给出您期望的结果。
不幸的是，这并没有解决它。与添加1000毫秒相比，添加100毫秒会加快第一个滴答声，而不是最后一个滴答声。例如，如果计时器设置为10秒，10到9比9到8、8到7等快得多。也许我需要在调用onFinish（）之前取消并重新启动计时器？如果不是，也许我可以使用处理程序每2秒安排一次倒计时？