ExerciseClient

open fun addDebouncedGoalToActiveExerciseAsync(debouncedGoal: DebouncedGoal<*>): ListenableFuture<Void>

Adds a DebouncedGoal for an active exercise.

DebouncedGoals apply to only sample data types (e.g. HeartRate, Speed) for active exercises owned by the client, and will be invalidated once the exercise is complete. Note: To add goals for Cumulative DataTypes (i.e. steps, distance...) please see addGoalToActiveExerciseAsync.

Before adding, DebouncedGoal should be checked for support against ExerciseTypeCapabilities.supportedDebouncedGoals. Only one DebouncedGoal is allowed per DataType+ComparisonType combination.

fun addGoalToActiveExerciseAsync(exerciseGoal: ExerciseGoal<*>): ListenableFuture<Void>

Adds an ExerciseGoal for an active exercise.

Goals apply to only active exercises owned by the client, and will be invalidated once the exercise is complete.

fun clearUpdateCallbackAsync(callback: ExerciseUpdateCallback): ListenableFuture<Void>

Clears the callback set using setUpdateCallback.

If this callback is not already registered then this will be a no-op.

fun endExerciseAsync(): ListenableFuture<Void>

Ends the current exercise, if it has been started.

Health Services will flush and then shut down the active sensors and return an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.USER_END to the ExerciseUpdateCallback. If the exercise has ended then this future will fail.

No additional metrics will be produced for the exercise and any on device persisted data about the exercise will be deleted after the summary has been sent back.

fun flushAsync(): ListenableFuture<Void>

Flushes the sensors for the active exercise. This call should be used sparingly and will be subject to throttling by Health Services.

fun getCapabilitiesAsync(): ListenableFuture<ExerciseCapabilities>

Returns the ExerciseCapabilities of this client for the device.

This can be used to determine what ExerciseTypes and DataTypes this device supports. Clients should use the capabilities to inform their requests since Health Services will typically reject requests made for DataTypes or features (such as auto-pause) which are not enabled for the rejected ExerciseType.

fun getCurrentExerciseInfoAsync(): ListenableFuture<ExerciseInfo>

Returns the current ExerciseInfo.

This can be used by clients to determine if they or another app already owns an active exercise being tracked by Health Services. For example, if an app is killed and it learns it owns the active exercise it can register a new ExerciseUpdateCallback and pick tracking up from where it left off.

fun markLapAsync(): ListenableFuture<Void>

Ends the current lap, calls ExerciseUpdateCallback.onLapSummaryReceived with data spanning the marked lap and starts a new lap. If the exercise supports laps this method can be called at any point after an exercise has been started and before it has been ended regardless of the exercise status.

The metrics in the lap summary will start from either the start time of the exercise or the last time a lap was marked to the time this method is being called.

If there's no exercise being tracked or if the exercise does not support laps then this future will fail.

fun overrideAutoPauseAndResumeForActiveExerciseAsync(enabled: Boolean): ListenableFuture<Void>

Enables or disables auto pause/resume for the current exercise.

fun overrideBatchingModesForActiveExerciseAsync(
    batchingModes: Set<BatchingMode>
): ListenableFuture<Void>

Sets the batching mode for the current exercise.

fun pauseExerciseAsync(): ListenableFuture<Void>

Pauses the current exercise, if it is currently started.

Before transitioning to ExerciseState.USER_PAUSED, Health Services will flush and return the sensor data. While the exercise is paused, active time and cumulative metrics such as distance will not accumulate. Instantaneous measurements such as speed and heart rate will continue to update if requested in the ExerciseConfig.

Note that GPS and other sensors may be stopped when the exercise is paused in order to conserve battery. This may happen immediately, or after some time. (The exact behavior is hardware dependent.) Should this happen, access will automatically resume when the exercise is resumed.

If the exercise is already paused then this method has no effect. If the exercise has ended then the returned future will fail.

fun prepareExerciseAsync(configuration: WarmUpConfig): ListenableFuture<Void>

Prepares for a new exercise.

Once called, Health Services will warmup the sensors based on the ExerciseType and requested DataTypes

If the calling app already has an active exercise in progress or if it does not have the required permissions, then this call returns a failed future. If another app owns the active exercise then this call will succeed.

Sensors available for warmup are GPS DataType.LOCATION and HeartRate DataType.HEART_RATE_BPM. Other DataTypes requested for warmup based on exercise capabilities will be a no-op for the prepare stage.

The DataType availability can be obtained through the ExerciseUpdateCallback.onAvailabilityChanged callback. ExerciseUpdates with the supported DataType DataPoint will also be returned in the ExerciseState.PREPARING state, though no aggregation will occur until the exercise is started.

If an app is actively preparing and another app starts tracking an active exercise then the preparing app should expect to receive an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.AUTO_END_SUPERSEDED to the ExerciseUpdateCallback indicating that their session has been superseded and ended. At that point no additional updates to availability or data will be sent until the app calls prepareExercise again.

open fun removeDebouncedGoalFromActiveExerciseAsync(
    debouncedGoal: DebouncedGoal<*>
): ListenableFuture<Void>

Removes a debounced goal from an active exercise.

fun removeGoalFromActiveExerciseAsync(exerciseGoal: ExerciseGoal<*>): ListenableFuture<Void>

Removes an exercise goal for an active exercise.

Takes into account equivalent milestones (i.e. milestones which are not equal but are different representation of a common milestone. e.g. milestone A for every 2kms, currently at threshold of 10kms, and milestone B for every 2kms, currently at threshold of 8kms).

fun resumeExerciseAsync(): ListenableFuture<Void>

Resumes the current exercise, if it is currently paused.

Once resumed active time and cumulative metrics such as distance will resume accumulating.

If the exercise has been started but is not currently paused this method has no effect. If the exercise has ended then the returned future will fail.

fun setUpdateCallback(callback: ExerciseUpdateCallback): Unit

Sets the callback for the current ExerciseUpdate.

This callback won't be called until the calling application prepares or starts an exercise. It will only receive updates from exercises tracked by this app.

If an exercise is in progress, the ExerciseUpdateCallback is immediately called with the associated ExerciseUpdate, and subsequently whenever the state is updated or an event is triggered. Health Services will cache ExerciseUpdates of an active exercise that are generated while a callback is not active (for example, due to the app getting killed) and deliver them as soon as the callback is registered again. If the client fails to maintain a live ExerciseUpdateCallback for at least five minutes during the duration of the exercise Health Services can decide to terminate the exercise automatically. If this occurs, clients can expect to receive an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.AUTO_END_MISSING_LISTENER to the ExerciseUpdateCallback indicating that their exercise has been automatically ended due to the lack of callback.

Calls to the callback will be executed on the main application thread. To control where to execute the callback, see the overload taking an Executor. To remove the callback use clearUpdateCallbackAsync.

fun setUpdateCallback(executor: Executor, callback: ExerciseUpdateCallback): Unit

Calls to the callback will be executed using the specified Executor. To execute the callback on the main application thread use the overload without the Executor.

fun startExerciseAsync(configuration: ExerciseConfig): ListenableFuture<Void>

Starts a new exercise.

Once started, Health Services will begin collecting data associated with the exercise.

Since Health Services only allows a single active exercise at a time, this will terminate any active exercise currently in progress before starting the new one. If this occurs, clients can expect to receive an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.AUTO_END_SUPERSEDED to the ExerciseUpdateCallback indicating that their exercise has been superseded and that no additional updates will be sent. Clients can use getCurrentExerciseInfoAsync (described below) to check if they or another app has an active exercise in-progress.

The exercise will be terminated and clients can expect to receive an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.AUTO_END_MISSING_LISTENER (indicating that their exercise has been automatically ended due to the lack of callback) if there is ever a five minute period where no ExerciseUpdateCallback is registered. A notable example is if the process with the registered ExerciseUpdateCallback dies and does not re-register the ExerciseUpdateCallback within five minutes.

Clients should only request ExerciseTypes, DataTypes, goals, and auto-pause enabled that matches the ExerciseCapabilities returned by getCapabilitiesAsync since Health Services will reject requests asking for unsupported configurations.

fun updateExerciseTypeConfigAsync(exerciseTypeConfig: ExerciseTypeConfig): ListenableFuture<Void>

Updates the configurable exercise type attributes for the current exercise.

This can be used to update the configurable attributes for the ongoing exercise, as defined in ExerciseTypeConfig. Minimum Exercise API version for this function is 3.

suspend fun ExerciseClient.addDebouncedGoalToActiveExercise(
    debouncedGoal: DebouncedGoal<*>
): Void

Adds a DebouncedGoal for an active exercise.

DebouncedGoals apply to only sample data types (e.g. HeartRate, Speed) for active exercises owned by the client, and will be invalidated once the exercise is complete. Note: To add goals for Cumulative DataTypes (i.e. steps, distance...) please see addGoalToActiveExerciseAsync.

Before adding, DebouncedGoal should be checked for support against ExerciseTypeCapabilities.supportedDebouncedGoals. Only one DebouncedGoal is allowed per DataType+ComparisonType pair.

suspend fun ExerciseClient.addGoalToActiveExercise(exerciseGoal: ExerciseGoal<*>): Void

Adds an ExerciseGoal for an active exercise.

Goals apply to only active exercises owned by the client, and will be invalidated once the exercise is complete.

suspend fun ExerciseClient.clearUpdateCallback(callback: ExerciseUpdateCallback): Void

Clears the callback set using ExerciseClient.setUpdateCallback.

If this callback is not already registered then this will be a no-op.

suspend fun ExerciseClient.endExercise(): Void

Ends the current exercise, if it has been started.

Health Services will flush and then shut down the active sensors and return an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.USER_END to the ExerciseUpdateCallback. If the exercise has already ended then this call fails with a HealthServicesException.

No additional metrics will be produced for the exercise and any on device persisted data about the exercise will be deleted after the summary has been sent back.

suspend fun ExerciseClient.flush(): Void

Flushes the sensors for the active exercise. This call should be used sparingly and will be subject to throttling by Health Services.

suspend fun ExerciseClient.getCapabilities(): ExerciseCapabilities

Returns the ExerciseCapabilities of this client for the device.

This can be used to determine what ExerciseTypes and DataTypes this device supports. Clients should use the capabilities to inform their requests since Health Services will typically reject requests made for DataTypes or features (such as auto-pause) which are not enabled for the rejected ExerciseType.

suspend fun ExerciseClient.getCurrentExerciseInfo(): ExerciseInfo

Returns the current ExerciseInfo.

This can be used by clients to determine if they or another app already owns an active exercise being tracked by Health Services. For example, if an app is killed and it learns it owns the active exercise it can register a new ExerciseUpdateCallback and pick tracking up from where it left off.

suspend fun ExerciseClient.markLap(): Void

Ends the current lap, calls ExerciseUpdateCallback.onLapSummaryReceived with data spanning the marked lap and starts a new lap. If the exercise supports laps this method can be called at any point after an exercise has been started and before it has been ended regardless of the exercise status.

The metrics in the lap summary will start from either the start time of the exercise or the last time a lap was marked to the time this method is being called.

suspend fun ExerciseClient.overrideAutoPauseAndResumeForActiveExercise(
    enabled: Boolean
): Void

Enables or disables auto pause/resume for the current exercise.

suspend fun ExerciseClient.overrideBatchingModesForActiveExercise(
    batchingModes: Set<BatchingMode>
): Void

Sets the batching mode for the current exercise synchronously.

suspend fun ExerciseClient.pauseExercise(): Void

Pauses the current exercise, if it is currently started.

Before transitioning to ExerciseState.USER_PAUSED, Health Services will flush and return the sensor data. While the exercise is paused, active time and cumulative metrics such as distance will not accumulate. Instantaneous measurements such as speed and heart rate will continue to update if requested in the ExerciseConfig.

Note that GPS and other sensors may be stopped when the exercise is paused in order to conserve battery. This may happen immediately, or after some time. (The exact behavior is hardware dependent.) Should this happen, access will automatically resume when the exercise is resumed.

If the exercise is already paused then this method has no effect. If the exercise has ended then HealthServicesException is thrown.

suspend fun ExerciseClient.prepareExercise(configuration: WarmUpConfig): Unit

Prepares for a new exercise.

Once called, Health Services will warmup the sensors based on the ExerciseType and requested DataTypes.

If the calling app already has an active exercise in progress or if it does not have the required permissions, then this call throws HealthServicesException. If another app owns the active exercise then this call will succeed.

Sensors available for warmup are GPS DataType.LOCATION and HeartRate DataType.HEART_RATE_BPM. Other DataTypes requested for warmup based on exercise capabilities will be a no-op for the prepare stage.

The DataType availability can be obtained through the ExerciseUpdateCallback.onAvailabilityChanged callback. ExerciseUpdates with the supported DataType DataPoint will also be returned in the ExerciseState.PREPARING state, though no aggregation will occur until the exercise is started.

If an app is actively preparing and another app starts tracking an active exercise then the preparing app should expect to receive an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.AUTO_END_SUPERSEDED to the ExerciseUpdateCallback indicating that their session has been superseded and ended. At that point no additional updates to availability or data will be sent until the app calls prepareExercise again.

suspend fun ExerciseClient.removeDebouncedGoalFromActiveExercise(
    debouncedGoal: DebouncedGoal<*>
): Void

Removes a debounced goal from an active exercise.

suspend fun ExerciseClient.removeGoalFromActiveExercise(
    exerciseGoal: ExerciseGoal<*>
): Void

Removes an exercise goal for an active exercise.

Takes into account equivalent milestones (i.e. milestones which are not equal but are different representation of a common milestone. e.g. milestone A for every 2kms, currently at threshold of 10kms, and milestone B for every 2kms, currently at threshold of 8kms).

suspend fun ExerciseClient.resumeExercise(): Void

Resumes the current exercise, if it is currently paused.

Once resumed active time and cumulative metrics such as distance will resume accumulating.

If the exercise has been started but is not currently paused this method has no effect. If the exercise has ended then HealthServicesException is thrown.

suspend fun ExerciseClient.startExercise(configuration: ExerciseConfig): Unit

Starts a new exercise.

Once started, Health Services will begin collecting data associated with the exercise.

Since Health Services only allows a single active exercise at a time, this will terminate any active exercise currently in progress before starting the new one. If this occurs, clients can expect to receive an ExerciseUpdate with ExerciseState.ENDED, indicating that their exercise has been superseded and that no additional updates will be sent. Clients can use getCurrentExerciseInfo (described below) to check if they or another app has an active exercise in-progress.

The exercise will be terminated and clients can expect to receive an ExerciseUpdate with ExerciseState.ENDED along with the reason ExerciseEndReason.AUTO_END_MISSING_LISTENER (indicating that their exercise has been automatically ended due to the lack of callback) if there is ever a five minute period where no ExerciseUpdateCallback is registered. A notable example is if the process with the registered ExerciseUpdateCallback dies and does not re-register the ExerciseUpdateCallback within five minutes.

Clients should only request ExerciseTypes, DataTypes, goals, and auto-pause enabled that matches the ExerciseCapabilities returned by getCapabilities since Health Services will reject requests asking for unsupported configurations.

suspend fun ExerciseClient.updateExerciseTypeConfig(
    exerciseTypeConfig: ExerciseTypeConfig
): Void

Updates the configurable exercise type attributes for the current exercise.

This can be used to update the configurable attributes for the ongoing exercise, as defined in ExerciseTypeConfig.