android.bluetooth.bluetoothgatt Java Examples

private boolean internalEnableIndications(final BluetoothGattCharacteristic characteristic) {
	final BluetoothGatt gatt = bluetoothGatt;
	if (gatt == null || characteristic == null)
		return false;

	// Check characteristic property
	final int properties = characteristic.getProperties();
	if ((properties & BluetoothGattCharacteristic.PROPERTY_INDICATE) == 0)
		return false;

	gatt.setCharacteristicNotification(characteristic, true);
	final BluetoothGattDescriptor descriptor = characteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG_DESCRIPTOR_UUID);
	if (descriptor != null) {
		descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
		return internalWriteDescriptorWorkaround(descriptor);
	}
	return false;
}
 

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        device = getIntent().getParcelableExtra("device");
        setContentView(R.layout.activity_main);
        assignViews();
        initViews();
        //连接配置，举个例随意配置两项
        ConnectionConfiguration config = new ConnectionConfiguration();
        config.setConnectTimeoutMillis(10000);
        config.setRequestTimeoutMillis(1000);
        config.setAutoReconnect(false);
//        connection = EasyBLE.getInstance().connect(device, config, observer);//回调监听连接状态，设置此回调不影响观察者接收连接状态消息
        connection = EasyBLE.getInstance().connect(device, config);//观察者监听连接状态  
        connection.setBluetoothGattCallback(new BluetoothGattCallback() {
            @Override
            public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
                Log.d("EasyBLE", "原始写入数据：" + StringUtils.toHex(characteristic.getValue()));
            }
        });
    }
 

@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");
        }
    } else {
        Log.e(TAG, "Unknown error writing Characteristic");
    }
}
 

@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    super.onServicesDiscovered(gatt, status);
    Timber.i("onServicesDiscovered called");
    if (status == BluetoothGatt.GATT_SUCCESS) {
        Timber.i("onServicesDiscovered called, status == BluetoothGatt.GATT_SUCCESS");
        boolean recognisedWheel = WheelData.getInstance().detectWheel(BluetoothLeService.this);
        if (recognisedWheel) {
            mConnectionState = STATE_CONNECTED;
            broadcastConnectionUpdate(mConnectionState);

        } else
            disconnect();
        return;
    }
    Timber.i("onServicesDiscovered called, status == BluetoothGatt.GATT_FAILURE");
}
 

@Override
public void onServerConnectionStateChange(BluetoothDevice device, int status, int newState) {
    Timber.d("[%s] Gatt State %s, Disconnect Reason : %s", getDevice(), GattStatus.values()[status].name(),
            GattDisconnectReason.getReasonForCode(newState));
    TransactionResult.Builder builder = new TransactionResult.Builder().transactionName(getName());
    builder.responseStatus(GattDisconnectReason.getReasonForCode(status).ordinal());
    if (status == BluetoothGatt.GATT_SUCCESS) {
        if (newState == BluetoothProfile.STATE_DISCONNECTED) {
            getGattServer().setState(GattState.DISCONNECTED);
            builder.gattState(getGattServer().getGattState())
                    .resultStatus(TransactionResult.TransactionResultStatus.SUCCESS);
            callCallbackWithTransactionResultAndRelease(callback, builder.build());
        } else if (newState == BluetoothProfile.STATE_CONNECTED) {
            getGattServer().setState(GattState.CONNECTED);
            builder.gattState(getGattServer().getGattState())
                    .resultStatus(TransactionResult.TransactionResultStatus.FAILURE);
            callCallbackWithTransactionResultAndRelease(callback, builder.build());
        }
    } else {
        builder.gattState(getGattServer().getGattState())
                .resultStatus(TransactionResult.TransactionResultStatus.FAILURE);
        callCallbackWithTransactionResultAndRelease(callback, builder.build());
    }
}
 

@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
    String intentAction;
    if (newState == BluetoothProfile.STATE_CONNECTED) {
        intentAction = ACTION_GATT_CONNECTED;
        mConnectionState = STATE_CONNECTED;
        broadcastUpdate(intentAction);
        Log.i(TAG, "Connected to GATT server.");
        // Attempts to discover services after successful connection.
        Log.i(TAG, "Attempting to start service discovery:" +
                mBluetoothGatt.discoverServices());

    } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
        intentAction = ACTION_GATT_DISCONNECTED;
        mConnectionState = STATE_DISCONNECTED;
        Log.i(TAG, "Disconnected from GATT server.");
        broadcastUpdate(intentAction);
    }
}
 

@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
    String intentAction;
    if (newState == BluetoothProfile.STATE_CONNECTED) {
        intentAction = ACTION_GATT_CONNECTED;
        broadcastUpdate(intentAction);
        Log.i(TAG, "Connected to GATT server.");
        // Attempts to discover services after successful connection.
        Log.i(TAG, "Attempting to start service discovery:" +
                mBluetoothGatt.discoverServices());

    } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
        intentAction = ACTION_GATT_DISCONNECTED;
        Log.i(TAG, "Disconnected from GATT server.");
        broadcastUpdate(intentAction);
    }
}
 

/**
 * Call to private Android method 'refresh'
 * This method does actually clear the cache from a bluetooth device. But the problem is that we don't have access to it. But in java we have reflection, so we can access this method.
 * http://stackoverflow.com/questions/22596951/how-to-programmatically-force-bluetooth-low-energy-service-discovery-on-android
 */
public boolean refreshDeviceCache() {
    try {
        BluetoothGatt localBluetoothGatt = mGatt;
        Method localMethod = localBluetoothGatt.getClass().getMethod("refresh");
        if (localMethod != null) {
            boolean result = (Boolean) localMethod.invoke(localBluetoothGatt);
            if (result) {
                Log.d(TAG, "Bluetooth refresh cache");
            }
            return result;
        }
    } catch (Exception localException) {
        Log.e(TAG, "An exception occurred while refreshing device");
    }
    return false;
}
 

@Override
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
    super.onCharacteristicWrite(gatt, characteristic, status);
    if (status == BluetoothGatt.GATT_SUCCESS) {
        String address = gatt.getDevice().getAddress();
        String serviceUuid = characteristic.getService().getUuid().toString();
        String characteristicUuid = characteristic.getUuid().toString();
        OperationIdentify identify = getOperationIdentifyFromMap(mWriteCallbackMap, address, serviceUuid, characteristicUuid);
        if (identify == null) {
            return;
        }
        final BleWriteCallback callback = mWriteCallbackMap.get(identify);
        final BleDevice device = getBleDeviceFromMap(address, mConnectCallbackMap);
        final byte[] data = characteristic.getValue();
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (callback != null) {
                    callback.onWriteSuccess(data, device);
                }
            }
        });
    }
}
 

@Override
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
    super.onConnectionStateChange(gatt, status, newState);

    String intentAction;
    if (newState == BluetoothProfile.STATE_CONNECTED) {
        intentAction = ACTION_GATT_CONNECTED;
        connectionState = STATE_CONNECTED;
        broadcastUpdate(intentAction);
        Log.i(TAG, "Connected to GATT server.");
        // Attempts to discover services after successful connection.
        Log.i(TAG, "Attempting to start service discovery:" +
                BleService.this.gatt.discoverServices());
    } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
        intentAction = ACTION_GATT_DISCONNECTED;
        connectionState = STATE_DISCONNECTED;
        Log.i(TAG, "Disconnected from GATT server.");
        broadcastUpdate(intentAction);
    }
}
 

private String readCharacteristicNoFailure(final BluetoothGatt gatt, final BluetoothGattCharacteristic characteristic) {
    if (mConnectionState != STATE_CONNECTED_AND_READY)
        return "not_ready";
    if (characteristic == null)
        return "unknown";
    logi("readCharacteristicNoFailure");
    gatt.readCharacteristic(characteristic);
    try {
        synchronized (mLock) {
            while ((!mRequestCompleted && mConnectionState == STATE_CONNECTED_AND_READY && mError == 0 && !mAborted) || mPaused)
                mLock.wait();
        }
    } catch (final InterruptedException e) {
        loge("Sleeping interrupted", e);
    }

    if (mAborted)
        return "unknown";

    if (mError != 0)
        return "unknown";

    if (mConnectionState != STATE_CONNECTED_AND_READY)
        return "unknown";
    return characteristic.getStringValue(0);
}
 

@Override
public void onCharacteristicWrite(final BluetoothGatt gatt, final BluetoothGattCharacteristic characteristic, final int status) {
    Log.e(TAG, "OnCharacteristic WRITE started: "
            + getUUIDName(characteristic.getUuid())
            + " status: " + getStatusName(status));
    //Log.e(TAG, "Write Status " + String.valueOf(status));
    //Log.e(TAG, "Characteristic " + String.valueOf(characteristic.getUuid()));

    if (enforceMainThread()) {
        Handler iHandler = new Handler(Looper.getMainLooper());
        iHandler.post(new Runnable() {
            @Override
            public void run() {
                processOnCharacteristicWrite(gatt, characteristic, status);
            }
        });
    } else {
        processOnCharacteristicWrite(gatt, characteristic, status);
    }


}
 

@Test
public void testInputSourceClosesOnError() throws IOException {
    when(gatt.getService(eq(serviceUUID))).thenReturn(gattService);
    when(gattService.getCharacteristic(characteristicUUID)).thenReturn(gattCharacteristic);
    when(gatt.writeCharacteristic(eq(gattCharacteristic))).thenReturn(true);
    InputSource inputSource = Mockito.mock(InputSource.class);
    when(inputSource.nextChunk()).thenThrow(new IOException());

    writeCommand = new WriteCommand(
            serviceUUID,
            characteristicUUID,
            BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,
            inputSource,
            commandObserver);

    writeCommand.execute(device, operationCommandObserver, gatt);
    writeCommand.onCharacteristicWrite(gatt, gattCharacteristic, BluetoothGatt.GATT_SUCCESS);

    verify(inputSource).close();
}
 

void onConnect() {
	if (mNumDevs > 0) {

		int connState = mBluetoothManager.getConnectionState(mBluetoothDevice,
		    BluetoothGatt.GATT);

		switch (connState) {
		case BluetoothGatt.STATE_CONNECTED:
			mBluetoothLeService.disconnect(null);
			break;
		case BluetoothGatt.STATE_DISCONNECTED:
			boolean ok = mBluetoothLeService.connect(mBluetoothDevice.getAddress());
			if (!ok) {
				setError("Connect failed");
			}
			break;
		default:
			setError("Device busy (connecting/disconnecting)");
			break;
		}
	}
}
 

@Override
// TODO: maybe here we should set status == CONNECTED
public void onServicesDiscovered( BluetoothGatt gatt, int status ) {
    if( status != BluetoothGatt.GATT_SUCCESS ) {
        Log.e( CLASS, "onServicesDiscovered: Status != SUCCESS: status=" + status );
        return;
    }
    mGatt = gatt;

    List<BluetoothGattService> services = gatt.getServices();
    Log.d( CLASS, "onServicesDiscovered: services=" + services.size() );

    for( BtBridgeListener listener : mListeners ) {
        listener.onServicesDiscovered( services );
    }
}
 

@Override
public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
    super.onConnectionStateChange(device, status, newState);

    if (newState == BluetoothGatt.STATE_DISCONNECTED) {
        log(device + " has disconnected");
        if (device.equals(mEddystoneGattService.getConnectedOwner())) {
            log("Owner disconnected, stopping GATT server");
            mEddystoneGattService.onOwnerDisconnected();
            close();
        }
    }
    else if (newState == BluetoothGatt.STATE_CONNECTED) {
        log(device + " has connected");
        if (mEddystoneGattService.getConnectedOwner() != null) {
            // don't allow a second client to connect at the same time
            log(device + " tried to connect, but owner is active. Disconnecting.");
            mGattServer.cancelConnection(device);
        }
    }
}
 

public static boolean refreshDeviceCache(String thisTAG, BluetoothGatt gatt){
    try {
        final Method method = gatt.getClass().getMethod("refresh", new Class[0]);
        if (method != null) {
            return (Boolean) method.invoke(gatt, new Object[0]);
        }
    }
    catch (Exception e) {
        Log.e(thisTAG, "An exception occured while refreshing gatt device cache: "+e);
    }
    return false;
}
 

@Implementation
public  boolean connect(){
    if(userCallBack!=null) {
        Robolectric.getBackgroundThreadScheduler().postDelayed(new Runnable() {
            @Override
            public void run() {
                userCallBack.onConnectionStateChange(bluetoothGatt, BluetoothGatt.GATT_SUCCESS,
                        BluetoothProfile.STATE_CONNECTED);
            }
        },CALLBACK_DELAY_MS);
        return true;
    }
    return false;
}
 

@Test(timeout = 1000)
public void testOnCharacteristicWriteFinishedAsyncSource() throws IOException {
    when(gatt.getService(eq(serviceUUID))).thenReturn(gattService);
    when(gattService.getCharacteristic(characteristicUUID)).thenReturn(gattCharacteristic);
    when(gatt.writeCharacteristic(eq(gattCharacteristic))).thenReturn(true);
    AsyncInputSource inputSource = Mockito.mock(AsyncInputSource.class);
    when(inputSource.nextChunk()).thenReturn(new byte[]{12, 21});

    writeCommand = new WriteCommand(
            serviceUUID,
            characteristicUUID,
            BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,
            inputSource,
            commandObserver);

    writeCommand.execute(device, operationCommandObserver, gatt);

    when(inputSource.nextChunk()).thenReturn(null);
    writeCommand.onCharacteristicWrite(gatt, gattCharacteristic, BluetoothGatt.GATT_SUCCESS);

    while (writeCommand.readerThread.isAlive()) {
        Robolectric.getForegroundThreadScheduler().advanceBy(0, TimeUnit.MILLISECONDS);
        Thread.yield();
    }

    Robolectric.getForegroundThreadScheduler().advanceBy(0, TimeUnit.MILLISECONDS);

    CommandResult result = CommandResult.createEmptySuccess(characteristicUUID);
    verify(commandObserver, only()).finished(eq(writeCommand), refEq(result, "timestamp"));
    verify(operationCommandObserver, only()).finished(eq(writeCommand), refEq(result, "timestamp"));
    verify(inputSource).close();
}
 

final ReadWriteEvent newAlreadyEnabledEvent(BluetoothGattCharacteristic characteristic, final UUID serviceUuid, final UUID characteristicUuid, final DescriptorFilter descriptorFilter)
{
	//--- DRK > Just being anal with the null check here.
	byte[] writeValue = characteristic != null ? P_Task_ToggleNotify.getWriteValue(characteristic, /*enable=*/true) : P_Const.EMPTY_BYTE_ARRAY;
	int gattStatus = BluetoothGatt.GATT_SUCCESS;
	ReadWriteEvent result = new ReadWriteEvent(m_device, serviceUuid, characteristicUuid, Uuids.CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_UUID, descriptorFilter, Type.ENABLING_NOTIFICATION, Target.DESCRIPTOR, writeValue, Status.SUCCESS, gattStatus, 0.0, 0.0, /*solicited=*/true);

	return result;
}
 

@Override
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    for (BluetoothGattService s : gatt.getServices()) {
        for (BluetoothGattCharacteristic c : s.getCharacteristics()) {
            mCharacteristicMap.put(getKey(c), c);
        }
    }

    // Fire onConnected event after all the services have been discovered
    if(mConnectionListener != null) {
        mConnectionListener.onConnected(ESenseManager.this);
    }
}
 

private static List<BluetoothGattCharacteristic> findCharacteristics(BluetoothGatt gatt, UUID serviceUuid, UUID characteristicUuid, int property) {
    if (serviceUuid == null) {
        return null;
    }

    if (characteristicUuid == null) {
        return null;
    }

    if (gatt == null) {
        return null;
    }

    BluetoothGattService service = gatt.getService(serviceUuid);
    if (service == null) {
        return null;
    }

    List<BluetoothGattCharacteristic> results = new ArrayList<>();
    for (BluetoothGattCharacteristic c : service.getCharacteristics()) {
        int props = c.getProperties();
        if (characteristicUuid.equals(c.getUuid())
                && (property == (property & props))) {
            results.add(c);
        }
    }
    return results;
}
 

@Test
public void testIntValues() {
    CommandResult commandResult = new CommandResult(Neatle.createUUID(1), new byte[]{22, 21}, BluetoothGatt.GATT_SUCCESS, 1);
    assertArrayEquals(new byte[]{22, 21}, commandResult.getValue());

    CommandResult commandResult1 = new CommandResult(Neatle.createUUID(1), new byte[]{22}, BluetoothGatt.GATT_SUCCESS, 1);
    CommandResult commandResult2 = new CommandResult(Neatle.createUUID(1), new byte[]{22, 21}, BluetoothGatt.GATT_SUCCESS, 1);
    CommandResult commandResult3 = new CommandResult(Neatle.createUUID(1), new byte[]{22, 21, 20}, BluetoothGatt.GATT_SUCCESS, 1);
    CommandResult commandResult4 = new CommandResult(Neatle.createUUID(1), new byte[]{22, 21, 20, 19}, BluetoothGatt.GATT_SUCCESS, 1);

    assertEquals(22, commandResult1.getValueAsInt());
    assertEquals(5653, commandResult2.getValueAsInt());
    assertEquals(1447188, commandResult3.getValueAsInt());
    assertEquals(370480147, commandResult4.getValueAsInt());
}
 

@Override
public void onPhyRead(BluetoothGatt gatt, int txPhy, int rxPhy, int status) {
    super.onPhyRead(gatt, txPhy, rxPhy, status);
    Timber.v("[%s] onPhyRead: Gatt Response Status %s", getDeviceMacFromGatt(gatt), GattStatus.getStatusForCode(status));
    Timber.d("[%s][Threading] Originally called on thread : %s", getDeviceMacFromGatt(gatt), Thread.currentThread().getName());
    ArrayList<GattClientListener> copy = new ArrayList<>(listeners.size());
    copy.addAll(listeners);
    for (GattClientListener listener : copy) {
        if(listener.getDevice() != null && gatt != null && listener.getDevice().equals(gatt.getDevice())) {
            handler.post(() -> listener.onPhyRead(gatt, txPhy, rxPhy, status));
        }
    }
}
 

@Override
protected void start(Connection connection, BluetoothGatt gatt) {
    List<BluetoothGattService> services = gatt.getServices();
    for (BluetoothGattService service : services) {
        List<BluetoothGattCharacteristic> characteristics = service.getCharacteristics();
        for (BluetoothGattCharacteristic characteristic : characteristics) {
            int props = characteristic.getProperties();
            if ((props & BluetoothGattCharacteristic.PROPERTY_READ) != 0) {
                queue.add(characteristic);
            }
        }
    }

    readNext(gatt);
}
 

@Override
// New services discovered
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
    if (status == BluetoothGatt.GATT_SUCCESS) {
    	Logs.d(TAG, "# New GATT service discovered.");
    	checkGattServices(gatt.getServices());
    } else {
        Logs.d(TAG, "# onServicesDiscovered received: " + status);
    }
}
 

public static void logConnectionUpdateCallback(String callbackName, BluetoothGatt gatt,
                                               int status, int interval, int latency, int timeout) {
    if (!RxBleLog.isAtLeast(LogConstants.INFO)) {
        return;
    }
    String customValueMessage = ", interval=%d (%.2f ms), latency=%d, timeout=%d (%.0f ms)";
    RxBleLog.i(commonMacMessage(gatt) + commonCallbackMessage() + commonStatusMessage() + customValueMessage,
            callbackName, status, interval, interval * 1.25f, latency, timeout, timeout * 10f);
}
 

/**
 * 阅读设备信号值
 * @param gatt GATT
 * @param rssi 设备当前信号
 * @param status 当前状态
 */
@Override
public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
    ViseLog.i("onReadRemoteRssi  status: " + status + ", rssi:" + rssi +
            "  ,thread: " + Thread.currentThread());
    if (status == BluetoothGatt.GATT_SUCCESS) {
        if (rssiCallback != null) {
            rssiCallback.onSuccess(rssi);
        }
    } else {
        if (rssiCallback != null) {
            rssiCallback.onFailure(new GattException(status));
        }
    }
}
 

@Override
public void onConnectionStateChange(BluetoothDevice device, int status, int newState) throws RemoteException {
    BluetoothLog.v(String.format("%s.onConnectionStateChange: status = %d, newState = %d", TAG, status, newState));

    if (newState == BluetoothGatt.STATE_CONNECTED) {
        mHandler.sendEmptyMessageDelayed(0, NOTIFY_CYCLE);
    } else if (newState == BluetoothGatt.STATE_DISCONNECTED) {
    }
}
 

@Override
public void onCharacteristicRead(BluetoothGatt gatt,
                                 BluetoothGattCharacteristic characteristic,
                                 int status) {
    if (status == BluetoothGatt.GATT_SUCCESS) {
        broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
    }
}