@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1

package/src/utils/useStopwatch.test.tsx

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 2015 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import React from 'react';
+import { act, render } from '@testing-library/react';
+
+import useStopWatch, { ITimer, Stopwatch } from './useStopwatch';
+
+let appCallback = () => {};
+
+const setup = (stopwatch: Stopwatch) => {
+    const returnVal = {};
+    const TestComponent = () => {
+        Object.assign(returnVal, useStopWatch(stopwatch));
+        return null;
+    };
+    render(<TestComponent />);
+    return returnVal as ReturnType<typeof useStopWatch>;
+};
+
+describe('Stop Watch', () => {
+    const mockNow = jest.fn(() => 0);
+    const mockSetTimeout = jest.fn((callback: () => void) => {
+        appCallback = callback;
+        return () => {};
+    });
+
+    const timerMock: ITimer = {
+        now: mockNow,
+        setTimeout: mockSetTimeout,
+    };
+
+    const expectZeroElapsedTime = (
+        stopwatch: ReturnType<typeof useStopWatch>
+    ) => {
+        expect(stopwatch.time).toBe(0);
+        expect(stopwatch.seconds).toBe(0);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+    };
+
+    beforeEach(() => {
+        mockNow.mockReturnValue(0);
+        jest.clearAllMocks();
+    });
+
+    test('Auto Start will init timer', () => {
+        const { isRunning } = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(1);
+        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
+        expect(isRunning).toBeTruthy();
+    });
+
+    test('Pause will stop the stopwatch and report elapsed time', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(1);
+        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
+        expect(stopwatch.isRunning).toBeTruthy();
+
+        expectZeroElapsedTime(stopwatch);
+
+        mockNow.mockReturnValue(433);
+
+        act(() => {
+            stopwatch.pause();
+            stopwatch;
+        });
+
+        expect(stopwatch.time).toBe(433);
+        expect(stopwatch.seconds).toBe(0);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+        expect(stopwatch.isRunning).toBeFalsy();
+    });
+
+    test('Start a paused timer will continue timer', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(1);
+        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
+        expect(stopwatch.isRunning).toBeTruthy();
+
+        expectZeroElapsedTime(stopwatch);
+
+        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
+
+        mockNow.mockReturnValue(500);
+
+        act(() => {
+            stopwatch.pause();
+            stopwatch;
+        });
+
+        expect(stopwatch.time).toBe(500);
+        expect(stopwatch.seconds).toBe(0);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+        expect(stopwatch.isRunning).toBeFalsy();
+
+        mockNow.mockReturnValue(5000);
+
+        act(() => {
+            stopwatch.start();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(2);
+        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 500);
+    });
+
+    test('Timer will not automatically start', () => {
+        const { isRunning } = setup({
+            autoStart: false,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(0);
+        expect(isRunning).toBeFalsy();
+    });
+
+    test('Start call will start the timer', () => {
+        const stopwatch = setup({
+            autoStart: false,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(0);
+        expect(stopwatch.isRunning).toBeFalsy();
+
+        mockNow.mockReturnValue(5000);
+
+        act(() => {
+            stopwatch.start();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(1);
+        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
+        expect(stopwatch.isRunning).toBeTruthy();
+    });
+
+    test('Reset will reset all time the stopwatch and report elapsed time', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(1);
+        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
+        expect(stopwatch.isRunning).toBeTruthy();
+
+        expectZeroElapsedTime(stopwatch);
+
+        mockNow.mockReturnValue(1200);
+
+        act(() => {
+            appCallback();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 800);
+
+        expect(stopwatch.time).toBe(1200);
+        expect(stopwatch.seconds).toBe(1);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+        expect(stopwatch.isRunning).toBeTruthy();
+
+        mockNow.mockReturnValue(6800);
+        act(() => {
+            stopwatch.reset();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).nthCalledWith(3, expect.anything(), 1000);
+
+        expectZeroElapsedTime(stopwatch);
+        expect(stopwatch.isRunning).toBeTruthy();
+    });
+
+    test('Time will update output after precise interval elapsed trigger a new timeout', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expectZeroElapsedTime(stopwatch);
+
+        // trigger timeout with precise time elapsed
+        mockNow.mockReturnValue(1000);
+
+        act(() => {
+            appCallback();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(2);
+        expect(timerMock.setTimeout).toBeCalledWith(expect.anything(), 1000);
+
+        expect(stopwatch.time).toBe(1000);
+        expect(stopwatch.seconds).toBe(1);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+    });
+
+    test('Time will update trigger a new timeout and add positive correction', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expectZeroElapsedTime(stopwatch);
+
+        // trigger timeout with error of -200ms
+        mockNow.mockReturnValue(800);
+
+        act(() => {
+            appCallback();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(2);
+        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
+        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 200);
+
+        expect(stopwatch.time).toBe(800);
+        expect(stopwatch.seconds).toBe(0);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+    });
+
+    test('Time will update trigger a new timeout and add negative correction', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expectZeroElapsedTime(stopwatch);
+
+        // trigger timeout with error of +200ms
+        mockNow.mockReturnValue(1200);
+
+        act(() => {
+            appCallback();
+            stopwatch;
+        });
+
+        expect(timerMock.setTimeout).toBeCalledTimes(2);
+        expect(timerMock.setTimeout).nthCalledWith(1, expect.anything(), 1000);
+        expect(timerMock.setTimeout).nthCalledWith(2, expect.anything(), 800);
+
+        expect(stopwatch.time).toBe(1200);
+        expect(stopwatch.seconds).toBe(1);
+        expect(stopwatch.minutes).toBe(0);
+        expect(stopwatch.hours).toBe(0);
+        expect(stopwatch.days).toBe(0);
+    });
+
+    test('Test time part splitting', () => {
+        const stopwatch = setup({
+            autoStart: true,
+            resolution: 1000,
+            timer: timerMock,
+        });
+
+        expectZeroElapsedTime(stopwatch);
+
+        // 2days 1hr 1 min 3 seconds 500ms
+        mockNow.mockReturnValue(176588500);
+
+        act(() => {
+            appCallback();
+            stopwatch;
+        });
+
+        expect(stopwatch.time).toBe(176588500);
+        expect(stopwatch.seconds).toBe(8);
+        expect(stopwatch.minutes).toBe(3);
+        expect(stopwatch.hours).toBe(1);
+        expect(stopwatch.days).toBe(2);
+    });
+});

package/src/utils/useStopwatch.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2023 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+export interface ITimer {
+    now: () => number;
+    setTimeout: (callback: () => void, ms: number) => () => void;
+}
+
+export type Stopwatch = {
+    autoStart: boolean;
+    resolution?: number;
+    timer?: ITimer;
+};
+
+const defaultTimer: ITimer = {
+    now: () => Date.now(),
+    setTimeout: (callback: () => void, ms: number) => {
+        const t = setTimeout(callback, ms);
+        return () => clearTimeout(t);
+    },
+};
+
+const splitMS = (ms: number) => {
+    const time = ms;
+    const days = Math.floor(ms / (24 * 60 * 60 * 1000));
+    ms -= days * 24 * 60 * 60 * 1000;
+
+    const hours = Math.floor(ms / (60 * 60 * 1000));
+    ms -= hours * 60 * 60 * 1000;
+
+    const minutes = Math.floor(ms / (60 * 1000));
+    ms -= minutes * 60 * 1000;
+
+    const seconds = Math.floor(ms / 1000);
+    const millisecond = ms - seconds * 60 * 1000;
+
+    return {
+        time,
+        days,
+        hours,
+        minutes,
+        seconds,
+        millisecond,
+    };
+};
+
+export default ({
+    autoStart = false,
+    timer = defaultTimer,
+    resolution = 1000,
+}: Stopwatch) => {
+    const previousTickTime = useRef(timer.now());
+    const expectedTickTime = useRef(-1);
+    const autoStarted = useRef(false);
+    const pauseTimeout = useRef<(() => void) | null>(null);
+    const [isRunning, setIsRunning] = useState(false);
+    const [time, setTime] = useState(0);
+
+    const nextTick = useCallback(
+        (elapsedTime: number) => {
+            expectedTickTime.current =
+                previousTickTime.current +
+                (resolution - (elapsedTime % resolution));
+
+            const nextInterval = expectedTickTime.current - timer.now();
+
+            const handler = (delta: number, shouldContinue = true) => {
+                setTime(elapsedTime + delta);
+                previousTickTime.current = timer.now();
+                if (shouldContinue)
+                    pauseTimeout.current = nextTick(elapsedTime + delta);
+            };
+
+            const release = timer.setTimeout(() => {
+                handler(timer.now() - previousTickTime.current);
+            }, nextInterval);
+
+            return () => {
+                handler(timer.now() - previousTickTime.current, false);
+                release();
+            };
+        },
+        [resolution, timer]
+    );
+
+    const start = useCallback(
+        (elapsedTime = time) => {
+            if (pauseTimeout.current === null) {
+                previousTickTime.current = timer.now();
+                expectedTickTime.current =
+                    timer.now() + (resolution - (elapsedTime % resolution));
+                setIsRunning(true);
+                pauseTimeout.current = nextTick(elapsedTime);
+            }
+        },
+        [nextTick, resolution, time, timer]
+    );
+
+    const pause = useCallback(() => {
+        setIsRunning(false);
+        if (pauseTimeout.current) {
+            pauseTimeout.current();
+            pauseTimeout.current = null;
+        }
+    }, []);
+
+    const reset = useCallback(() => {
+        pause();
+        setTime(0);
+        start(0);
+    }, [pause, start]);
+
+    useEffect(
+        () => () => {
+            if (pauseTimeout.current) {
+                pauseTimeout.current();
+                pauseTimeout.current = null;
+            }
+        },
+        []
+    );
+
+    if (autoStart && !autoStarted.current) {
+        autoStarted.current = true;
+        start(0);
+    }
+
+    return {
+        ...splitMS(time),
+        start,
+        pause,
+        reset,
+        isRunning,
+    };
+};