如果java中有旧毫秒，如何计算提供的当前毫秒

我正在我的android应用程序中制作计时器。我有一个场景，即使应用程序关闭，我也不需要停止计时器。如果计时器正在运行，用户关闭应用程序并在一段时间后重新打开。他应该在计时器上看到最近的时间。但目前我无法显示最新时间。我只能显示用户关闭应用程序的时间。我正在存储计时器的时间，当用户打开应用程序时，我将存储的时间放回计时器。但我想展示最新的时间。这就是我到现在为止所做的。我正在使用计时器部件

MainActivity.class：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = MainActivity.class.getSimpleName();
    Chronometer tvTextView;
    Button btnStart, btnStop;
    private int state = 0; //0 means stop state,1 means play, 2 means pause

    SharedPreferences sharedPreferences;
    private boolean running = false;
    private long pauseOffSet = -1;

    ProgressBar progressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tvTextView = findViewById(R.id.textview);
        progressBar = findViewById(R.id.puzzleProgressBar);

        btnStart = findViewById(R.id.button1);
        btnStop = findViewById(R.id.button2);
        btnStart.setOnClickListener(this);
        btnStop.setOnClickListener(this);

        sharedPreferences = getSharedPreferences("myprefs", MODE_PRIVATE);
        state = sharedPreferences.getInt("state", 0);

        tvTextView.setOnChronometerTickListener(new Chronometer.OnChronometerTickListener() {
            @Override
            public void onChronometerTick(Chronometer chronometer) {
                long time = SystemClock.elapsedRealtime() - chronometer.getBase();
                pauseOffSet=time;
                Log.e(TAG,"pauseOffSet "+pauseOffSet);
                if (time >= 79200000) {
                    tvTextView.setBase(SystemClock.elapsedRealtime());
                    tvTextView.stop();
                    running = false;
                    progressBar.setProgress(0);
                } else {
                    chronometer.setText(setFormat(time));
                    int convertTime = (int) time;
                    progressBar.setProgress(convertTime);
                }
            }
        });

        if (state == 1) { // its in play mode
            running = true;
            tvTextView.setBase(SystemClock.elapsedRealtime() - sharedPreferences.getLong("milli", 0));
            tvTextView.start();
        } else if (state == 2) { //its in pause mode
            running = false;
            pauseOffSet = sharedPreferences.getLong("milli", -1);
            long time = SystemClock.elapsedRealtime() - pauseOffSet;
            tvTextView.setBase(time);
            int convertTime = (int) pauseOffSet;
            progressBar.setProgress(convertTime);
        } else {
            running = false;
            tvTextView.setBase(SystemClock.elapsedRealtime());
        }
    }

    public void onClick(View v) {
        if (btnStart == v) {
            if (!running) {
                if (pauseOffSet != -1) {
                    pauseOffSet = sharedPreferences.getLong("milli", -1);
                }
                tvTextView.setBase(SystemClock.elapsedRealtime() - pauseOffSet);
                tvTextView.start();
                state = 1;
                pauseOffSet = 0;
                running = true;
            }
        } else if (btnStop == v) {
            if (running) {
                tvTextView.stop();
                pauseOffSet = SystemClock.elapsedRealtime() - tvTextView.getBase();
                state = 2;
                running = false;
            }
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        sharedPreferences.edit().putLong("milli", pauseOffSet).commit();
        sharedPreferences.edit().putInt("state", state).commit();
    }

    @Override
    protected void onDestroy() {
        Log.e(TAG, "onDestroy called, state: " + state);
        super.onDestroy();
    }

    String setFormat(long time) {
        int h = (int) (time / 3600000);
        int m = (int) (time - h * 3600000) / 60000;
        int s = (int) (time - h * 3600000 - m * 60000) / 1000;
        String hh = h < 10 ? "0" + h : h + "";
        String mm = m < 10 ? "0" + m : m + "";
        String ss = s < 10 ? "0" + s : s + "";
        return hh + ":" + mm + ":" + ss;
    }
}

public类MainActivity扩展AppCompatActivity实现View.OnClickListener{
私有静态最终字符串标记=MainActivity.class.getSimpleName（）；
天文钟tvTextView；
按钮btnStart，btnStop；
private int state=0；//0表示停止状态，1表示播放，2表示暂停
SharedReferences SharedReferences；
私有布尔运行=false；
专用长暂停偏移=-1；
ProgressBar ProgressBar；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
tvTextView=findViewById（R.id.textview）；
progressBar=findViewById（R.id.progressBar）；
btnStart=findviewbyd（R.id.button1）；
btnStop=findviewbyd（R.id.button2）；
btnStart.setOnClickListener（此）；
btnStop.setOnClickListener（这个）；
SharedReferences=GetSharedReferences（“myprefs”，MODE_PRIVATE）；
state=SharedReferences.getInt（“state”，0）；
tvTextView.setOnChronometerTickListener（新的Chronometer.OnChronometerTickListener（）{
@凌驾
公测时计（天文时计）{
long time=SystemClock.elapsedRealtime（）-chronometer.getBase（）；
pauseOffSet=时间；
Log.e（标记“pauseOffSet”+pauseOffSet）；
如果（时间>=79200000）{
setBase（SystemClock.elapsedRealtime（））；
tvTextView.stop（）；
运行=错误；
progressBar.setProgress（0）；
}否则{
天文钟.setxt（setFormat（time））；
int convertTime=（int）时间；
progressBar.setProgress（转换时间）；
}
}
});
如果（状态==1）{//它处于播放模式
运行=真；
setBase（SystemClock.elapsedRealtime（）-sharedreferences.getLong（“milli”，0））；
tvTextView.start（）；
}如果（state==2）{//它处于暂停模式，则为else
运行=错误；
pauseOffSet=sharedPreferences.getLong（“milli”，-1）；
long time=SystemClock.elapsedRealtime（）-pauseOffSet；
tvTextView.setBase（时间）；
int convertTime=（int）pauseOffSet；
progressBar.setProgress（转换时间）；
}否则{
运行=错误；
setBase（SystemClock.elapsedRealtime（））；
}
}
公共void onClick（视图v）{
如果（btnStart==v）{
如果（！正在运行）{
如果（pauseOffSet！=-1）{
pauseOffSet=sharedPreferences.getLong（“milli”，-1）；
}
tvTextView.setBase（SystemClock.elapsedRealtime（）-pauseOffSet）；
tvTextView.start（）；
状态=1；
pauseOffSet=0；
运行=真；
}
}else if（btnStop==v）{
如果（正在运行）{
tvTextView.stop（）；
pauseOffSet=SystemClock.elapsedRealtime（）-tvTextView.getBase（）；
状态=2；
运行=错误；
}
}
}
@凌驾
受保护的void onStop（）{
super.onStop（）；
sharedReferences.edit（）.putLong（“milli”，pauseOffSet.commit（）；
SharedReferences.edit（）.putInt（“state”，state.commit（）；
}
@凌驾
受保护的空onDestroy（）{
Log.e（标记“onDestroy called，state:“+state”）；
super.ondestory（）；
}
字符串设置格式（长时间）{
int h=（int）（时间/3600000）；
int m=（int）（时间-h*3600000）/60000；
int s=（int）（时间-h*3600000-m*60000）/1000；
字符串hh=h<10？“0”+h:h+”；
字符串mm=m<10？“0”+m:m+”；
字符串ss=s<10？“0”+s:s+”；
返回hh+“：”+mm+“：”+ss；
}
}

如果你想让事情在后台发生，就使用服务。我甚至想，但是否可以使用存储的时间来计算最新时间？是的，这是简单的数学，但你应该使用服务。