incyclist-services 1.7.95 → 1.7.97

package/lib/cjs/ride/page/service.js

@@ -40,9 +40,16 @@ const decorators_1 = require("../../base/decorators");
 const pages_1 = require("../../base/pages");
 const display_1 = require("../display");
 const sleep_1 = require("../../utils/sleep");
-const api_1 = require("../../api");
 const monitoring_1 = require("../../monitoring");
+const activities_1 = require("../../activities");
+const settings_1 = require("../../settings");
+const service_1 = require("../../workouts/ride/service");
+const graph_1 = require("../../workouts/base/graph");
 const BACKGROUND_PAUSE_TIMEOUT_MS = 300000;
+const UPCOMING_STEPS_COUNT = 3;
+const DEFAULT_LOAD_INCREMENT = 1;
+const HINTS_WORKOUT_GESTURES_KEY = 'hints.workoutRideGestures';
+const LOAD_INCREMENT_SETTING_KEY = 'preferences.workouts.loadIncrement';
 let RidePageService = (() => {
     let _classDecorators = [decorators_1.Singleton];
     let _classDescriptor;
@@ -51,17 +58,23 @@ let RidePageService = (() => {
     let _classSuper = pages_1.IncyclistPageService;
     let _instanceExtraInitializers = [];
     let _getRideDisplay_decorators;
-    let _getindings_decorators;
+    let _getWorkoutRide_decorators;
+    let _getActivityRide_decorators;
+    let _getUserSettings_decorators;
     let _getOnlineStatusMonitoring_decorators;
     var RidePageService = class extends _classSuper {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getRideDisplay_decorators = [decorators_1.Injectable];
-            _getindings_decorators = [decorators_1.Injectable];
+            _getWorkoutRide_decorators = [decorators_1.Injectable];
+            _getActivityRide_decorators = [decorators_1.Injectable];
+            _getUserSettings_decorators = [decorators_1.Injectable];
             _getOnlineStatusMonitoring_decorators = [decorators_1.Injectable];
             __esDecorate(this, null, _getRideDisplay_decorators, { kind: "method", name: "getRideDisplay", static: false, private: false, access: { has: obj => "getRideDisplay" in obj, get: obj => obj.getRideDisplay }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _getindings_decorators, { kind: "method", name: "getindings", static: false, private: false, access: { has: obj => "getindings" in obj, get: obj => obj.getindings }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getWorkoutRide_decorators, { kind: "method", name: "getWorkoutRide", static: false, private: false, access: { has: obj => "getWorkoutRide" in obj, get: obj => obj.getWorkoutRide }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getActivityRide_decorators, { kind: "method", name: "getActivityRide", static: false, private: false, access: { has: obj => "getActivityRide" in obj, get: obj => obj.getActivityRide }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getUserSettings_decorators, { kind: "method", name: "getUserSettings", static: false, private: false, access: { has: obj => "getUserSettings" in obj, get: obj => obj.getUserSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getOnlineStatusMonitoring_decorators, { kind: "method", name: "getOnlineStatusMonitoring", static: false, private: false, access: { has: obj => "getOnlineStatusMonitoring" in obj, get: obj => obj.getOnlineStatusMonitoring }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             RidePageService = _classThis = _classDescriptor.value;
@@ -69,15 +82,24 @@ let RidePageService = (() => {
             __runInitializers(_classThis, _classExtraInitializers);
         }
         eventHandler = (__runInitializers(this, _instanceExtraInitializers), {});
+        workoutEventHandler = {};
+        workoutObserverSubscribed = false;
         backgroundTimer;
         backgroundPausedByService = false;
         menuProps = null;
         isInitialized = false;
         startGateProps = null;
+        gestureHintDismissed = false;
         constructor() {
             super('RidePage');
             this.eventHandler['state-update'] = this.onDisplayStateUpdate.bind(this);
             this.eventHandler['route-update'] = this.onRouteUpdate.bind(this);
+            this.workoutEventHandler['step-changed'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['update'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['forward'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['backward'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['completed'] = this.onWorkoutFinished.bind(this);
+            this.workoutEventHandler['stopped'] = this.onWorkoutFinished.bind(this);
         }
         async initPage() {
             try {
@@ -92,19 +114,24 @@ let RidePageService = (() => {
         }
         openPage(simulate) {
             try {
-                this.logEvent({ message: 'page shown', page: 'Rides' });
-                gd_eventlog_1.EventLogger.setGlobalConfig('page', 'Rides');
+                const pageLogName = this.getPageLogName();
+                this.logEvent({ message: 'page shown', page: pageLogName });
+                gd_eventlog_1.EventLogger.setGlobalConfig('page', pageLogName);
+                this.gestureHintDismissed = false;
                 super.openPage();
                 try {
                     const service = this.getRideDisplay();
                     const registerAndStart = () => {
-                        this.registerEventHandlers();
+                        this.registerHandlers(this.rideObserver, this.eventHandler);
+                        this.subscribeToWorkoutObserver();
                         service.start(simulate);
-                        (0, sleep_1.sleep)(5).then(() => {
-                            this.updatePageDisplay();
-                        });
+                        if (this.isRideType('Video', 'GPX')) {
+                            (0, sleep_1.sleep)(5).then(() => {
+                                this.updatePageDisplay();
+                            });
+                        }
                     };
-                    if (!this.isInitialized) {
+                    if (this.requiresOwnInit() && !this.isInitialized) {
                         service.init()
                             .then(() => {
                             this.isInitialized = true;
@@ -129,8 +156,10 @@ let RidePageService = (() => {
         closePage() {
             try {
                 gd_eventlog_1.EventLogger.setGlobalConfig('page', null);
-                this.logEvent({ message: 'page closed', page: 'Rides' });
+                this.logEvent({ message: 'page closed', page: this.getPageLogName() });
                 this.getRideDisplay().stop();
+                this.unregisterHandlers(this.rideObserver, this.eventHandler);
+                this.unsubscribeFromWorkoutObserver();
                 this.menuProps = null;
                 this.isInitialized = false;
                 super.closePage();
@@ -142,7 +171,7 @@ let RidePageService = (() => {
         async pausePage() {
             try {
                 this.backgroundTimer = setTimeout(() => {
-                    this.getRideDisplay().pause('user');
+                    this.getRideDisplay().pause(this.getBackgroundPauseRequester());
                     this.backgroundPausedByService = true;
                 }, BACKGROUND_PAUSE_TIMEOUT_MS);
                 this.isInitialized = false;
@@ -166,63 +195,13 @@ let RidePageService = (() => {
         getRideObserver() {
             return this.rideObserver ?? null;
         }
-        getPageDisplayProps() {
-            const startOverlayProps = this.getRideDisplay().getStartOverlayProps();
-            const noRideProps = {
-                rideState: 'Error',
-                startOverlayProps,
-                rideType: null,
-                menuProps: null,
-                startGateProps: null
-            };
-            try {
-                const rideType = this.getRideDisplay().getRideType();
-                switch (rideType) {
-                    case 'Video': return this.getVideoRideDisplayProps();
-                    case 'GPX': return this.getGPXRideDisplayProps();
-                    default:
-                        return noRideProps;
-                }
-            }
-            catch {
-                return noRideProps;
-            }
-        }
-        onRefreshSecrets() {
-            this.hideStartgate();
-        }
-        onContinueAnyway() {
-            this.hideStartgate();
-        }
-        onMenuOpen() {
-            try {
-                const state = this.getRideDisplay().getState();
-                this.menuProps = { showResume: state === 'Paused' };
-                this.updatePageDisplay();
-            }
-            catch (err) {
-                this.logError(err, 'onMenuOpen');
-            }
-        }
-        onMenuClose() {
-            try {
-                const state = this.getRideDisplay().getState();
-                if (state === 'Finished' || this.menuProps?.finished) {
-                    this.moveToPreviousPage();
-                    this.closePage();
-                    return;
-                }
-                this.menuProps = null;
-                this.updatePageDisplay();
-            }
-            catch (err) {
-                this.logError(err, 'onMenuClose');
-            }
+        getRideType() {
+            return this.getRideDisplay().getRideType();
         }
         onPause() {
             try {
                 this.getRideDisplay().pause('user');
-                this.menuProps = { showResume: true };
+                this.menuProps = this.buildPausedMenuProps();
                 this.updatePageDisplay();
             }
             catch (err) {
@@ -239,25 +218,6 @@ let RidePageService = (() => {
                 this.logError(err, 'onResume');
             }
         }
-        onFinished() {
-            try {
-                this.menuProps = { showResume: false, finished: true };
-                this.updatePageDisplay();
-            }
-            catch (err) {
-                this.logError(err, 'onResume');
-            }
-        }
-        onEndRide() {
-            try {
-                this.getRideDisplay().stop();
-                this.moveToPreviousPage();
-                this.closePage();
-            }
-            catch (err) {
-                this.logError(err, 'onEndRide');
-            }
-        }
         onRetryStart() {
             try {
                 this.getRideDisplay().retryStart();
@@ -288,17 +248,81 @@ let RidePageService = (() => {
                 this.logError(err, 'onCancelStart');
             }
         }
+        onMenuOpen() {
+            try {
+                const state = this.getRideDisplay().getState();
+                this.menuProps = this.isRideType('Workout')
+                    ? { showResume: state === 'Paused', ...this.getStepFlags() }
+                    : { showResume: state === 'Paused' };
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onMenuOpen');
+            }
+        }
+        onMenuClose() {
+            try {
+                if (this.isRideType('Workout')) {
+                    this.menuProps = null;
+                    this.updatePageDisplay();
+                    return;
+                }
+                const state = this.getRideDisplay().getState();
+                if (state === 'Finished' || this.menuProps?.finished) {
+                    this.moveToPreviousPage();
+                    this.closePage();
+                    return;
+                }
+                this.menuProps = null;
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onMenuClose');
+            }
+        }
+        getPageDisplayProps() {
+            const startOverlayProps = this.getRideDisplay().getStartOverlayProps();
+            const noRideProps = {
+                rideState: 'Error',
+                startOverlayProps,
+                rideType: null,
+                menuProps: null,
+                startGateProps: null
+            };
+            try {
+                const rideType = this.getRideDisplay().getRideType();
+                switch (rideType) {
+                    case 'Video': return this.getVideoRideDisplayProps();
+                    case 'GPX': return this.getGPXRideDisplayProps();
+                    case 'Workout': return this.getWorkoutRideDisplayProps();
+                    default:
+                        return noRideProps;
+                }
+            }
+            catch {
+                return noRideProps;
+            }
+        }
+        onRefreshSecrets() {
+            this.hideStartgate();
+        }
+        onContinueAnyway() {
+            this.hideStartgate();
+        }
+        onEndRide() {
+            try {
+                this.getRideDisplay().stop();
+                this.moveToPreviousPage();
+                this.closePage();
+            }
+            catch (err) {
+                this.logError(err, 'onEndRide');
+            }
+        }
         getVideoRideDisplayProps() {
             const props = this.rideDisplayProps;
-            const state = this.getRideDisplay().getState();
-            const rideType = this.getRideDisplay().getRideType();
-            const isStarting = state === 'Idle' || state === 'Starting' || state === 'Error';
             const displayProps = {
-                rideState: state,
-                rideType,
-                startGateProps: this.startGateProps,
-                startOverlayProps: isStarting ? this.getRideDisplay().getStartOverlayProps() : null,
-                menuProps: this.menuProps,
+                ...this.buildBaseDisplayProps(),
                 video: props.video,
                 videos: props.videos,
                 route: props.route
@@ -307,15 +331,8 @@ let RidePageService = (() => {
         }
         getGPXRideDisplayProps() {
             const props = this.rideDisplayProps;
-            const state = this.getRideDisplay().getState();
-            const rideType = this.getRideDisplay().getRideType();
-            const isStarting = state === 'Idle' || state === 'Starting' || state === 'Error';
             const displayProps = {
-                rideState: state,
-                rideType,
-                startGateProps: this.startGateProps,
-                startOverlayProps: isStarting ? this.getRideDisplay().getStartOverlayProps() : null,
-                menuProps: this.menuProps,
+                ...this.buildBaseDisplayProps(),
                 rideView: props.rideView,
                 route: props.route,
                 displayObserver: props.displayObserver
@@ -342,36 +359,351 @@ let RidePageService = (() => {
             this.startGateProps = null;
             this.updatePageDisplay();
         }
-        getRideType() {
-            return this.getRideDisplay().getRideType();
+        onRouteUpdate() {
+            this.updatePageDisplay();
         }
-        updatePageDisplay() {
-            this.getPageObserver()?.emit('page-update');
+        get rideDisplayProps() {
+            return this.getRideDisplay().getDisplayProperties();
+        }
+        getSecretBinding() {
+            return this.getBindings().secret;
+        }
+        getGraphActuals() {
+            try {
+                const state = this.getRideDisplay().getState();
+                if (state === 'Idle' || state === 'Starting' || state === 'Started') {
+                    return { power: [], heartrate: [], position: 0 };
+                }
+                const logs = this.getActivityRide().getActivity()?.logs ?? [];
+                const power = [];
+                const heartrate = [];
+                logs.forEach(log => {
+                    if (log.power !== undefined)
+                        power.push({ x: log.time, y: log.power });
+                    if (log.heartrate !== undefined)
+                        heartrate.push({ x: log.time, y: log.heartrate });
+                });
+                return { power, heartrate, position: this.getElapsedActivityTime() };
+            }
+            catch (err) {
+                this.logError(err, 'getGraphActuals');
+                return { power: [], heartrate: [], position: 0 };
+            }
+        }
+        onStop() {
+            try {
+                this.finishRide();
+            }
+            catch (err) {
+                this.logError(err, 'onStop');
+            }
+        }
+        onStepBack() {
+            try {
+                this.getRideDisplay().backward();
+            }
+            catch (err) {
+                this.logError(err, 'onStepBack');
+            }
+        }
+        onStepForward() {
+            try {
+                this.getRideDisplay().forward();
+            }
+            catch (err) {
+                this.logError(err, 'onStepForward');
+            }
+        }
+        onIncreaseLoad() {
+            this.adjustLoad(this.getLoadIncrement());
         }
-        registerEventHandlers() {
-            const events = Object.keys(this.eventHandler);
-            events.forEach(event => { this.rideObserver?.on(event, this.eventHandler[event]); });
+        onDecreaseLoad() {
+            this.adjustLoad(-this.getLoadIncrement());
+        }
+        onSetLoadIncrement(value) {
+            try {
+                this.getUserSettings().set(LOAD_INCREMENT_SETTING_KEY, value);
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onSetLoadIncrement');
+            }
         }
-        unregisterEventHandlers() {
-            const events = Object.keys(this.eventHandler);
-            events.forEach(event => { this.rideObserver?.off(event, this.eventHandler[event]); });
+        onGestureHintDismissed({ dontShowAgain }) {
+            try {
+                this.gestureHintDismissed = true;
+                if (dontShowAgain) {
+                    this.getUserSettings().set(HINTS_WORKOUT_GESTURES_KEY, true);
+                }
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onGestureHintDismissed');
+            }
+        }
+        adjustLoad(deltaPct) {
+            try {
+                if (deltaPct >= 0)
+                    return this.getWorkoutRide().powerUp(deltaPct);
+                else
+                    return this.getWorkoutRide().powerDown(-deltaPct);
+            }
+            catch (err) {
+                this.logError(err, 'adjustLoad');
+                return undefined;
+            }
+        }
+        getLoadButtonMode() {
+            try {
+                return this.getWorkoutRide().getLoadButtonMode();
+            }
+            catch (err) {
+                this.logError(err, 'getLoadButtonMode');
+                return 'power';
+            }
+        }
+        getWorkoutRideDisplayProps() {
+            try {
+                const rideType = this.getRideDisplay().getRideType();
+                if (rideType !== 'Workout') {
+                    this.logError(new Error(`unexpected ride type '${rideType}' for WorkoutRidePage`), 'getWorkoutRideDisplayProps');
+                    return this.getEmptyWorkoutDisplayProps();
+                }
+                const base = this.buildBaseDisplayProps();
+                const wo = this.getWorkoutRide().getDashboardDisplayProperties();
+                const current = this.getRideDisplay().getDisplayProperties().workout;
+                return {
+                    ...base,
+                    menuProps: base.menuProps,
+                    title: wo.title ?? '',
+                    graph: this.buildGraphPlan(current, wo.ftp),
+                    steps: this.buildUpcomingSteps(current, wo.ftp),
+                    dashboard: this.buildDashboardLine(wo),
+                    gestureHint: this.buildGestureHint(base.startOverlayProps === null),
+                    loadIncrement: this.getLoadIncrement(),
+                    loadButtonMode: wo.loadButtonMode ?? 'power'
+                };
+            }
+            catch (err) {
+                this.logError(err, 'getWorkoutRideDisplayProps');
+                return this.getEmptyWorkoutDisplayProps();
+            }
+        }
+        onWorkoutUpdate() {
+            this.updatePageDisplay();
+        }
+        onWorkoutFinished() {
+            try {
+                this.menuProps = this.buildFinishedMenuProps();
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onWorkoutFinished');
+            }
+        }
+        finishRide() {
+            this.getRideDisplay().stop(true);
+            this.onWorkoutFinished();
+        }
+        subscribeToWorkoutObserver() {
+            if (!this.isRideType('Workout') || this.workoutObserverSubscribed)
+                return;
+            const observer = this.getWorkoutRide().getObserver();
+            if (!observer)
+                return;
+            this.registerHandlers(observer, this.workoutEventHandler);
+            this.workoutObserverSubscribed = true;
+        }
+        unsubscribeFromWorkoutObserver() {
+            if (!this.workoutObserverSubscribed)
+                return;
+            this.unregisterHandlers(this.getWorkoutRide().getObserver(), this.workoutEventHandler);
+            this.workoutObserverSubscribed = false;
+        }
+        buildGestureHint(startOverlayCleared) {
+            if (this.gestureHintDismissed || !startOverlayCleared)
+                return null;
+            if (this.getElapsedActivityTime() !== 0 || this.getCurrentCadence() !== 0)
+                return null;
+            if (this.getUserSettings().get(HINTS_WORKOUT_GESTURES_KEY, false))
+                return null;
+            return { visible: true };
+        }
+        getCurrentCadence() {
+            return this.getActivityRide().getCurrentValues?.()?.cadence ?? 0;
+        }
+        getLoadIncrement() {
+            return this.getUserSettings().get(LOAD_INCREMENT_SETTING_KEY, DEFAULT_LOAD_INCREMENT);
+        }
+        buildGraphPlan(current, ftp) {
+            if (!current) {
+                return { bars: [], ftp: ftp ?? 0, ftpLine: ftp ?? 0, domain: { x: [0, 0], y: [0, 0] } };
+            }
+            const bars = (0, graph_1.getWorkoutGraphSeries)(current, { ftp, absValues: true });
+            const lastBarX = bars.length ? bars.at(-1).x : 0;
+            const maxXCandidates = [this.getLastLogTime(), lastBarX, current.duration ?? 0].filter(Number.isFinite);
+            const maxX = maxXCandidates.length ? Math.max(...maxXCandidates) : 0;
+            const maxBarPower = bars.length ? Math.max(...bars.map(b => b.y)) : 0;
+            return {
+                bars,
+                ftp,
+                ftpLine: ftp,
+                domain: { x: [0, maxX], y: [0, maxBarPower * 1.1] }
+            };
+        }
+        buildUpcomingSteps(current, ftp) {
+            const empty = { previous: null, current: null, upcoming: [], hasMore: false };
+            if (!current)
+                return empty;
+            const limits = this.getWorkoutRide().getCurrentLimits();
+            if (!limits)
+                return empty;
+            const currentStep = {
+                label: (0, graph_1.getStepTargetText)(limits.step ?? {}, ftp),
+                targetPower: limits.targetPower ?? null,
+                duration: limits.duration,
+                remaining: limits.remaining,
+                isCurrent: true
+            };
+            const elapsedTime = this.getElapsedActivityTime();
+            const flattened = (0, graph_1.getFlattenedSteps)(current);
+            const currentIndex = flattened.findIndex(s => s.start <= elapsedTime && s.end > elapsedTime);
+            const toDisplay = (entry) => ({
+                label: (0, graph_1.getStepTargetText)(entry.step, ftp),
+                targetPower: this.getStepAbsolutePower(entry.step, ftp),
+                duration: entry.duration,
+                remaining: null,
+                isCurrent: false
+            });
+            if (currentIndex === -1)
+                return { previous: null, current: currentStep, upcoming: [], hasMore: false };
+            const previous = currentIndex > 0 ? toDisplay(flattened[currentIndex - 1]) : null;
+            const upcomingEntries = flattened.slice(currentIndex + 1, currentIndex + 1 + UPCOMING_STEPS_COUNT);
+            const upcoming = upcomingEntries.map(toDisplay);
+            const hasMore = currentIndex + 1 + UPCOMING_STEPS_COUNT < flattened.length;
+            return { previous, current: currentStep, upcoming, hasMore };
+        }
+        buildDashboardLine(wo) {
+            const limits = this.getWorkoutRide().getCurrentLimits();
+            const title = wo.title ?? '';
+            if (!limits)
+                return { text: title, mode: wo.mode ?? null };
+            const target = (0, graph_1.getStepTargetText)(limits.step ?? {}, wo.ftp);
+            const duration = (0, graph_1.getStepDuration)({ duration: limits.duration });
+            const base = `${target} for ${duration}`;
+            let text = base;
+            if (title && title !== base)
+                text = title.startsWith('(') ? `${base}${title}` : `${base} - ${title}`;
+            return { text, mode: wo.mode ?? null };
+        }
+        getStepAbsolutePower(step, ftp) {
+            const p = step.power;
+            if (!p)
+                return null;
+            const val = p.max ?? p.min;
+            if (val === undefined)
+                return null;
+            if (p.type === 'watt')
+                return Math.round(val);
+            if (ftp === undefined)
+                return null;
+            return Math.round(val / 100 * ftp);
+        }
+        getStepFlags() {
+            const wo = this.getWorkoutRide().getDashboardDisplayProperties();
+            return { canStepBack: !!wo.canShowBackward, canStepForward: !!wo.canShowForward };
+        }
+        getLastLogTime() {
+            const logs = this.getActivityRide().getActivity()?.logs;
+            if (!logs || logs.length === 0)
+                return 0;
+            return logs.at(-1).time ?? 0;
+        }
+        getElapsedActivityTime() {
+            return this.getActivityRide().getActivity()?.time ?? 0;
+        }
+        getEmptyWorkoutDisplayProps() {
+            return {
+                rideState: 'Error',
+                rideType: null,
+                startOverlayProps: null,
+                menuProps: null,
+                startGateProps: null,
+                title: '',
+                graph: { bars: [], ftp: 0, ftpLine: 0, domain: { x: [0, 0], y: [0, 0] } },
+                steps: { previous: null, current: null, upcoming: [], hasMore: false },
+                dashboard: { text: '', mode: null },
+                gestureHint: null,
+                loadIncrement: DEFAULT_LOAD_INCREMENT,
+                loadButtonMode: 'power'
+            };
+        }
+        getPageLogName() {
+            return this.isRideType('Workout') ? 'WorkoutRide' : 'Rides';
+        }
+        requiresOwnInit() {
+            return !this.isRideType('Workout');
+        }
+        getBackgroundPauseRequester() {
+            return this.isRideType('Workout') ? 'device' : 'user';
+        }
+        isRideType(...types) {
+            try {
+                return types.includes(this.getRideDisplay().getRideType());
+            }
+            catch {
+                return false;
+            }
+        }
+        buildPausedMenuProps() {
+            return this.isRideType('Workout')
+                ? { showResume: true, ...this.getStepFlags() }
+                : { showResume: true };
+        }
+        buildFinishedMenuProps() {
+            return this.isRideType('Workout')
+                ? { showResume: false, finished: true, canStepBack: false, canStepForward: false }
+                : { showResume: false, finished: true };
+        }
+        buildBaseDisplayProps() {
+            const state = this.getRideDisplay().getState();
+            const isStarting = state === 'Idle' || state === 'Starting' || state === 'Error';
+            return {
+                rideState: state,
+                rideType: this.getRideDisplay().getRideType(),
+                startOverlayProps: isStarting ? this.getRideDisplay().getStartOverlayProps() : null,
+                menuProps: this.menuProps,
+                startGateProps: this.startGateProps
+            };
         }
         onDisplayStateUpdate(state) {
+            this.subscribeToWorkoutObserver();
             switch (state) {
                 case 'Paused':
-                    this.menuProps = { showResume: true };
+                    this.menuProps = this.buildPausedMenuProps();
                     break;
                 case 'Finished':
-                    this.menuProps = { showResume: false, finished: true };
-                    break;
+                    this.menuProps = this.buildFinishedMenuProps();
+                    this.updatePageDisplay();
+                    return;
                 case 'Active':
                     this.menuProps = null;
                     break;
             }
             this.updatePageDisplay();
         }
-        onRouteUpdate() {
-            this.updatePageDisplay();
+        updatePageDisplay() {
+            this.getPageObserver()?.emit('page-update');
+        }
+        registerHandlers(observer, map) {
+            if (!observer)
+                return;
+            Object.keys(map).forEach(event => { observer.on(event, map[event]); });
+        }
+        unregisterHandlers(observer, map) {
+            if (!observer)
+                return;
+            Object.keys(map).forEach(event => { observer.off(event, map[event]); });
         }
         moveToPreviousPage() {
             this.moveTo('$contentPage');
@@ -385,17 +717,17 @@ let RidePageService = (() => {
             }
             return null;
         }
-        get rideDisplayProps() {
-            return this.getRideDisplay().getDisplayProperties();
-        }
         getRideDisplay() {
             return (0, display_1.useRideDisplay)();
         }
-        getSecretBinding() {
-            return this.getBindings().secret;
+        getWorkoutRide() {
+            return (0, service_1.useWorkoutRide)();
+        }
+        getActivityRide() {
+            return (0, activities_1.useActivityRide)();
         }
-        getindings() {
-            return (0, api_1.getBindings)();
+        getUserSettings() {
+            return (0, settings_1.useUserSettings)();
         }
         getOnlineStatusMonitoring() {
             return (0, monitoring_1.useOnlineStatusMonitoring)();
@@ -404,5 +736,7 @@ let RidePageService = (() => {
     return RidePageService = _classThis;
 })();
 exports.RidePageService = RidePageService;
-const getRidePageService = () => new RidePageService();
+const getRidePageService = () => {
+    return new RidePageService();
+};
 exports.getRidePageService = getRidePageService;