计算一次倒计时所用的时间'；什么是从java开始的？

我有倒计时代码，工作正常。但我想计算一下couterdowntimer开始运行后的时间

如果我有2小时的倒计时时间。一旦它开始运行，我想计算时间，就像2:00:00小时-1:45:00=0:15:00

并在TimeOver文本视图中显示该时间

它应该随着倒计时的运行而动态改变

用户界面截图：

这是我的密码

public class MainActivity extends AppCompatActivity {
    private EditText mEditTextInput;
    private TextView mTextViewCountDown,mTextTimeOver;
    private Button mButtonSet;
    private Button mButtonStartPause;
    private Button mButtonReset;

    private CountDownTimer mCountDownTimer;

    private boolean mTimerRunning;

    private long mStartTimeInMillis;
    private long mTimeLeftInMillis;
    private long mEndTime;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mEditTextInput = findViewById(R.id.edit_text_input);
        mTextViewCountDown = findViewById(R.id.text_view_countdown);
        mTextTimeOver = findViewById(R.id.text_view_timeOver)

        mButtonSet = findViewById(R.id.button_set);
        mButtonStartPause = findViewById(R.id.button_start_pause);
        mButtonReset = findViewById(R.id.button_reset);

        mButtonSet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String input = mEditTextInput.getText().toString();
                if (input.length() == 0) {
                    Toast.makeText(MainActivity.this, "Field can't be empty", Toast.LENGTH_SHORT).show();
                    return;
                }

                long millisInput = Long.parseLong(input) * 60000;
                if (millisInput == 0) {
                    Toast.makeText(MainActivity.this, "Please enter a positive number", Toast.LENGTH_SHORT).show();
                    return;
                }

                setTime(millisInput);
                mEditTextInput.setText("");
            }
        });

        mButtonStartPause.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mTimerRunning) {
                    pauseTimer();
                } else {
                    startTimer();
                }
            }
        });

        mButtonReset.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                resetTimer();
            }
        });
    }

    private void setTime(long milliseconds) {
        mStartTimeInMillis = milliseconds;
        resetTimer();
        closeKeyboard();
    }

    private void startTimer() {
        mEndTime = System.currentTimeMillis() + mTimeLeftInMillis;

        mCountDownTimer = new CountDownTimer(mTimeLeftInMillis, 1000) {
            @Override
            public void onTick(long millisUntilFinished) {
                mTimeLeftInMillis = millisUntilFinished;
                updateCountDownText();
            }

            @Override
            public void onFinish() {
                mTimerRunning = false;
                updateWatchInterface();
            }
        }.start();

        mTimerRunning = true;
        updateWatchInterface();
    }

    private void pauseTimer() {
        mCountDownTimer.cancel();
        mTimerRunning = false;
        updateWatchInterface();
    }

    private void resetTimer() {
        mTimeLeftInMillis = mStartTimeInMillis;
        updateCountDownText();
        updateWatchInterface();
    }

    private void updateCountDownText() {
        int hours = (int) (mTimeLeftInMillis / 1000) / 3600;
        int minutes = (int) ((mTimeLeftInMillis / 1000) % 3600) / 60;
        int seconds = (int) (mTimeLeftInMillis / 1000) % 60;

        String timeLeftFormatted;
        if (hours > 0) {
            timeLeftFormatted = String.format(Locale.getDefault(),
                    "%d:%02d:%02d", hours, minutes, seconds);
        } else {
            timeLeftFormatted = String.format(Locale.getDefault(),
                    "%02d:%02d", minutes, seconds);
        }

        mTextViewCountDown.setText(timeLeftFormatted);
    }

    private void updateWatchInterface() {
        if (mTimerRunning) {
            mEditTextInput.setVisibility(View.INVISIBLE);
            mButtonSet.setVisibility(View.INVISIBLE);
            mButtonReset.setVisibility(View.INVISIBLE);
            mButtonStartPause.setText("Pause");
        } else {
            mEditTextInput.setVisibility(View.VISIBLE);
            mButtonSet.setVisibility(View.VISIBLE);
            mButtonStartPause.setText("Start");

            if (mTimeLeftInMillis < 1000) {
                mButtonStartPause.setVisibility(View.INVISIBLE);
            } else {
                mButtonStartPause.setVisibility(View.VISIBLE);
            }

            if (mTimeLeftInMillis < mStartTimeInMillis) {
                mButtonReset.setVisibility(View.VISIBLE);
            } else {
                mButtonReset.setVisibility(View.INVISIBLE);
            }
        }
    }

    private void closeKeyboard() {
        View view = this.getCurrentFocus();
        if (view != null) {
            InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    }

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

        SharedPreferences prefs = getSharedPreferences("prefs", MODE_PRIVATE);
        SharedPreferences.Editor editor = prefs.edit();

        editor.putLong("startTimeInMillis", mStartTimeInMillis);
        editor.putLong("millisLeft", mTimeLeftInMillis);
        editor.putBoolean("timerRunning", mTimerRunning);
        editor.putLong("endTime", mEndTime);

        editor.apply();

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

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

        SharedPreferences prefs = getSharedPreferences("prefs", MODE_PRIVATE);

        mStartTimeInMillis = prefs.getLong("startTimeInMillis", 600000);
        mTimeLeftInMillis = prefs.getLong("millisLeft", mStartTimeInMillis);
        mTimerRunning = prefs.getBoolean("timerRunning", false);

        updateCountDownText();
        updateWatchInterface();

        if (mTimerRunning) {
            mEndTime = prefs.getLong("endTime", 0);
            mTimeLeftInMillis = mEndTime - System.currentTimeMillis();

            if (mTimeLeftInMillis < 0) {
                mTimeLeftInMillis = 0;
                mTimerRunning = false;
                updateCountDownText();
                updateWatchInterface();
            } else {
                startTimer();
            }
        }
    }
} 

public类MainActivity扩展了AppCompatActivity{
私有EditText mEditTextInput；
私有文本视图mtextview倒计时，mTextTimeOver；
私人按钮mButtonSet；
私人按钮mButtonStartPause；
私人按钮；
专用倒数计时器mCountDownTimer；
私有布尔mTimerRunning；
私人长mStartTimeInMillis；
私有长mtimelftinmillis；
私生活时间长；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
mEditTextInput=findViewById（R.id.edit\u text\u input）；
mTextViewCountDown=findviewbyd（R.id.text\u view\u countdown）；
mTextTimeOver=findviewbyd（R.id.text\u view\u timeOver）
mButtonSet=findviewbyd（R.id.按钮组）；
mButtonStartPause=findViewById（R.id.按钮\启动\暂停）；
mbutonreset=findviewbyd（R.id.按钮\ U重置）；
mButtonSet.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
字符串输入=mEditTextInput.getText（）.toString（）；
if（input.length（）==0）{
Toast.makeText（MainActivity.this，“字段不能为空”，Toast.LENGTH_SHORT.show（）；
返回；
}
long millisInput=long.parseLong（输入）*60000；
如果（毫秒输入==0）{
Toast.makeText（MainActivity.this，“请输入正数”，Toast.LENGTH_SHORT.show（）；
返回；
}
设定时间（毫输入）；
mEditTextInput.setText（“”）；
}
});
mButtonStartPause.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
如果（mTimerRunning）{
pauseTimer（）；
}否则{
startTimer（）；
}
}
});
mbutonreset.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
重置计时器（）；
}
});
}
私有void设置时间（长毫秒）{
mStartTimeInMillis=毫秒；
重置计时器（）；
关闭键盘（）；
}
私有void startTimer（）{
mEndTime=System.currentTimeMillis（）+mTimeLeftInMillis；
mCountDownTimer=新的倒计时（mtimelftinmillis，1000）{
@凌驾
公共void onTick（长毫秒未完成）{
mTimeLeftInMillis=毫秒直至完成；
updateCountDownText（）；
}
@凌驾
公共无效onFinish（）{
mTimerRunning=假；
updateWatchInterface（）；
}
}.start（）；
mTimerRunning=真；
updateWatchInterface（）；
}
私有void pauseTimer（）{
mCountDownTimer.cancel（）；
mTimerRunning=假；
updateWatchInterface（）；
}
私有void resetTimer（）{
mTimeLeftInMillis=mStartTimeInMillis；
updateCountDownText（）；
updateWatchInterface（）；
}
私有void updateCountDownText（）{
整数小时=（整数）（mtimelftinmillis/1000）/3600；
int分钟=（int）（（mTimeLeftInMillis/1000）%3600）/60；
整数秒=（整数）（mTimeLeftInMillis/1000）%60；
字符串时间倒转格式；
如果（小时数>0）{
timeLeftFormatted=String.format（Locale.getDefault（），
%d:%02d:%02d”，小时、分钟、秒）；
}否则{
timeLeftFormatted=String.format（Locale.getDefault（），
“%02d:%02d”，分，秒）；
}
mTextViewCountDown.setText（timeLeftFormatted）；
}
私有void updateWatchInterface（）{
如果（mTimerRunning）{
mEditTextInput.setVisibility（视图不可见）；
mbutonset.setVisibility（视图不可见）；
mbutonreset.setVisibility（视图不可见）；
mButtonStartPause.setText（“暂停”）；
}否则{
mEditTextInput.setVisibility（View.VISIBLE）；
mbutonset.setVisibility（View.VISIBLE）；
mButtonStartPause.setText（“开始”）；
if（mTimeLeftInMillis<1000）{
mButtonStartPause.setVisibility（视图不可见）；
}否则{
mButtonStartPause.setVisibility（View.VISIBLE）；
}
if（mTimeLeftInMillis