下面列出了android.bluetooth.BluetoothGatt#readCharacteristic ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
Log.d(TAG, "characteristic wrote " + status);
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.d(TAG, "Wrote a characteristic successfully " + characteristic.getUuid());
if (mAuthenticationCharacteristic.getUuid().equals(characteristic.getUuid())) {
state_authSucess = true;
gatt.readCharacteristic(mHeartBeatCharacteristic);
}
} else if ((status & BluetoothGatt.GATT_INSUFFICIENT_AUTHENTICATION) != 0 || (status & BluetoothGatt.GATT_INSUFFICIENT_ENCRYPTION) != 0) {
if (gatt.getDevice().getBondState() == BluetoothDevice.BOND_NONE) {
device = gatt.getDevice();
state_authInProgress = true;
bondDevice();
} else {
Log.e(TAG, "The phone is trying to read from paired device without encryption. Android Bug? Have the dexcom forget whatever device it was previously paired to: oncharacteristicwrite code: "+status+ "bond: "+gatt.getDevice().getBondState());
}
} else {
Log.e(TAG, "Unknown error writing Characteristic");
}
}
public void start(BluetoothGatt bluetoothGatt) {
switch (requestType) {
case READ_CHARACTERISTIC:
if (!bluetoothGatt.readCharacteristic(characteristic)) {
throw new IllegalArgumentException("Characteristic is not valid: " + characteristic.getUuid().toString());
}
break;
case READ_DESCRIPTOR:
if (!bluetoothGatt.readDescriptor(descriptor)) {
throw new IllegalArgumentException("Descriptor is not valid");
}
break;
case WRITE_CHARACTERISTIC:
if (!bluetoothGatt.writeCharacteristic(characteristic)) {
throw new IllegalArgumentException("Characteristic is not valid");
}
break;
case WRITE_DESCRIPTOR:
if (!bluetoothGatt.writeDescriptor(descriptor)) {
throw new IllegalArgumentException("Characteristic is not valid");
}
break;
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid());
if(mHeartBeatCharacteristic.getUuid().equals(characteristic.getUuid())) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid() + " " + characteristic.getValue());
setCharacteristicNotification(mHeartBeatCharacteristic);
}
gatt.readCharacteristic(mHeartBeatCharacteristic);
} else {
Log.e(TAG, "Characteristic failed to read");
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic,
int status) {
// Make sure the site is running. It can stop if the dialog is dismissed very quickly.
if (!isRunning()) {
close();
return;
}
// Make sure the read was successful.
if (status != BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "onCharacteristicRead unsuccessful: " + status);
close();
Toast.makeText(activity, R.string.ble_download_error_message, Toast.LENGTH_SHORT).show();
return;
}
// Record the data.
Log.i(TAG, "onCharacteristicRead successful");
try {
mHtml.write(characteristic.getValue());
} catch (IOException e) {
Log.e(TAG, "Could not write to buffer", e);
close();
return;
}
// Request a new read if we are not done.
if (characteristic.getValue().length == transferRate) {
gatt.readCharacteristic(this.characteristic);
return;
}
// At this point we are done. Show the file.
Log.i(TAG, "transfer is complete");
close();
openInChrome(getHtmlFile());
}
@Override
public void onExecute(@NonNull BluetoothGatt gatt) {
BluetoothGattCharacteristic c = extractCharacteristic(gatt);
if (c == null) {
postOnNotFound(ErrorStrings.NO_CHARACTERISTIC + ": " + this.characteristic.toString());
return;
}
if (!gatt.readCharacteristic(c)) {
postOnError(ErrorStrings.WRITE_OP_INIT_FAIL);
}
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
Timber.i( "onDescriptorWrite: " + status + ",descriptor=" + descriptor.getUuid().toString() +
",descriptor_characteristic=" + descriptor.getCharacteristic().getUuid().toString());
if (isGemini && descriptor.getCharacteristic().getUuid().toString().equals(OWDevice.OnewheelCharacteristicUartSerialRead)) {
Timber.d("Stability Step 3: if isGemini and the characteristic descriptor that was written was Serial Write" +
"then trigger the 20 byte input key over multiple serial ble notification stream by writing the firmware version onto itself");
gatt.writeCharacteristic(owGatService.getCharacteristic(UUID.fromString(OWDevice.OnewheelCharacteristicFirmwareRevision)));
}
//DeviceCharacteristic dc = mOWDevice.characteristics.get(descriptor.getCharacteristic().getUuid().toString());
//if (dc != null && (dc.state == 0 || dc.state == 1)) {
// gatt.setCharacteristicNotification( owGatService.getCharacteristic(UUID.fromString(dc.uuid.get())), true);
//
// }
if (descriptorWriteQueue.size() > 0) {
descriptorWriteQueue.remove();
if (descriptorWriteQueue.size() > 0) {
gatt.writeDescriptor(descriptorWriteQueue.element());
} else if (characteristicReadQueue.size() > 0) {
gatt.readCharacteristic(characteristicReadQueue.element());
}
}
// Step 3: In OnDescriptorWrite, if isGemini and the characteristic descriptor that was
// written was Serial Write, then trigger the byte stream by writing the firmware version
// onto itself.
/*
if (isGemini && (descriptor.equals(OWDevice.OnewheelCharacteristicUartSerialWrite))) {
Timber.d("Step 3: Is Gemini, writing the descriptor onto itself");
gatt.writeDescriptor(descriptor);
}
*/
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
super.onServicesDiscovered(gatt, status);
boolean startNotificationForCharacteristicFromHere = true;
List<BluetoothGattService> services = gatt.getServices();
if (services != null) {
for (BluetoothGattService s : services) {
if (s.getCharacteristics() != null) {
for (BluetoothGattCharacteristic ch : s.getCharacteristics()) {
if (GattCharacteristic.TemperatureType.uuid.equals(ch.getUuid())) {
startNotificationForCharacteristicFromHere = false;
gatt.readCharacteristic(ch);
break;
}
}
}
}
}
if (startNotificationForCharacteristicFromHere) {
BLEUtils.SetNotificationForCharacteristic(gatt, GattService.HealthThermometer,
GattCharacteristic.Temperature,
BLEUtils.Notifications.INDICATE);
}
}
private boolean internalReadCharacteristic(@Nullable final BluetoothGattCharacteristic characteristic) {
final BluetoothGatt gatt = bluetoothGatt;
if (gatt == null || characteristic == null || !connected)
return false;
// Check characteristic property.
final int properties = characteristic.getProperties();
if ((properties & BluetoothGattCharacteristic.PROPERTY_READ) == 0)
return false;
log(Log.VERBOSE, "Reading characteristic " + characteristic.getUuid());
log(Log.DEBUG, "gatt.readCharacteristic(" + characteristic.getUuid() + ")");
return gatt.readCharacteristic(characteristic);
}
@Override
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
if (DESCRIPTOR_CONFIG.equals(descriptor.getUuid())) {
BluetoothGattCharacteristic characteristic = gatt.getService(SERVICE_UUID).getCharacteristic(CHARACTERISTIC_COUNTER_UUID);
gatt.readCharacteristic(characteristic);
}
}
private void readNext(BluetoothGatt gatt) {
BluetoothGattCharacteristic characteristic = queue.poll();
if (characteristic == null) {
finish(CommandResult.createEmptySuccess(null));
return;
}
if (!gatt.readCharacteristic(characteristic)) {
finish(CommandResult.createErrorResult(null, BluetoothGatt.GATT_FAILURE));
}
}
public static boolean readCharacteristic(BluetoothGatt gatt, UUID serviceUuid, UUID characteristicUuid) {
if (gatt == null) {
return false;
}
BluetoothGattService service = gatt.getService(serviceUuid);
if (service == null) {
return false;
}
BluetoothGattCharacteristic characteristic = service.getCharacteristic(characteristicUuid);
if (characteristic == null) {
return false;
}
return gatt.readCharacteristic(characteristic);
}
public boolean readCharacteristic(String address,
BleGattCharacteristic characteristic) {
BluetoothGatt gatt = mBluetoothGatts.get(address);
if (gatt == null) {
return false;
}
return gatt.readCharacteristic(characteristic.getGattCharacteristicA());
}
void readValue(String address, BluetoothGattCharacteristic theCharacteristic) {
BluetoothGatt bluetoothGatt = addressToGattClient.get(address);
if (bluetoothGatt == null) {
Log.w(TAG, "No connection found for: " + address);
sendGattBroadcast(address, BleEvents.READ_CHAR_FAIL, null);
return;
}
bluetoothGatt.readCharacteristic(theCharacteristic);
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid());
if(mHeartBeatCharacteristic.getUuid().equals(characteristic.getUuid())) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid() + " " + characteristic.getValue());
setCharacteristicNotification(mHeartBeatCharacteristic);
}
gatt.readCharacteristic(mHeartBeatCharacteristic);
} else {
Log.e(TAG, "Characteristic failed to read");
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid());
if(mHeartBeatCharacteristic.getUuid().equals(characteristic.getUuid())) {
Log.v(TAG, "Characteristic Read " + characteristic.getUuid() + " " + characteristic.getValue());
setCharacteristicNotification(mHeartBeatCharacteristic);
}
gatt.readCharacteristic(mHeartBeatCharacteristic);
} else {
Log.e(TAG, "Characteristic failed to read");
}
}
@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic c, int status) {
String characteristic_uuid = c.getUuid().toString();
Timber.d( "BluetoothGattCallback.onCharacteristicRead: CharacteristicUuid=" +
characteristic_uuid +
",status=" + status +
",isGemini=" + isGemini);
if (characteristicReadQueue.size() > 0) {
characteristicReadQueue.remove();
}
// Stability Step 2: In OnCharacteristicRead, if the value is of the char firmware version, parse it's value.
// If its >= 4034, JUST write the descriptor for the Serial Read characteristic to Enable notifications,
// and set notify to true with gatt. Otherwise its Andromeda or lower and we can call the method to
// read & notify all the characteristics we want. (Although I learned doing this that some android devices
// have a max of 12 notify characteristics at once for some reason. At least I'm pretty sure.)
// I also set a class-wide boolean value isGemini to true here so I don't have to keep checking if its Andromeda
// or Gemini later on.
if (characteristic_uuid.equals(OWDevice.OnewheelCharacteristicFirmwareRevision)) {
Timber.d("We have the firmware revision! Checking version.");
if (unsignedShort(c.getValue()) >= 4034) {
Timber.d("It's Gemini!");
isGemini = true;
Timber.d("Stability Step 2.1: JUST write the descriptor for the Serial Read characteristic to Enable notifications");
BluetoothGattCharacteristic gC = owGatService.getCharacteristic(UUID.fromString(OWDevice.OnewheelCharacteristicUartSerialRead));
gatt.setCharacteristicNotification(gC, true);
Timber.d("and set notify to true with gatt...");
BluetoothGattDescriptor descriptor = gC.getDescriptor(UUID.fromString(OWDevice.OnewheelConfigUUID));
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
gatt.writeDescriptor(descriptor);
} else {
Timber.d("It's before Gemini, likely Andromeda - calling read and notify characteristics");
isGemini = false;
whenActuallyConnected();
}
} else if (characteristic_uuid.equals(OWDevice.OnewheelCharacteristicRidingMode)) {
Timber.d( "Got ride mode from the main UI thread:" + c.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 1));
}
//else if (characteristic_uuid.equals(OWDevice.OnewheelCharacteristicUartSerialRead)) {
// Timber.d("Got OnewheelCharacteristicUartSerialRead, calling unlockKeyGemini! ");
// unlockKeyGemini(gatt, c.getValue());
// }
if (BuildConfig.DEBUG) {
byte[] v_bytes = c.getValue();
StringBuilder sb = new StringBuilder();
for (byte b : c.getValue()) {
sb.append(String.format("%02x", b));
}
Timber.d( "HEX %02x: " + sb);
Timber.d( "Arrays.toString() value: " + Arrays.toString(v_bytes));
Timber.d( "String value: " + c.getStringValue(0));
Timber.d( "Unsigned short: " + unsignedShort(v_bytes));
Timber.d( "getIntValue(FORMAT_UINT8,0) " + c.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 0));
Timber.d( "getIntValue(FORMAT_UINT8,1) " + c.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 1));
}
mOWDevice.processUUID(c);
mOWDevice.setBatteryRemaining(mainActivity);
// Callback to make sure the queue is drained
if (characteristicReadQueue.size() > 0) {
gatt.readCharacteristic(characteristicReadQueue.element());
}
}
@Override
@TargetApi(21)
// New services discovered
public void onServicesDiscovered(BluetoothGatt gatt, int status)
{
PodEmuLog.debug("SIBLE: GATT onServiceDiscovered with status=" + status);
super.onServicesDiscovered(gatt, status);
boolean isSerialSupported = false;
for (BluetoothGattService service : gatt.getServices())
{
PodEmuLog.debug("SIBLE: Service: " + service.getUuid());
//if (Arrays.asList(BLE_UUIDS).contains(service.getUuid()))
if(SERVICE_UUID.equals(service.getUuid()))
{
PodEmuLog.debug("SIBLE: BLE found serial device!");
//gatt.readCharacteristic(service.getCharacteristic(CHARACTERISTIC_VERSION_UUID));
//gatt.readCharacteristic(service.getCharacteristic(CHARACTERISTIC_DESC_UUID));
//gatt.setCharacteristicNotification(service.getCharacteristic(CHARACTERISTIC_MESSAGE_UUID), true);
//gatt.setCharacteristicNotification(service.getCharacteristic(CHARACTERISTIC_RFCOMM_TRANSFER_UUID), true);
BluetoothGattCharacteristic bleGattCharacteristic = service.getCharacteristic(CHARACTERISTIC_SERIAL_UUID);
if(bleGattCharacteristic != null)
{
isSerialSupported = true;
gatt.readCharacteristic(service.getCharacteristic(CHARACTERISTIC_SERIAL_UUID));
gatt.setCharacteristicNotification(bleGattCharacteristic, true);
}
}
}
if(isSerialSupported)
{
PodEmuLog.debug("SIBLE: BLE serial supported!");
}
else
{
PodEmuLog.debug("SIBLE: BLE serial NOT supported!");
}
}
@Override
// New services discovered
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
MLog.d(TAG, "onServicesDiscovered " + gatt + " " + status);
ReturnObject ret = new ReturnObject();
if (status == BluetoothGatt.GATT_SUCCESS) {
List<BluetoothGattService> services = gatt.getServices();
PhonkNativeArray retServicesArray = new PhonkNativeArray(services.size());
ret.put("services", retServicesArray);
int countServices = 0;
for (BluetoothGattService service : services) {
MLog.d(TAG, "service " + service.getUuid() + " " + service.getType());
ReturnObject retService = new ReturnObject();
retService.put("uuid", service.getUuid());
retService.put("type", service.getType());
retServicesArray.addPE(countServices++, retService);
List<BluetoothGattCharacteristic> gattCharacteristic = service.getCharacteristics();
PhonkNativeArray retCharArray = new PhonkNativeArray(gattCharacteristic.size());
retService.put("characteristics", retCharArray);
int counterCharacteristics = 0;
for (BluetoothGattCharacteristic characteristic : gattCharacteristic) {
MLog.d(TAG, "Characteristics" + characteristic.getUuid() + " " + characteristic.getProperties() + " " + characteristic.getWriteType() + " " + characteristic.getValue());
gatt.readCharacteristic(characteristic);
ReturnObject retChar = new ReturnObject();
retChar.put("uuid", characteristic.getUuid());
retChar.put("writeType", characteristic.getWriteType());
/*
retChar.put("descriptors", characteristic.getDescriptors());
*/
retCharArray.addPE(counterCharacteristics++, retChar);
}
}
if (mCallbackServices != null) {
mCallbackServices.event(ret);
}
} else {
MLog.d(TAG, "onServicesDiscovered received: " + status);
}
}
@Override
protected boolean startOperation(BluetoothGatt bluetoothGatt) {
return bluetoothGatt.readCharacteristic(bluetoothGattCharacteristic);
}
@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
super.onServicesDiscovered(gatt, status);
// Notify connection failure if service discovery failed.
if (status == BluetoothGatt.GATT_FAILURE) {
connectFailure();
return;
}
// Save reference to each UART characteristic.
tx = gatt.getService(UART_UUID).getCharacteristic(TX_UUID);
rx = gatt.getService(UART_UUID).getCharacteristic(RX_UUID);
// Save reference to each DIS characteristic.
disManuf = gatt.getService(DIS_UUID).getCharacteristic(DIS_MANUF_UUID);
disModel = gatt.getService(DIS_UUID).getCharacteristic(DIS_MODEL_UUID);
disHWRev = gatt.getService(DIS_UUID).getCharacteristic(DIS_HWREV_UUID);
disSWRev = gatt.getService(DIS_UUID).getCharacteristic(DIS_SWREV_UUID);
// Add device information characteristics to the read queue
// These need to be queued because we have to wait for the response to the first
// read request before a second one can be processed (which makes you wonder why they
// implemented this with async logic to begin with???)
readQueue.offer(disManuf);
readQueue.offer(disModel);
readQueue.offer(disHWRev);
readQueue.offer(disSWRev);
// Request a dummy read to get the device information queue going
gatt.readCharacteristic(disManuf);
// Setup notifications on RX characteristic changes (i.e. data received).
// First call setCharacteristicNotification to enable notification.
if (!gatt.setCharacteristicNotification(rx, true)) {
// Stop if the characteristic notification setup failed.
connectFailure();
return;
}
// Next update the RX characteristic's client descriptor to enable notifications.
BluetoothGattDescriptor desc = rx.getDescriptor(CLIENT_UUID);
if (desc == null) {
// Stop if the RX characteristic has no client descriptor.
connectFailure();
return;
}
desc.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
if (!gatt.writeDescriptor(desc)) {
// Stop if the client descriptor could not be written.
connectFailure();
return;
}
// Notify of connection completion.
notifyOnConnected(this);
}