Gérer les connexions

Établir une connexion

Lorsque des appareils à proximité sont détectés, le détecteur peut établir des connexions. La L'exemple suivant demande une connexion avec un appareil dès qu'il est détecté.

private final EndpointDiscoveryCallback endpointDiscoveryCallback =
    new EndpointDiscoveryCallback() {
      @Override
      public void onEndpointFound(String endpointId, DiscoveredEndpointInfo info) {
        // An endpoint was found. We request a connection to it.
        Nearby.getConnectionsClient(context)
            .requestConnection(getLocalUserName(), endpointId, connectionLifecycleCallback)
            .addOnSuccessListener(
                (Void unused) -> {
                  // We successfully requested a connection. Now both sides
                  // must accept before the connection is established.
                })
            .addOnFailureListener(
                (Exception e) -> {
                  // Nearby Connections failed to request the connection.
                });
      }

      @Override
      public void onEndpointLost(String endpointId) {
        // A previously discovered endpoint has gone away.
      }
    };

Selon votre cas d'utilisation, vous pouvez afficher à la place une liste des appareils à l'utilisateur, ce qui lui permet de choisir les appareils auxquels se connecter.

Accepter ou refuser une connexion

Une fois que le découvreur a demandé une connexion à un annonceur, les deux côtés sont notifié du processus d'initiation de la connexion via l'onConnectionInitiated() de la classe ConnectionLifecycleCallback . Notez que ce rappel est transmis à startAdvertising() sur le et requestConnection() dans le découvreur, mais à partir de là, l'API est symétrique.

Les deux parties doivent maintenant choisir d'accepter ou de rejeter la connexion via un appel à acceptConnection() ou rejectConnection(), respectivement. La connexion est n'est entièrement établi que lorsque les deux parties ont accepté. En cas de refus de l'un ou des deux, le connexion est supprimée. Dans tous les cas, le résultat est envoyé à onConnectionResult()

L'extrait de code suivant montre comment implémenter ce rappel:

private final ConnectionLifecycleCallback connectionLifecycleCallback =
    new ConnectionLifecycleCallback() {
      @Override
      public void onConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {
        // Automatically accept the connection on both sides.
        Nearby.getConnectionsClient(context).acceptConnection(endpointId, payloadCallback);
      }

      @Override
      public void onConnectionResult(String endpointId, ConnectionResolution result) {
        switch (result.getStatus().getStatusCode()) {
          case ConnectionsStatusCodes.STATUS_OK:
            // We're connected! Can now start sending and receiving data.
            break;
          case ConnectionsStatusCodes.STATUS_CONNECTION_REJECTED:
            // The connection was rejected by one or both sides.
            break;
          case ConnectionsStatusCodes.STATUS_ERROR:
            // The connection broke before it was able to be accepted.
            break;
          default:
            // Unknown status code
        }
      }

      @Override
      public void onDisconnected(String endpointId) {
        // We've been disconnected from this endpoint. No more data can be
        // sent or received.
      }
    };

Là encore, cet exemple montre que la connexion est automatiquement acceptée par les deux côtés, mais en fonction de votre cas d'utilisation, vous pouvez présenter ce choix à l'utilisateur d'une manière ou d'une autre.

Authentifier une connexion

Lorsqu'une connexion est demandée, votre application peut authentifier la connexion en à l'aide du jeton d'authentification fourni à onConnectionInitiated(). Ce permet aux utilisateurs de confirmer qu'ils se connectent au réseau appareil. Les deux appareils reçoivent le même jeton, qui est une courte chaîne aléatoire. c'est à vous de décider comment le valider. Généralement, cela implique de montrer sur les deux appareils et demander aux utilisateurs de les comparer et de confirmer manuellement, similaire à une boîte de dialogue d'association Bluetooth.

Attention :Bien que l'authentification soit facultative, les connexions établies sans ne sont pas sécurisées et peuvent exposer les appareils à des systèmes de sécurité les failles. Pour éviter cela, utilisez toujours l'authentification pour sécuriser vos connexions.

Cet exemple de code présente une façon de s'authentifier en affichant le d'authentification à l'utilisateur dans un AlertDialog:

@Override
public void onConnectionInitiated(String endpointId, ConnectionInfo info) {
  new AlertDialog.Builder(context)
      .setTitle("Accept connection to " + info.getEndpointName())
      .setMessage("Confirm the code matches on both devices: " + info.getAuthenticationDigits())
      .setPositiveButton(
          "Accept",
          (DialogInterface dialog, int which) ->
              // The user confirmed, so we can accept the connection.
              Nearby.getConnectionsClient(context)
                  .acceptConnection(endpointId, payloadCallback))
      .setNegativeButton(
          android.R.string.cancel,
          (DialogInterface dialog, int which) ->
              // The user canceled, so we should reject the connection.
              Nearby.getConnectionsClient(context).rejectConnection(endpointId))
      .setIcon(android.R.drawable.ic_dialog_alert)
      .show();
}