Zarządzaj połączeniami

Zainicjuj połączenie

Po znalezieniu urządzeń w pobliżu detektor może zainicjować połączenia. ten przykład żąda nawiązania połączenia od razu po wykryciu urządzenia.

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

W zależności od zastosowania możesz zamiast tego wyświetlić listę wykrytych urządzeń mobilnych, co pozwala mu wybierać urządzenia, z którymi chcą się połączyć.

Akceptowanie i odrzucanie połączenia

Gdy odkrywca poprosi o połączenie z reklamodawcą, obie strony powiadomienie o procesie inicjowania połączenia przez onConnectionInitiated() funkcji ConnectionLifecycleCallback. oddzwanianie. To wywołanie zwrotne jest przekazywane do startAdvertising() w reklamodawcy i requestConnection() w narzędziu Discovery, ale od tego momentu interfejs API jest symetryczny.

Teraz obie strony muszą zdecydować, czy chcą zaakceptować, czy odrzucić połączenie w ramach połączenia. odpowiednio acceptConnection() lub rejectConnection(). Połączenie jest zostanie w pełni ustalona dopiero po zaakceptowaniu jej przez obie strony. Jeśli co najmniej jedna z nich zostanie odrzucona, połączenie zostało odrzucone. W obu przypadkach wynik jest dostarczany do onConnectionResult()

Fragment kodu, który pokazuje, jak zaimplementować to wywołanie zwrotne:

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

W tym przykładzie połączenie jest automatycznie akceptowane przez obie strony, ale w zależności od zastosowania możesz przedstawić tę opcję użytkownikowi.

Uwierzytelnianie połączenia

Gdy wymagane jest połączenie, aplikacja może je uwierzytelnić, wykonując te czynności: za pomocą tokena uwierzytelniania udostępnionego onConnectionInitiated(). Ten pozwala użytkownikom sprawdzić, czy łączą się z urządzenia. Oba urządzenia otrzymują ten sam token, który jest krótkim losowym ciągiem. to Ty decydujesz, jak chcesz go zweryfikować. Zwykle polega to na pokazaniu na obu urządzeniach i prosząc użytkowników o ręczne porównanie i potwierdzenie, podobnie jak okno parowania Bluetooth.

Uwaga: uwierzytelnianie jest opcjonalne, jednak połączenia nawiązywane bez uwierzytelnianie jest niezabezpieczone i może narazić urządzenia na poważne niebezpieczeństwo Luki w zabezpieczeniach. Aby tego uniknąć, zawsze używaj uwierzytelniania do zabezpieczania połączeń.

Ten przykładowy kod przedstawia jeden ze sposobów uwierzytelniania przez wyświetlenie token uwierzytelniania użytkownika w 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();
}