Android
Bluetooth Low Energy

introduzione

Ricerca di dispositivi BLE

Per utilizzare le API Bluetooth sono necessarie le seguenti autorizzazioni:

android.permission.BLUETOOTH
android.permission.BLUETOOTH_ADMIN

Se stai prendendo di mira dispositivi con Android 6.0 ( livello API 23 ) o superiore e desideri eseguire operazioni di scansione / pubblicità, devi disporre di un permesso di posizione:

android.permission.ACCESS_FINE_LOCATION

o

android.permission.ACCESS_COARSE_LOCATION

Nota. I dispositivi con Android 6.0 (livello API 23 o superiore) devono anche avere i servizi di localizzazione abilitati.

Per avviare le operazioni di scansione / pubblicità è necessario un oggetto BluetoothAdapter:

BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
bluetoothAdapter = bluetoothManager.getAdapter();

Il startScan (ScanCallback callback) della classe BluetoothLeScanner è il modo più semplice per avviare un'operazione di scansione. Per ricevere i risultati è necessario un oggetto ScanCallback :

bluetoothAdapter.getBluetoothLeScanner().startScan(new ScanCallback() {
     @Override
     public void onScanResult(int callbackType, ScanResult result) {
     super.onScanResult(callbackType, result);
     Log.i(TAG, "Remote device name: " + result.getDevice().getName());
       }
    });

Connessione a un server GATT

Una volta scoperto l'oggetto BluetoothDevice desiderato, è possibile connettersi ad esso utilizzando il suo metodo connectGatt() che accetta come parametri un oggetto Context, un booleano che indica se connettersi automaticamente al dispositivo BLE e un riferimento BluetoothGattCallback dove eventi di connessione e operazioni client i risultati saranno consegnati:

 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        device.connectGatt(context, false, bluetoothGattCallback, BluetoothDevice.TRANSPORT_AUTO);
    } else {
        device.connectGatt(context, false, bluetoothGattCallback);
    }

Sostituire onConnectionStateChange in BluetoothGattCallback per ricevere la connessione di eventi di disconnessione:

    BluetoothGattCallback bluetoothGattCallback =
        new BluetoothGattCallback() {
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status,
            int newState) {
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            Log.i(TAG, "Connected to GATT server.");

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

Scrivere e leggere dalle caratteristiche

Una volta connesso a un server Gatt, interagirai con esso scrivendo e leggendo dalle caratteristiche del server. Per fare questo, prima devi scoprire quali servizi sono disponibili su questo server e quali caratteristiche sono disponibili in ogni servizio:

 @Override
 public void onConnectionStateChange(BluetoothGatt gatt, int status,
        int newState) {
    if (newState == BluetoothProfile.STATE_CONNECTED) {
        Log.i(TAG, "Connected to GATT server.");
        gatt.discoverServices();

    }
. . .

 @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        if (status == BluetoothGatt.GATT_SUCCESS) {
             List<BluetoothGattService> services = gatt.getServices();
                for (BluetoothGattService service : services) {
                    List<BluetoothGattCharacteristic> characteristics = service.getCharacteristics();
                    for (BluetoothGattCharacteristic characteristic : characteristics) { 
                        ///Once you have a characteristic object, you can perform read/write
                        //operations with it         
                    }
                 }
              }
            }

Un'operazione di scrittura di base va così:

characteristic.setValue(newValue);
characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
gatt.writeCharacteristic(characteristic);

Al termine del processo di scrittura, verrà chiamato il metodo onCharacteristicWrite del tuo BluetoothGattCallback :

    @Override
    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicWrite(gatt, characteristic, status);
        Log.d(TAG, "Characteristic " + characteristic.getUuid() + " written);
    }

Un'operazione di scrittura di base va così:

gatt.readCharacteristic(characteristic);

Al termine del processo di scrittura, verrà chiamato il metodo onCharacteristicRead del tuo BluetoothGattCallback :

@Override
public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
  super.onCharacteristicRead(gatt, characteristic, status);
  byte[] value = characteristic.getValue();
  }

Sottoscrizione alle notifiche dal server Gatt

È possibile richiedere di essere avvisati dal server Gatt quando il valore di una caratteristica è stato modificato:

gatt.setCharacteristicNotification(characteristic, true);
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
    UUID.fromString("00002902-0000-1000-8000-00805f9b34fb");
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
mBluetoothGatt.writeDescriptor(descriptor);

Tutte le notifiche dal server verranno ricevute nel metodo onCharacteristicChanged di BluetoothGattCallback:

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        super.onCharacteristicChanged(gatt, characteristic);
        byte[] newValue = characteristic.getValue();
}

Pubblicità di un dispositivo BLE

È possibile utilizzare Bluetooth LE Advertising per trasmettere pacchetti di dati a tutti i dispositivi vicini senza prima stabilire una connessione. Ricorda che esiste un limite rigoroso di 31 byte di dati pubblicitari. Pubblicizzare il tuo dispositivo è anche il primo passo per consentire ad altri utenti di connettersi a te.

Poiché non tutti i dispositivi supportano Bluetooth LE Advertising, il primo passo consiste nel verificare che il dispositivo disponga di tutti i requisiti necessari per supportarlo. Successivamente, puoi inizializzare un oggetto BluetoothLeAdvertiser e con esso puoi iniziare le operazioni pubblicitarie:

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && bluetoothAdapter.isMultipleAdvertisementSupported())
        {
            BluetoothLeAdvertiser advertiser = bluetoothAdapter.getBluetoothLeAdvertiser();

            AdvertiseData.Builder dataBuilder = new AdvertiseData.Builder();
           //Define a service UUID according to your needs                
           dataBuilder.addServiceUuid(SERVICE_UUID);
            dataBuilder.setIncludeDeviceName(true);


             AdvertiseSettings.Builder settingsBuilder = new AdvertiseSettings.Builder();
             settingsBuilder.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_POWER);
             settingsBuilder.setTimeout(0);

             //Use the connectable flag if you intend on opening a Gatt Server
             //to allow remote connections to your device.
             settingsBuilder.setConnectable(true);

            AdvertiseCallback advertiseCallback=new AdvertiseCallback() {
            @Override
            public void onStartSuccess(AdvertiseSettings settingsInEffect) {
                super.onStartSuccess(settingsInEffect);
                Log.i(TAG, "onStartSuccess: ");
            }

            @Override
            public void onStartFailure(int errorCode) {
                super.onStartFailure(errorCode);
                Log.e(TAG, "onStartFailure: "+errorCode );
            }
          };
advertising.startAdvertising(settingsBuilder.build(),dataBuilder.build(),advertiseCallback);
        }

Utilizzando un server Gatt

Affinché il dispositivo possa agire come periferica, per prima cosa è necessario aprire un BluetoothGattServer e popolarlo con almeno un BluetoothGattService e un BluetoothGattCharacteristic :

BluetoothGattServer server=bluetoothManager.openGattServer(context, bluetoothGattServerCallback);

BluetoothGattService service = new BluetoothGattService(SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY);

Questo è un esempio di BluetoothGattCharacteristic con autorizzazioni complete di scrittura, lettura e notifica. In base alle tue esigenze, potresti voler perfezionare le autorizzazioni che concedi questa caratteristica:

BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(CHARACTERISTIC_UUID,
                    BluetoothGattCharacteristic.PROPERTY_READ | BluetoothGattCharacteristic.PROPERTY_WRITE |
                            BluetoothGattCharacteristic.PROPERTY_NOTIFY,
                    BluetoothGattCharacteristic.PERMISSION_READ | BluetoothGattCharacteristic.PERMISSION_WRITE);

characteristic.addDescriptor(new BluetoothGattDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"), BluetoothGattCharacteristic.PERMISSION_WRITE));

service.addCharacteristic(characteristic);

server.addService(service);

Il BluetoothGattServerCallback è responsabile della ricezione di tutti gli eventi relativi a BluetoothGattServer :

BluetoothGattServerCallback bluetoothGattServerCallback= new BluetoothGattServerCallback() {
                @Override
                public void onConnectionStateChange(BluetoothDevice device, int status, int newState) {
                    super.onConnectionStateChange(device, status, newState);
                }

                @Override
                public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattCharacteristic characteristic) {
                    super.onCharacteristicReadRequest(device, requestId, offset, characteristic);
                }

                @Override
                public void onCharacteristicWriteRequest(BluetoothDevice device, int requestId, BluetoothGattCharacteristic characteristic, boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
                    super.onCharacteristicWriteRequest(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value);
                }

                @Override
                public void onDescriptorReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattDescriptor descriptor) {
                    super.onDescriptorReadRequest(device, requestId, offset, descriptor);
                }

                @Override
                public void onDescriptorWriteRequest(BluetoothDevice device, int requestId, BluetoothGattDescriptor descriptor, boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
                    super.onDescriptorWriteRequest(device, requestId, descriptor, preparedWrite, responseNeeded, offset, value);
                }

Ogni volta che si riceve una richiesta di scrittura / lettura su una caratteristica o un descrittore, è necessario inviare una risposta al fine di completare la richiesta con successo:

@Override
 public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattCharacteristic characteristic) {
    super.onCharacteristicReadRequest(device, requestId, offset, characteristic);
    server.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, YOUR_RESPONSE);
}