Mengelola koneksi

Memulai koneksi

Saat perangkat di sekitar ditemukan, penemu dapat memulai koneksi. Tujuan contoh berikut meminta koneksi dengan perangkat segera setelah ditemukan.

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

Bergantung pada kasus penggunaan Anda, sebaiknya tampilkan daftar perangkat kepada pengguna, memungkinkan mereka memilih perangkat mana yang akan dihubungkan.

Menerima atau menolak koneksi

Setelah penemu meminta koneksi dengan pengiklan, kedua belah pihak diberi tahu tentang proses inisiasi koneksi melalui onConnectionInitiated() dari ConnectionLifecycleCallback . Perhatikan bahwa callback ini diteruskan ke startAdvertising() pada pengiklan dan requestConnection() pada penemu, tetapi mulai saat ini terus, API-nya bersifat simetris.

Sekarang kedua belah pihak harus memilih apakah akan menerima atau menolak koneksi melalui panggilan masing-masing menjadi acceptConnection() atau rejectConnection(). Koneksinya adalah telah ditetapkan sepenuhnya hanya ketika kedua belah pihak telah sepakat. Jika salah satu atau keduanya menolak, koneksi dibuang. Bagaimanapun, hasilnya dikirim ke onConnectionResult().

Cuplikan kode berikut menunjukkan cara menerapkan callback ini:

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

Sekali lagi, contoh ini menunjukkan koneksi yang diterima secara otomatis oleh kedua belah pihak, tetapi bergantung pada kasus penggunaan, Anda mungkin ingin menyajikan pilihan ini kepada pengguna dengan cara tertentu.

Mengautentikasi koneksi

Saat koneksi diminta, aplikasi Anda dapat mengautentikasi koneksi dengan menggunakan token autentikasi yang diberikan ke onConnectionInitiated(). Ini memberi cara agar pengguna dapat mengonfirmasi bahwa mereka terhubung ke jaringan yang perangkat seluler. Kedua perangkat diberi token yang sama, yang merupakan string acak pendek; terserah Anda untuk memutuskan cara memverifikasinya. Biasanya hal ini melibatkan penayangan token di kedua perangkat dan meminta pengguna untuk membandingkan dan mengonfirmasi secara manual, mirip dengan dialog penyambungan bluetooth.

Perhatian: Meskipun autentikasi bersifat opsional, koneksi yang dibuat tanpa autentikasi tidak aman, dan dapat menyebabkan keamanan perangkat menjadi parah kerentanan. Untuk menghindari hal ini, selalu gunakan autentikasi untuk mengamankan koneksi Anda.

Kode contoh ini mendemonstrasikan satu cara untuk mengautentikasi dengan menampilkan token autentikasi ke pengguna di 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();
}