Android 4.3: Comment se connecter à plusieurs périphériques Bluetooth Low Energy

Re visitent la bluetooth-lowenergy problème android: je suis toujours à l'aide de retards.

Le concept: après chaque action qui provoque la BluetoothGattCallback (par exemple conenction, la découverte de services, écrire, lire) un dealy est nécessaire. P. S. avez un oeil à Google exemple sur BLE API de niveau 19 de l'échantillon pour la connectivité à comprendre comment des Émissions doit être envoyée à obtenir une certaine compréhension générale etc...

Tout d'abord, scan (ou scan) pour BluetoothDevices, remplir le connectionQueue avec les périphériques souhaités et de les appeler initConnection().

Un coup d'oeil sur l'exemple suivant.

private Queue<BluetoothDevice> connectionQueue = new LinkedList<BluetoothDevice>();

public void initConnection(){
    if(connectionThread == null){
        connectionThread = new Thread(new Runnable() {
            @Override
            public void run() {
                connectionLoop();
                connectionThread.interrupt();
                connectionThread = null;
            }
        });

        connectionThread.start();
    }
}

private void connectionLoop(){
    while(!connectionQueue.isEmpty()){
        connectionQueue.poll().connectGatt(context, false, bleInterface.mGattCallback);
        try {
            Thread.sleep(250);
        } catch (InterruptedException e) {}
    }
}

Maintenant, si tout est bon, vous avez fait les connexions et BluetoothGattCallback.onConnectionStateChange(BluetoothGatt gatt, int status, int newState) a été appelé.

public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        switch(status){
            case BluetoothGatt.GATT_SUCCESS:
                if (newState == BluetoothProfile.STATE_CONNECTED) {
                    broadcastUpdate(BluetoothConstants.ACTION_GATT_CONNECTED, gatt);
                }else if(newState == BluetoothProfile.STATE_DISCONNECTED){
                    broadcastUpdate(BluetoothConstants.ACTION_GATT_DISCONNECTED, gatt);
                }
                break;
        }

    }
protected void broadcastUpdate(String action, BluetoothGatt gatt) {
    final Intent intent = new Intent(action);

    intent.putExtra(BluetoothConstants.EXTRA_MAC, gatt.getDevice().getAddress());

    sendBroadcast(intent);
}

P. S. sendBroadcast(intention) peut-être besoin d'être fait comme ceci:

Context context = activity.getBaseContext();
context.sendBroadcast(intent);

Puis l'émission est reçue par BroadcastReceiver.onReceive(...)

public BroadcastReceiver myUpdateReceiver = new BroadcastReceiver(){

    @Override
    public void onReceive(Context context, Intent intent) {
        final String action = intent.getAction();
        if(BluetoothConstants.ACTION_GATT_CONNECTED.equals(action)){
            //Connection made, here you can make a decision: do you want to initiate service discovery.
            //P.S. If you are working with multiple devices, 
            //make sure that you start the service discovery 
            //after all desired connections are made
        }
        ....
    }
}

Après avoir fait ce que vous voulez dans le récepteur de radiodiffusion, voici comment je continue:

private Queue<BluetoothGatt> serviceDiscoveryQueue = new LinkedList<BluetoothGatt>();

private void initServiceDiscovery(){
    if(serviceDiscoveryThread == null){
        serviceDiscoveryThread = new Thread(new Runnable() {
            @Override
            public void run() {
                serviceDiscovery();

                serviceDiscoveryThread.interrupt();
                serviceDiscoveryThread = null;
            }
        });

        serviceDiscoveryThread.start();
    }
}

private void serviceDiscovery(){
    while(!serviceDiscoveryQueue.isEmpty()){
        serviceDiscoveryQueue.poll().discoverServices();
        try {
            Thread.sleep(250);
        } catch (InterruptedException e){}
    }
}

De nouveau, après avoir réussi à la découverte de service, BluetoothGattCallback.onServicesDiscovered(...) est appelé. Encore une fois, j'ai envoyer une intention de le BroadcastReceiver (cette fois avec différents Chaîne d'action) et c'est maintenant que vous pouvez commencer la lecture, l'écriture et l'activation des notifications/indications...
P. S. Si vous travaillez avec plusieurs appareils, assurez-vous que vous démarrez la lecture, l'écriture, etc... des trucs après tous les appareils ont déclaré que leurs services ont été découverts.

private Queue<BluetoothGattCharacteristic> characteristicReadQueue = new LinkedList<BluetoothGattCharacteristic>();

private void startThread(){

    if(initialisationThread == null){
        initialisationThread = new Thread(new Runnable() {
            @Override
            public void run() {
                loopQueues();

                initialisationThread.interrupt();
                initialisationThread = null;
            }
        });

        initialisationThread.start();
    }

}

private void loopQueues() {

    while(!characteristicReadQueue.isEmpty()){
        readCharacteristic(characteristicReadQueue.poll());
        try {
            Thread.sleep(BluetoothConstants.DELAY);
        } catch (InterruptedException e) {}
    }
    //A loop for starting indications and all other stuff goes here!
}

BluetoothGattCallback aurez toutes vos données en provenance du BLE capteur. Une bonne pratique consiste à envoyer une diffusion avec les données de votre BroadcastReceiver et de les traiter de là-bas.

Pluie est droit dans sa réponse, vous avez besoin de retards pour à peu près tout quand vous travaillez avec BLE dans Android. J'ai développé plusieurs applications avec elle et elle est vraiment nécessaire. En les utilisant vous éviter beaucoup d'accidents.

Dans mon cas, j'utilise les retards après chaque lecture/écriture de la commande. Ce faisant, vous vous assurer de recevoir la réponse du BLE appareil presque toujours. - Je faire quelque chose comme ceci: (bien sûr, tout est fait dans un thread séparé pour éviter à beaucoup de travail sur le thread principal)

 readCharacteristic(myChar);
 try {
    Thread.sleep(100);
 } catch (InterruptedException e) {
    e.printStackTrace();
 }
 myChar.getValue();

ou:

 myChar.setValue(myByte);
 writeCharacteristic(myChar);
 try {
    Thread.sleep(100);
 } catch (InterruptedException e) {
    e.printStackTrace();
 }

C'est vraiment utile lorsque vous écrivez ou lisez sur plusieurs caractères dans une ligne... Comme Android est assez rapide à exécuter les commandes presque instantanément, si vous n'utilisez pas un décalage entre eux, vous pouvez obtenir des erreurs d'incohérence ou de valeurs...

J'espère que ça aide, même si elle n'est pas exactement la réponse à votre question.