Short Messages

  • The Android Nearby Connections API enables users to publish and subscribe messages between devices.

  • Messages within 131 bytes can be transferred without establishing a connection, using advertising and discovery.

  • For messages larger than 131 bytes, a connection needs to be established between devices using a P2P strategy.

  • Sample code is provided to demonstrate message publishing and subscription for both small and large messages.

  • Developers can adapt their existing Nearby Message designs to leverage the functionalities of Nearby Connections.

Users can publish and subscribe messages via the Android NearbyConnections API. Nearby Message users could adapt their current design to Nearby Connections via below samples. For more detailed usage about Nearby Connections, please refer to Nearby Connections API Overview.

Nearby Connections allows its clients to send data within 131 bytes without establishing a connection to the remote device. Please refer to the flow below as how to transfer messages within 131 bytes.

Publisher

private void startPublishing() {
  // Using the default advertising option is enough since  connecting is not required.
  AdvertisingOptions advertisingOptions = new AdvertisingOptions.Builder().build();
  Nearby.getConnectionsClient(context)
      .startAdvertising(getMessagesInBytes(), SERVICE_ID, connectionLifecycleCallback, advertisingOptions)
      .addOnSuccessListener(
          (Void unused) -> {
            // We're advertising!
          })
      .addOnFailureListener(
          (Exception e) -> {
            // We were unable to start advertising.
          });
}

// To manage incoming connections from the subscriber.
// In this flow since we are not establishing connections between the two devices, we could
// ignore the implementation.
private final ConnectionLifecycleCallback connectionLifecycleCallback =
    new ConnectionLifecycleCallback() {
      @Override
      public void onConnectionInitiated(String endpointId, ConnectionInfo connectionInfo) {}

      @Override
      public void onConnectionResult(String endpointId, ConnectionResolution result) {}

      @Override
      public void onDisconnected(String endpointId) {}
    };

private void stopPublishing() {
  // Stop advertising when done.
  Nearby.getConnectionsClient(context).stopAdvertising();
  Nearby.getConnectionsClient(context).stopAllEndpoints();
}

Subscriber

private void startSubscription() {
  // Using the default discovery option is enough since connection is not required.
  DiscoveryOptions discoveryOptions = new DiscoveryOptions.Builder().build();
  Nearby.getConnectionsClient(context)
      // The SERVICE_ID value must uniquely identify your app.
      // As a best practice, use the package name of your app
      // (for example, com.google.example.myapp).
      .startDiscovery(SERVICE_ID, endpointDiscoveryCallback, discoveryOptions)
      .addOnSuccessListener(
          (Void unused) -> {
            // We're discovering!
          })
      .addOnFailureListener(
          (Exception e) -> {
            // We're unable to start discovering.
          });
}

private final EndpointDiscoveryCallback endpointDiscoveryCallback =
    new EndpointDiscoveryCallback() {
      @Override
      public void onEndpointFound(String endpointId, DiscoveredEndpointInfo info) {
        // A remote advertising endpoint is found.
        // To retrieve the published message data.
        byte[] message = info.getEndpointInfo();
      }

      @Override
      public void onEndpointLost(String endpointId) {
        // A previously discovered endpoint has gone away.
      }
    };

private void stopSubscription() {
  // Stop discovery when the subscription is done.
  Nearby.getConnectionsClient(context).stopDiscovery();
  Nearby.getConnectionsClient(context).stopAllEndpoints();
}

Long Messages

For messages which are larger than 131 bytes, a connection between the devices needs to be established to transfer the message. Please refer to the flow below as how to transfer large data using Nearby Connections.

Publisher

private void startPublishing() {
  // Using P2P strategy for 1:1 connection.
  AdvertisingOptions advertisingOptions =
      new AdvertisingOptions.Builder().setStrategy(Strategy.P2P_POINT_TO_POINT).build();
  Nearby.getConnectionsClient(context)
      .startAdvertising(
          getLocalUserName(), SERVICE_ID, connectionLifecycleCallback, advertisingOptions)
      .addOnSuccessListener(
          (Void unused) -> {
            // We're advertising!
          })
      .addOnFailureListener(
          (Exception e) -> {
            // We were unable to start advertising.
          });
}