CompanionDeviceManager

EXTRA_ASSOCIATION

static val EXTRA_ASSOCIATION: String

Extra field name for the AssociationInfo object, included into android.content.Intent which application receive in Activity#onActivityResult(int, int, Intent) after the application's AssociationRequest was successfully processed and an association was created.

Value: "android.companion.extra.ASSOCIATION"

EXTRA_DEVICE

static val EXTRA_DEVICE: String

Deprecated: use AssociationInfo#getAssociatedDevice() instead.

A device, returned in the activity result of the IntentSender received in Callback#onDeviceFound Type is:

• for classic Bluetooth - android.bluetooth.BluetoothDevice
• for Bluetooth LE - android.bluetooth.le.ScanResult
• for WiFi - android.net.wifi.ScanResult

Value: "android.companion.extra.DEVICE"

FLAG_CALL_METADATA

static val FLAG_CALL_METADATA: Int

Used by enableSystemDataSyncForTypes(int,int)}. Sync call metadata like muting, ending and silencing a call.

Value: 1

RESULT_CANCELED

static val RESULT_CANCELED: Int

The result code to propagate back to the user activity, indicates if the association dialog is implicitly cancelled. E.g. phone is locked, switch to another app or press outside the dialog.

Value: 0

RESULT_DISCOVERY_TIMEOUT

static val RESULT_DISCOVERY_TIMEOUT: Int

The result code to propagate back to the user activity, indicates the association dialog is dismissed if there's no device found after 20 seconds.

Value: 2

RESULT_INTERNAL_ERROR

static val RESULT_INTERNAL_ERROR: Int

The result code to propagate back to the user activity, indicates the internal error in CompanionDeviceManager.

Value: 3

RESULT_OK

static val RESULT_OK: Int

The result code to propagate back to the user activity, indicates the association is created successfully.

Value: -1

RESULT_USER_REJECTED

static val RESULT_USER_REJECTED: Int

The result code to propagate back to the user activity, indicates the association dialog is explicitly declined by the users.

Value: 1

associate

fun associate(
    request: AssociationRequest, 
    callback: CompanionDeviceManager.Callback, 
    handler: Handler?
): Unit

Request to associate this app with a companion device.

Note that before creating establishing association the system may need to show UI to collect user confirmation.

If the app needs to be excluded from battery optimizations (run in the background) or to have unrestricted data access (use data in the background) it should declare use of android.Manifest.permission#REQUEST_COMPANION_RUN_IN_BACKGROUND and android.Manifest.permission#REQUEST_COMPANION_USE_DATA_IN_BACKGROUND in its AndroidManifest.xml respectively. Note that these special capabilities have a negative effect on the device's battery and user's data usage, therefore you should request them when absolutely necessary.

Application can use getMyAssociations() for retrieving the list of currently AssociationInfo objects, that represent their existing associations. Applications can also use disassociate(int) to remove an association, and are recommended to do when an association is no longer relevant to avoid unnecessary battery and/or data drain resulting from special privileges that the association provides

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

associate

fun associate(
    request: AssociationRequest, 
    executor: Executor, 
    callback: CompanionDeviceManager.Callback
): Unit

Request to associate this app with a companion device.

Note that before creating establishing association the system may need to show UI to collect user confirmation.

If the app needs to be excluded from battery optimizations (run in the background) or to have unrestricted data access (use data in the background) it should declare use of android.Manifest.permission#REQUEST_COMPANION_RUN_IN_BACKGROUND and android.Manifest.permission#REQUEST_COMPANION_USE_DATA_IN_BACKGROUND in its AndroidManifest.xml respectively. Note that these special capabilities have a negative effect on the device's battery and user's data usage, therefore you should request them when absolutely necessary.

Application can use getMyAssociations() for retrieving the list of currently AssociationInfo objects, that represent their existing associations. Applications can also use disassociate(int) to remove an association, and are recommended to do when an association is no longer relevant to avoid unnecessary battery and/or data drain resulting from special privileges that the association provides

Note that if you use this api to associate with a Bluetooth device, please make sure to cancel your own Bluetooth discovery before calling this api, otherwise the callback may fail to return the desired device.

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

attachSystemDataTransport

fun attachSystemDataTransport(
    associationId: Int, 
    in: InputStream, 
    out: OutputStream
): Unit

Attach a bidirectional communication stream to be used as a transport channel for transporting system data between associated devices.
Requires android.Manifest.permission#DELIVER_COMPANION_MESSAGES

buildAssociationCancellationIntent

fun buildAssociationCancellationIntent(): IntentSender?

Cancel the current association activity.

The app should launch the returned intentSender by calling Activity#startIntentSenderForResult(IntentSender, int, Intent, int, int, int) to cancel the current association activity

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

buildPermissionTransferUserConsentIntent

fun buildPermissionTransferUserConsentIntent(associationId: Int): IntentSender?

Build a permission sync user consent dialog.

Only the companion app which owns the association can call this method. Otherwise a null IntentSender will be returned from this method and an error will be logged. The app should launch the Activity in the returned intentSender IntentSender by calling Activity#startIntentSenderForResult(IntentSender, int, Intent, int, int, int).

The permission transfer doesn't happen immediately after the call or when the user consents. The app needs to call attachSystemDataTransport(int,java.io.InputStream,java.io.OutputStream) to attach a transport channel and startSystemDataTransfer(int,java.util.concurrent.Executor,android.os.OutcomeReceiver) to trigger the system data transfer}.

detachSystemDataTransport

fun detachSystemDataTransport(associationId: Int): Unit

Detach the transport channel that's previously attached for the associated device. The system will stop transferring any system data when this method is called.
Requires android.Manifest.permission#DELIVER_COMPANION_MESSAGES

disableSystemDataSyncForTypes

fun disableSystemDataSyncForTypes(
    associationId: Int, 
    flags: Int
): Unit

Disable system data sync (it only supports call metadata sync for now). By default all supported system data types are enabled.

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

disassociate

fun disassociate(deviceMacAddress: String): Unit

Deprecated: use disassociate(int)

Remove the association between this app and the device with the given mac address.

Any privileges provided via being associated with a given device will be revoked

Consider doing so when the association is no longer relevant to avoid unnecessary battery and/or data drain resulting from special privileges that the association provides

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

disassociate

fun disassociate(associationId: Int): Unit

Remove an association.

Any privileges provided via being associated with a given device will be revoked

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

enableSystemDataSyncForTypes

fun enableSystemDataSyncForTypes(
    associationId: Int, 
    flags: Int
): Unit

Enable system data sync (it only supports call metadata sync for now). By default all supported system data types are enabled.

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

getAssociations

fun getAssociations(): MutableList<String!>

Deprecated: use getMyAssociations()

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

getMyAssociations

fun getMyAssociations(): MutableList<AssociationInfo!>

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

hasNotificationAccess

fun hasNotificationAccess(component: ComponentName!): Boolean

Deprecated: Use NotificationManager#isNotificationListenerAccessGranted(ComponentName) instead.

Check whether the given component can access the notifications via a NotificationListenerService Your app must have an association with a device before calling this API

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

isPermissionTransferUserConsented

fun isPermissionTransferUserConsented(associationId: Int): Boolean

Return the current state of consent for permission transfer for the association. True if the user has allowed permission transfer for the association, false otherwise.

Note: The initial user consent is collected via a permission transfer user consent dialog. After the user has made their initial selection, they can toggle the permission transfer feature in the settings. This method always returns the state of the toggle setting.

requestNotificationAccess

fun requestNotificationAccess(component: ComponentName!): Unit

Request notification access for the given component. The given component must follow the protocol specified in NotificationListenerService Only components from the same package as the calling app are allowed. Your app must have an association with a device before calling this API. Side-loaded apps must allow restricted settings before requesting notification access.

Calling this API requires a uses-feature PackageManager#FEATURE_COMPANION_DEVICE_SETUP declaration in the manifest

startObservingDevicePresence

fun startObservingDevicePresence(deviceAddress: String): Unit

Register to receive callbacks whenever the associated device comes in and out of range.

The provided device must be #associate with the calling app before calling this method.

Caller must implement a single CompanionDeviceService which will be bound to and receive callbacks to android.companion.CompanionDeviceService#onDeviceAppeared and android.companion.CompanionDeviceService#onDeviceDisappeared. The app doesn't need to remain running in order to receive its callbacks.

Calling app must declare uses-permission android.Manifest.permission#REQUEST_OBSERVE_COMPANION_DEVICE_PRESENCE.

Calling app must check for feature presence of PackageManager#FEATURE_COMPANION_DEVICE_SETUP before calling this API.

For Bluetooth LE devices, this is based on scanning for device with the given address. The system will scan for the device when Bluetooth is ON or Bluetooth scanning is ON.

For Bluetooth classic devices this is triggered when the device connects/disconnects. WiFi devices are not supported.

If a Bluetooth LE device wants to use a rotating mac address, it is recommended to use Resolvable Private Address, and ensure the device is bonded to the phone so that android OS is able to resolve the address.

startSystemDataTransfer

fun startSystemDataTransfer(
    associationId: Int, 
    executor: Executor, 
    result: OutcomeReceiver<Void!, CompanionException!>
): Unit

Start system data transfer which has been previously approved by the user.

Before calling this method, the app needs to make sure the transport channel is, and the user consent dialog has prompted to. The transfer will fail if the transport channel is disconnected or detached during the transfer.

stopObservingDevicePresence

fun stopObservingDevicePresence(deviceAddress: String): Unit

Unregister for receiving callbacks whenever the associated device comes in and out of range. The provided device must be #associate with the calling app before calling this method. Calling app must declare uses-permission android.Manifest.permission#REQUEST_OBSERVE_COMPANION_DEVICE_PRESENCE. Calling app must check for feature presence of PackageManager#FEATURE_COMPANION_DEVICE_SETUP before calling this API.
Requires android.Manifest.permission#REQUEST_OBSERVE_COMPANION_DEVICE_PRESENCE