BluetoothAdapter

ACTION_CONNECTION_STATE_CHANGED

static val ACTION_CONNECTION_STATE_CHANGED: String

Intent used to broadcast the change in connection state of the local Bluetooth adapter to a profile of the remote device. When the adapter is not connected to any profiles of any remote devices and it attempts a connection to a profile this intent will be sent. Once connected, this intent will not be sent for any more connection attempts to any profiles of any remote device. When the adapter disconnects from the last profile its connected to of any remote device, this intent will be sent.

This intent is useful for applications that are only concerned about whether the local adapter is connected to any profile of any device and are not really concerned about which profile. For example, an application which displays an icon to display whether Bluetooth is connected or not can use this intent.

This intent will have 3 extras: EXTRA_CONNECTION_STATE - The current connection state. EXTRA_PREVIOUS_CONNECTION_STATE- The previous connection state. android.bluetooth.BluetoothDevice#EXTRA_DEVICE - The remote device.

EXTRA_CONNECTION_STATE or EXTRA_PREVIOUS_CONNECTION_STATE can be any of STATE_DISCONNECTED, STATE_CONNECTING, STATE_CONNECTED, STATE_DISCONNECTING.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

Value: "android.bluetooth.adapter.action.CONNECTION_STATE_CHANGED"

ACTION_DISCOVERY_FINISHED

static val ACTION_DISCOVERY_FINISHED: String

Broadcast Action: The local Bluetooth adapter has finished the device discovery process.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

Value: "android.bluetooth.adapter.action.DISCOVERY_FINISHED"

ACTION_DISCOVERY_STARTED

static val ACTION_DISCOVERY_STARTED: String

Broadcast Action: The local Bluetooth adapter has started the remote device discovery process.

This usually involves an inquiry scan of about 12 seconds, followed by a page scan of each new device to retrieve its Bluetooth name.

Register for BluetoothDevice.ACTION_FOUND to be notified as remote Bluetooth devices are found.

Device discovery is a heavyweight procedure. New connections to remote Bluetooth devices should not be attempted while discovery is in progress, and existing connections will experience limited bandwidth and high latency. Use cancelDiscovery() to cancel an ongoing discovery.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

Value: "android.bluetooth.adapter.action.DISCOVERY_STARTED"

ACTION_LOCAL_NAME_CHANGED

static val ACTION_LOCAL_NAME_CHANGED: String

Broadcast Action: The local Bluetooth adapter has changed its friendly Bluetooth name.

This name is visible to remote Bluetooth devices.

Always contains the extra field EXTRA_LOCAL_NAME containing the name.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

Value: "android.bluetooth.adapter.action.LOCAL_NAME_CHANGED"

ACTION_REQUEST_DISCOVERABLE

static val ACTION_REQUEST_DISCOVERABLE: String

Activity Action: Show a system activity that requests discoverable mode. This activity will also request the user to turn on Bluetooth if it is not currently enabled.

Discoverable mode is equivalent to SCAN_MODE_CONNECTABLE_DISCOVERABLE. It allows remote devices to see this Bluetooth adapter when they perform a discovery.

For privacy, Android is not discoverable by default.

The sender of this Intent can optionally use extra field EXTRA_DISCOVERABLE_DURATION to request the duration of discoverability. Currently the default duration is 120 seconds, and maximum duration is capped at 300 seconds for each request.

Notification of the result of this activity is posted using the android.app.Activity#onActivityResult callback. The resultCode will be the duration (in seconds) of discoverability or android.app.Activity#RESULT_CANCELED if the user rejected discoverability or an error has occurred.

Applications can also listen for ACTION_SCAN_MODE_CHANGED for global notification whenever the scan mode changes. For example, an application can be notified when the device has ended discoverability.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_ADVERTISE permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_ADVERTISE

Value: "android.bluetooth.adapter.action.REQUEST_DISCOVERABLE"

ACTION_REQUEST_ENABLE

static val ACTION_REQUEST_ENABLE: String

Activity Action: Show a system activity that allows the user to turn on Bluetooth.

This system activity will return once Bluetooth has completed turning on, or the user has decided not to turn Bluetooth on.

Notification of the result of this activity is posted using the android.app.Activity#onActivityResult callback. The resultCode will be android.app.Activity#RESULT_OK if Bluetooth has been turned on or android.app.Activity#RESULT_CANCELED if the user has rejected the request or an error has occurred.

Applications can also listen for ACTION_STATE_CHANGED for global notification whenever Bluetooth is turned on or off.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

Value: "android.bluetooth.adapter.action.REQUEST_ENABLE"

ACTION_SCAN_MODE_CHANGED

static val ACTION_SCAN_MODE_CHANGED: String

Broadcast Action: Indicates the Bluetooth scan mode of the local Adapter has changed.

Always contains the extra fields EXTRA_SCAN_MODE and EXTRA_PREVIOUS_SCAN_MODE containing the new and old scan modes respectively.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

Value: "android.bluetooth.adapter.action.SCAN_MODE_CHANGED"

ACTION_STATE_CHANGED

static val ACTION_STATE_CHANGED: String

Broadcast Action: The state of the local Bluetooth adapter has been changed.

For example, Bluetooth has been turned on or off.

Always contains the extra fields EXTRA_STATE and EXTRA_PREVIOUS_STATE containing the new and old states respectively.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

Value: "android.bluetooth.adapter.action.STATE_CHANGED"

ERROR

static val ERROR: Int

Sentinel error value for this class. Guaranteed to not equal any other integer constant in this class. Provided as a convenience for functions that require a sentinel error value, for example:

Intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)

Value: -2147483648

EXTRA_CONNECTION_STATE

static val EXTRA_CONNECTION_STATE: String

Extra used by ACTION_CONNECTION_STATE_CHANGED

This extra represents the current connection state.

Value: "android.bluetooth.adapter.extra.CONNECTION_STATE"

EXTRA_DISCOVERABLE_DURATION

static val EXTRA_DISCOVERABLE_DURATION: String

Used as an optional int extra field in ACTION_REQUEST_DISCOVERABLE intents to request a specific duration for discoverability in seconds. The current default is 120 seconds, and requests over 300 seconds will be capped. These values could change.

Value: "android.bluetooth.adapter.extra.DISCOVERABLE_DURATION"

EXTRA_LOCAL_NAME

static val EXTRA_LOCAL_NAME: String

Used as a String extra field in ACTION_LOCAL_NAME_CHANGED intents to request the local Bluetooth name.

Value: "android.bluetooth.adapter.extra.LOCAL_NAME"

EXTRA_PREVIOUS_CONNECTION_STATE

static val EXTRA_PREVIOUS_CONNECTION_STATE: String

Extra used by ACTION_CONNECTION_STATE_CHANGED

This extra represents the previous connection state.

Value: "android.bluetooth.adapter.extra.PREVIOUS_CONNECTION_STATE"

EXTRA_PREVIOUS_SCAN_MODE

static val EXTRA_PREVIOUS_SCAN_MODE: String

Used as an int extra field in ACTION_SCAN_MODE_CHANGED intents to request the previous scan mode. Possible values are: SCAN_MODE_NONE, SCAN_MODE_CONNECTABLE, SCAN_MODE_CONNECTABLE_DISCOVERABLE,

Value: "android.bluetooth.adapter.extra.PREVIOUS_SCAN_MODE"

EXTRA_PREVIOUS_STATE

static val EXTRA_PREVIOUS_STATE: String

Used as an int extra field in ACTION_STATE_CHANGED intents to request the previous power state. Possible values are: STATE_OFF, STATE_TURNING_ON, STATE_ON, STATE_TURNING_OFF

Value: "android.bluetooth.adapter.extra.PREVIOUS_STATE"

EXTRA_SCAN_MODE

static val EXTRA_SCAN_MODE: String

Used as an int extra field in ACTION_SCAN_MODE_CHANGED intents to request the current scan mode. Possible values are: SCAN_MODE_NONE, SCAN_MODE_CONNECTABLE, SCAN_MODE_CONNECTABLE_DISCOVERABLE,

Value: "android.bluetooth.adapter.extra.SCAN_MODE"

EXTRA_STATE

static val EXTRA_STATE: String

Used as an int extra field in ACTION_STATE_CHANGED intents to request the current power state. Possible values are: STATE_OFF, STATE_TURNING_ON, STATE_ON, STATE_TURNING_OFF,

Value: "android.bluetooth.adapter.extra.STATE"

SCAN_MODE_CONNECTABLE

static val SCAN_MODE_CONNECTABLE: Int

Indicates that inquiry scan is disabled, but page scan is enabled on the local Bluetooth adapter. Therefore this device is not discoverable from remote Bluetooth devices, but is connectable from remote devices that have previously discovered this device.

Value: 21

SCAN_MODE_CONNECTABLE_DISCOVERABLE

static val SCAN_MODE_CONNECTABLE_DISCOVERABLE: Int

Indicates that both inquiry scan and page scan are enabled on the local Bluetooth adapter. Therefore this device is both discoverable and connectable from remote Bluetooth devices.

Value: 23

SCAN_MODE_NONE

static val SCAN_MODE_NONE: Int

Indicates that both inquiry scan and page scan are disabled on the local Bluetooth adapter. Therefore this device is neither discoverable nor connectable from remote Bluetooth devices.

Value: 20

STATE_CONNECTED

static val STATE_CONNECTED: Int

The profile is in connected state

Value: 2

STATE_CONNECTING

static val STATE_CONNECTING: Int

The profile is in connecting state

Value: 1

STATE_DISCONNECTED

static val STATE_DISCONNECTED: Int

The profile is in disconnected state

Value: 0

STATE_DISCONNECTING

static val STATE_DISCONNECTING: Int

The profile is in disconnecting state

Value: 3

STATE_OFF

static val STATE_OFF: Int

Indicates the local Bluetooth adapter is off.

Value: 10

STATE_ON

static val STATE_ON: Int

Indicates the local Bluetooth adapter is on, and ready for use.

Value: 12

STATE_TURNING_OFF

static val STATE_TURNING_OFF: Int

Indicates the local Bluetooth adapter is turning off. Local clients should immediately attempt graceful disconnection of any remote links.

Value: 13

STATE_TURNING_ON

static val STATE_TURNING_ON: Int

Indicates the local Bluetooth adapter is turning on. However local clients should wait for STATE_ON before attempting to use the adapter.

Value: 11

cancelDiscovery

fun cancelDiscovery(): Boolean

Cancel the current device discovery process.

Because discovery is a heavyweight procedure for the Bluetooth adapter, this method should always be called before attempting to connect to a remote device with android.bluetooth.BluetoothSocket#connect(). Discovery is not managed by the Activity, but is run as a system service, so an application should always call cancel discovery even if it did not directly request a discovery, just to be sure.

If Bluetooth state is not STATE_ON, this API will return false. After turning on Bluetooth, wait for ACTION_STATE_CHANGED with STATE_ON to get the updated value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

checkBluetoothAddress

static fun checkBluetoothAddress(address: String!): Boolean

Validate a String Bluetooth address, such as "00:43:A8:23:10:F0"

Alphabetic characters must be uppercase to be valid.

closeProfileProxy

fun closeProfileProxy(
    unusedProfile: Int, 
    proxy: BluetoothProfile!
): Unit

Close the connection of the profile proxy to the Service.

Clients should call this when they are no longer using the proxy obtained from getProfileProxy. Profile can be one of BluetoothProfile.HEADSET or android.bluetooth.BluetoothProfile#A2DP

disable

fun disable(): Boolean

Deprecated: Starting with android.os.Build.VERSION_CODES#TIRAMISU, applications are not allowed to enable/disable Bluetooth. Compatibility Note: For applications targeting android.os.Build.VERSION_CODES#TIRAMISU or above, this API will always fail and return false. If apps are targeting an older SDK (android.os.Build.VERSION_CODES#S or below), they can continue to use this API.

Deprecation Exemptions:

Turn off the local Bluetooth adapter—do not use without explicit user action to turn off Bluetooth.

This gracefully shuts down all Bluetooth connections, stops Bluetooth system services, and powers down the underlying Bluetooth hardware.

Bluetooth should never be disabled without direct user consent. The disable() method is provided only for applications that include a user interface for changing system settings, such as a "power manager" app.

This is an asynchronous call: it will return immediately, and clients should listen for ACTION_STATE_CHANGED to be notified of subsequent adapter state changes. If this call returns true, then the adapter state will immediately transition from STATE_ON to STATE_TURNING_OFF, and some time later transition to either STATE_OFF or STATE_ON. If this call returns false then there was an immediate problem that will prevent the adapter from being turned off - such as the adapter already being turned off.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

enable

fun enable(): Boolean

Deprecated: Starting with android.os.Build.VERSION_CODES#TIRAMISU, applications are not allowed to enable/disable Bluetooth. Compatibility Note: For applications targeting android.os.Build.VERSION_CODES#TIRAMISU or above, this API will always fail and return false. If apps are targeting an older SDK (android.os.Build.VERSION_CODES#S or below), they can continue to use this API.

Deprecation Exemptions:

Turn on the local Bluetooth adapter—do not use without explicit user action to turn on Bluetooth.

This powers on the underlying Bluetooth hardware, and starts all Bluetooth system services.

Bluetooth should never be enabled without direct user consent. If you want to turn on Bluetooth in order to create a wireless connection, you should use the ACTION_REQUEST_ENABLE Intent, which will raise a dialog that requests user permission to turn on Bluetooth. The enable() method is provided only for applications that include a user interface for changing system settings, such as a "power manager" app.

This is an asynchronous call: it will return immediately, and clients should listen for ACTION_STATE_CHANGED to be notified of subsequent adapter state changes. If this call returns true, then the adapter state will immediately transition from STATE_OFF to STATE_TURNING_ON, and some time later transition to either STATE_OFF or STATE_ON. If this call returns false then there was an immediate problem that will prevent the adapter from being turned on - such as Airplane mode, or the adapter is already turned on.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

getAddress

fun getAddress(): String!

Returns the hardware address of the local Bluetooth adapter.

For example, "00:11:22:AA:BB:CC".
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT and android.Manifest.permission#LOCAL_MAC_ADDRESS

getBluetoothLeAdvertiser

fun getBluetoothLeAdvertiser(): BluetoothLeAdvertiser!

Returns a BluetoothLeAdvertiser object for Bluetooth LE Advertising operations. Will return null if Bluetooth is turned off or if Bluetooth LE Advertising is not supported on this device.

Use isMultipleAdvertisementSupported() to check whether LE Advertising is supported on this device before calling this method.

getBluetoothLeScanner

fun getBluetoothLeScanner(): BluetoothLeScanner!

Returns a BluetoothLeScanner object for Bluetooth LE scan operations.

getBondedDevices

fun getBondedDevices(): MutableSet<BluetoothDevice!>!

Return the set of BluetoothDevice objects that are bonded (paired) to the local adapter.

If Bluetooth state is not STATE_ON, this API will return an empty set. After turning on Bluetooth, wait for ACTION_STATE_CHANGED with STATE_ON to get the updated value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

getDefaultAdapter

static fun getDefaultAdapter(): BluetoothAdapter!

Deprecated: this method will continue to work, but developers are strongly encouraged to migrate to using BluetoothManager.getAdapter(), since that approach enables support for Context.createAttributionContext.

Get a handle to the default local Bluetooth adapter.

Currently Android only supports one Bluetooth adapter, but the API could be extended to support more. This will always return the default adapter.

getDiscoverableTimeout

fun getDiscoverableTimeout(): Duration?

Get the timeout duration of the SCAN_MODE_CONNECTABLE_DISCOVERABLE.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

getLeMaximumAdvertisingDataLength

fun getLeMaximumAdvertisingDataLength(): Int

Return the maximum LE advertising data length in bytes, if LE Extended Advertising feature is supported, 0 otherwise.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

getMaxConnectedAudioDevices

fun getMaxConnectedAudioDevices(): Int

Get the maximum number of connected devices per audio profile for this device.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

getName

fun getName(): String!

Get the friendly Bluetooth name of the local Bluetooth adapter.

This name is visible to remote Bluetooth devices.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

getProfileConnectionState

fun getProfileConnectionState(profile: Int): Int

Get the current connection state of a profile. This function can be used to check whether the local Bluetooth adapter is connected to any remote device for a specific profile. Profile can be one of BluetoothProfile.HEADSET, BluetoothProfile.A2DP.

Return the profile connection state
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

getProfileProxy

fun getProfileProxy(
    context: Context!, 
    listener: BluetoothProfile.ServiceListener!, 
    profile: Int
): Boolean

Get the profile proxy object associated with the profile.

The ServiceListener's methods will be invoked on the application's main looper

getRemoteDevice

fun getRemoteDevice(address: ByteArray!): BluetoothDevice!

Get a BluetoothDevice object for the given Bluetooth hardware address.

Valid Bluetooth hardware addresses must be 6 bytes. This method expects the address in network byte order (MSB first).

A BluetoothDevice will always be returned for a valid hardware address, even if this adapter has never seen that device.

getRemoteDevice

fun getRemoteDevice(address: String!): BluetoothDevice!

Get a BluetoothDevice object for the given Bluetooth hardware address.

Valid Bluetooth hardware addresses must be upper case, in big endian byte order, and in a format such as "00:11:22:33:AA:BB". The helper checkBluetoothAddress is available to validate a Bluetooth address.

A BluetoothDevice will always be returned for a valid hardware address, even if this adapter has never seen that device.

getRemoteLeDevice

fun getRemoteLeDevice(
    address: String, 
    addressType: Int
): BluetoothDevice

Get a BluetoothDevice object for the given Bluetooth hardware address and addressType.

Valid Bluetooth hardware addresses must be upper case, in big endian byte order, and in a format such as "00:11:22:33:AA:BB". The helper checkBluetoothAddress is available to validate a Bluetooth address.

A BluetoothDevice will always be returned for a valid hardware address and type, even if this adapter has never seen that device.

getScanMode

fun getScanMode(): Int

Get the current Bluetooth scan mode of the local Bluetooth adapter.

The Bluetooth scan mode determines if the local adapter is connectable and/or discoverable from remote Bluetooth devices.

Possible values are: SCAN_MODE_NONE, SCAN_MODE_CONNECTABLE, SCAN_MODE_CONNECTABLE_DISCOVERABLE.

If Bluetooth state is not STATE_ON, this API will return SCAN_MODE_NONE. After turning on Bluetooth, wait for ACTION_STATE_CHANGED with STATE_ON to get the updated value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

getState

fun getState(): Int

Get the current state of the local Bluetooth adapter.

Possible return values are STATE_OFF, STATE_TURNING_ON, STATE_ON, STATE_TURNING_OFF.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isDiscovering

fun isDiscovering(): Boolean

Return true if the local Bluetooth adapter is currently in the device discovery process.

Device discovery is a heavyweight procedure. New connections to remote Bluetooth devices should not be attempted while discovery is in progress, and existing connections will experience limited bandwidth and high latency. Use cancelDiscovery() to cancel an ongoing discovery.

Applications can also register for ACTION_DISCOVERY_STARTED or ACTION_DISCOVERY_FINISHED to be notified when discovery starts or completes.

If Bluetooth state is not STATE_ON, this API will return false. After turning on Bluetooth, wait for ACTION_STATE_CHANGED with STATE_ON to get the updated value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

isEnabled

fun isEnabled(): Boolean

Return true if Bluetooth is currently enabled and ready for use.

Equivalent to: getBluetoothState() == STATE_ON
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isLe2MPhySupported

fun isLe2MPhySupported(): Boolean

Return true if LE 2M PHY feature is supported.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isLeAudioBroadcastAssistantSupported

fun isLeAudioBroadcastAssistantSupported(): Int

Returns BluetoothStatusCodes.FEATURE_SUPPORTED if the LE audio broadcast assistant feature is supported, BluetoothStatusCodes.FEATURE_NOT_SUPPORTED if the feature is not supported, or an error code.

isLeAudioBroadcastSourceSupported

fun isLeAudioBroadcastSourceSupported(): Int

Returns BluetoothStatusCodes.FEATURE_SUPPORTED if the LE audio broadcast source feature is supported, BluetoothStatusCodes.FEATURE_NOT_SUPPORTED if the feature is not supported, or an error code.

isLeAudioSupported

fun isLeAudioSupported(): Int

Returns BluetoothStatusCodes.FEATURE_SUPPORTED if the LE audio feature is supported, BluetoothStatusCodes.FEATURE_NOT_SUPPORTED if the feature is not supported, or an error code.

isLeCodedPhySupported

fun isLeCodedPhySupported(): Boolean

Return true if LE Coded PHY feature is supported.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isLeExtendedAdvertisingSupported

fun isLeExtendedAdvertisingSupported(): Boolean

Return true if LE Extended Advertising feature is supported.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isLePeriodicAdvertisingSupported

fun isLePeriodicAdvertisingSupported(): Boolean

Return true if LE Periodic Advertising feature is supported.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isMultipleAdvertisementSupported

fun isMultipleAdvertisementSupported(): Boolean

Return true if the multi advertisement is supported by the chipset
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isOffloadedFilteringSupported

fun isOffloadedFilteringSupported(): Boolean

Return true if offloaded filters are supported
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

isOffloadedScanBatchingSupported

fun isOffloadedScanBatchingSupported(): Boolean

Return true if offloaded scan batching is supported
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.

listenUsingInsecureL2capChannel

fun listenUsingInsecureL2capChannel(): BluetoothServerSocket

Create an insecure L2CAP Connection-oriented Channel (CoC) BluetoothServerSocket and assign a dynamic PSM value. This socket can be used to listen for incoming connections. The supported Bluetooth transport is LE only.

The link key is not required to be authenticated, i.e. the communication may be vulnerable to person-in-the-middle attacks. Use listenUsingL2capChannel, if an encrypted and authenticated communication channel is desired.

Use android.bluetooth.BluetoothServerSocket#accept to retrieve incoming connections from a listening BluetoothServerSocket.

The system will assign a dynamic protocol/service multiplexer (PSM) value. This PSM value can be read from the BluetoothServerSocket.getPsm() and this value will be released when this server socket is closed, Bluetooth is turned off, or the application exits unexpectedly.

The mechanism of disclosing the assigned dynamic PSM value to the initiating peer is defined and performed by the application.

Use BluetoothDevice.createInsecureL2capChannel(int) to connect to this server socket from another Android device that is given the PSM value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

listenUsingInsecureRfcommWithServiceRecord

fun listenUsingInsecureRfcommWithServiceRecord(
    name: String!, 
    uuid: UUID!
): BluetoothServerSocket!

Create a listening, insecure RFCOMM Bluetooth socket with Service Record.

The link key is not required to be authenticated, i.e. the communication may be vulnerable to Person In the Middle attacks. For Bluetooth 2.1 devices, the link will be encrypted, as encryption is mandatory. For legacy devices (pre Bluetooth 2.1 devices) the link will not be encrypted. Use listenUsingRfcommWithServiceRecord, if an encrypted and authenticated communication channel is desired.

Use android.bluetooth.BluetoothServerSocket#accept to retrieve incoming connections from a listening BluetoothServerSocket.

The system will assign an unused RFCOMM channel to listen on.

The system will also register a Service Discovery Protocol (SDP) record with the local SDP server containing the specified UUID, service name, and auto-assigned channel. Remote Bluetooth devices can use the same UUID to query our SDP server and discover which channel to connect to. This SDP record will be removed when this socket is closed, or if this application closes unexpectedly.

Use BluetoothDevice.createInsecureRfcommSocketToServiceRecord to connect to this socket from another device using the same UUID.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

listenUsingL2capChannel

fun listenUsingL2capChannel(): BluetoothServerSocket

Create a secure L2CAP Connection-oriented Channel (CoC) BluetoothServerSocket and assign a dynamic protocol/service multiplexer (PSM) value. This socket can be used to listen for incoming connections. The supported Bluetooth transport is LE only.

A remote device connecting to this socket will be authenticated and communication on this socket will be encrypted.

Use android.bluetooth.BluetoothServerSocket#accept to retrieve incoming connections from a listening BluetoothServerSocket.

The system will assign a dynamic PSM value. This PSM value can be read from the android.bluetooth.BluetoothServerSocket#getPsm() and this value will be released when this server socket is closed, Bluetooth is turned off, or the application exits unexpectedly.

The mechanism of disclosing the assigned dynamic PSM value to the initiating peer is defined and performed by the application.

Use BluetoothDevice.createL2capChannel(int) to connect to this server socket from another Android device that is given the PSM value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

listenUsingRfcommWithServiceRecord

fun listenUsingRfcommWithServiceRecord(
    name: String!, 
    uuid: UUID!
): BluetoothServerSocket!

Create a listening, secure RFCOMM Bluetooth socket with Service Record.

A remote device connecting to this socket will be authenticated and communication on this socket will be encrypted.

Use android.bluetooth.BluetoothServerSocket#accept to retrieve incoming connections from a listening BluetoothServerSocket.

The system will assign an unused RFCOMM channel to listen on.

The system will also register a Service Discovery Protocol (SDP) record with the local SDP server containing the specified UUID, service name, and auto-assigned channel. Remote Bluetooth devices can use the same UUID to query our SDP server and discover which channel to connect to. This SDP record will be removed when this socket is closed, or if this application closes unexpectedly.

Use BluetoothDevice.createRfcommSocketToServiceRecord to connect to this socket from another device using the same UUID.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

setName

fun setName(name: String!): Boolean

Set the friendly Bluetooth name of the local Bluetooth adapter.

This name is visible to remote Bluetooth devices.

Valid Bluetooth names are a maximum of 248 bytes using UTF-8 encoding, although many remote devices can only display the first 40 characters, and some may be limited to just 20.

If Bluetooth state is not STATE_ON, this API will return false. After turning on Bluetooth, wait for ACTION_STATE_CHANGED with STATE_ON to get the updated value.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_CONNECT permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_CONNECT

startDiscovery

fun startDiscovery(): Boolean

Start the remote device discovery process.

The discovery process usually involves an inquiry scan of about 12 seconds, followed by a page scan of each new device to retrieve its Bluetooth name.

This is an asynchronous call, it will return immediately. Register for ACTION_DISCOVERY_STARTED and ACTION_DISCOVERY_FINISHED intents to determine exactly when the discovery starts and completes. Register for android.bluetooth.BluetoothDevice#ACTION_FOUND to be notified as remote Bluetooth devices are found.

Device discovery is a heavyweight procedure. New connections to remote Bluetooth devices should not be attempted while discovery is in progress, and existing connections will experience limited bandwidth and high latency. Use cancelDiscovery() to cancel an ongoing discovery. Discovery is not managed by the Activity, but is run as a system service, so an application should always call BluetoothAdapter.cancelDiscovery() even if it did not directly request a discovery, just to be sure.

Device discovery will only find remote devices that are currently discoverable (inquiry scan enabled). Many Bluetooth devices are not discoverable by default, and need to be entered into a special mode.

If Bluetooth state is not STATE_ON, this API will return false. After turning on Bluetooth, wait for ACTION_STATE_CHANGED with STATE_ON to get the updated value.

If a device is currently bonding, this request will be queued and executed once that device has finished bonding. If a request is already queued, this request will be ignored.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
In addition, this requires either the Manifest.permission.ACCESS_FINE_LOCATION permission or a strong assertion that you will never derive the physical location of the device. You can make this assertion by declaring usesPermissionFlags="neverForLocation" on the relevant <uses-permission> manifest tag, but it may restrict the types of Bluetooth devices you can interact with.
Requires android.Manifest.permission#BLUETOOTH_SCAN

startLeScan

fun startLeScan(callback: BluetoothAdapter.LeScanCallback!): Boolean

Deprecated: use BluetoothLeScanner.startScan(List, ScanSettings, ScanCallback) instead.

Starts a scan for Bluetooth LE devices.

Results of the scan are reported using the LeScanCallback.onLeScan callback.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
In addition, this requires either the Manifest.permission.ACCESS_FINE_LOCATION permission or a strong assertion that you will never derive the physical location of the device. You can make this assertion by declaring usesPermissionFlags="neverForLocation" on the relevant <uses-permission> manifest tag, but it may restrict the types of Bluetooth devices you can interact with.
Requires android.Manifest.permission#BLUETOOTH_SCAN

startLeScan

fun startLeScan(
    serviceUuids: Array<UUID!>!, 
    callback: BluetoothAdapter.LeScanCallback!
): Boolean

Deprecated: use BluetoothLeScanner.startScan(List, ScanSettings, ScanCallback) instead.

Starts a scan for Bluetooth LE devices, looking for devices that advertise given services.

Devices which advertise all specified services are reported using the android.bluetooth.BluetoothAdapter.LeScanCallback#onLeScan callback.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
In addition, this requires either the Manifest.permission.ACCESS_FINE_LOCATION permission or a strong assertion that you will never derive the physical location of the device. You can make this assertion by declaring usesPermissionFlags="neverForLocation" on the relevant <uses-permission> manifest tag, but it may restrict the types of Bluetooth devices you can interact with.
Requires android.Manifest.permission#BLUETOOTH_SCAN

stopLeScan

fun stopLeScan(callback: BluetoothAdapter.LeScanCallback!): Unit

Deprecated: Use BluetoothLeScanner.stopScan(ScanCallback) instead.

Stops an ongoing Bluetooth LE device scan.
For apps targeting Build.VERSION_CODES.R or lower, this requires the Manifest.permission.BLUETOOTH_ADMIN permission which can be gained with a simple <uses-permission> manifest tag.
For apps targeting Build.VERSION_CODES.S or or higher, this requires the Manifest.permission.BLUETOOTH_SCAN permission which can be gained with android.app.Activity#requestPermissions(String[], int).
Requires android.Manifest.permission#BLUETOOTH_SCAN

finalize

protected fun finalize(): Unit