BleManager (ble 2.2.4 API)

java.lang.Object
- no.nordicsemi.android.ble.BleManager

All Implemented Interfaces:

ILogger

Direct Known Subclasses:

LegacyBleManager
```
public abstract class BleManager
extends java.lang.Object
implements ILogger
```
The BleManager is responsible for managing the low level communication with a Bluetooth LE device. Please see profiles implementation in Android nRF Blinky or Android nRF Toolbox app for an example of use.
This base manager has been tested against number of devices and samples from Nordic SDK.
The manager handles connection events and initializes the device after establishing the connection.
1. For bonded devices it ensures that the Service Changed indications, if this characteristic is present, are enabled. Before Android Marshmallow, Android did not enable them by default, leaving this to the developers.
2. The manager tries to read the Battery Level characteristic. No matter the result of this operation (for example the Battery Level characteristic may not have the READ property) it tries to enable Battery Level notifications to get battery updates from the device. This feature is now deprecated and will not work with the new API. Instead, read or enabledBattery Level notifications just like any other.
3. After connecting and service discovery, the manager initializes the device using given queue of commands. See BleManagerHandler.initialize() method for more details.
4. When initialization complete, the ConnectRequest.done(SuccessCallback) callback is called.
~~The manager also is responsible for parsing the Battery Level values and calling BleManagerCallbacks.onBatteryValueReceived(BluetoothDevice, int) method.~~
To get logs, override the log(int, String) method.
The BleManager should be overridden in your app and all the 'high level' callbacks should be called from there.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class BleManager.BleManagerGattCallback
The GATT Callback handler.

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`BleManager.BleManagerGattCallback` The GATT Callback handler.

Field Summary

Fields
Modifier and Type	Field and Description
`protected BleManagerCallbacks`	`callbacks` Deprecated.
`static int`	`PAIRING_VARIANT_CONSENT`
`static int`	`PAIRING_VARIANT_DISPLAY_PASSKEY`
`static int`	`PAIRING_VARIANT_DISPLAY_PIN`
`static int`	`PAIRING_VARIANT_OOB_CONSENT`
`static int`	`PAIRING_VARIANT_PASSKEY`
`static int`	`PAIRING_VARIANT_PASSKEY_CONFIRMATION`
`static int`	`PAIRING_VARIANT_PIN`

Constructor Summary

Constructors
Constructor and Description
`BleManager(android.content.Context context)` The manager constructor.
`BleManager(android.content.Context context, android.os.Handler handler)` The manager constructor.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected RequestQueue`	`beginAtomicRequestQueue()` Creates an atomic request queue.
`protected ReliableWriteRequest`	`beginReliableWrite()` Begins the Reliable Write sub-procedure.
`protected void`	`cancelQueue()` Removes all enqueued requests from the queue.
`void`	`close()` Closes and releases resources.
`ConnectRequest`	`connect(android.bluetooth.BluetoothDevice device)` Creates a Connect request that will try to connect to the given Bluetooth LE device.
`ConnectRequest`	`connect(android.bluetooth.BluetoothDevice device, int phy)` Deprecated. Use `connect(BluetoothDevice)` instead and set preferred PHY using `ConnectRequest.usePreferredPhy(int)`.
`protected Request`	`createBond()` Deprecated. Use `createBondInsecure()` or `ensureBond()` instead. Deprecated in 2.2.1.
`protected Request`	`createBondInsecure()` Returns a request to create bond with the device.
`protected void`	`disableBatteryLevelNotifications()` Deprecated. Use `disableNotifications(BluetoothGattCharacteristic)` instead.
`protected WriteRequest`	`disableIndications(android.bluetooth.BluetoothGattCharacteristic characteristic)` Disables indications on given characteristic.
`protected WriteRequest`	`disableNotifications(android.bluetooth.BluetoothGattCharacteristic characteristic)` Disables notifications on given characteristic.
`DisconnectRequest`	`disconnect()` Disconnects from the device or cancels the pending connection attempt.
`protected void`	`enableBatteryLevelNotifications()` Deprecated. Use `setNotificationCallback(BluetoothGattCharacteristic)` and `enableNotifications(BluetoothGattCharacteristic)` instead.
`protected WriteRequest`	`enableIndications(android.bluetooth.BluetoothGattCharacteristic characteristic)` Enables indications on given characteristic.
`protected WriteRequest`	`enableNotifications(android.bluetooth.BluetoothGattCharacteristic characteristic)` Enables notifications on given characteristic.
`protected void`	`enqueue(Request request)` Deprecated. This way of enqueueing requests is deprecated, use above methods instead.
`protected Request`	`ensureBond()` Returns a request to ensure the device is bonded and link is encrypted.
`int`	`getBatteryValue()` Deprecated. Keep the battery level in your manager instead.
`android.bluetooth.BluetoothDevice`	`getBluetoothDevice()` Returns the Bluetooth device object used in `connect(BluetoothDevice)`.
`int`	`getConnectionState()` Method returns the connection state: `STATE_CONNECTING`, `STATE_CONNECTED`, `STATE_DISCONNECTING`, `STATE_DISCONNECTED`
`protected android.content.Context`	`getContext()` Returns the context that the manager was created with.
`protected abstract BleManager.BleManagerGattCallback`	`getGattCallback()` This method must return the GATT callback used by the manager.
`protected int`	`getMtu()` Returns the current MTU (Maximum Transfer Unit).
`protected int`	`getServiceDiscoveryDelay(boolean bonded)` The onConnectionStateChange event is triggered just after the Android connects to a device.
`protected boolean`	`isBonded()` Returns whether the target device is bonded.
`boolean`	`isConnected()` This method returns true if the device is connected.
`boolean`	`isReady()` Returns true if the device is connected and the initialization has finished, that is when `BleManagerHandler.onDeviceReady()` was called.
`protected boolean`	`isReliableWriteInProgress()` Returns true if `BluetoothGatt.beginReliableWrite()` has been called and the Reliable Write hasn't been executed nor aborted yet.
`void`	`log(int priority, int messageRes, java.lang.Object... params)` Logs the given message with given log priority into the all managed devices' log session.
`void`	`log(int priority, java.lang.String message)` Logs the given message with given log priority into the all managed devices' log session.
`protected void`	`onPairingRequestReceived(android.bluetooth.BluetoothDevice device, int variant)` This method will be called if a remote device requires a non-'just works' pairing.
`protected void`	`overrideMtu(int mtu)` This method overrides the MTU value.
`protected void`	`readBatteryLevel()` Deprecated. Use `readCharacteristic(BluetoothGattCharacteristic)` instead.
`protected ReadRequest`	`readCharacteristic(android.bluetooth.BluetoothGattCharacteristic characteristic)` Sends the read request to the given characteristic.
`protected ReadRequest`	`readDescriptor(android.bluetooth.BluetoothGattDescriptor descriptor)` Sends the read request to the given descriptor.
`protected PhyRequest`	`readPhy()` Reads the current PHY for this connections.
`protected ReadRssiRequest`	`readRssi()` Reads the current RSSI (Received Signal Strength Indication).
`protected Request`	`refreshDeviceCache()` Refreshes the device cache.
`protected Request`	`removeBond()` Enqueues removing bond information.
`protected void`	`removeIndicationCallback(android.bluetooth.BluetoothGattCharacteristic characteristic)` Removes the indications callback set using `setIndicationCallback(BluetoothGattCharacteristic)`.
`protected void`	`removeNotificationCallback(android.bluetooth.BluetoothGattCharacteristic characteristic)` Removes the notifications callback set using `setNotificationCallback(BluetoothGattCharacteristic)`.
`protected void`	`removeWriteCallback(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)` Removes the write callback set using `setWriteCallback(BluetoothGattCharacteristic)`.
`protected void`	`removeWriteCallback(android.bluetooth.BluetoothGattDescriptor serverDescriptor)` Removes the write callback set using `setWriteCallback(BluetoothGattCharacteristic)`.
`protected ConnectionPriorityRequest`	`requestConnectionPriority(int priority)` Requests the new connection priority.
`protected MtuRequest`	`requestMtu(int mtu)` Requests new MTU.
`protected void`	`runOnCallbackThread(java.lang.Runnable runnable)` Runs the given runnable using a handler given to the constructor.
`protected WriteRequest`	`sendIndication(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data)` Sends the indication from the server characteristic.
`protected WriteRequest`	`sendIndication(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data, int offset, int length)` Sends the indication with at most length bytes from offset at given data from the server characteristic.
`protected WriteRequest`	`sendIndication(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, Data data)` Sends the indication from the server characteristic.
`protected WriteRequest`	`sendNotification(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data)` Sends the notification from the server characteristic.
`protected WriteRequest`	`sendNotification(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data, int offset, int length)` Sends the notification with at most length bytes from offset at given data from the server characteristic.
`protected WriteRequest`	`sendNotification(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, Data data)` Sends the notification from the server characteristic.
`void`	`setBondingObserver(BondingObserver callback)` Sets the observer, that will receive events related to bonding.
`protected SetValueRequest`	`setCharacteristicValue(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data)` Sets the given data to the readable server characteristic.
`protected SetValueRequest`	`setCharacteristicValue(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data, int offset, int length)` Sets the given data to the readable server characteristic.
`protected SetValueRequest`	`setCharacteristicValue(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, Data data)` Sets the given data to the readable server characteristic.The data will be available to be read by the remote device.
`void`	`setConnectionObserver(ConnectionObserver callback)` Sets the connection observer.
`protected SetValueRequest`	`setDescriptorValue(android.bluetooth.BluetoothGattDescriptor serverDescriptor, byte[] data)` Sets the given data to the readable server descriptor.
`protected SetValueRequest`	`setDescriptorValue(android.bluetooth.BluetoothGattDescriptor serverDescriptor, byte[] data, int offset, int length)` Sets the given data to the readable server descriptor.
`protected SetValueRequest`	`setDescriptorValue(android.bluetooth.BluetoothGattDescriptor serverDescriptor, Data data)` Sets the given data to the readable server descriptor.
`void`	`setGattCallbacks(BleManagerCallbacks callbacks)` Deprecated. Use per-request callbacks.
`protected ValueChangedCallback`	`setIndicationCallback(android.bluetooth.BluetoothGattCharacteristic characteristic)` Returns the callback that is registered for value changes (indications) of given characteristic.
`protected ValueChangedCallback`	`setNotificationCallback(android.bluetooth.BluetoothGattCharacteristic characteristic)` Returns the callback that is registered for value changes (notifications) of given characteristic.
`protected PhyRequest`	`setPreferredPhy(int txPhy, int rxPhy, int phyOptions)` Enqueues a request to set the preferred PHY.
`protected ValueChangedCallback`	`setWriteCallback(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)` Returns the callback that is registered for value changes (write command or write request initiated by the remote device) of given characteristic.
`protected ValueChangedCallback`	`setWriteCallback(android.bluetooth.BluetoothGattDescriptor serverDescriptor)` Returns the callback that is registered for value changes (write command or write request initiated by the remote device) of given descriptor.
`protected boolean`	`shouldAutoConnect()` Deprecated. Use `ConnectRequest.useAutoConnect(boolean)` instead.
`protected boolean`	`shouldClearCacheWhenDisconnected()` Returns whether the device cache should be cleared after the device disconnected, before calling `BluetoothGatt.close()`.
`protected SleepRequest`	`sleep(long delay)` Enqueues a sleep operation with given duration.
`void`	`useServer(BleServerManager server)` This method binds the manager with the give server instance.
`protected WaitForValueChangedRequest`	`waitForIndication(android.bluetooth.BluetoothGattCharacteristic characteristic)` Sets a one-time callback that will be notified when the value of the given characteristic changes.
`protected WaitForValueChangedRequest`	`waitForNotification(android.bluetooth.BluetoothGattCharacteristic characteristic)` Sets a one-time callback that will be notified when the value of the given characteristic changes.
`protected WaitForReadRequest`	`waitForRead(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)` Waits until the given characteristic is read by the remote device.
`protected WaitForReadRequest`	`waitForRead(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data)` Sets the given data to the readable server characteristic and waits until they are read by the remote device.
`protected WaitForReadRequest`	`waitForRead(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic, byte[] data, int offset, int length)` Sets the given data to the readable server characteristic and waits until they are read by the remote device.
`protected WaitForReadRequest`	`waitForRead(android.bluetooth.BluetoothGattDescriptor serverDescriptor)` Waits until the given descriptor is read by the remote device.
`protected WaitForReadRequest`	`waitForRead(android.bluetooth.BluetoothGattDescriptor serverDescriptor, byte[] data)` Sets the given data to the readable server descriptor and waits until they are read by the remote device.
`protected WaitForReadRequest`	`waitForRead(android.bluetooth.BluetoothGattDescriptor serverDescriptor, byte[] data, int offset, int length)` Sets the given data to the readable server descriptor and waits until they are read by the remote device.
`protected WaitForValueChangedRequest`	`waitForWrite(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)` Sets a one-time callback that will be notified when the value of the given characteristic changes.
`protected WaitForValueChangedRequest`	`waitForWrite(android.bluetooth.BluetoothGattDescriptor serverDescriptor)` Sets a one-time callback that will be notified when the value of the given descriptor changes.
`protected ConditionalWaitRequest<java.lang.Void>`	`waitIf(ConditionalWaitRequest.Condition<java.lang.Void> condition)` Creates a conditional wait request that will wait if the given condition is satisfied.
`protected <T> ConditionalWaitRequest<T>`	`waitIf(T parameter, ConditionalWaitRequest.Condition<T> condition)` Creates a conditional wait request that will wait if the given condition is satisfied.
`protected ConditionalWaitRequest<java.lang.Void>`	`waitUntil(ConditionalWaitRequest.Condition<java.lang.Void> condition)` Creates a conditional wait request that will wait until the given condition is not satisfied.
`protected <T> ConditionalWaitRequest<T>`	`waitUntil(T parameter, ConditionalWaitRequest.Condition<T> condition)` Creates a conditional wait request that will wait until the given condition is not satisfied.
`protected ConditionalWaitRequest<android.bluetooth.BluetoothGattCharacteristic>`	`waitUntilIndicationsEnabled(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)` Creates a request that will wait for enabling indications.
`protected ConditionalWaitRequest<android.bluetooth.BluetoothGattCharacteristic>`	`waitUntilNotificationsEnabled(android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)` Creates a request that will wait for enabling notifications.
`protected WriteRequest`	`writeCharacteristic(android.bluetooth.BluetoothGattCharacteristic characteristic, byte[] data)` Writes the given data to the characteristic.
`protected WriteRequest`	`writeCharacteristic(android.bluetooth.BluetoothGattCharacteristic characteristic, byte[] data, int offset, int length)` Writes at most length bytes from offset at given data to the characteristic.
`protected WriteRequest`	`writeCharacteristic(android.bluetooth.BluetoothGattCharacteristic characteristic, Data data)` Writes the given data to the characteristic.
`protected WriteRequest`	`writeDescriptor(android.bluetooth.BluetoothGattDescriptor descriptor, byte[] data)` Writes the given data to the descriptor.
`protected WriteRequest`	`writeDescriptor(android.bluetooth.BluetoothGattDescriptor descriptor, byte[] data, int offset, int length)` Writes at most length bytes from offset at given data to the descriptor.
`protected WriteRequest`	`writeDescriptor(android.bluetooth.BluetoothGattDescriptor descriptor, Data data)` Writes the given data to the descriptor.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PAIRING_VARIANT_PIN
```
public static final int PAIRING_VARIANT_PIN
```
    See Also:
    
    Constant Field Values
  - PAIRING_VARIANT_PASSKEY
```
public static final int PAIRING_VARIANT_PASSKEY
```
    See Also:
    
    Constant Field Values
  - PAIRING_VARIANT_PASSKEY_CONFIRMATION
```
public static final int PAIRING_VARIANT_PASSKEY_CONFIRMATION
```
    See Also:
    
    Constant Field Values
  - PAIRING_VARIANT_CONSENT
```
public static final int PAIRING_VARIANT_CONSENT
```
    See Also:
    
    Constant Field Values
  - PAIRING_VARIANT_DISPLAY_PASSKEY
```
public static final int PAIRING_VARIANT_DISPLAY_PASSKEY
```
    See Also:
    
    Constant Field Values
  - PAIRING_VARIANT_DISPLAY_PIN
```
public static final int PAIRING_VARIANT_DISPLAY_PIN
```
    See Also:
    
    Constant Field Values
  - PAIRING_VARIANT_OOB_CONSENT
```
public static final int PAIRING_VARIANT_OOB_CONSENT
```
    See Also:
    
    Constant Field Values
  - callbacks
```
@Deprecated
protected BleManagerCallbacks callbacks
```
    Deprecated.
    
    Manager callbacks, set using setGattCallbacks(BleManagerCallbacks).
- Constructor Detail
  - BleManager
```
public BleManager(@NonNull
                  android.content.Context context)
```
    The manager constructor.
    To connect a device, call connect(BluetoothDevice).
    
    Parameters:
    
    context - the context.
  - BleManager
```
public BleManager(@NonNull
                  android.content.Context context,
                  @NonNull
                  android.os.Handler handler)
```
    The manager constructor.
    To connect a device, call connect(BluetoothDevice).
    
    Parameters:
    
    context - the context.
    
    handler - the handler used for delaying operations, timeouts and, most of all, the request callbacks (done/fail/with, etc).
- Method Detail
  - close
```
public void close()
```
    Closes and releases resources. This method will be called automatically after calling disconnect(). When the device disconnected with link loss and ConnectRequest.shouldAutoConnect() returned true you have to call this method to close the connection.
  - runOnCallbackThread
```
protected void runOnCallbackThread(@NonNull
                                   java.lang.Runnable runnable)
```
    Runs the given runnable using a handler given to the constructor. If no handler was given, the callbacks will be called on UI thread.
    
    Parameters:
    
    runnable - the runnable to be executed.
  - setGattCallbacks
```
@Deprecated
public void setGattCallbacks(@NonNull
                                          BleManagerCallbacks callbacks)
```
    Deprecated. Use per-request callbacks.
    
    Sets the manager callback listener.
    
    Parameters:
    
    callbacks - the callback listener.
  - setConnectionObserver
```
public final void setConnectionObserver(@Nullable
                                        ConnectionObserver callback)
```
    Sets the connection observer. This callback will be called using the handler given in BleManager(Context, Handler).
    
    Parameters:
    
    callback - the callback listener.
  - setBondingObserver
```
public final void setBondingObserver(@Nullable
                                     BondingObserver callback)
```
    Sets the observer, that will receive events related to bonding. This callback will be called using the handler given in BleManager(Context, Handler).
    
    Parameters:
    
    callback - the callback.
    
    See Also:
    
    BondingObserver
  - useServer
```
public final void useServer(@NonNull
                            BleServerManager server)
```
    This method binds the manager with the give server instance. Apps that allow multiple simultaneous connections and GATT server should use a single server instance, shared between all clients.
    
    Parameters:
    
    server - the server instance.
  - onPairingRequestReceived
```
protected void onPairingRequestReceived(@NonNull
                                        android.bluetooth.BluetoothDevice device,
                                        int variant)
```
    This method will be called if a remote device requires a non-'just works' pairing. See PAIRING_* constants for possible options.
    
    Parameters:
    
    device - the device.
    
    variant - pairing variant.
  - getGattCallback
```
@NonNull
protected abstract BleManager.BleManagerGattCallback getGattCallback()
```
    This method must return the GATT callback used by the manager. This method must not create a new gatt callback each time it is being invoked, but rather return a single object. The object must exist when this method is called, that is in the BleManager's constructor. Therefore, it cannot return a local field in the extending manager, as this is created after the constructor finishes.
    
    Returns:
    
    The gatt callback object.
  - getContext
```
@NonNull
protected final android.content.Context getContext()
```
    Returns the context that the manager was created with.
    
    Returns:
    
    The context.
  - getBluetoothDevice
```
@Nullable
public android.bluetooth.BluetoothDevice getBluetoothDevice()
```
    Returns the Bluetooth device object used in connect(BluetoothDevice).
    
    Returns:
    
    The Bluetooth device or null, if connect(BluetoothDevice) wasn't called.
  - isConnected
```
public final boolean isConnected()
```
    This method returns true if the device is connected. Services could have not been discovered yet.
  - isReady
```
public final boolean isReady()
```
    Returns true if the device is connected and the initialization has finished, that is when BleManagerHandler.onDeviceReady() was called.
  - isBonded
```
protected final boolean isBonded()
```
    Returns whether the target device is bonded. The device does not have to be connected, but must have been set prior to call this method.
    
    Returns:
    
    True, if the Android has bonds information of the device. This does not mean that the target device also has such information, or that the link is in fact encrypted.
  - getConnectionState
```
public final int getConnectionState()
```
    Method returns the connection state: STATE_CONNECTING, STATE_CONNECTED, STATE_DISCONNECTING, STATE_DISCONNECTED
    
    Returns:
    
    The connection state.
  - getBatteryValue
```
@Deprecated
public final int getBatteryValue()
```
    Deprecated. Keep the battery level in your manager instead.
    
    Returns the last received value of Battery Level characteristic, or -1 if such does not exist, hasn't been read or notification wasn't received yet.
    The value returned will be invalid if overridden readBatteryLevel() and enableBatteryLevelNotifications() were used.
    
    Returns:
    
    The last battery level value in percent.
  - log
```
public void log(int priority,
                @NonNull
                java.lang.String message)
```
    Description copied from interface: ILogger
    
    Logs the given message with given log priority into the all managed devices' log session.
    
    Specified by:
    
    log in interface ILogger
    
    Parameters:
    
    priority - the log priority.
    
    message - the message to be logged.
  - log
```
public void log(int priority,
                @StringRes
                int messageRes,
                @Nullable
                java.lang.Object... params)
```
    Description copied from interface: ILogger
    
    Logs the given message with given log priority into the all managed devices' log session.
    
    Specified by:
    
    log in interface ILogger
    
    Parameters:
    
    priority - the log priority.
    
    messageRes - string resource id.
    
    params - additional (optional) parameters used to fill the message.
  - shouldAutoConnect
```
@Deprecated
protected boolean shouldAutoConnect()
```
    Deprecated. Use ConnectRequest.useAutoConnect(boolean) instead.
    
    Returns whether to connect to the remote device just once (false) or to add the address to white list of devices that will be automatically connect as soon as they become available (true). In the latter case, if Bluetooth adapter is enabled, Android scans periodically for devices from the white list and if a advertising packet is received from such, it tries to connect to it. When the connection is lost, the system will keep trying to reconnect to it in. If true is returned, and the connection to the device is lost the BleManagerCallbacks.onLinkLossOccurred(BluetoothDevice) callback is called instead of BleManagerCallbacks.onDeviceDisconnected(BluetoothDevice).
    This feature works much better on newer Android phone models and many not work on older phones.
    This method should only be used with bonded devices, as otherwise the device may change it's address. It will however work also with non-bonded devices with private static address. A connection attempt to a device with private resolvable address will fail.
    The first connection to a device will always be created with autoConnect flag to false (see BluetoothDevice.connectGatt(Context, boolean, BluetoothGattCallback)). This is to make it quick as the user most probably waits for a quick response. However, if this method returned true during first connection and the link was lost, the manager will try to reconnect to it using BluetoothGatt.connect() which forces autoConnect to true.
    
    Returns:
    
    The AutoConnect flag value.
  - shouldClearCacheWhenDisconnected
```
protected boolean shouldClearCacheWhenDisconnected()
```
    Returns whether the device cache should be cleared after the device disconnected, before calling BluetoothGatt.close(). By default it returns false.
    If the returned value is true, the next time the Android device will connect to this peripheral the services will be discovered again. If false, the services will be obtained from the cache.
    Note, that the BluetoothGatt#refresh() method is not in the public API and it is not recommended to use this. However, as Android is caching services of all devices, even if they are not bonded and have Service Changed characteristic, it may necessary to clear the cache manually.
    On older Android versions clearing device cache helped with connection stability. It was common to get error 133 on the second and following connections when services were obtained from the cache. However, full service discovery takes time and consumes peripheral's battery.
    
    Returns:
    
    True, if the device cache should be cleared after the device disconnects or false, (default) if the cached value be used.
  - getServiceDiscoveryDelay
```
protected int getServiceDiscoveryDelay(boolean bonded)
```
    The onConnectionStateChange event is triggered just after the Android connects to a device. In case of bonded devices, the encryption is reestablished AFTER this callback is called. Moreover, when the device has Service Changed indication enabled, and the list of services has changed (e.g. using the DFU), the indication is received few hundred milliseconds later, depending on the connection interval. When received, Android will start performing a service discovery operation, internally, and will NOT notify the app that services has changed.
    If the gatt.discoverServices() method would be invoked here with no delay, if would return cached services, as the SC indication wouldn't be received yet. Therefore, we have to postpone the service discovery operation until we are (almost, as there is no such callback) sure, that it has been handled. It should be greater than the time from LLCP Feature Exchange to ATT Write for Service Change indication.
    If your device does not use Service Change indication (for example does not have DFU) the delay may be 0.
    Please calculate the proper delay that will work in your solution.
    For devices that are not bonded, but support pairing, a small delay is required on some older Android versions (Nexus 4 with Android 5.1.1) when the device will send pairing request just after connection. If so, we want to wait with the service discovery until bonding is complete.
    The default this implementation returns 1600 ms for bonded and 300 ms when the device is not bonded to be compatible with older versions of the library.
  - connect
```
@NonNull
public final ConnectRequest connect(@NonNull
                                              android.bluetooth.BluetoothDevice device)
```
    Creates a Connect request that will try to connect to the given Bluetooth LE device. Call TimeoutableRequest.enqueue() or TimeoutableRequest.await() in order to execute the request.
    This method returns a ConnectRequest which can be used to set completion and failure callbacks. The completion callback (done) will be called after the initialization is complete, after BleManagerCallbacks.onDeviceReady(BluetoothDevice) has been called.
    Calling TimeoutableRequest.await() will make this request synchronous (the callbacks set will be ignored, instead the synchronous method will return or throw an exception).
    For asynchronous call usage, TimeoutableRequest.enqueue() must be called on the returned request.
    
    Parameters:
    
    device - a device to connect to.
    
    Returns:
    
    The connect request.
  - connect
```
@NonNull
 @Deprecated
public final ConnectRequest connect(@NonNull
                                                            android.bluetooth.BluetoothDevice device,
                                                            int phy)
```
    Deprecated. Use connect(BluetoothDevice) instead and set preferred PHY using ConnectRequest.usePreferredPhy(int).
    
    Creates a Connect request that will try to connect to the given Bluetooth LE device using preferred PHY. Call TimeoutableRequest.enqueue() or TimeoutableRequest.await() in order to execute the request.
    This method returns a ConnectRequest which can be used to set completion and failure callbacks. The completion callback will be called after the initialization is complete, after BleManagerCallbacks.onDeviceReady(BluetoothDevice) has been called.
    Calling TimeoutableRequest.await() will make this request synchronous (the callbacks set will be ignored, instead the synchronous method will return or throw an exception).
    For asynchronous call usage, TimeoutableRequest.enqueue() must be called on the returned request.
    
    Parameters:
    
    device - a device to connect to.
    
    phy - preferred PHY for connections to remote LE device. Bitwise OR of any of PhyRequest.PHY_LE_1M_MASK, PhyRequest.PHY_LE_2M_MASK, and PhyRequest.PHY_LE_CODED_MASK. This option does not take effect if autoConnect is set to true. PHY 2M and Coded are supported on newer devices running Android Oreo or newer.
    
    Returns:
    
    The connect request.
  - disconnect
```
@NonNull
public final DisconnectRequest disconnect()
```
    Disconnects from the device or cancels the pending connection attempt. Does nothing if device was not connected.
    
    Returns:
    
    The disconnect request. The completion callback will be called after the device has disconnected and the connection was closed. If the device was not connected, the completion callback will be called immediately with device parameter set to null.
  - createBond
```
@Deprecated
 @NonNull
protected Request createBond()
```
    Deprecated. Use createBondInsecure() or ensureBond() instead. Deprecated in 2.2.1.
    
    Returns a request to create bond with the device. The device must be first set using connect(BluetoothDevice) which will try to connect to the device. If you need to pair with a device before connecting to it you may do it without the use of BleManager object and connect after bond is established.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    Important: This request does NOT guarantee that the link will be encrypted. If the bond information is present on the phone, but was removed from the peripheral (or another peripheral is pretending to be the one) this request will succeed, as it immediately returns if the bond information is present on the Android client. To make sure no sensitive information is stolen, protect your characteristics and/or descriptors by assigning them security level. Also, clearly inform user that a device is being bonded to avoid MITM.
    
    Returns:
    
    The request.
    
    See Also:
    
    ensureBond(), createBondInsecure()
  - createBondInsecure
```
@NonNull
protected Request createBondInsecure()
```
    Returns a request to create bond with the device. The device must be first set using connect(BluetoothDevice) which will try to connect to the device. If you need to pair with a device before connecting to it you may do it without the use of BleManager object and connect after bond is established.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    Important: This request does NOT guarantee that the link will be encrypted. If the bond information is present on the phone, but was removed from the peripheral (or another peripheral is pretending to be the one) this request will succeed, as it immediately returns if the bond information is present on the Android client. To make sure no sensitive information is stolen, protect your characteristics and/or descriptors by assigning them security level. Also, clearly inform user which device is being bonded to avoid MITM.
    To ensure link encryption, use ensureBond().
    
    Returns:
    
    The request.
    
    Since:
    
    2.2.1
    
    See Also:
    
    ensureBond()
  - ensureBond
```
protected Request ensureBond()
```
    Returns a request to ensure the device is bonded and link is encrypted. On Android versions 4.3-10 (and perhaps later as well) the BluetoothDevice.getBondState() returns true even if the link is not encrypted, or the device is not connected at all, checking only if the bond information is present on Android. Moreover, calling BluetoothDevice.createBond() returns false if bond is already present on Android, despite not being used, giving no trustworthy method to ensure that link is encrypted.
    This method will always call BluetoothDevice.createBond(). If this method returns false (e.g. because the bond information is already present on Android), this will remove the current bond information and call BluetoothDevice.createBond() again.
    Important: This may fail, if:
    - The device already has bonding, but encryption wasn't started, and your device does not support multiple bondings.
    - Someone is pretending to be your device, and advertising with the same MAC. Calling this method may remove the valid bond and create a new one against the intruder. Always make sure the user bonds to the right devices and indicate it to the user.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    Returns:
    
    The request.
    
    Since:
    
    2.2.3
  - removeBond
```
@NonNull
protected Request removeBond()
```
    Enqueues removing bond information. When the device was bonded and the bond information was successfully removed, the device will disconnect. Note, that this will not remove the bond information from the connected device!
    The success callback will be called after the device get disconnected, when the BluetoothDevice.getBondState() changes to BluetoothDevice.BOND_NONE.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Returns:
    
    The request.
  - setNotificationCallback
```
@NonNull
protected ValueChangedCallback setNotificationCallback(@Nullable
                                                                 android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Returns the callback that is registered for value changes (notifications) of given characteristic. After assigning the notifications callback, notifications must be enabled using enableNotifications(BluetoothGattCharacteristic). This applies also when they were already enabled on the remote side.
    To remove the callback, call removeNotificationCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    characteristic - characteristic to bind the callback with. If null, the returned callback will not be null, but will not be used.
    
    Returns:
    
    The callback.
  - setIndicationCallback
```
@NonNull
protected ValueChangedCallback setIndicationCallback(@Nullable
                                                               android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Returns the callback that is registered for value changes (indications) of given characteristic. After assigning the indication callback, indications must be enabled using enableIndications(BluetoothGattCharacteristic). This applies also when they were already enabled on the remote side.
    To remove the callback, call removeIndicationCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    characteristic - characteristic to bind the callback with. If null, the returned callback will not be null, but will not be used.
    
    Returns:
    
    The callback.
  - setWriteCallback
```
@NonNull
protected ValueChangedCallback setWriteCallback(@Nullable
                                                          android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)
```
    Returns the callback that is registered for value changes (write command or write request initiated by the remote device) of given characteristic.
    To remove the callback, call removeWriteCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    serverCharacteristic - characteristic to bind the callback with. If null, the returned callback will not be null, but will not be used.
    
    Returns:
    
    The callback.
  - setWriteCallback
```
@NonNull
protected ValueChangedCallback setWriteCallback(@Nullable
                                                          android.bluetooth.BluetoothGattDescriptor serverDescriptor)
```
    Returns the callback that is registered for value changes (write command or write request initiated by the remote device) of given descriptor.
    To remove the callback, call removeWriteCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    serverDescriptor - descriptor to bind the callback with. If null, the returned callback will not be null, but will not be used.
    
    Returns:
    
    The callback.
  - removeNotificationCallback
```
protected void removeNotificationCallback(@Nullable
                                          android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Removes the notifications callback set using setNotificationCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    characteristic - characteristic to unbind the callback from.
  - removeIndicationCallback
```
protected void removeIndicationCallback(@Nullable
                                        android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Removes the indications callback set using setIndicationCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    characteristic - characteristic to unbind the callback from.
  - removeWriteCallback
```
protected void removeWriteCallback(@Nullable
                                   android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)
```
    Removes the write callback set using setWriteCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    serverCharacteristic - characteristic to unbind the callback from.
  - removeWriteCallback
```
protected void removeWriteCallback(@Nullable
                                   android.bluetooth.BluetoothGattDescriptor serverDescriptor)
```
    Removes the write callback set using setWriteCallback(BluetoothGattCharacteristic).
    
    Parameters:
    
    serverDescriptor - descriptor to unbind the callback from.
  - waitForNotification
```
@NonNull
protected WaitForValueChangedRequest waitForNotification(@Nullable
                                                                   android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Sets a one-time callback that will be notified when the value of the given characteristic changes. This is a blocking request, so the next request will be executed after the notification was received.
    If WaitForValueChangedRequest.merge(DataMerger) was used, the whole message will be completed before the callback is notified.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic that value is expect to change.
    
    Returns:
    
    The request.
  - waitForIndication
```
@NonNull
protected WaitForValueChangedRequest waitForIndication(@Nullable
                                                                 android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Sets a one-time callback that will be notified when the value of the given characteristic changes. This is a blocking request, so the next request will be executed after the indication was received.
    If WaitForValueChangedRequest.merge(DataMerger) was used, the whole message will be completed before the callback is notified.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic that value is expect to change.
    
    Returns:
    
    The request.
  - waitForWrite
```
@NonNull
protected WaitForValueChangedRequest waitForWrite(@Nullable
                                                            android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)
```
    Sets a one-time callback that will be notified when the value of the given characteristic changes. This is a blocking request, so the next request will be executed after the write command or write request was received.
    If WaitForValueChangedRequest.merge(DataMerger) was used, the whole message will be completed before the callback is notified.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic that is expected to be written.
    
    Returns:
    
    The request.
  - waitForWrite
```
@NonNull
protected WaitForValueChangedRequest waitForWrite(@Nullable
                                                            android.bluetooth.BluetoothGattDescriptor serverDescriptor)
```
    Sets a one-time callback that will be notified when the value of the given descriptor changes. This is a blocking request, so the next request will be executed after the write command or write request was received.
    If WaitForValueChangedRequest.merge(DataMerger) was used, the whole message will be completed before the callback is notified.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the descriptor that is expected to be written.
    
    Returns:
    
    The request.
  - waitIf
```
@NonNull
protected ConditionalWaitRequest<java.lang.Void> waitIf(@NonNull
                                                                  ConditionalWaitRequest.Condition<java.lang.Void> condition)
```
    Creates a conditional wait request that will wait if the given condition is satisfied. The condition is checked when the request is executed and each time a new BLE operation is complete.
    
    Parameters:
    
    condition - The condition to examine. If it's satisfied, the manager will wait.
    
    Returns:
    
    The request.
  - waitIf
```
@NonNull
protected <T> ConditionalWaitRequest<T> waitIf(@Nullable
                                                         T parameter,
                                                         @NonNull
                                                         ConditionalWaitRequest.Condition<T> condition)
```
    Creates a conditional wait request that will wait if the given condition is satisfied. The condition is checked when the request is executed and each time a new BLE operation is complete.
    
    Parameters:
    
    parameter - An optional parameter that will be passed to the condition.
    
    condition - The condition to examine. If it's satisfied, the manager will wait.
    
    Returns:
    
    The request.
  - waitUntil
```
@NonNull
protected ConditionalWaitRequest<java.lang.Void> waitUntil(@NonNull
                                                                     ConditionalWaitRequest.Condition<java.lang.Void> condition)
```
    Creates a conditional wait request that will wait until the given condition is not satisfied. The condition is checked when the request is executed and each time a new BLE operation is complete.
    
    Parameters:
    
    condition - The condition to examine. If it's not satisfied, the manager will wait.
    
    Returns:
    
    The request.
  - waitUntil
```
@NonNull
protected <T> ConditionalWaitRequest<T> waitUntil(@Nullable
                                                            T parameter,
                                                            @NonNull
                                                            ConditionalWaitRequest.Condition<T> condition)
```
    Creates a conditional wait request that will wait until the given condition is not satisfied. The condition is checked when the request is executed and each time a new BLE operation is complete.
    
    Parameters:
    
    parameter - An optional parameter that will be passed to the condition.
    
    condition - The condition to examine. If it's not satisfied, the manager will wait.
    
    Returns:
    
    The request.
  - waitUntilNotificationsEnabled
```
@NonNull
protected ConditionalWaitRequest<android.bluetooth.BluetoothGattCharacteristic> waitUntilNotificationsEnabled(@Nullable
                                                                                                                        android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)
```
    Creates a request that will wait for enabling notifications. If notifications were enabled at the time of executing the request, it will complete immediately.
    
    Parameters:
    
    serverCharacteristic - the server characteristic with notify property.
    
    Returns:
    
    The request.
  - waitUntilIndicationsEnabled
```
@NonNull
protected ConditionalWaitRequest<android.bluetooth.BluetoothGattCharacteristic> waitUntilIndicationsEnabled(@Nullable
                                                                                                                      android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)
```
    Creates a request that will wait for enabling indications. If indications were enabled at the time of executing the request, it will complete immediately.
    
    Parameters:
    
    serverCharacteristic - the server characteristic with indicate property.
    
    Returns:
    
    The request.
  - waitForRead
```
@NonNull
protected WaitForReadRequest waitForRead(@Nullable
                                                   android.bluetooth.BluetoothGattCharacteristic serverCharacteristic)
```
    Waits until the given characteristic is read by the remote device. The data must have been set to the characteristic before the request is executed. Use setCharacteristicValue(BluetoothGattCharacteristic, Data) to set data, or waitForRead(BluetoothGattCharacteristic, byte[], int, int) to set the data immediately.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the target characteristic to be read.
    
    Returns:
    
    The request.
  - waitForRead
```
@NonNull
protected WaitForReadRequest waitForRead(@Nullable
                                                   android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                   @Nullable
                                                   byte[] data)
```
    Sets the given data to the readable server characteristic and waits until they are read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the target characteristic to be read.
    
    data - the data to be sent as read response.
    
    Returns:
    
    The request.
  - waitForRead
```
@NonNull
protected WaitForReadRequest waitForRead(@Nullable
                                                   android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                   @Nullable
                                                   byte[] data,
                                                   int offset,
                                                   int length)
```
    Sets the given data to the readable server characteristic and waits until they are read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the target characteristic to be read.
    
    data - the data buffer.
    
    offset - index of the first byte to be returned.
    
    length - number of bytes to be returned.
    
    Returns:
    
    The request.
  - waitForRead
```
@NonNull
protected WaitForReadRequest waitForRead(@Nullable
                                                   android.bluetooth.BluetoothGattDescriptor serverDescriptor)
```
    Waits until the given descriptor is read by the remote device. The data must have been set to the descriptor before the request is executed. Use setDescriptorValue(BluetoothGattDescriptor, byte[]) to set data, or waitForRead(BluetoothGattDescriptor, byte[], int, int) to set the data immediately.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the target descriptor to be read.
    
    Returns:
    
    The request.
  - waitForRead
```
@NonNull
protected WaitForReadRequest waitForRead(@Nullable
                                                   android.bluetooth.BluetoothGattDescriptor serverDescriptor,
                                                   @Nullable
                                                   byte[] data)
```
    Sets the given data to the readable server descriptor and waits until they are read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the target descriptor to be read.
    
    data - the data to be sent as read response.
    
    Returns:
    
    The request.
  - waitForRead
```
@NonNull
protected WaitForReadRequest waitForRead(@Nullable
                                                   android.bluetooth.BluetoothGattDescriptor serverDescriptor,
                                                   @Nullable
                                                   byte[] data,
                                                   int offset,
                                                   int length)
```
    Sets the given data to the readable server descriptor and waits until they are read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the target descriptor to be read.
    
    data - the data buffer.
    
    offset - index of the first byte to be returned.
    
    length - number of bytes to be returned.
    
    Returns:
    
    The request.
  - setCharacteristicValue
```
@NonNull
protected SetValueRequest setCharacteristicValue(@Nullable
                                                           android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                           @Nullable
                                                           Data data)
```
    Sets the given data to the readable server characteristic.The data will be available to be read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the target characteristic to set value.
    
    data - data to be set.
    
    Returns:
    
    The request.
  - setCharacteristicValue
```
@NonNull
protected SetValueRequest setCharacteristicValue(@Nullable
                                                           android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                           @Nullable
                                                           byte[] data)
```
    Sets the given data to the readable server characteristic. The data will be available to be read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the target characteristic to set value.
    
    data - data to be set.
    
    Returns:
    
    The request.
  - setCharacteristicValue
```
@NonNull
protected SetValueRequest setCharacteristicValue(@Nullable
                                                           android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                           @Nullable
                                                           byte[] data,
                                                           int offset,
                                                           int length)
```
    Sets the given data to the readable server characteristic. The data will be available to be read by the remote device until the device writes a new value, or sendNotification(BluetoothGattCharacteristic, byte[]) or #sendIn
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the target characteristic to set value.
    
    data - data to be set.
    
    offset - index of the first byte to be set.
    
    length - number of bytes to be set.
    
    Returns:
    
    The request.
  - setDescriptorValue
```
@NonNull
protected SetValueRequest setDescriptorValue(@Nullable
                                                       android.bluetooth.BluetoothGattDescriptor serverDescriptor,
                                                       @Nullable
                                                       Data data)
```
    Sets the given data to the readable server descriptor. The data will be available to be read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the target descriptor to set value.
    
    data - data to be set.
    
    Returns:
    
    The request.
  - setDescriptorValue
```
@NonNull
protected SetValueRequest setDescriptorValue(@Nullable
                                                       android.bluetooth.BluetoothGattDescriptor serverDescriptor,
                                                       @Nullable
                                                       byte[] data)
```
    Sets the given data to the readable server descriptor. The data will be available to be read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the target descriptor to set value.
    
    data - data to be set.
    
    Returns:
    
    The request.
  - setDescriptorValue
```
@NonNull
protected SetValueRequest setDescriptorValue(@Nullable
                                                       android.bluetooth.BluetoothGattDescriptor serverDescriptor,
                                                       @Nullable
                                                       byte[] data,
                                                       int offset,
                                                       int length)
```
    Sets the given data to the readable server descriptor. The data will be available to be read by the remote device.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverDescriptor - the target descriptor to set value.
    
    data - data to be set.
    
    offset - index of the first byte to be set.
    
    length - number of bytes to be set.
    
    Returns:
    
    The request.
  - enableNotifications
```
@NonNull
protected WriteRequest enableNotifications(@Nullable
                                                     android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Enables notifications on given characteristic. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to be enabled.
    
    Returns:
    
    The request.
  - disableNotifications
```
@NonNull
protected WriteRequest disableNotifications(@Nullable
                                                      android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Disables notifications on given characteristic. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to be disabled.
    
    Returns:
    
    The request.
  - enableIndications
```
@NonNull
protected WriteRequest enableIndications(@Nullable
                                                   android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Enables indications on given characteristic. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to be enabled.
    
    Returns:
    
    The request.
  - disableIndications
```
@NonNull
protected WriteRequest disableIndications(@Nullable
                                                    android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Disables indications on given characteristic. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to be disabled.
    
    Returns:
    
    The request.
  - readCharacteristic
```
@NonNull
protected ReadRequest readCharacteristic(@Nullable
                                                   android.bluetooth.BluetoothGattCharacteristic characteristic)
```
    Sends the read request to the given characteristic. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to read.
    
    Returns:
    
    The request.
  - writeCharacteristic
```
@NonNull
protected WriteRequest writeCharacteristic(@Nullable
                                                     android.bluetooth.BluetoothGattCharacteristic characteristic,
                                                     @Nullable
                                                     Data data)
```
    Writes the given data to the characteristic. The write type is taken from the characteristic.
    Use split() or split(DataSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to write to.
    
    data - data to be written to the characteristic.
    
    Returns:
    
    The request.
  - writeCharacteristic
```
@NonNull
protected WriteRequest writeCharacteristic(@Nullable
                                                     android.bluetooth.BluetoothGattCharacteristic characteristic,
                                                     @Nullable
                                                     byte[] data)
```
    Writes the given data to the characteristic. The write type is taken from the characteristic.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to write to.
    
    data - data to be written to the characteristic.
    
    Returns:
    
    The request.
  - writeCharacteristic
```
@NonNull
protected WriteRequest writeCharacteristic(@Nullable
                                                     android.bluetooth.BluetoothGattCharacteristic characteristic,
                                                     @Nullable
                                                     byte[] data,
                                                     int offset,
                                                     int length)
```
    Writes at most length bytes from offset at given data to the characteristic. The write type is taken from the characteristic.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    characteristic - the characteristic to write to.
    
    data - data to be written to the characteristic.
    
    offset - index of the first byte to be sent.
    
    length - number of bytes to be sent.
    
    Returns:
    
    The request.
  - readDescriptor
```
@NonNull
protected ReadRequest readDescriptor(@Nullable
                                               android.bluetooth.BluetoothGattDescriptor descriptor)
```
    Sends the read request to the given descriptor. If the descriptor is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    descriptor - the descriptor to read.
    
    Returns:
    
    The request.
  - writeDescriptor
```
@NonNull
protected WriteRequest writeDescriptor(@Nullable
                                                 android.bluetooth.BluetoothGattDescriptor descriptor,
                                                 @Nullable
                                                 Data data)
```
    Writes the given data to the descriptor.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the descriptor is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    descriptor - the descriptor to write to.
    
    data - data to be written to the descriptor.
    
    Returns:
    
    The request.
  - writeDescriptor
```
@NonNull
protected WriteRequest writeDescriptor(@Nullable
                                                 android.bluetooth.BluetoothGattDescriptor descriptor,
                                                 @Nullable
                                                 byte[] data)
```
    Writes the given data to the descriptor.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the descriptor is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    descriptor - the descriptor to write to.
    
    data - data to be written to the descriptor.
    
    Returns:
    
    The request.
  - writeDescriptor
```
@NonNull
protected WriteRequest writeDescriptor(@Nullable
                                                 android.bluetooth.BluetoothGattDescriptor descriptor,
                                                 @Nullable
                                                 byte[] data,
                                                 int offset,
                                                 int length)
```
    Writes at most length bytes from offset at given data to the descriptor.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the descriptor is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    descriptor - the descriptor to write to.
    
    data - data to be written to the descriptor.
    
    offset - index of the first byte to be sent.
    
    length - number of bytes to be sent.
    
    Returns:
    
    The request.
  - sendNotification
```
@NonNull
protected WriteRequest sendNotification(@Nullable
                                                  android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                  @Nullable
                                                  Data data)
```
    Sends the notification from the server characteristic. The notifications on this characteristic must be enabled before the request is executed.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic to notify.
    
    data - data to be sent to the characteristic.
    
    Returns:
    
    The request.
  - sendNotification
```
@NonNull
protected WriteRequest sendNotification(@Nullable
                                                  android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                  @Nullable
                                                  byte[] data)
```
    Sends the notification from the server characteristic. The notifications on this characteristic must be enabled before the request is executed.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic to notify.
    
    data - data to be sent to the characteristic.
    
    Returns:
    
    The request.
  - sendNotification
```
@NonNull
protected WriteRequest sendNotification(@Nullable
                                                  android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                  @Nullable
                                                  byte[] data,
                                                  int offset,
                                                  int length)
```
    Sends the notification with at most length bytes from offset at given data from the server characteristic. The notifications on this characteristic must be enabled before the request is executed.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic to notify.
    
    data - the data buffer.
    
    offset - index of the first byte to be sent.
    
    length - number of bytes to be sent.
    
    Returns:
    
    The request.
  - sendIndication
```
@NonNull
protected WriteRequest sendIndication(@Nullable
                                                android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                @Nullable
                                                Data data)
```
    Sends the indication from the server characteristic. The indications on this characteristic must be enabled before the request is executed.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic to indicate.
    
    data - data to be sent.
    
    Returns:
    
    The request.
  - sendIndication
```
@NonNull
protected WriteRequest sendIndication(@Nullable
                                                android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                @Nullable
                                                byte[] data)
```
    Sends the indication from the server characteristic. The indications on this characteristic must be enabled before the request is executed.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic to indicate.
    
    data - data to be sent.
    
    Returns:
    
    The request.
  - sendIndication
```
@NonNull
protected WriteRequest sendIndication(@Nullable
                                                android.bluetooth.BluetoothGattCharacteristic serverCharacteristic,
                                                @Nullable
                                                byte[] data,
                                                int offset,
                                                int length)
```
    Sends the indication with at most length bytes from offset at given data from the server characteristic. The indications on this characteristic must be enabled before the request is executed.
    Use split() or split(ValueSplitter) on the returned WriteRequest if data should be automatically split into multiple packets. If the characteristic is null, the fail(FailCallback) callback will be called.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    serverCharacteristic - the characteristic to indicate.
    
    data - the data buffer.
    
    offset - index of the first byte to be sent.
    
    length - number of bytes to be sent.
    
    Returns:
    
    The request.
  - beginAtomicRequestQueue
```
@NonNull
protected RequestQueue beginAtomicRequestQueue()
```
    Creates an atomic request queue. The requests from the queue will be executed in order. This is useful when more then one thread may add requests and you want some of them to be executed together.
    
    Returns:
    
    The request.
  - beginReliableWrite
```
@NonNull
protected ReliableWriteRequest beginReliableWrite()
```
    Begins the Reliable Write sub-procedure. Requests that need to be performed reliably should be enqueued with ReliableWriteRequest.add(Operation) instead of using Request.enqueue(). The library will verify all Write operations and will automatically abort the Reliable Write procedure when the returned data mismatch with the data sent. When all requests enqueued in the ReliableWriteRequest were completed, the Reliable Write will be automatically executed.
    Long Write will not work when Reliable Write is in progress. The library will make sure that WriteRequest.split() was called for all WriteRequest packets, had they not been assigned other splitter.
    At least one Write operation must be executed before executing or aborting, otherwise the GattError.GATT_INVALID_OFFSET error will be reported. Because of that, enqueueing a ReliableWriteRequest without any operations does nothing.
    Example of usage:
```
     beginReliableWrite()
           .add(writeCharacteristic(someCharacteristic, someData)
                   .fail(...)
                   .done(...))
           // Non-write requests are also possible
           .add(requestMtu(200))
           // Data will be written in the same order
           .add(writeCharacteristic(someCharacteristic, differentData))
           // This will return the OLD data, not 'differentData', as the RW wasn't executed!
           .add(readCharacteristic(someCharacteristic).with(callback))
           // Multiple characteristics may be written during a single RW
           .add(writeCharacteristic(someOtherCharacteristic, importantData))
        // Finally, enqueue the Reliable Write request in BleManager
          .enqueue();
 
```
    Returns:
    
    The request.
  - isReliableWriteInProgress
```
protected final boolean isReliableWriteInProgress()
```
    Returns true if BluetoothGatt.beginReliableWrite() has been called and the Reliable Write hasn't been executed nor aborted yet.
  - readBatteryLevel
```
@Deprecated
protected void readBatteryLevel()
```
    Deprecated. Use readCharacteristic(BluetoothGattCharacteristic) instead.
    
    Reads the battery level from the device.
  - enableBatteryLevelNotifications
```
@Deprecated
protected void enableBatteryLevelNotifications()
```
    Deprecated. Use setNotificationCallback(BluetoothGattCharacteristic) and enableNotifications(BluetoothGattCharacteristic) instead.
    
    This method enables notifications on the Battery Level characteristic.
  - disableBatteryLevelNotifications
```
@Deprecated
protected void disableBatteryLevelNotifications()
```
    Deprecated. Use disableNotifications(BluetoothGattCharacteristic) instead.
    
    This method disables notifications on the Battery Level characteristic.
  - requestMtu
```
protected MtuRequest requestMtu(int mtu)
```
    Requests new MTU. On Android Lollipop or newer it will send the MTU request to the connected device. On older versions of Android the MtuCallback.onMtuChanged(BluetoothDevice, int) set with MtuRequest.with(MtuCallback) will be called with current MTU value.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Returns:
    
    The request.
  - getMtu
```
protected int getMtu()
```
    Returns the current MTU (Maximum Transfer Unit). MTU specifies the maximum number of bytes that can be sent in a single write operation. 3 bytes are used for internal purposes, so the maximum size is MTU-3. The value will changed only if requested with requestMtu(int) and a successful callback is received. If the peripheral requests MTU change, the BluetoothGattCallback.onMtuChanged(BluetoothGatt, int, int) callback is not invoked, therefor the returned MTU value will not be correct. Use BluetoothGattServerCallback.onMtuChanged(BluetoothDevice, int) to get the callback with right value requested from the peripheral side.
    
    Returns:
    
    the current MTU value. Default to 23.
  - overrideMtu
```
protected void overrideMtu(int mtu)
```
    This method overrides the MTU value. Use it only when the peripheral has changed MTU and you received the BluetoothGattServerCallback.onMtuChanged(BluetoothDevice, int) callback. If you want to set MTU as a master, use requestMtu(int) instead.
    
    Parameters:
    
    mtu - the MTU value set by the peripheral.
  - requestConnectionPriority
```
protected ConnectionPriorityRequest requestConnectionPriority(int priority)
```
    Requests the new connection priority. Acceptable values are:
    1. BluetoothGatt.CONNECTION_PRIORITY_HIGH - Interval: 11.25 -15 ms, latency: 0, supervision timeout: 20 sec,
    2. BluetoothGatt.CONNECTION_PRIORITY_BALANCED - Interval: 30 - 50 ms, latency: 0, supervision timeout: 20 sec,
    3. BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER - Interval: 100 - 125 ms, latency: 2, supervision timeout: 20 sec.
    Works only on Android Lollipop or newer. On older system versions will cause Request.fail(FailCallback) callback or throw RequestFailedException with FailCallback.REASON_REQUEST_FAILED status if called synchronously. Starting from Android Oreo you may get a callback with the interval, latency and timeout using ConnectionPriorityRequest.with(ConnectionPriorityCallback).
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    Parameters:
    
    priority - one of: BluetoothGatt.CONNECTION_PRIORITY_HIGH, BluetoothGatt.CONNECTION_PRIORITY_BALANCED, BluetoothGatt.CONNECTION_PRIORITY_LOW_POWER.
    
    Returns:
    
    The request.
  - setPreferredPhy
```
protected PhyRequest setPreferredPhy(int txPhy,
                                     int rxPhy,
                                     int phyOptions)
```
    Enqueues a request to set the preferred PHY.
    PHY LE 2M and PHY LE Coded are supported only on Android Oreo or newer. You may safely request other PHYs on older platforms, but you will get PHY LE 1M as TX and RX PHY in the callback.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    txPhy - preferred transmitter PHY. Bitwise OR of any of PhyRequest.PHY_LE_1M_MASK, PhyRequest.PHY_LE_2M_MASK, and PhyRequest.PHY_LE_CODED_MASK.
    
    rxPhy - preferred receiver PHY. Bitwise OR of any of PhyRequest.PHY_LE_1M_MASK, PhyRequest.PHY_LE_2M_MASK, and PhyRequest.PHY_LE_CODED_MASK.
    
    phyOptions - preferred coding to use when transmitting on the LE Coded PHY. Can be one of PhyRequest.PHY_OPTION_NO_PREFERRED, PhyRequest.PHY_OPTION_S2 or PhyRequest.PHY_OPTION_S8.
    
    Returns:
    
    The request.
  - readPhy
```
protected PhyRequest readPhy()
```
    Reads the current PHY for this connections.
    PHY LE 2M and PHY LE Coded are supported only on Android Oreo or newer. You may safely read PHY on older platforms, but you will get PHY LE 1M as TX and RX PHY in the callback.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Returns:
    
    The request.
  - readRssi
```
protected ReadRssiRequest readRssi()
```
    Reads the current RSSI (Received Signal Strength Indication).
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Returns:
    
    The request.
  - refreshDeviceCache
```
protected Request refreshDeviceCache()
```
    Refreshes the device cache. As the BluetoothGatt#refresh() method is not in the public API (it's hidden, and on Android P it is on a light gray list) it is called using reflections and may be removed in some future Android release or on some devices.
    There is no callback indicating when the cache has been cleared. This library assumes some time and waits. After the delay, it will start service discovery and clear the task queue. When the service discovery finishes, the BleManagerHandler.isRequiredServiceSupported(BluetoothGatt) and BleManagerHandler.isOptionalServiceSupported(BluetoothGatt) will be called and the initialization will be performed as if the device has just connected.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Returns:
    
    The request.
  - sleep
```
protected SleepRequest sleep(long delay)
```
    Enqueues a sleep operation with given duration. The next request will be performed after at least given number of milliseconds.
    The returned request must be either enqueued using Request.enqueue() for asynchronous use, or awaited using await() in synchronous execution.
    
    Parameters:
    
    delay - the delay in milliseconds.
    
    Returns:
    
    The request.
  - enqueue
```
@Deprecated
protected final void enqueue(@NonNull
                                          Request request)
```
    Deprecated. This way of enqueueing requests is deprecated, use above methods instead.
    
    Enqueues a new request.
    
    Parameters:
    
    request - the new request to be added to the end of the queue.
  - cancelQueue
```
protected final void cancelQueue()
```
    Removes all enqueued requests from the queue. The currently executed request will be cancelled and will fail with status FailCallback.REASON_CANCELLED.
    If a BLE operation was in progress when the queue was cancelled, enqueueing a next BLE operation immediately may cause the Bluetooth to behave improperly, as the manager will try to execute it without waiting for the callback. A delay in such case is recommended.

Class BleManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PAIRING_VARIANT_PIN

PAIRING_VARIANT_PASSKEY

PAIRING_VARIANT_PASSKEY_CONFIRMATION

PAIRING_VARIANT_CONSENT

PAIRING_VARIANT_DISPLAY_PASSKEY

PAIRING_VARIANT_DISPLAY_PIN

PAIRING_VARIANT_OOB_CONSENT

callbacks

Constructor Detail

BleManager

BleManager

Method Detail

close

runOnCallbackThread

setGattCallbacks

setConnectionObserver

setBondingObserver

useServer

onPairingRequestReceived

getGattCallback

getContext

getBluetoothDevice

isConnected

isReady

isBonded

getConnectionState

getBatteryValue

log

log

shouldAutoConnect

shouldClearCacheWhenDisconnected

getServiceDiscoveryDelay

connect

connect

disconnect

createBond

createBondInsecure

ensureBond

removeBond

setNotificationCallback

setIndicationCallback

setWriteCallback

setWriteCallback

removeNotificationCallback

removeIndicationCallback

removeWriteCallback

removeWriteCallback

waitForNotification

waitForIndication

waitForWrite

waitForWrite

waitIf

waitIf

waitUntil

waitUntil

waitUntilNotificationsEnabled

waitUntilIndicationsEnabled

waitForRead

waitForRead

waitForRead

waitForRead

waitForRead

waitForRead

setCharacteristicValue

setCharacteristicValue

setCharacteristicValue

setDescriptorValue

setDescriptorValue

setDescriptorValue

enableNotifications

disableNotifications

enableIndications

disableIndications