giteadmin/script-astra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
script-astra/Android/Sdk/sources/android-35/android/bluetooth/BluetoothGatt.java

2214 lines
86 KiB
Java
Raw Permalink Normal View History

init
2025-01-20 15:15:20 +00:00
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.bluetooth;
import android.annotation.FlaggedApi;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.RequiresNoPermission;
import android.annotation.RequiresPermission;
import android.annotation.SuppressLint;
import android.bluetooth.BluetoothGattCharacteristic.WriteType;
import android.bluetooth.annotations.RequiresBluetoothConnectPermission;
import android.bluetooth.annotations.RequiresLegacyBluetoothPermission;
import android.compat.annotation.UnsupportedAppUsage;
import android.content.AttributionSource;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.ParcelUuid;
import android.os.RemoteException;
import android.util.Log;
import com.android.bluetooth.flags.Flags;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* Public API for the Bluetooth GATT Profile.
*
* <p>This class provides Bluetooth GATT functionality to enable communication with Bluetooth Smart
* or Smart Ready devices.
*
* <p>To connect to a remote peripheral device, create a {@link BluetoothGattCallback} and call
* {@link BluetoothDevice#connectGatt} to get a instance of this class. GATT capable devices can be
* discovered using the Bluetooth device discovery or BLE scan process.
*/
public final class BluetoothGatt implements BluetoothProfile {
private static final String TAG = "BluetoothGatt";
private static final boolean DBG = true;
private static final boolean VDBG = false;
@UnsupportedAppUsage private IBluetoothGatt mService;
@UnsupportedAppUsage private volatile BluetoothGattCallback mCallback;
private Handler mHandler;
@UnsupportedAppUsage private int mClientIf;
private BluetoothDevice mDevice;
@UnsupportedAppUsage private boolean mAutoConnect;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private int mAuthRetryState;
private int mConnState;
private final Object mStateLock = new Object();
private final Object mDeviceBusyLock = new Object();
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private Boolean mDeviceBusy = false;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private int mTransport;
private int mPhy;
private boolean mOpportunistic;
private final AttributionSource mAttributionSource;
private static final int AUTH_RETRY_STATE_IDLE = 0;
private static final int AUTH_RETRY_STATE_MITM = 2;
private static final int CONN_STATE_IDLE = 0;
private static final int CONN_STATE_CONNECTING = 1;
private static final int CONN_STATE_CONNECTED = 2;
private static final int CONN_STATE_CLOSED = 4;
private static final int WRITE_CHARACTERISTIC_MAX_RETRIES = 5;
private static final int WRITE_CHARACTERISTIC_TIME_TO_WAIT = 10; // milliseconds
// Max length of an attribute value, defined in gatt_api.h
private static final int GATT_MAX_ATTR_LEN = 512;
private List<BluetoothGattService> mServices;
/** A GATT operation completed successfully */
public static final int GATT_SUCCESS = 0;
/** GATT read operation is not permitted */
public static final int GATT_READ_NOT_PERMITTED = 0x2;
/** GATT write operation is not permitted */
public static final int GATT_WRITE_NOT_PERMITTED = 0x3;
/** Insufficient authentication for a given operation */
public static final int GATT_INSUFFICIENT_AUTHENTICATION = 0x5;
/** The given request is not supported */
public static final int GATT_REQUEST_NOT_SUPPORTED = 0x6;
/** Insufficient encryption for a given operation */
public static final int GATT_INSUFFICIENT_ENCRYPTION = 0xf;
/** A read or write operation was requested with an invalid offset */
public static final int GATT_INVALID_OFFSET = 0x7;
/** Insufficient authorization for a given operation */
public static final int GATT_INSUFFICIENT_AUTHORIZATION = 0x8;
/** A write operation exceeds the maximum length of the attribute */
public static final int GATT_INVALID_ATTRIBUTE_LENGTH = 0xd;
/** A remote device connection is congested. */
public static final int GATT_CONNECTION_CONGESTED = 0x8f;
/**
* GATT connection timed out, likely due to the remote device being out of range or not
* advertising as connectable.
*/
@FlaggedApi(Flags.FLAG_ENUMERATE_GATT_ERRORS)
public static final int GATT_CONNECTION_TIMEOUT = 0x93;
/** A GATT operation failed, errors other than the above */
public static final int GATT_FAILURE = 0x101;
/**
* Connection parameter update - Use the connection parameters recommended by the Bluetooth SIG.
* This is the default value if no connection parameter update is requested.
*/
public static final int CONNECTION_PRIORITY_BALANCED = 0;
/**
* Connection parameter update - Request a high priority, low latency connection. An application
* should only request high priority connection parameters to transfer large amounts of data
* over LE quickly. Once the transfer is complete, the application should request {@link
* BluetoothGatt#CONNECTION_PRIORITY_BALANCED} connection parameters to reduce energy use.
*/
public static final int CONNECTION_PRIORITY_HIGH = 1;
/** Connection parameter update - Request low power, reduced data rate connection parameters. */
public static final int CONNECTION_PRIORITY_LOW_POWER = 2;
/**
* Connection parameter update - Request the priority preferred for Digital Car Key for a lower
* latency connection. This connection parameter will consume more power than {@link
* BluetoothGatt#CONNECTION_PRIORITY_BALANCED}, so it is recommended that apps do not use this
* unless it specifically fits their use case.
*/
public static final int CONNECTION_PRIORITY_DCK = 3;
/**
* Connection subrate request - Balanced.
*
* @hide
*/
public static final int SUBRATE_REQUEST_MODE_BALANCED = 0;
/**
* Connection subrate request - High.
*
* @hide
*/
public static final int SUBRATE_REQUEST_MODE_HIGH = 1;
/**
* Connection Subrate Request - Low Power.
*
* @hide
*/
public static final int SUBRATE_REQUEST_MODE_LOW_POWER = 2;
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(
prefix = {"SUBRATE_REQUEST_MODE"},
value = {
SUBRATE_REQUEST_MODE_BALANCED,
SUBRATE_REQUEST_MODE_HIGH,
SUBRATE_REQUEST_MODE_LOW_POWER,
})
public @interface SubrateRequestMode {}
/**
* No authentication required.
*
* @hide
*/
/*package*/ static final int AUTHENTICATION_NONE = 0;
/**
* Authentication requested; no person-in-the-middle protection required.
*
* @hide
*/
/*package*/ static final int AUTHENTICATION_NO_MITM = 1;
/**
* Authentication with person-in-the-middle protection requested.
*
* @hide
*/
/*package*/ static final int AUTHENTICATION_MITM = 2;
/** Bluetooth GATT callbacks. Overrides the default BluetoothGattCallback implementation. */
@SuppressLint("AndroidFrameworkBluetoothPermission")
private final IBluetoothGattCallback mBluetoothGattCallback =
new IBluetoothGattCallback.Stub() {
/**
* Application interface registered - app is ready to go
*
* @hide
*/
@Override
@SuppressLint("AndroidFrameworkRequiresPermission")
public void onClientRegistered(int status, int clientIf) {
if (DBG) {
Log.d(
TAG,
"onClientRegistered() -"
+ (" status=" + status)
+ (" clientIf=" + clientIf));
}
mClientIf = clientIf;
synchronized (mStateLock) {
if (mConnState == CONN_STATE_CLOSED) {
if (DBG) {
Log.d(
TAG,
"Client registration completed after closed,"
+ " unregistering");
}
unregisterApp();
return;
}
if (VDBG) {
if (mConnState != CONN_STATE_CONNECTING) {
Log.e(TAG, "Bad connection state: " + mConnState);
}
}
}
if (status != GATT_SUCCESS) {
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onConnectionStateChange(
BluetoothGatt.this,
GATT_FAILURE,
BluetoothProfile.STATE_DISCONNECTED);
}
}
});
synchronized (mStateLock) {
mConnState = CONN_STATE_IDLE;
}
return;
}
try {
// autoConnect is inverse of "isDirect"
mService.clientConnect(
mClientIf,
mDevice.getAddress(),
mDevice.getAddressType(),
!mAutoConnect,
mTransport,
mOpportunistic,
mPhy,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
/**
* Phy update callback
*
* @hide
*/
@Override
public void onPhyUpdate(String address, int txPhy, int rxPhy, int status) {
if (DBG) {
Log.d(
TAG,
"onPhyUpdate() -"
+ (" status=" + status)
+ (" address=" + address)
+ (" txPhy=" + txPhy)
+ (" rxPhy=" + rxPhy));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onPhyUpdate(
BluetoothGatt.this, txPhy, rxPhy, status);
}
}
});
}
/**
* Phy read callback
*
* @hide
*/
@Override
public void onPhyRead(String address, int txPhy, int rxPhy, int status) {
if (DBG) {
Log.d(
TAG,
"onPhyRead() -"
+ (" status=" + status)
+ (" address=" + address)
+ (" txPhy=" + txPhy)
+ (" rxPhy=" + rxPhy));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onPhyRead(
BluetoothGatt.this, txPhy, rxPhy, status);
}
}
});
}
/**
* Client connection state changed
*
* @hide
*/
@Override
public void onClientConnectionState(
int status, int clientIf, boolean connected, String address) {
if (DBG) {
Log.d(
TAG,
"onClientConnectionState() -"
+ (" status=" + status)
+ (" clientIf=" + clientIf)
+ (" device=" + address));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
int profileState =
connected
? BluetoothProfile.STATE_CONNECTED
: BluetoothProfile.STATE_DISCONNECTED;
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onConnectionStateChange(
BluetoothGatt.this, status, profileState);
}
}
});
synchronized (mStateLock) {
if (connected) {
mConnState = CONN_STATE_CONNECTED;
} else {
mConnState = CONN_STATE_IDLE;
}
}
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
}
/**
* Remote search has been completed. The internal object structure should now
* reflect the state of the remote device database. Let the application know that we
* are done at this point.
*
* @hide
*/
@Override
public void onSearchComplete(
String address, List<BluetoothGattService> services, int status) {
if (DBG) {
Log.d(TAG, "onSearchComplete() = Device=" + address + " Status=" + status);
}
if (!address.equals(mDevice.getAddress())) {
return;
}
for (BluetoothGattService s : services) {
// services we receive don't have device set properly.
s.setDevice(mDevice);
}
mServices.addAll(services);
// Fix references to included services, as they doesn't point to right objects.
for (BluetoothGattService fixedService : mServices) {
ArrayList<BluetoothGattService> includedServices =
new ArrayList(fixedService.getIncludedServices());
fixedService.getIncludedServices().clear();
for (BluetoothGattService brokenRef : includedServices) {
BluetoothGattService includedService =
getService(
mDevice,
brokenRef.getUuid(),
brokenRef.getInstanceId());
if (includedService != null) {
fixedService.addIncludedService(includedService);
} else {
Log.e(TAG, "Broken GATT database: can't find included service.");
}
}
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onServicesDiscovered(BluetoothGatt.this, status);
}
}
});
}
/**
* Remote characteristic has been read. Updates the internal value.
*
* @hide
*/
@Override
@SuppressLint("AndroidFrameworkRequiresPermission")
public void onCharacteristicRead(
String address, int status, int handle, byte[] value) {
if (VDBG) {
Log.d(
TAG,
"onCharacteristicRead() -"
+ (" Device=" + address)
+ (" handle=" + handle)
+ (" Status=" + status));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
if ((status == GATT_INSUFFICIENT_AUTHENTICATION
|| status == GATT_INSUFFICIENT_ENCRYPTION)
&& (mAuthRetryState != AUTH_RETRY_STATE_MITM)) {
try {
final int authReq =
(mAuthRetryState == AUTH_RETRY_STATE_IDLE)
? AUTHENTICATION_NO_MITM
: AUTHENTICATION_MITM;
mService.readCharacteristic(
mClientIf, address, handle, authReq, mAttributionSource);
mAuthRetryState++;
return;
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
mAuthRetryState = AUTH_RETRY_STATE_IDLE;
BluetoothGattCharacteristic characteristic =
getCharacteristicById(mDevice, handle);
if (characteristic == null) {
Log.w(TAG, "onCharacteristicRead() failed to find characteristic!");
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
if (status == 0) characteristic.setValue(value);
callback.onCharacteristicRead(
BluetoothGatt.this, characteristic, value, status);
}
}
});
}
/**
* Characteristic has been written to the remote device. Let the app know how we
* did...
*
* @hide
*/
@Override
@SuppressLint("AndroidFrameworkRequiresPermission")
public void onCharacteristicWrite(
String address, int status, int handle, byte[] value) {
if (VDBG) {
Log.d(
TAG,
"onCharacteristicWrite() -"
+ (" Device=" + address)
+ (" handle=" + handle)
+ (" Status=" + status));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
BluetoothGattCharacteristic characteristic =
getCharacteristicById(mDevice, handle);
if (characteristic == null) return;
if ((status == GATT_INSUFFICIENT_AUTHENTICATION
|| status == GATT_INSUFFICIENT_ENCRYPTION)
&& (mAuthRetryState != AUTH_RETRY_STATE_MITM)) {
try {
final int authReq =
(mAuthRetryState == AUTH_RETRY_STATE_IDLE)
? AUTHENTICATION_NO_MITM
: AUTHENTICATION_MITM;
int requestStatus = BluetoothStatusCodes.ERROR_UNKNOWN;
for (int i = 0; i < WRITE_CHARACTERISTIC_MAX_RETRIES; i++) {
requestStatus =
mService.writeCharacteristic(
mClientIf,
address,
handle,
characteristic.getWriteType(),
authReq,
value,
mAttributionSource);
if (requestStatus
!= BluetoothStatusCodes.ERROR_GATT_WRITE_REQUEST_BUSY) {
break;
}
try {
Thread.sleep(WRITE_CHARACTERISTIC_TIME_TO_WAIT);
} catch (InterruptedException e) {
Log.e(TAG, "", e);
}
}
mAuthRetryState++;
return;
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
mAuthRetryState = AUTH_RETRY_STATE_IDLE;
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onCharacteristicWrite(
BluetoothGatt.this, characteristic, status);
}
}
});
}
/**
* Remote characteristic has been updated. Updates the internal value.
*
* @hide
*/
@Override
public void onNotify(String address, int handle, byte[] value) {
if (VDBG) Log.d(TAG, "onNotify() - Device=" + address + " handle=" + handle);
if (!address.equals(mDevice.getAddress())) {
return;
}
BluetoothGattCharacteristic characteristic =
getCharacteristicById(mDevice, handle);
if (characteristic == null) return;
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
characteristic.setValue(value);
callback.onCharacteristicChanged(
BluetoothGatt.this, characteristic, value);
}
}
});
}
/**
* Descriptor has been read.
*
* @hide
*/
@Override
@SuppressLint("AndroidFrameworkRequiresPermission")
public void onDescriptorRead(String address, int status, int handle, byte[] value) {
if (VDBG) {
Log.d(TAG, "onDescriptorRead() - Device=" + address + " handle=" + handle);
}
if (!address.equals(mDevice.getAddress())) {
return;
}
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
BluetoothGattDescriptor descriptor = getDescriptorById(mDevice, handle);
if (descriptor == null) return;
if ((status == GATT_INSUFFICIENT_AUTHENTICATION
|| status == GATT_INSUFFICIENT_ENCRYPTION)
&& (mAuthRetryState != AUTH_RETRY_STATE_MITM)) {
try {
final int authReq =
(mAuthRetryState == AUTH_RETRY_STATE_IDLE)
? AUTHENTICATION_NO_MITM
: AUTHENTICATION_MITM;
mService.readDescriptor(
mClientIf, address, handle, authReq, mAttributionSource);
mAuthRetryState++;
return;
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
mAuthRetryState = AUTH_RETRY_STATE_IDLE;
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
if (status == 0) descriptor.setValue(value);
callback.onDescriptorRead(
BluetoothGatt.this, descriptor, status, value);
}
}
});
}
/**
* Descriptor write operation complete.
*
* @hide
*/
@Override
@SuppressLint("AndroidFrameworkRequiresPermission")
public void onDescriptorWrite(
String address, int status, int handle, byte[] value) {
if (VDBG) {
Log.d(TAG, "onDescriptorWrite() - Device=" + address + " handle=" + handle);
}
if (!address.equals(mDevice.getAddress())) {
return;
}
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
BluetoothGattDescriptor descriptor = getDescriptorById(mDevice, handle);
if (descriptor == null) return;
if ((status == GATT_INSUFFICIENT_AUTHENTICATION
|| status == GATT_INSUFFICIENT_ENCRYPTION)
&& (mAuthRetryState != AUTH_RETRY_STATE_MITM)) {
try {
final int authReq =
(mAuthRetryState == AUTH_RETRY_STATE_IDLE)
? AUTHENTICATION_NO_MITM
: AUTHENTICATION_MITM;
mService.writeDescriptor(
mClientIf, address, handle, authReq, value, mAttributionSource);
mAuthRetryState++;
return;
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
mAuthRetryState = AUTH_RETRY_STATE_IDLE;
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onDescriptorWrite(
BluetoothGatt.this, descriptor, status);
}
}
});
}
/**
* Prepared write transaction completed (or aborted)
*
* @hide
*/
@Override
public void onExecuteWrite(String address, int status) {
if (VDBG) {
Log.d(TAG, "onExecuteWrite() - Device=" + address + " status=" + status);
}
if (!address.equals(mDevice.getAddress())) {
return;
}
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onReliableWriteCompleted(
BluetoothGatt.this, status);
}
}
});
}
/**
* Remote device RSSI has been read
*
* @hide
*/
@Override
public void onReadRemoteRssi(String address, int rssi, int status) {
if (VDBG) {
Log.d(
TAG,
"onReadRemoteRssi() -"
+ (" Device=" + address)
+ (" rssi=" + rssi)
+ (" status=" + status));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onReadRemoteRssi(BluetoothGatt.this, rssi, status);
}
}
});
}
/**
* Callback invoked when the MTU for a given connection changes
*
* @hide
*/
@Override
public void onConfigureMTU(String address, int mtu, int status) {
if (DBG) {
Log.d(
TAG,
"onConfigureMTU() -"
+ (" Device=" + address)
+ (" mtu=" + mtu)
+ (" status=" + status));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onMtuChanged(BluetoothGatt.this, mtu, status);
}
}
});
}
/**
* Callback invoked when the given connection is updated
*
* @hide
*/
@Override
public void onConnectionUpdated(
String address, int interval, int latency, int timeout, int status) {
if (DBG) {
Log.d(
TAG,
"onConnectionUpdated() -"
+ (" Device=" + address)
+ (" interval=" + interval)
+ (" latency=" + latency)
+ (" timeout=" + timeout)
+ (" status=" + status));
}
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onConnectionUpdated(
BluetoothGatt.this,
interval,
latency,
timeout,
status);
}
}
});
}
/**
* Callback invoked when service changed event is received
*
* @hide
*/
@Override
public void onServiceChanged(String address) {
if (DBG) {
Log.d(TAG, "onServiceChanged() - Device=" + address);
}
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onServiceChanged(BluetoothGatt.this);
}
}
});
}
/**
* Callback invoked when the given connection's subrate is changed
*
* @hide
*/
@Override
public void onSubrateChange(
String address,
int subrateFactor,
int latency,
int contNum,
int timeout,
int status) {
Log.d(
TAG,
"onSubrateChange() - "
+ (" Device=" + address)
+ (" subrateFactor=" + subrateFactor)
+ (" latency=" + latency)
+ (" contNum=" + contNum)
+ (" timeout=" + timeout)
+ (" status=" + status));
if (!address.equals(mDevice.getAddress())) {
return;
}
runOrQueueCallback(
new Runnable() {
@Override
public void run() {
final BluetoothGattCallback callback = mCallback;
if (callback != null) {
callback.onSubrateChange(
BluetoothGatt.this,
subrateFactor,
latency,
contNum,
timeout,
status);
}
}
});
}
};
/* package */ BluetoothGatt(
IBluetoothGatt iGatt,
BluetoothDevice device,
int transport,
boolean opportunistic,
int phy,
AttributionSource attributionSource) {
mService = iGatt;
mDevice = device;
mTransport = transport;
mPhy = phy;
mOpportunistic = opportunistic;
mAttributionSource = attributionSource;
mServices = new ArrayList<BluetoothGattService>();
mConnState = CONN_STATE_IDLE;
mAuthRetryState = AUTH_RETRY_STATE_IDLE;
}
/** @hide */
@Override
public void onServiceConnected(IBinder service) {}
/** @hide */
@Override
public void onServiceDisconnected() {}
/** @hide */
@Override
public BluetoothAdapter getAdapter() {
return null;
}
/**
* Close this Bluetooth GATT client.
*
* <p>Application should call this method as early as possible after it is done with this GATT
* client.
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public void close() {
if (DBG) Log.d(TAG, "close()");
unregisterApp();
mConnState = CONN_STATE_CLOSED;
mAuthRetryState = AUTH_RETRY_STATE_IDLE;
}
/**
* Returns a service by UUID, instance and type.
*
* @hide
*/
/*package*/ BluetoothGattService getService(BluetoothDevice device, UUID uuid, int instanceId) {
for (BluetoothGattService svc : mServices) {
if (svc.getDevice().equals(device)
&& svc.getInstanceId() == instanceId
&& svc.getUuid().equals(uuid)) {
return svc;
}
}
return null;
}
/**
* Returns a characteristic with id equal to instanceId.
*
* @hide
*/
/*package*/ BluetoothGattCharacteristic getCharacteristicById(
BluetoothDevice device, int instanceId) {
for (BluetoothGattService svc : mServices) {
for (BluetoothGattCharacteristic charac : svc.getCharacteristics()) {
if (charac.getInstanceId() == instanceId) {
return charac;
}
}
}
return null;
}
/**
* Returns a descriptor with id equal to instanceId.
*
* @hide
*/
/*package*/ BluetoothGattDescriptor getDescriptorById(BluetoothDevice device, int instanceId) {
for (BluetoothGattService svc : mServices) {
for (BluetoothGattCharacteristic charac : svc.getCharacteristics()) {
for (BluetoothGattDescriptor desc : charac.getDescriptors()) {
if (desc.getInstanceId() == instanceId) {
return desc;
}
}
}
}
return null;
}
/**
* Queue the runnable on a {@link Handler} provided by the user, or execute the runnable
* immediately if no Handler was provided.
*/
private void runOrQueueCallback(final Runnable cb) {
if (mHandler == null) {
try {
cb.run();
} catch (Exception ex) {
Log.w(TAG, "Unhandled exception in callback", ex);
}
} else {
mHandler.post(cb);
}
}
/**
* Register an application callback to start using GATT.
*
* <p>This is an asynchronous call. The callback {@link BluetoothGattCallback#onAppRegistered}
* is used to notify success or failure if the function returns true.
*
* @param callback GATT callback handler that will receive asynchronous callbacks.
* @return If true, the callback will be called to notify success or failure, false on immediate
* error
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
private boolean registerApp(BluetoothGattCallback callback, Handler handler) {
return registerApp(callback, handler, false);
}
/**
* Register an application callback to start using GATT.
*
* <p>This is an asynchronous call. The callback {@link BluetoothGattCallback#onAppRegistered}
* is used to notify success or failure if the function returns true.
*
* @param callback GATT callback handler that will receive asynchronous callbacks.
* @param eattSupport indicate to allow for eatt support
* @return If true, the callback will be called to notify success or failure, false on immediate
* error
* @hide
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
private boolean registerApp(
BluetoothGattCallback callback, Handler handler, boolean eattSupport) {
if (DBG) Log.d(TAG, "registerApp()");
if (mService == null) return false;
mCallback = callback;
mHandler = handler;
UUID uuid = UUID.randomUUID();
if (DBG) Log.d(TAG, "registerApp() - UUID=" + uuid);
try {
mService.registerClient(
new ParcelUuid(uuid), mBluetoothGattCallback, eattSupport, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/** Unregister the current application and callbacks. */
@UnsupportedAppUsage
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
private void unregisterApp() {
if (mService == null || mClientIf == 0) return;
if (DBG) Log.d(TAG, "unregisterApp() - mClientIf=" + mClientIf);
try {
mCallback = null;
mService.unregisterClient(mClientIf, mAttributionSource);
mClientIf = 0;
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
/**
* Initiate a connection to a Bluetooth GATT capable device.
*
* <p>The connection may not be established right away, but will be completed when the remote
* device is available. A {@link BluetoothGattCallback#onConnectionStateChange} callback will be
* invoked when the connection state changes as a result of this function.
*
* <p>The autoConnect parameter determines whether to actively connect to the remote device, or
* rather passively scan and finalize the connection when the remote device is in
* range/available. Generally, the first ever connection to a device should be direct
* (autoConnect set to false) and subsequent connections to known devices should be invoked with
* the autoConnect parameter set to true.
*
* @param autoConnect Whether to directly connect to the remote device (false) or to
* automatically connect as soon as the remote device becomes available (true).
* @return true, if the connection attempt was initiated successfully
*/
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
/*package*/ boolean connect(
Boolean autoConnect, BluetoothGattCallback callback, Handler handler) {
if (DBG) {
Log.d(TAG, "connect() - device: " + mDevice + ", auto: " + autoConnect);
}
synchronized (mStateLock) {
if (mConnState != CONN_STATE_IDLE) {
throw new IllegalStateException("Not idle");
}
mConnState = CONN_STATE_CONNECTING;
}
mAutoConnect = autoConnect;
if (!registerApp(callback, handler)) {
synchronized (mStateLock) {
mConnState = CONN_STATE_IDLE;
}
Log.e(TAG, "Failed to register callback");
return false;
}
// The connection will continue in the onClientRegistered callback
return true;
}
/**
* Disconnects an established connection, or cancels a connection attempt currently in progress.
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public void disconnect() {
if (DBG) Log.d(TAG, "cancelOpen() - device: " + mDevice);
if (mService == null || mClientIf == 0) return;
try {
mService.clientDisconnect(mClientIf, mDevice.getAddress(), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
/**
* Connect back to remote device.
*
* <p>This method is used to re-connect to a remote device after the connection has been
* dropped. If the device is not in range, the re-connection will be triggered once the device
* is back in range.
*
* @return true, if the connection attempt was initiated successfully
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean connect() {
try {
if (DBG) {
Log.d(TAG, "connect(void) - device: " + mDevice + ", auto=" + mAutoConnect);
}
// autoConnect is inverse of "isDirect"
mService.clientConnect(
mClientIf,
mDevice.getAddress(),
mDevice.getAddressType(),
!mAutoConnect,
mTransport,
mOpportunistic,
mPhy,
mAttributionSource);
return true;
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
}
/**
* Set the preferred connection PHY for this app. Please note that this is just a
* recommendation, whether the PHY change will happen depends on other applications preferences,
* local and remote controller capabilities. Controller can override these settings.
*
* <p>{@link BluetoothGattCallback#onPhyUpdate} will be triggered as a result of this call, even
* if no PHY change happens. It is also triggered when remote device updates the PHY.
*
* @param txPhy preferred transmitter PHY. Bitwise OR of any of {@link
* BluetoothDevice#PHY_LE_1M_MASK}, {@link BluetoothDevice#PHY_LE_2M_MASK}, and {@link
* BluetoothDevice#PHY_LE_CODED_MASK}.
* @param rxPhy preferred receiver PHY. Bitwise OR of any of {@link
* BluetoothDevice#PHY_LE_1M_MASK}, {@link BluetoothDevice#PHY_LE_2M_MASK}, and {@link
* BluetoothDevice#PHY_LE_CODED_MASK}.
* @param phyOptions preferred coding to use when transmitting on the LE Coded PHY. Can be one
* of {@link BluetoothDevice#PHY_OPTION_NO_PREFERRED}, {@link BluetoothDevice#PHY_OPTION_S2}
* or {@link BluetoothDevice#PHY_OPTION_S8}
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public void setPreferredPhy(int txPhy, int rxPhy, int phyOptions) {
try {
mService.clientSetPreferredPhy(
mClientIf, mDevice.getAddress(), txPhy, rxPhy, phyOptions, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
/**
* Read the current transmitter PHY and receiver PHY of the connection. The values are returned
* in {@link BluetoothGattCallback#onPhyRead}
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public void readPhy() {
try {
mService.clientReadPhy(mClientIf, mDevice.getAddress(), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
/**
* Return the remote bluetooth device this GATT client targets to
*
* @return remote bluetooth device
*/
@RequiresNoPermission
public BluetoothDevice getDevice() {
return mDevice;
}
/**
* Discovers services offered by a remote device as well as their characteristics and
* descriptors.
*
* <p>This is an asynchronous operation. Once service discovery is completed, the {@link
* BluetoothGattCallback#onServicesDiscovered} callback is triggered. If the discovery was
* successful, the remote services can be retrieved using the {@link #getServices} function.
*
* @return true, if the remote service discovery has been started
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean discoverServices() {
if (DBG) Log.d(TAG, "discoverServices() - device: " + mDevice);
if (mService == null || mClientIf == 0) return false;
mServices.clear();
try {
mService.discoverServices(mClientIf, mDevice.getAddress(), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Discovers a service by UUID. This is exposed only for passing PTS tests. It should never be
* used by real applications. The service is not searched for characteristics and descriptors,
* or returned in any callback.
*
* @return true, if the remote service discovery has been started
* @hide
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean discoverServiceByUuid(UUID uuid) {
if (DBG) Log.d(TAG, "discoverServiceByUuid() - device: " + mDevice);
if (mService == null || mClientIf == 0) return false;
mServices.clear();
try {
mService.discoverServiceByUuid(
mClientIf, mDevice.getAddress(), new ParcelUuid(uuid), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Returns a list of GATT services offered by the remote device.
*
* <p>This function requires that service discovery has been completed for the given device.
*
* @return List of services on the remote device. Returns an empty list if service discovery has
* not yet been performed.
*/
@RequiresLegacyBluetoothPermission
@RequiresNoPermission
public List<BluetoothGattService> getServices() {
List<BluetoothGattService> result = new ArrayList<BluetoothGattService>();
for (BluetoothGattService service : mServices) {
if (service.getDevice().equals(mDevice)) {
result.add(service);
}
}
return result;
}
/**
* Returns a {@link BluetoothGattService}, if the requested UUID is supported by the remote
* device.
*
* <p>This function requires that service discovery has been completed for the given device.
*
* <p>If multiple instances of the same service (as identified by UUID) exist, the first
* instance of the service is returned.
*
* @param uuid UUID of the requested service
* @return BluetoothGattService if supported, or null if the requested service is not offered by
* the remote device.
*/
@RequiresLegacyBluetoothPermission
@RequiresNoPermission
public BluetoothGattService getService(UUID uuid) {
for (BluetoothGattService service : mServices) {
if (service.getDevice().equals(mDevice) && service.getUuid().equals(uuid)) {
return service;
}
}
return null;
}
/**
* Reads the requested characteristic from the associated remote device.
*
* <p>This is an asynchronous operation. The result of the read operation is reported by the
* {@link BluetoothGattCallback#onCharacteristicRead(BluetoothGatt, BluetoothGattCharacteristic,
* byte[], int)} callback.
*
* @param characteristic Characteristic to read from the remote device
* @return true, if the read operation was initiated successfully
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean readCharacteristic(BluetoothGattCharacteristic characteristic) {
if ((characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) == 0) {
return false;
}
if (VDBG) Log.d(TAG, "readCharacteristic() - uuid: " + characteristic.getUuid());
if (mService == null || mClientIf == 0) return false;
BluetoothGattService service = characteristic.getService();
if (service == null) return false;
BluetoothDevice device = service.getDevice();
if (device == null) return false;
synchronized (mDeviceBusyLock) {
if (mDeviceBusy) return false;
mDeviceBusy = true;
}
try {
mService.readCharacteristic(
mClientIf,
device.getAddress(),
characteristic.getInstanceId(),
AUTHENTICATION_NONE,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
return false;
}
return true;
}
/**
* Reads the characteristic using its UUID from the associated remote device.
*
* <p>This is an asynchronous operation. The result of the read operation is reported by the
* {@link BluetoothGattCallback#onCharacteristicRead(BluetoothGatt, BluetoothGattCharacteristic,
* byte[], int)} callback.
*
* @param uuid UUID of characteristic to read from the remote device
* @return true, if the read operation was initiated successfully
* @hide
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean readUsingCharacteristicUuid(UUID uuid, int startHandle, int endHandle) {
if (VDBG) Log.d(TAG, "readUsingCharacteristicUuid() - uuid: " + uuid);
if (mService == null || mClientIf == 0) return false;
synchronized (mDeviceBusyLock) {
if (mDeviceBusy) return false;
mDeviceBusy = true;
}
try {
mService.readUsingCharacteristicUuid(
mClientIf,
mDevice.getAddress(),
new ParcelUuid(uuid),
startHandle,
endHandle,
AUTHENTICATION_NONE,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
return false;
}
return true;
}
/**
* Writes a given characteristic and its values to the associated remote device.
*
* <p>Once the write operation has been completed, the {@link
* BluetoothGattCallback#onCharacteristicWrite} callback is invoked, reporting the result of the
* operation.
*
* @param characteristic Characteristic to write on the remote device
* @return true, if the write operation was initiated successfully
* @throws IllegalArgumentException if characteristic or its value are null
* @deprecated Use {@link BluetoothGatt#writeCharacteristic(BluetoothGattCharacteristic, byte[],
* int)} as this is not memory safe because it relies on a {@link
* BluetoothGattCharacteristic} object whose underlying fields are subject to change outside
* this method.
*/
@Deprecated
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean writeCharacteristic(BluetoothGattCharacteristic characteristic) {
try {
return writeCharacteristic(
characteristic,
characteristic.getValue(),
characteristic.getWriteType())
== BluetoothStatusCodes.SUCCESS;
} catch (Exception e) {
return false;
}
}
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(
value = {
BluetoothStatusCodes.SUCCESS,
BluetoothStatusCodes.ERROR_MISSING_BLUETOOTH_CONNECT_PERMISSION,
BluetoothStatusCodes.ERROR_DEVICE_NOT_CONNECTED,
BluetoothStatusCodes.ERROR_PROFILE_SERVICE_NOT_BOUND,
BluetoothStatusCodes.ERROR_GATT_WRITE_NOT_ALLOWED,
BluetoothStatusCodes.ERROR_GATT_WRITE_REQUEST_BUSY,
BluetoothStatusCodes.ERROR_UNKNOWN
})
public @interface WriteOperationReturnValues {}
/**
* Writes a given characteristic and its values to the associated remote device.
*
* <p>Once the write operation has been completed, the {@link
* BluetoothGattCallback#onCharacteristicWrite} callback is invoked, reporting the result of the
* operation.
*
* @param characteristic Characteristic to write on the remote device
* @return whether the characteristic was successfully written to
* @throws IllegalArgumentException if characteristic or value are null
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
@WriteOperationReturnValues
public int writeCharacteristic(
@NonNull BluetoothGattCharacteristic characteristic,
@NonNull byte[] value,
@WriteType int writeType) {
if (characteristic == null) {
throw new IllegalArgumentException("characteristic must not be null");
}
if (value == null) {
throw new IllegalArgumentException("value must not be null");
}
if (value.length > GATT_MAX_ATTR_LEN) {
throw new IllegalArgumentException(
"value should not be longer than max length of an attribute value");
}
if (VDBG) Log.d(TAG, "writeCharacteristic() - uuid: " + characteristic.getUuid());
if ((characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_WRITE) == 0
&& (characteristic.getProperties()
& BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE)
== 0) {
return BluetoothStatusCodes.ERROR_GATT_WRITE_NOT_ALLOWED;
}
if (mService == null || mClientIf == 0) {
return BluetoothStatusCodes.ERROR_PROFILE_SERVICE_NOT_BOUND;
}
BluetoothGattService service = characteristic.getService();
if (service == null) {
throw new IllegalArgumentException("Characteristic must have a non-null service");
}
BluetoothDevice device = service.getDevice();
if (device == null) {
throw new IllegalArgumentException("Service must have a non-null device");
}
synchronized (mDeviceBusyLock) {
if (mDeviceBusy) {
return BluetoothStatusCodes.ERROR_GATT_WRITE_REQUEST_BUSY;
}
mDeviceBusy = true;
}
int requestStatus = BluetoothStatusCodes.ERROR_UNKNOWN;
try {
for (int i = 0; i < WRITE_CHARACTERISTIC_MAX_RETRIES; i++) {
requestStatus =
mService.writeCharacteristic(
mClientIf,
device.getAddress(),
characteristic.getInstanceId(),
writeType,
AUTHENTICATION_NONE,
value,
mAttributionSource);
if (requestStatus != BluetoothStatusCodes.ERROR_GATT_WRITE_REQUEST_BUSY) {
break;
}
try {
Thread.sleep(WRITE_CHARACTERISTIC_TIME_TO_WAIT);
} catch (InterruptedException e) {
Log.e(TAG, "", e);
}
}
} catch (RemoteException e) {
Log.e(TAG, "", e);
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
throw e.rethrowAsRuntimeException();
}
if (Flags.gattFixDeviceBusy()) {
if (requestStatus != BluetoothStatusCodes.SUCCESS) {
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
}
}
return requestStatus;
}
/**
* Reads the value for a given descriptor from the associated remote device.
*
* <p>Once the read operation has been completed, the {@link
* BluetoothGattCallback#onDescriptorRead} callback is triggered, signaling the result of the
* operation.
*
* @param descriptor Descriptor value to read from the remote device
* @return true, if the read operation was initiated successfully
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean readDescriptor(BluetoothGattDescriptor descriptor) {
if (VDBG) Log.d(TAG, "readDescriptor() - uuid: " + descriptor.getUuid());
if (mService == null || mClientIf == 0) return false;
BluetoothGattCharacteristic characteristic = descriptor.getCharacteristic();
if (characteristic == null) return false;
BluetoothGattService service = characteristic.getService();
if (service == null) return false;
BluetoothDevice device = service.getDevice();
if (device == null) return false;
synchronized (mDeviceBusyLock) {
if (mDeviceBusy) return false;
mDeviceBusy = true;
}
try {
mService.readDescriptor(
mClientIf,
device.getAddress(),
descriptor.getInstanceId(),
AUTHENTICATION_NONE,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
return false;
}
return true;
}
/**
* Write the value of a given descriptor to the associated remote device.
*
* <p>A {@link BluetoothGattCallback#onDescriptorWrite} callback is triggered to report the
* result of the write operation.
*
* @param descriptor Descriptor to write to the associated remote device
* @return true, if the write operation was initiated successfully
* @throws IllegalArgumentException if descriptor or its value are null
* @deprecated Use {@link BluetoothGatt#writeDescriptor(BluetoothGattDescriptor, byte[])} as
* this is not memory safe because it relies on a {@link BluetoothGattDescriptor} object
* whose underlying fields are subject to change outside this method.
*/
@Deprecated
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean writeDescriptor(BluetoothGattDescriptor descriptor) {
try {
return writeDescriptor(descriptor, descriptor.getValue())
== BluetoothStatusCodes.SUCCESS;
} catch (Exception e) {
return false;
}
}
/**
* Write the value of a given descriptor to the associated remote device.
*
* <p>A {@link BluetoothGattCallback#onDescriptorWrite} callback is triggered to report the
* result of the write operation.
*
* @param descriptor Descriptor to write to the associated remote device
* @return true, if the write operation was initiated successfully
* @throws IllegalArgumentException if descriptor or value are null
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
@WriteOperationReturnValues
public int writeDescriptor(@NonNull BluetoothGattDescriptor descriptor, @NonNull byte[] value) {
if (descriptor == null) {
throw new IllegalArgumentException("descriptor must not be null");
}
if (value == null) {
throw new IllegalArgumentException("value must not be null");
}
if (VDBG) Log.d(TAG, "writeDescriptor() - uuid: " + descriptor.getUuid());
if (mService == null || mClientIf == 0) {
return BluetoothStatusCodes.ERROR_PROFILE_SERVICE_NOT_BOUND;
}
BluetoothGattCharacteristic characteristic = descriptor.getCharacteristic();
if (characteristic == null) {
throw new IllegalArgumentException("Descriptor must have a non-null characteristic");
}
BluetoothGattService service = characteristic.getService();
if (service == null) {
throw new IllegalArgumentException("Characteristic must have a non-null service");
}
BluetoothDevice device = service.getDevice();
if (device == null) {
throw new IllegalArgumentException("Service must have a non-null device");
}
synchronized (mDeviceBusyLock) {
if (mDeviceBusy) return BluetoothStatusCodes.ERROR_GATT_WRITE_REQUEST_BUSY;
mDeviceBusy = true;
}
try {
return mService.writeDescriptor(
mClientIf,
device.getAddress(),
descriptor.getInstanceId(),
AUTHENTICATION_NONE,
value,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
throw e.rethrowAsRuntimeException();
}
}
/**
* Initiates a reliable write transaction for a given remote device.
*
* <p>Once a reliable write transaction has been initiated, all calls to {@link
* #writeCharacteristic} are sent to the remote device for verification and queued up for atomic
* execution. The application will receive a {@link BluetoothGattCallback#onCharacteristicWrite}
* callback in response to every {@link #writeCharacteristic(BluetoothGattCharacteristic,
* byte[], int)} call and is responsible for verifying if the value has been transmitted
* accurately.
*
* <p>After all characteristics have been queued up and verified, {@link #executeReliableWrite}
* will execute all writes. If a characteristic was not written correctly, calling {@link
* #abortReliableWrite} will cancel the current transaction without committing any values on the
* remote device.
*
* @return true, if the reliable write transaction has been initiated
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean beginReliableWrite() {
if (VDBG) Log.d(TAG, "beginReliableWrite() - device: " + mDevice);
if (mService == null || mClientIf == 0) return false;
try {
mService.beginReliableWrite(mClientIf, mDevice.getAddress(), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Executes a reliable write transaction for a given remote device.
*
* <p>This function will commit all queued up characteristic write operations for a given remote
* device.
*
* <p>A {@link BluetoothGattCallback#onReliableWriteCompleted} callback is invoked to indicate
* whether the transaction has been executed correctly.
*
* @return true, if the request to execute the transaction has been sent
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean executeReliableWrite() {
if (VDBG) Log.d(TAG, "executeReliableWrite() - device: " + mDevice);
if (mService == null || mClientIf == 0) return false;
synchronized (mDeviceBusyLock) {
if (mDeviceBusy) return false;
mDeviceBusy = true;
}
try {
mService.endReliableWrite(mClientIf, mDevice.getAddress(), true, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
synchronized (mDeviceBusyLock) {
mDeviceBusy = false;
}
return false;
}
return true;
}
/**
* Cancels a reliable write transaction for a given device.
*
* <p>Calling this function will discard all queued characteristic write operations for a given
* remote device.
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public void abortReliableWrite() {
if (VDBG) Log.d(TAG, "abortReliableWrite() - device: " + mDevice);
if (mService == null || mClientIf == 0) return;
try {
mService.endReliableWrite(mClientIf, mDevice.getAddress(), false, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
}
}
/**
* @deprecated Use {@link #abortReliableWrite()}
*/
@Deprecated
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public void abortReliableWrite(BluetoothDevice mDevice) {
abortReliableWrite();
}
/**
* Enable or disable notifications/indications for a given characteristic.
*
* <p>Once notifications are enabled for a characteristic, a {@link
* BluetoothGattCallback#onCharacteristicChanged(BluetoothGatt, BluetoothGattCharacteristic,
* byte[])} callback will be triggered if the remote device indicates that the given
* characteristic has changed.
*
* @param characteristic The characteristic for which to enable notifications
* @param enable Set to true to enable notifications/indications
* @return true, if the requested notification status was set successfully
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean setCharacteristicNotification(
BluetoothGattCharacteristic characteristic, boolean enable) {
if (DBG) {
Log.d(
TAG,
"setCharacteristicNotification() - uuid: "
+ characteristic.getUuid()
+ " enable: "
+ enable);
}
if (mService == null || mClientIf == 0) return false;
BluetoothGattService service = characteristic.getService();
if (service == null) return false;
BluetoothDevice device = service.getDevice();
if (device == null) return false;
try {
mService.registerForNotification(
mClientIf,
device.getAddress(),
characteristic.getInstanceId(),
enable,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Clears the internal cache and forces a refresh of the services from the remote device.
*
* @hide
*/
@UnsupportedAppUsage
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean refresh() {
if (DBG) Log.d(TAG, "refresh() - device: " + mDevice);
if (mService == null || mClientIf == 0) return false;
try {
mService.refreshDevice(mClientIf, mDevice.getAddress(), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Read the RSSI for a connected remote device.
*
* <p>The {@link BluetoothGattCallback#onReadRemoteRssi} callback will be invoked when the RSSI
* value has been read.
*
* @return true, if the RSSI value has been requested successfully
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean readRemoteRssi() {
if (DBG) Log.d(TAG, "readRssi() - device: " + mDevice);
if (mService == null || mClientIf == 0) return false;
try {
mService.readRemoteRssi(mClientIf, mDevice.getAddress(), mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Request an MTU size used for a given connection. Please note that starting from Android 14,
* the Android Bluetooth stack requests the BLE ATT MTU to 517 bytes when the first GATT client
* requests an MTU, and disregards all subsequent MTU requests. Check out <a
* href="{@docRoot}about/versions/14/behavior-changes-all#mtu-set-to-517">MTU is set to 517 for
* the first GATT client requesting an MTU</a> for more information.
*
* <p>When performing a write request operation (write without response), the data sent is
* truncated to the MTU size. This function may be used to request a larger MTU size to be able
* to send more data at once.
*
* <p>A {@link BluetoothGattCallback#onMtuChanged} callback will indicate whether this operation
* was successful.
*
* @return true, if the new MTU value has been requested successfully
*/
@RequiresLegacyBluetoothPermission
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean requestMtu(int mtu) {
if (DBG) {
Log.d(TAG, "configureMTU() - device: " + mDevice + " mtu: " + mtu);
}
if (mService == null || mClientIf == 0) return false;
try {
mService.configureMTU(mClientIf, mDevice.getAddress(), mtu, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Request a connection parameter update.
*
* <p>This function will send a connection parameter update request to the remote device.
*
* @param connectionPriority Request a specific connection priority. Must be one of {@link
* BluetoothGatt#CONNECTION_PRIORITY_BALANCED}, {@link
* BluetoothGatt#CONNECTION_PRIORITY_HIGH} {@link
* BluetoothGatt#CONNECTION_PRIORITY_LOW_POWER}, or {@link
* BluetoothGatt#CONNECTION_PRIORITY_DCK}.
* @throws IllegalArgumentException If the parameters are outside of their specified range.
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean requestConnectionPriority(int connectionPriority) {
if (connectionPriority < CONNECTION_PRIORITY_BALANCED
|| connectionPriority > CONNECTION_PRIORITY_DCK) {
throw new IllegalArgumentException("connectionPriority not within valid range");
}
if (DBG) Log.d(TAG, "requestConnectionPriority() - params: " + connectionPriority);
if (mService == null || mClientIf == 0) return false;
try {
mService.connectionParameterUpdate(
mClientIf, mDevice.getAddress(), connectionPriority, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Request an LE connection parameter update.
*
* <p>This function will send an LE connection parameters update request to the remote device.
*
* @return true, if the request is send to the Bluetooth stack.
* @hide
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean requestLeConnectionUpdate(
int minConnectionInterval,
int maxConnectionInterval,
int slaveLatency,
int supervisionTimeout,
int minConnectionEventLen,
int maxConnectionEventLen) {
if (DBG) {
Log.d(
TAG,
"requestLeConnectionUpdate() - min=("
+ minConnectionInterval
+ ")"
+ (1.25 * minConnectionInterval)
+ "msec, max=("
+ maxConnectionInterval
+ ")"
+ (1.25 * maxConnectionInterval)
+ "msec, latency="
+ slaveLatency
+ ", timeout="
+ supervisionTimeout
+ "msec"
+ ", min_ce="
+ minConnectionEventLen
+ ", max_ce="
+ maxConnectionEventLen);
}
if (mService == null || mClientIf == 0) return false;
try {
mService.leConnectionUpdate(
mClientIf,
mDevice.getAddress(),
minConnectionInterval,
maxConnectionInterval,
slaveLatency,
supervisionTimeout,
minConnectionEventLen,
maxConnectionEventLen,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Request LE subrate mode.
*
* <p>This function will send a LE subrate request to the remote device.
*
* @param subrateMode Request a specific subrate mode.
* @throws IllegalArgumentException If the parameters are outside of their specified range.
* @return true, if the request is send to the Bluetooth stack.
* @hide
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean requestSubrateMode(@SubrateRequestMode int subrateMode) {
if (subrateMode < SUBRATE_REQUEST_MODE_BALANCED
|| subrateMode > SUBRATE_REQUEST_MODE_LOW_POWER) {
throw new IllegalArgumentException("Subrate Mode not within valid range");
}
if (DBG) {
Log.d(TAG, "requestsubrateMode() - subrateMode: " + subrateMode);
}
if (mService == null || mClientIf == 0) {
return false;
}
try {
mService.subrateModeRequest(
mClientIf, mDevice.getAddress(), subrateMode, mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* Request a LE subrate request.
*
* <p>This function will send a LE subrate request to the remote device.
*
* @return true, if the request is send to the Bluetooth stack.
* @hide
*/
@RequiresBluetoothConnectPermission
@RequiresPermission(android.Manifest.permission.BLUETOOTH_CONNECT)
public boolean bleSubrateRequest(
int subrateMin,
int subrateMax,
int maxLatency,
int contNumber,
int supervisionTimeout) {
if (DBG) {
Log.d(
TAG,
"bleSubrateRequest() - subrateMin="
+ subrateMin
+ " subrateMax="
+ (subrateMax)
+ " maxLatency= "
+ maxLatency
+ "contNumber="
+ contNumber
+ " supervisionTimeout="
+ supervisionTimeout);
}
if (mService == null || mClientIf == 0) {
return false;
}
try {
mService.leSubrateRequest(
mClientIf,
mDevice.getAddress(),
subrateMin,
subrateMax,
maxLatency,
contNumber,
supervisionTimeout,
mAttributionSource);
} catch (RemoteException e) {
Log.e(TAG, "", e);
return false;
}
return true;
}
/**
* @deprecated Not supported - please use {@link BluetoothManager#getConnectedDevices(int)} with
* {@link BluetoothProfile#GATT} as argument
* @throws UnsupportedOperationException on every call
*/
@Override
@RequiresNoPermission
@Deprecated
public int getConnectionState(BluetoothDevice device) {
throw new UnsupportedOperationException("Use BluetoothManager#getConnectionState instead.");
}
/**
* @deprecated Not supported - please use {@link BluetoothManager#getConnectedDevices(int)} with
* {@link BluetoothProfile#GATT} as argument
* @throws UnsupportedOperationException on every call
*/
@Override
@RequiresNoPermission
@Deprecated
public List<BluetoothDevice> getConnectedDevices() {
throw new UnsupportedOperationException(
"Use BluetoothManager#getConnectedDevices instead.");
}
/**
* @deprecated Not supported - please use {@link
* BluetoothManager#getDevicesMatchingConnectionStates(int, int[])} with {@link
* BluetoothProfile#GATT} as first argument
* @throws UnsupportedOperationException on every call
*/
@Override
@RequiresNoPermission
@Deprecated
public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
throw new UnsupportedOperationException(
"Use BluetoothManager#getDevicesMatchingConnectionStates instead.");
}
}
Reference in New Issue Copy Permalink