androidx.health.services.client

Interfaces

ExerciseClient

Client which provides a way to subscribe to the health data of a device during an exercise.
ExerciseUpdateCallback

Callback that is called when the state of the current exercise is updated.
HealthServicesClient

Client which provides a way to subscribe to the health data of a device, in the background or in the foreground.
MeasureCallback

Callback for MeasureClient.registerMeasureCallback.
MeasureClient

Client which provides a way to make measurements of health data on a device.
PassiveListenerCallback

A callback for receiving passive monitoring updates.
PassiveMonitoringClient

Client which provides a means to passively monitor data without requiring an ongoing workout.

Classes

PassiveListenerService

Service that enables receiving passive monitoring updates throughout the day when the app may not be running.

Exceptions

HealthServicesException

Exception class for all the Health Services errors.

Objects

HealthServices

Entry point for all Health Services APIs.

Extension functions summary

suspend Void

Adds a DebouncedGoal for an active exercise.
suspend Void

Adds an ExerciseGoal for an active exercise.
suspend T

Extension function on ListenableFuture performs ListenableFuture.await operation and if any exception thrown by the asynchronous API, converts android.os.RemoteException into HealthServicesException
suspend Void

Unregisters the subscription made by PassiveMonitoringClient.setPassiveListenerCallback.
suspend Void

Unregisters the subscription made by setPassiveListenerService.
suspend Void

Clears the callback set using ExerciseClient.setUpdateCallback.
suspend Void

Ends the current exercise, if it has been started.
suspend Void

Flushes the sensors for the active exercise.
suspend Void

Flushes the sensors for the registered DataTypes.
suspend ExerciseCapabilities

Returns the ExerciseCapabilities of this client for the device.
suspend MeasureCapabilities

Returns the MeasureCapabilities of this client for the device.
suspend PassiveMonitoringCapabilities

Returns the PassiveMonitoringCapabilities of this client for this device.
suspend ExerciseInfo

Returns the current ExerciseInfo.
suspend Void

Ends the current lap, calls ExerciseUpdateCallback.onLapSummaryReceived with data spanning the marked lap and starts a new lap.
suspend Void

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

Sets the batching mode for the current exercise synchronously.
suspend Void

Pauses the current exercise, if it is currently started.
suspend Unit

Prepares for a new exercise.
suspend Void

Removes a debounced goal from an active exercise.
suspend Void

Removes an exercise goal for an active exercise.
suspend Void

Resumes the current exercise, if it is currently paused.
suspend Void

Subscribes for updates to be periodically delivered to the app.
suspend Unit

Starts a new exercise.
suspend Void
MeasureClient.unregisterMeasureCallback(
    dataType: DeltaDataType<*, *>,
    callback: MeasureCallback
)

Unregisters the given MeasureCallback for updates of the given DeltaDataType.
suspend Void

Updates the configurable exercise type attributes for the current exercise.

Extension functions

addDebouncedGoalToActiveExercise

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.

Parameters
debouncedGoal: DebouncedGoal<*>

the DebouncedGoal to add to this exercise
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

addGoalToActiveExercise

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.

Parameters
exerciseGoal: ExerciseGoal<*>

the ExerciseGoal to add to this exercise
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

awaitWithException

suspend fun <T : Any?> ListenableFuture<T>.awaitWithException(): T

Extension function on ListenableFuture performs ListenableFuture.await operation and if any exception thrown by the asynchronous API, converts android.os.RemoteException into HealthServicesException

Throws
androidx.health.services.client.HealthServicesException

if remote operation fails

clearPassiveListenerCallback

suspend fun PassiveMonitoringClient.clearPassiveListenerCallback(): Void

Unregisters the subscription made by PassiveMonitoringClient.setPassiveListenerCallback.

Data will not be delivered after this call so if clients care about any pending batched data they should call flush before unregistering.

Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

clearPassiveListenerService

suspend fun PassiveMonitoringClient.clearPassiveListenerService(): Void

Unregisters the subscription made by setPassiveListenerService.

Data will not be delivered after this call so if clients care about any pending batched data they should call flush before unregistering.

Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

clearUpdateCallback

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.

Parameters
callback: ExerciseUpdateCallback

the ExerciseUpdateCallback to clear
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

endExercise

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.

Throws
androidx.health.services.client.HealthServicesException

if exercise has already ended or if Health Service fails to process the call

flush

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.

Throws
androidx.health.services.client.HealthServicesException

if the Health Service fails to process the request

flush

suspend fun PassiveMonitoringClient.flush(): Void

Flushes the sensors for the registered DataTypes.

If no listener has been registered by this client, this will be a no-op. This call should be used sparingly and will be subject to throttling by Health Services.

Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

getCapabilities

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.

Returns
ExerciseCapabilities

a the ExerciseCapabilities for this device
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

getCapabilities

suspend fun MeasureClient.getCapabilities(): MeasureCapabilities

Returns the MeasureCapabilities of this client for the device.

This can be used to determine what DeltaDataTypes this device supports for live measurement. Clients should use the capabilities to inform their requests since Health Services will typically reject requests made for DeltaDataTypes which are not enabled for measurement.

Returns
MeasureCapabilities

a MeasureCapabilities for this device
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

getCapabilities

suspend fun PassiveMonitoringClient.getCapabilities(): PassiveMonitoringCapabilities

Returns the PassiveMonitoringCapabilities of this client for this device.

This can be used to determine what DataTypes this device supports for passive monitoring and goals. Clients should use the capabilities to inform their requests since Health Services will typically reject requests made for DataTypes which are not supported.

Returns
PassiveMonitoringCapabilities

a PassiveMonitoringCapabilities for this device
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

getCurrentExerciseInfo

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.

Returns
ExerciseInfo

a ExerciseInfo that contains information about the current exercise
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

markLap

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.

Throws
androidx.health.services.client.HealthServicesException

If there's no exercise being tracked or if Health Service fails to process the call

overrideAutoPauseAndResumeForActiveExercise

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

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

Parameters
enabled: Boolean

a boolean to indicate if should be enabled or disabled
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

overrideBatchingModesForActiveExercise

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

Sets the batching mode for the current exercise synchronously.

Parameters
batchingModes: Set<BatchingMode>

BatchingMode overrides for exercise updates. Passing an empty set will clear all existing overrides.
Throws
androidx.health.services.client.HealthServicesException

if an exercise is not active for this app or Health Service fails to process the call

pauseExercise

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.

Throws
androidx.health.services.client.HealthServicesException

if the exercise has ended or if Health Service fails to process the call

prepareExercise

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.

Parameters
configuration: WarmUpConfig

the WarmUpConfig containing the desired exercise and data types
Throws
androidx.health.services.client.HealthServicesException

if the calling app already has an active exercise in progress or if Health Service fails to process the call
java.lang.SecurityException

if the calling app does not have the required permissions

removeDebouncedGoalFromActiveExercise

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

Removes a debounced goal from an active exercise.

Parameters
debouncedGoal: DebouncedGoal<*>

the DebouncedGoal to remove from this exercise
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

removeGoalFromActiveExercise

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).

Parameters
exerciseGoal: ExerciseGoal<*>

the ExerciseGoal to remove from this exercise
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

resumeExercise

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.

Throws
androidx.health.services.client.HealthServicesException

if the exercise has ended or if Health Service fails to process the call

setPassiveListenerService

suspend fun PassiveMonitoringClient.setPassiveListenerService(
    service: Class<PassiveListenerService>,
    config: PassiveListenerConfig
): Void

Subscribes for updates to be periodically delivered to the app.

Data updates will be batched and delivered from the point of initial registration and will continue to be delivered until the DataType is unregistered, either by explicitly calling clearPassiveListenerService or by registering again without that DataType included in the request. Higher frequency updates are available through ExerciseClient or MeasureClient. Any requested goal, user activity, or health event updates will not be batched.

Health Services will automatically bind to the provided PassiveListenerService to send the update. Clients are responsible for defining the service in their app manifest. They should also require the com.google.android.wearable.healthservices.permission.PASSIVE_DATA_BINDING permission in their app manifest service definition in order to ensure that Health Services is the source of the binding.

This registration is unique per subscribing app. Subsequent registrations will replace the previous registration, if one had been made. The client is responsible for ensuring that their requested PassiveListenerConfig is supported on this device by checking the PassiveMonitoringCapabilities. The returned future will fail if the request is not supported on the current device or the client does not have the required permissions for the request.

Parameters
service: Class<PassiveListenerService>

the PassiveListenerService to bind to
config: PassiveListenerConfig

the PassiveListenerConfig from the client
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call
java.lang.SecurityException

if calling app does not have the required permissions

startExercise

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.

Parameters
configuration: ExerciseConfig

the ExerciseConfig describing this exercise
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call
java.lang.SecurityException

if the calling app does not have the required permissions

unregisterMeasureCallback

suspend fun MeasureClient.unregisterMeasureCallback(
    dataType: DeltaDataType<*, *>,
    callback: MeasureCallback
): Void

Unregisters the given MeasureCallback for updates of the given DeltaDataType.

Parameters
dataType: DeltaDataType<*, *>

the DeltaDataType that needs to be unregistered
callback: MeasureCallback

the MeasureCallback which was used in registration
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call

updateExerciseTypeConfig

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.

Parameters
exerciseTypeConfig: ExerciseTypeConfig

configuration containing the new values for the configurable attributes
Throws
androidx.health.services.client.HealthServicesException

if Health Service fails to process the call