Administra conexiones

Cómo iniciar una conexión

Cuando se encuentran dispositivos cercanos, el detective puede iniciar las conexiones. El El siguiente ejemplo solicita una conexión con un dispositivo en cuanto se detecta.

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

Según tu caso de uso, tal vez quieras mostrar en su lugar una lista de los recursos al usuario para que pueda elegir a qué dispositivos conectarse.

Cómo aceptar o rechazar una conexión

Después de que el descubridor solicita conectarse con un anunciante, ambos lados notificación del proceso de inicio de la conexión a través del onConnectionInitiated() método de la ConnectionLifecycleCallback devolución de llamada. Ten en cuenta que esta devolución de llamada se pasa a startAdvertising() en el el anunciante y requestConnection() sobre el descubridor, pero, a partir de este momento, en adelante, la API es simétrica.

Ahora ambas partes deben elegir si aceptan o rechazan la conexión mediante una llamada. a acceptConnection() o rejectConnection(), respectivamente. La conexión es completamente establecidas solo cuando ambas partes han aceptado. Si se rechazan uno o ambos, el se descarta la conexión. De cualquier manera, el resultado se entrega onConnectionResult()

En el siguiente fragmento de código, se muestra cómo implementar esta devolución de llamada:

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

Nuevamente, este ejemplo muestra que ambos extremos aceptan automáticamente la conexión, pero, según tu caso de uso, es posible que desees presentar esta opción al usuario de alguna manera.

Autentica una conexión

Cuando se solicita una conexión, tu app puede autenticar la conexión mediante el token de autenticación proporcionado a onConnectionInitiated(). Esta proporciona una forma de permitir que los usuarios confirmen que se están conectando a la red dispositivo. Ambos dispositivos reciben el mismo token, que es una cadena corta al azar; depende de ti decidir cómo verificarla. Por lo general, esto implica mostrar token de la aplicación en ambos dispositivos y pedirles a los usuarios que comparen y confirmen manualmente. similar a un diálogo de vinculación por Bluetooth.

Precaución: Si bien la autenticación es opcional, las conexiones que se establecen sin autenticación no son seguros y pueden exponer los dispositivos a riesgos de seguridad vulnerabilidades. Si quieres evitar esto, usa siempre la autenticación para proteger tus conexiones.

Este código de muestra demuestra una forma de autenticarse mostrando el token de autenticación al usuario en 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();
}