Stopwatch classes for android

ExampleActivity.class

public class ExampleActivity extends AppCompatActivity implements SmartTimer.OnSecondTickListener {

    private static final String TAG = TimerActivity.class.getSimpleName();

    private TextView mTextViewTime;
    private Button mButtonStart;
    private Button mButtonStop;
    private Button mButtonClear;

    private SmartTimer mSmartTimer = new SmartTimer(this, this);

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

        mTextViewTime = (TextView) findViewById(R.id.textView);
        mButtonStart = (Button) findViewById(R.id.button_start);
        mButtonStop = (Button) findViewById(R.id.button_stop);
        mButtonClear = (Button) findViewById(R.id.button_clear);

        mButtonStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                Log.d(TAG, "click start");
                mSmartTimer.start();
            }
        });

        mButtonStop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                Log.d(TAG, "click stop");
                mSmartTimer.stop();
            }
        });

        mButtonClear.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                Log.d(TAG, "click clear");
                mSmartTimer.clear();
                tick(mSmartTimer.getElapsedTime());
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        mSmartTimer.onResume(this);
        tick(mSmartTimer.getElapsedTime());
    }

    @Override
    public void tick(final long time) {
        Log.d(TAG, "tick: " + time);
        setTimeText(time);
    }

    private void setTimeText(final long timeText) {
        mTextViewTime.setText("time: " + timeText/1000 + "s\nor " + getHumanableTime(timeText));
    }

    private String getHumanableTime(final long timeText) {
        return new SimpleDateFormat("mm - ss").format(new Date(timeText));
    }

    @Override
    protected void onPause() {
        super.onPause();
        mSmartTimer.onPause();
    }
}

SmartTimer.class

public class SmartTimer implements Timer.OnTickListener {

    private static final String TAG = SmartTimer.class.getSimpleName();

    private static final String ELAPSED_TIME = "ELAPSED_TIME";
    private static final String PAUSE_TIME = "PAUSE_TIME";
    private static final String RUNNING = "RUNNING";

    private Timer mTimer;

    private Context mContext;

    private boolean isRunnung = false;
    private OnSecondTickListener mTickSecondListener;

    public interface OnSecondTickListener {
        void tick(long time);
    }

    public SmartTimer(final Context context, OnSecondTickListener listener) {
        mContext = context;
        mTimer = new Timer(this);
        mTickSecondListener = listener;
    }

    public void start() {
        if (isNotRunning()) {
//            saveStartTime(System.currentTimeMillis());
            isRunnung = true;
            saveStatus(isRunnung);
        } else {
            long pauseTime = getPauseTime();
            if (pauseTime != 0L) {
                plusElapsedTime(System.currentTimeMillis() - pauseTime);
                clearPauseTime();
            }
        }

        mTimer.start();
    }

    private boolean isNotRunning() {
        return !getStatus();
    }

    private boolean isRunning() {
        return getStatus();
    }

    public void stop() {
        mTimer.stop();
        if (isRunning()) {
            plusElapsedTime(mTimer.getElapsedTime());
        }
        isRunnung = false;
        saveStatus(isRunnung);
    }

    private void pause() {
        mTimer.stop();
        plusElapsedTime(mTimer.getElapsedTime());
        savePauseTime();
    }

    public void clear() {
        stop();
        clearPauseTime();
        clearElapsedTime();
    }


    //most important in Activity/Fragment:
    //@Override 
    //onPause() {
    //super.onPause();
    //SmartTimer.onPause()
    //}
    public void onPause() {
        mTimer.unregisterListener();
        if (isRunning()) {
            pause();
        }
        mTickSecondListener = null;
    }

    //most important in Activity/Fragment:
    //@Override 
    //onResume() {
    //super.onResume();
    //SmartTimer.onResume(this)
    //}
    public void onResume(OnSecondTickListener onTickListener) {
        mTimer.registerListener(this);
        if (isRunning()) {
            start();
        }

        mTickSecondListener = onTickListener;
    }

    private void saveStatus(final boolean isRunnung) {
        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
        editor.putBoolean(RUNNING, isRunnung).apply();
    }

    private boolean getStatus() {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
        return prefs.getBoolean(RUNNING, false);
    }

    private void savePauseTime() {
        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
        editor.putLong(PAUSE_TIME, System.currentTimeMillis()).apply();
    }

    private long getPauseTime() {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
        return prefs.getLong(PAUSE_TIME, 0L);
    }

    private void clearPauseTime() {
        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
        editor.putLong(PAUSE_TIME, 0L).apply();
    }

    private void clearElapsedTime() {
        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
        editor.putLong(ELAPSED_TIME, 0L).apply();
    }

    private void plusElapsedTime(final long unregisterTime) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
        long oldTime = prefs.getLong(ELAPSED_TIME, 0L);

        SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
        editor.putLong(ELAPSED_TIME, oldTime + unregisterTime).apply();
    }

    public long getElapsedTime() {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
        return prefs.getLong(ELAPSED_TIME, 0L);
    }

    @Override
    public void tick(long time) {
        Log.d(TAG, "tick");
        mTickSecondListener.tick(time + getElapsedTime());
    }
}

Stopwatch.class

public class Stopwatch {

    private long startTime = 0;
    private long stopTime = 0;
    private boolean isRunning = false;

    void start() {
        startTime = System.currentTimeMillis();
        isRunning = true;
    }

    void stop() {
        stopTime = System.currentTimeMillis();
        isRunning = false;
    }

    long getElapsedTime() {
        if (isRunning) {
            return System.currentTimeMillis() - startTime;
        }

        return stopTime - startTime;
    }

    boolean isRunning() {
        return isRunning;
    }
}

Timer.class

public class Timer {

    private static final int START_TIMER = 0;
    private static final int STOP_TIMER = 1;
    private static final int UPDATE_TIMER = 2;
    private final int refreshRate = 1000;

    private OnTickListener mOnTickListener;

    private Stopwatch timer = new Stopwatch();

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(final Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case START_TIMER: {
                    if (mOnTickListener != null) {
                        timer.start();
                        mHandler.sendEmptyMessage(UPDATE_TIMER);
                    }
                    break;
                }
                case STOP_TIMER: {
                    if (mOnTickListener != null) {
                        mHandler.removeMessages(UPDATE_TIMER);
                        timer.stop();
                    }
                    break;
                }
                case UPDATE_TIMER: {
                    if (mOnTickListener != null) {
                        mOnTickListener.tick(timer.getElapsedTime());
                        mHandler.sendEmptyMessageDelayed(UPDATE_TIMER, refreshRate);
                    }
                    break;
                }
            }
        }
    };

    void unregisterListener() {
        mOnTickListener = null;
        stop();
    }

    void registerListener(final OnTickListener listener) {
        mOnTickListener = listener;
    }

    interface OnTickListener {
        void tick(long time);
    }

    Timer(OnTickListener listener) {
        mOnTickListener = listener;
    }

    void start() {
        mHandler.sendEmptyMessage(START_TIMER);
    }

    void stop() {
        mHandler.sendEmptyMessage(STOP_TIMER);
    }

    long getElapsedTime() {
        return timer.getElapsedTime();
    }

    boolean isRunning() {
        return timer.isRunning();
    }
}