API Secure Connection

Dopo aver trovato un dispositivo remoto, viene chiamata la funzione handleIntent. è il momento di iniziare a passare dati tra i clienti. Questa sezione tratta le quattro passaggi essenziali per mantenere una connessione sicura:

• L'apertura di una connessione
• Accettazione della connessione in corso...
• Invio e ricezione di dati
• Chiusura della connessione in corso...

Apri una connessione

Per aprire una connessione per ricevere dati da un dispositivo remoto, utilizza la l'oggetto partecipante ricevuto in precedenza e specifica CHANNEL_NAME:

KotlinJava

participant
  .openConnection(CHANNEL_HELLO)
  .onFailure { /* handle failure */}
  .getOrNull()
  ?.let { connection ->
    connection.send("Hello, world".toByteArray(UTF_8)).onFailure { /* handle failure */}
  }

public void openConnection(Participant participant) {
  Futures.addCallback(
      participant.openConnectionFuture(CHANNEL_HELLO),
      new FutureCallback<RemoteConnection>() {
        @Override
        public void onSuccess(RemoteConnection remoteConnection) {
          // use remoteConnection object to pass data, e.g.:
          sendDataToRemoteConnection(remoteConnection);
        }

        @Override
        public void onFailure(Throwable t) {
          // handle error opening a remote connection
        }
      },
      mainExecutor);
}

private void sendDataToRemoteConnection(RemoteConnection remoteConnection) {
  Futures.addCallback(
      remoteConnection.sendFuture("Hello, world".getBytes()),
      new FutureCallback<Void>() {
        @Override
        public void onSuccess(Void result) {
          // data sent successfully
        }

        @Override
        public void onFailure(Throwable t) {
          // handle error
        }
      },
      mainExecutor);
}

Accettare, inviare/ricevere e chiudere una connessione

Per le connessioni sicure è necessario che il dispositivo ricevente accetti le connessioni in arrivo prima di ricevere i dati. Per accettare una connessione remota, utilizza quanto segue snippet:

KotlinJava

suspend fun acceptIncomingConnection(participant: Participant) {
  val connection = participant.acceptConnection(CHANNEL_HELLO).getOrThrow()
  connection.registerReceiver(
    object : ConnectionReceiver {
      override fun onMessageReceived(remoteConnection: RemoteConnection, payload: ByteArray) {
        displayMessage(payload.toString(UTF_8))
      }

      override fun onConnectionClosed(
        remoteConnection: RemoteConnection,
        error: Throwable?,
        reason: String?
      ) {
        // handle connection closure
      }
    }
  )
}

public void acceptIncomingConnection(Participant participant) {
  // Registers call back to accept incoming remote connection
  Futures.addCallback(
      participant.acceptConnectionFuture(CHANNEL_HELLO),
      new FutureCallback<>() {
        @Override
        public void onSuccess(RemoteConnection result) {
          receiveData(result);
        }

        @Override
        public void onFailure(Throwable t) {
          // handle connection error
        }
      },
      mainExecutor);
}

private void receiveData(RemoteConnection remoteConnection) {
  remoteConnection.registerReceiver(
      new ConnectionReceiver() {
        @Override
        public void onMessageReceived(RemoteConnection remoteConnection, byte[] payload) {
          displayMessage(new String(payload, UTF_8));
        }

        @Override
        public void onConnectionClosed(
            RemoteConnection remoteConnection,
            @Nullable Throwable error,
            @Nullable String reason) {
          // handle connection closure
        }
      });
}