Gestire le connessioni

Avvia una connessione

Quando vengono trovati dispositivi nelle vicinanze, il rilevatore può avviare connessioni. La nell'esempio seguente viene richiesta una connessione con un dispositivo non appena viene rilevato.

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.
      }
    };

A seconda del tuo caso d'uso, potresti voler mostrare invece un elenco dispositivi per l'utente, consentendogli di scegliere a quali dispositivi connettersi.

Accettare o rifiutare una connessione

Dopo che lo strumento di rilevamento ha richiesto una connessione con un inserzionista, entrambe le parti vengono notificato il processo di avvio della connessione tramite onConnectionInitiated() del metodo ConnectionLifecycleCallback di Google. Tieni presente che questo callback viene passato a startAdvertising() su inserzionista e requestConnection() sullo strumento di rilevamento, ma da questo punto l'API è simmetrica.

Ora entrambe le parti devono scegliere se accettare o rifiutare la connessione tramite una chiamata rispettivamente a acceptConnection() o rejectConnection(). La connessione è completamente stabilite solo quando entrambe le parti hanno accettato l'accordo. Se una o entrambe le opzioni rifiutano, viene ignorata. In ogni caso, il risultato viene inviato onConnectionResult().

Il seguente snippet di codice mostra come implementare questo callback:

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.
      }
    };

Anche in questo caso, questo esempio mostra che la connessione viene accettata automaticamente da entrambe le parti, ma a seconda del caso d'uso potresti voler presentare questa scelta all'utente in qualche modo.

Autenticare una connessione

Quando viene richiesta una connessione, l'app può autenticarla tramite utilizzando il token di autenticazione fornito a onConnectionInitiated(). Questo consente agli utenti di confermare che si connettono all'app dispositivo. A entrambi i dispositivi viene assegnato lo stesso token, che è una breve stringa casuale. spetta a te decidere come verificarlo. In genere ciò comporta la visualizzazione su entrambi i dispositivi e chiedere agli utenti di confrontare e confermare manualmente. in modo simile a una finestra di dialogo per l'accoppiamento Bluetooth.

Attenzione: sebbene l'autenticazione sia facoltativa, le connessioni stabilite senza di autenticazione non sono sicuri e possono esporre i dispositivi a gravi le vulnerabilità. Per evitare che questo accada, utilizza sempre l'autenticazione per proteggere le connessioni.

Questo codice di esempio illustra un modo per eseguire l'autenticazione visualizzando di autenticazione per l'utente in 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();
}