CompanionDeviceManager

EXTRA_ASSOCIATION

public static final String EXTRA_ASSOCIATION

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

Constant Value: "android.companion.extra.ASSOCIATION"

EXTRA_DEVICE

public static final String EXTRA_DEVICE

This constant was deprecated in API level 33.
use AssociationInfo.getAssociatedDevice() instead.

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

• for classic Bluetooth - BluetoothDevice
• for Bluetooth LE - ScanResult
• for WiFi - ScanResult

Constant Value: "android.companion.extra.DEVICE"

FLAG_CALL_METADATA

public static final int FLAG_CALL_METADATA

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

Constant Value: 1 (0x00000001)

RESULT_CANCELED

public static final int RESULT_CANCELED

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.

Constant Value: 0 (0x00000000)

RESULT_DISCOVERY_TIMEOUT

public static final int RESULT_DISCOVERY_TIMEOUT

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.

Constant Value: 2 (0x00000002)

RESULT_INTERNAL_ERROR

public static final int RESULT_INTERNAL_ERROR

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

Constant Value: 3 (0x00000003)

RESULT_OK

public static final int RESULT_OK

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

Constant Value: -1 (0xffffffff)

RESULT_SECURITY_ERROR

public static final int RESULT_SECURITY_ERROR

The result code to propagate back to the user activity and Callback.onFailure(int, CharSequence), indicates app is not allow to create the association due to the security issue. E.g. There are missing necessary permissions when creating association.

Constant Value: 4 (0x00000004)

RESULT_USER_REJECTED

public static final int RESULT_USER_REJECTED

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

Constant Value: 1 (0x00000001)

associate

public void associate (AssociationRequest request, 
                Executor executor, 
                CompanionDeviceManager.Callback callback)

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 Manifest.permission.REQUEST_COMPANION_RUN_IN_BACKGROUND and 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

associate

public void associate (AssociationRequest request, 
                CompanionDeviceManager.Callback callback, 
                Handler handler)

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 Manifest.permission.REQUEST_COMPANION_RUN_IN_BACKGROUND and 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

attachSystemDataTransport

public void attachSystemDataTransport (int associationId, 
                InputStream in, 
                OutputStream out)

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

buildAssociationCancellationIntent

public IntentSender buildAssociationCancellationIntent ()

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

public IntentSender buildPermissionTransferUserConsentIntent (int associationId)

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

createAndSetDeviceId

public DeviceId createAndSetDeviceId (int associationId, 
                DeviceId deviceId)

Returns a new DeviceId which can be passed to device manufacturers' apps, allowing them to fetch AssociationInfo or observe device presence for this associated device. This method creates a new object and does not mutate any existing DeviceId.

The system will generate and assign a new, random 128-bit key to this returned DeviceId. Each call to this method generates a new key, any previously associated key will be obsoleted. Therefore, the returned DeviceId is the one that contains the newly assigned key and should be used for subsequent operations.

This device id also helps the system uniquely identify your device for efficient device management and prevents duplicate entries.

WARNING: Do not pass the returned DeviceId to apps you do not trust.

detachSystemDataTransport

public void detachSystemDataTransport (int associationId)

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 Manifest.permission.DELIVER_COMPANION_MESSAGES

disableSystemDataSyncForTypes

public void disableSystemDataSyncForTypes (int associationId, 
                int flags)

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

public void disassociate (int associationId)

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

disassociate

public void disassociate (String deviceMacAddress)

This method was deprecated in API level 33.
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

enableSystemDataSyncForTypes

public void enableSystemDataSyncForTypes (int associationId, 
                int flags)

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

public List<String> getAssociations ()

This method was deprecated in API level 33.
use getMyAssociations()

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

getMyAssociations

public List<AssociationInfo> getMyAssociations ()

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

hasNotificationAccess

public boolean hasNotificationAccess (ComponentName component)

This method was deprecated in API level 33.
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

public boolean isPermissionTransferUserConsented (int associationId)

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.

removeBond

public boolean removeBond (int associationId)

Remove bonding between this device and an associated companion device.

This is an asynchronous call, it will return immediately. Register for BluetoothDevice.ACTION_BOND_STATE_CHANGED intents to be notified when the bond removal process completes, and its result.

This API should be used to remove a bluetooth bond that was created either by using BluetoothDevice.createBond() or by a direct user action. The association must already exist with this device before calling this method, but this may be done retroactively to remove a bond that was created outside of the CompanionDeviceManager.
Requires Manifest.permission.BLUETOOTH_CONNECT

requestNotificationAccess

public void requestNotificationAccess (ComponentName component)

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

setDeviceId

public void setDeviceId (int associationId, 
                DeviceId deviceId)

This method was deprecated in API level 36.1.
use createAndSetDeviceId(int, android.companion.DeviceId) instead.

Sets the deviceId for this association.

This device id helps the system uniquely identify your device for efficient device management and prevents duplicate entries.

startObservingDevicePresence

public void startObservingDevicePresence (String deviceAddress)

This method was deprecated in API level 36.
use startObservingDevicePresence(android.companion.ObservingDevicePresenceRequest) instead.

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

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

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

Calling app must declare uses-permission 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.

startObservingDevicePresence

public void startObservingDevicePresence (ObservingDevicePresenceRequest request)

Register to receive callbacks whenever the associated device's presence changes. The presence could be:

• BLE range changes (in/out)
• Bluetooth connection status changes (connected/disconnected)

Caller app must implement the CompanionDeviceService to receive callbacks via CompanionDeviceService.onDevicePresenceEvent(DevicePresenceEvent). The system will bind to the implemented CompanionDeviceService to deliver the callbacks./p>

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

public void startSystemDataTransfer (int associationId, 
                Executor executor, 
                OutcomeReceiver<Void, CompanionException> result)

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 attached, and the user consent dialog has prompted to the user. The transfer will fail if the transport channel is disconnected or detached during the transfer.

stopObservingDevicePresence

public void stopObservingDevicePresence (String deviceAddress)

This method was deprecated in API level 36.
use stopObservingDevicePresence(android.companion.ObservingDevicePresenceRequest) instead.

Unregister for receiving callbacks whenever the associated device comes in and out of range. The provided device must be associated with the calling app before calling this method. Calling app must declare uses-permission 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 Manifest.permission.REQUEST_OBSERVE_COMPANION_DEVICE_PRESENCE

stopObservingDevicePresence

public void stopObservingDevicePresence (ObservingDevicePresenceRequest request)

Unregister for receiving callbacks whenever the associated device comes in and out of range. Calling app must check for feature presence of PackageManager.FEATURE_COMPANION_DEVICE_SETUP before calling this API.
Requires Manifest.permission.REQUEST_OBSERVE_COMPANION_DEVICE_PRESENCE