Cette page a été traduite par l'API Cloud Translation.

Rechercher des appareils Bluetooth

Avec BluetoothAdapter, vous pouvez trouver des appareils Bluetooth distants grâce à la détection d'appareils ou en interrogeant la liste des appareils associés.

Assurez-vous de disposer des autorisations Bluetooth appropriées. et configurez votre application pour le Bluetooth. avant d'essayer de trouver des appareils Bluetooth.

La détection d'appareils est une procédure d'analyse qui recherche dans la région appareils sur lesquels le Bluetooth est activé et demande des informations à leur sujet. Ce processus est parfois appelé découverte, demande ou analyse. Un appareil Bluetooth à proximité ne répond à une requête de détection que s'il est acceptent actuellement les demandes d'informations en étant visible. Si un appareil est visible, il répond à la requête de découverte en partageant certaines informations, telles que le nom de l'appareil, sa classe et son adresse MAC unique. Utilisation informations, l'appareil qui effectue le processus de détection peut alors choisir pour initier une connexion à l'appareil détecté.

Comme les appareils visibles peuvent révéler des informations sur la position de l'utilisateur, le processus de détection d'appareils nécessite un accès à la position. Si votre application est utilisée sur un appareil équipé d'Android 8.0 (niveau d'API 26) ou version ultérieure, envisagez d'utiliser la Gestionnaire d'appareils associés API. Cette API effectue la détection d'appareils pour le compte de votre application, de sorte que celle-ci n'a pas besoin de demander l'autorisation d'accéder à la position.

Lorsqu'une connexion est établie pour la première fois avec un appareil distant, est automatiquement présentée à l'utilisateur. Lorsqu'un appareil est associé, le des informations de base sur l'appareil, telles que son nom, sa classe et son adresse MAC est enregistrée et peut être lue à l'aide des API Bluetooth. Avec l'adresse MAC connue pour un appareil distant, vous pouvez établir une connexion avec celui-ci à tout moment sans effectuer de détection, en supposant que l'appareil est toujours à portée.

Notez qu'il existe une différence entre le fait d'être associé et d'être connecté:

Être associé signifie que deux appareils sont informés de l'existence de l'autre. ont une clé de lien partagée pouvant être utilisée pour l'authentification et sont capables de en établissant une connexion chiffrée les uns avec les autres.
Pour être connectés, les appareils partagent actuellement un canal RFCOMM et sont capables de se transmettre des données entre eux. Le Bluetooth actuel Les API exigent que les appareils soient associés avant qu'une connexion RFCOMM puisse être établi. L'association est effectuée automatiquement lorsque vous lancez un processus avec les API Bluetooth.

Les sections suivantes décrivent comment trouver les appareils qui ont été associés et comment découvrir de nouveaux appareils à l'aide de la détection d'appareils.

Interroger les appareils associés

Avant de procéder à la détection d'appareils, il est utile d'interroger l'ensemble des appareils appareils pour voir si l'appareil souhaité est déjà connu. Pour ce faire, appelez getBondedDevices() Cela renvoie un ensemble de Objets BluetoothDevice représentant des appareils associés. Par exemple, vous pouvez envoyer une requête à tous les appareils associés et obtenir le nom et l'adresse MAC de chaque appareil, comme dans l'extrait de code suivant : montre comment:

Kotlin

val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter?.bondedDevices
pairedDevices?.forEach { device ->
   val deviceName = device.name
   val deviceHardwareAddress = device.address // MAC address
}

Java

Set<BluetoothDevice> pairedDevices = bluetoothAdapter.getBondedDevices();

if (pairedDevices.size() > 0) {
   // There are paired devices. Get the name and address of each paired device.
   for (BluetoothDevice device : pairedDevices) {
       String deviceName = device.getName();
       String deviceHardwareAddress = device.getAddress(); // MAC address
   }
}

Pour établir une connexion avec un appareil Bluetooth, il vous suffit de passer par l'objet BluetoothDevice associé est l'adresse MAC, que vous récupérez en Appel en cours getAddress() Toi vous pouvez en savoir plus sur la création d'une connexion dans Connecter des appareils mobiles.

Découvrir des appareils

Pour commencer à découvrir des appareils, appelez startDiscovery() Le processus est asynchrone et renvoie une valeur booléenne indiquant si la découverte a démarré. Le processus de découverte implique généralement analyse de la demande d'environ 12 secondes, suivie d'une analyse de la page pour chaque appareil détecté pour récupérer son nom Bluetooth.

Pour recevoir des informations sur chaque appareil détecté, votre application doit enregistrer un BroadcastReceiver pour le ACTION_FOUND l'intention. Le système diffuse cet intent pour chaque appareil. L'intent contient les champs supplémentaires EXTRA_DEVICE et EXTRA_CLASS, qui et elles contiennent à leur tour un BluetoothDevice et un BluetoothClass. L'extrait de code suivant montre comment vous inscrire pour gérer la diffusion lorsque des appareils sont détectés:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
   ...

   // Register for broadcasts when a device is discovered.
   val filter = IntentFilter(BluetoothDevice.ACTION_FOUND)
   registerReceiver(receiver, filter)
}

// Create a BroadcastReceiver for ACTION_FOUND.
private val receiver = object : BroadcastReceiver() {

   override fun onReceive(context: Context, intent: Intent) {
       val action: String = intent.action
       when(action) {
           BluetoothDevice.ACTION_FOUND -> {
               // Discovery has found a device. Get the BluetoothDevice
               // object and its info from the Intent.
               val device: BluetoothDevice =
                       intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
               val deviceName = device.name
               val deviceHardwareAddress = device.address // MAC address
           }
       }
   }
}

override fun onDestroy() {
   super.onDestroy()
   ...

   // Don't forget to unregister the ACTION_FOUND receiver.
   unregisterReceiver(receiver)
}

Java

@Override
protected void onCreate(Bundle savedInstanceState) {
   ...

   // Register for broadcasts when a device is discovered.
   IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
   registerReceiver(receiver, filter);
}

// Create a BroadcastReceiver for ACTION_FOUND.
private final BroadcastReceiver receiver = new BroadcastReceiver() {
   public void onReceive(Context context, Intent intent) {
       String action = intent.getAction();
       if (BluetoothDevice.ACTION_FOUND.equals(action)) {
           // Discovery has found a device. Get the BluetoothDevice
           // object and its info from the Intent.
           BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
           String deviceName = device.getName();
           String deviceHardwareAddress = device.getAddress(); // MAC address
       }
   }
};

@Override
protected void onDestroy() {
   super.onDestroy();
   ...

   // Don't forget to unregister the ACTION_FOUND receiver.
   unregisterReceiver(receiver);
}

Pour établir une connexion avec un appareil Bluetooth, vous devez appeler getAddress() sur le BluetoothDevice pour récupérer l'adresse MAC associée.

Activer la visibilité

Pour rendre l'appareil local visible par d'autres appareils, appelez startActivityForResult(Intent, int) avec le ACTION_REQUEST_DISCOVERABLE l'intention. Une requête est alors émise pour activer le mode visible du système sans avoir à accéder à l'application Paramètres, ce qui arrête votre propre application. Par par défaut, l'appareil devient visible pendant deux minutes. Vous pouvez définir d'une durée différente, jusqu'à une heure, en ajoutant le paramètre EXTRA_DISCOVERABLE_DURATION supplémentaires.

L'extrait de code suivant définit l'appareil pour qu'il soit visible pendant cinq minutes:

Kotlin

val requestCode = 1;
val discoverableIntent: Intent = Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE).apply {
   putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300)
}
startActivityForResult(discoverableIntent, requestCode)

Java

int requestCode = 1;
Intent discoverableIntent =
       new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivityForResult(discoverableIntent, requestCode);

Figure 2:Boîte de dialogue d'activation de la visibilité

Une boîte de dialogue s'affiche, demandant l'autorisation de l'utilisateur pour rendre l'appareil visible, comme illustré dans la figure 2. Si l'utilisateur répond "Autoriser", puis l'appareil devient visible pendant la durée spécifiée. Votre activité à ce moment-là reçoit un appel vers onActivityResult() avec un code de résultat égal à la durée d'exécution de l'appareil visible. Si l'utilisateur a répondu "Refuser" ou si une erreur s'est produite, le résultat le code est RESULT_CANCELED.

L'appareil reste silencieux pendant le temps imparti. Pour être notifié lorsque le mode visible a été modifié, enregistrez un BroadcastReceiver pour le ACTION_SCAN_MODE_CHANGED l'intention. Cet intent contient les champs supplémentaires EXTRA_SCAN_MODE et EXTRA_PREVIOUS_SCAN_MODE, qui fournissent respectivement le nouveau et l'ancien mode d'analyse. Les valeurs possibles pour chaque supplémentaires sont les suivants:

SCAN_MODE_CONNECTABLE_DISCOVERABLE: L'appareil est en mode visible.
SCAN_MODE_CONNECTABLE: L'appareil n'est pas en mode visible, mais peut toujours recevoir des connexions.
SCAN_MODE_NONE: L'appareil n'est pas en mode visible et ne peut pas recevoir de connexions.

Si vous initiez la connexion à un appareil distant, vous n'avez pas besoin de permettent d'améliorer la visibilité des appareils. L'activation de la visibilité n'est nécessaire que vous voulez que votre application héberge un socket de serveur qui accepte les connexions car les appareils distants doivent pouvoir détecter d'autres appareils avant initier des connexions à ces autres appareils.