nearby: snapshot of cl/313536507

Signed-off-by: Alexey Polyudov <apolyudov@google.com>
Change-Id: I8936b527079074d5c3af5531b9245063767cc4a7

cpp/platform_v2/api/BUILD

@@ -0,0 +1,43 @@
+cc_library(
+    name = "api",
+    hdrs = [
+        "atomic_boolean.h",
+        "atomic_reference.h",
+        "ble.h",
+        "ble_v2.h",
+        "bluetooth_adapter.h",
+        "bluetooth_classic.h",
+        "cancelable.h",
+        "condition_variable.h",
+        "count_down_latch.h",
+        "crypto.h",
+        "executor.h",
+        "future.h",
+        "input_file.h",
+        "listenable_future.h",
+        "mutex.h",
+        "output_file.h",
+        "platform.h",
+        "scheduled_executor.h",
+        "server_sync.h",
+        "settable_future.h",
+        "submittable_executor.h",
+        "system_clock.h",
+        "webrtc.h",
+        "wifi.h",
+        "wifi_lan.h",
+    ],
+    visibility = [
+        "//platform_v2/base:__pkg__",
+        "//platform_v2/impl:__subpackages__",
+        "//platform_v2/public:__subpackages__",
+    ],
+    deps = [
+        "//platform_v2/base",
+        "//absl/base:core_headers",
+        "//absl/strings",
+        "//absl/time",
+        "//absl/types:any",
+        "//webrtc/files/stable/webrtc/api:libjingle_peerconnection_api",
+    ],
+)

cpp/platform_v2/api/atomic_boolean.h

@@ -0,0 +1,24 @@
+#ifndef PLATFORM_V2_API_ATOMIC_BOOLEAN_H_
+#define PLATFORM_V2_API_ATOMIC_BOOLEAN_H_
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// A boolean value that may be updated atomically.
+class AtomicBoolean {
+ public:
+  virtual ~AtomicBoolean() = default;
+
+  // Atomically read and return current value.
+  virtual bool Get() const = 0;
+
+  // Atomically exchange original value with a new one. Return previous value.
+  virtual bool Set(bool value) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_ATOMIC_BOOLEAN_H_

cpp/platform_v2/api/atomic_reference.h

@@ -0,0 +1,26 @@
+#ifndef PLATFORM_V2_API_ATOMIC_REFERENCE_H_
+#define PLATFORM_V2_API_ATOMIC_REFERENCE_H_
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// An object reference that may be updated atomically.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+template <typename T>
+class AtomicReference {
+ public:
+  virtual ~AtomicReference() = default;
+
+  virtual T Get() const & = 0;
+  virtual T Get() && = 0;
+  virtual void Set(const T& value) = 0;
+  virtual void Set(T&& value) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_ATOMIC_REFERENCE_H_

cpp/platform_v2/api/ble.h

@@ -0,0 +1,112 @@
+#ifndef PLATFORM_V2_API_BLE_H_
+#define PLATFORM_V2_API_BLE_H_
+
+#include "platform_v2/api/bluetooth_classic.h"
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/output_stream.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// Opaque wrapper over a BLE peripheral. Must contain enough data about a
+// particular BLE device to connect to its GATT server.
+class BlePeripheral {
+ public:
+  virtual ~BlePeripheral() {}
+
+  // The returned reference lifetime matches BlePeripheral object.
+  virtual BluetoothDevice& GetBluetoothDevice() = 0;
+};
+
+class BleSocket {
+ public:
+  virtual ~BleSocket() {}
+
+  // Returns the InputStream of the BleSocket.
+  // On error, returned stream will report Exception::kIo on any operation.
+  //
+  // The returned object is not owned by the caller, and can be invalidated once
+  // the BleSocket object is destroyed.
+  virtual InputStream& GetInputStream() = 0;
+
+  // Returns the OutputStream of the BleSocket.
+  // On error, returned stream will report Exception::kIo on any operation.
+  //
+  // The returned object is not owned by the caller, and can be invalidated once
+  // the BleSocket object is destroyed.
+  virtual OutputStream& GetOutputStream() = 0;
+
+  // Conforms to the same contract as
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#close().
+  //
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  virtual Exception Close() = 0;
+
+  // The returned object is not owned by the caller, and can be invalidated once
+  // the BleSocket object is destroyed.
+  virtual BlePeripheral& GetRemotePeripheral() = 0;
+};
+
+// Container of operations that can be performed over the BLE medium.
+class BleMedium {
+ public:
+  virtual ~BleMedium() {}
+
+  virtual bool StartAdvertising(absl::string_view service_id,
+                                const ByteArray& advertisement) = 0;
+  virtual void StopAdvertising(absl::string_view service_id) = 0;
+
+  class DiscoveredPeripheralCallback {
+   public:
+    virtual ~DiscoveredPeripheralCallback() {}
+
+    // The BlePeripheral* is not owned by callbacks.
+    // It is passed to give access to its non-const methods.
+    // It is guaranteed to be valid for the duration of call.
+    virtual void OnPeripheralDiscovered(BlePeripheral* ble_peripheral,
+                                        absl::string_view service_id,
+                                        const ByteArray& advertisement) = 0;
+    virtual void OnPeripheralLost(BlePeripheral* ble_peripheral,
+                                  absl::string_view service_id) = 0;
+  };
+
+  // Returns true once the BLE scan has been initiated.
+  virtual bool StartScanning(
+      absl::string_view service_id,
+      const DiscoveredPeripheralCallback& discovered_peripheral_callback) = 0;
+
+  // Returns true once BLE scanning for service_id is well and truly stopped;
+  // after this returns, there must be no more invocations of the
+  // DiscoveredPeripheralCallback passed in to StartScanning() for service_id.
+  virtual void StopScanning(absl::string_view service_id) = 0;
+
+  // Callback that is invoked when a new connection is accepted.
+  class AcceptedConnectionCallback {
+   public:
+    virtual ~AcceptedConnectionCallback() {}
+
+    virtual void OnConnectionAccepted(std::unique_ptr<BleSocket> socket,
+                                      absl::string_view service_id) = 0;
+  };
+
+  // Returns true once BLE socket connection requests to service_id can be
+  // accepted.
+  virtual bool StartAcceptingConnections(
+      absl::string_view service_id,
+      const AcceptedConnectionCallback& accepted_connection_callback) = 0;
+  virtual void StopAcceptingConnections(const std::string& service_id) = 0;
+
+  // BlePeripheral* is not owned by this call;
+  // it must remain valid for the duration of a call.
+  virtual std::unique_ptr<BleSocket> Connect(BlePeripheral* ble_peripheral,
+                                             absl::string_view service_id) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_BLE_H_

cpp/platform_v2/api/ble_v2.h

@@ -0,0 +1,392 @@
+#ifndef PLATFORM_V2_API_BLE_V2_H_
+#define PLATFORM_V2_API_BLE_V2_H_
+
+#include <cstdint>
+#include <limits>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+namespace ble_v2 {
+
+// https://developer.android.com/reference/android/bluetooth/le/AdvertiseData
+//
+// Bundle of data found in a BLE advertisement.
+//
+// All service UUIDs will conform to the 16-bit Bluetooth base UUID,
+// 0000xxxx-0000-1000-8000-00805F9B34FB. This makes it possible to store two
+// byte service UUIDs in the advertisement.
+struct BleAdvertisementData {
+  using TxPowerLevel = int8_t;
+
+  static const TxPowerLevel kUnspecifiedTxPowerLevel =
+      std::numeric_limits<TxPowerLevel>::min();
+
+  bool is_connectable;
+  // When set to kUnspecifiedTxPowerLevel, TX power should not be included in
+  // the advertisement data.
+  TxPowerLevel tx_power_level;
+  // When set to an empty string, local name should not be included in the
+  // advertisement data.
+  std::string local_name;
+  // When set to an empty vector, the set of 16-bit service class UUIDs should
+  // not be included in the advertisement data.
+  std::set<std::string> service_uuids;
+  // Maps service UUIDs to their service data.
+  std::map<std::string, ByteArray> service_data;
+};
+
+// Opaque wrapper over a BLE peripheral. Must be able to uniquely identify a
+// peripheral so that we can connect to its GATT server.
+class BlePeripheral {
+ public:
+  virtual ~BlePeripheral() {}
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice#getAddress()
+  //
+  // This should be the MAC address when possible. If the implementation is
+  // unable to retrieve that, any unique identifier should suffice.
+  virtual std::string GetId() const = 0;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic
+//
+// Representation of a GATT characteristic.
+class GattCharacteristic {
+ public:
+  virtual ~GattCharacteristic() {}
+
+  // Possible permissions of a GATT characteristic.
+  enum class Permission {
+    kUnknown = 0,
+    kRead = 1,
+    kWrite = 2,
+    kLast,
+  };
+
+  // Possible properties of a GATT characteristic.
+  enum class Property {
+    kUnknown = 0,
+    kRead = 1,
+    kWrite = 2,
+    kIndicate = 3,
+    kLast,
+  };
+
+  // Returns the UUID of this characteristic.
+  virtual std::string GetUuid() = 0;
+
+  // Returns the UUID of the containing GATT service.
+  virtual std::string GetServiceUuid() = 0;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothGatt
+//
+// Representation of a client GATT connection to a remote GATT server.
+class ClientGattConnection {
+ public:
+  virtual ~ClientGattConnection() {}
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#getDevice()
+  //
+  // Retrieves the BLE peripheral that this connection is tied to.
+  virtual BlePeripheral& GetPeripheral() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#discoverServices()
+  //
+  // Discovers all available services and characteristics on this connection.
+  // Returns whether or not discovery finished successfully.
+  //
+  // This function should block until discovery has finished.
+  virtual bool DiscoverServices() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#getService(java.util.UUID)
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattService.html#getCharacteristic(java.util.UUID)
+  //
+  // Retrieves a GATT characteristic. On error, does not return a value.
+  //
+  // DiscoverServices() should be called before this method to fetch all
+  // available services and characteristics first.
+  //
+  // It is okay for duplicate services to exist, as long as the specified
+  // characteristic UUID is unique among all services of the same UUID.
+  virtual std::optional<GattCharacteristic> GetCharacteristic(
+      absl::string_view service_uuid,
+      absl::string_view characteristic_uuid) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#readCharacteristic(android.bluetooth.BluetoothGattCharacteristic)
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic.html#getValue()
+  //
+  // Reads a GATT characteristic. No value is returned upon error.
+  virtual std::optional<ByteArray> ReadCharacteristic(
+      const GattCharacteristic& characteristic) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic.html#setValue(byte[])
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#writeCharacteristic(android.bluetooth.BluetoothGattCharacteristic)
+  //
+  // Sends a remote characteristic write request to the server and returns
+  // whether or not it was successful.
+  virtual bool WriteCharacteristic(const GattCharacteristic& characteristic,
+                                   const ByteArray& value) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#disconnect()
+  //
+  // Disconnects a GATT connection.
+  virtual void Disconnect() = 0;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothGattServer
+//
+// Representation of a server GATT connection to a remote GATT client.
+class ServerGattConnection {
+ public:
+  virtual ~ServerGattConnection() {}
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic.html#setValue(byte[])
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattServer.html#notifyCharacteristicChanged(android.bluetooth.BluetoothDevice,%20android.bluetooth.BluetoothGattCharacteristic,%20boolean)
+  //
+  // Sends a notification (via indication) to the client that a characteristic
+  // has changed with the given value. Returns whether or not it was successful.
+  //
+  // The value sent does not have to reflect the locally stored characteristic
+  // value. To update the local value, call GattServer::UpdateCharacteristic.
+  virtual bool SendCharacteristic(const GattCharacteristic& characteristic,
+                                  const ByteArray& value) = 0;
+};
+
+// Callback for asynchronous events on the client side of a GATT connection.
+class ClientGattConnectionLifeCycleCallback {
+ public:
+  virtual ~ClientGattConnectionLifeCycleCallback() {}
+
+  // Called when the client is disconnected from the GATT server.
+  virtual void OnDisconnected(ClientGattConnection* connection) = 0;
+};
+
+// Callback for asynchronous events on the server side of a GATT connection.
+class ServerGattConnectionLifeCycleCallback {
+ public:
+  virtual ~ServerGattConnectionLifeCycleCallback() {}
+
+  // Called when a remote peripheral connected to us and subscribed to one of
+  // our characteristics.
+  virtual void OnCharacteristicSubscription(
+      ServerGattConnection* connection,
+      const GattCharacteristic& characteristic) = 0;
+
+  // Called when a remote peripheral unsubscribed from one of our
+  // characteristics.
+  virtual void OnCharacteristicUnsubscription(
+      ServerGattConnection* connection,
+      const GattCharacteristic& characteristic) = 0;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothGattServer
+//
+// Representation of a BLE GATT server.
+class GattServer {
+ public:
+  virtual ~GattServer() {}
+
+  // Creates a characteristic and adds it to the GATT server under the given
+  // characteristic and service UUIDs. Returns no value upon error.
+  //
+  // Characteristics of the same service UUID should be put under one
+  // service rather than many services with the same UUID.
+  //
+  // If the INDICATE property is included, the characteristic should include the
+  // official Bluetooth Client Characteristic Configuration descriptor with UUID
+  // 0x2902 and a WRITE permission. This allows remote clients to write to this
+  // descriptor and subscribe for characteristic changes. For more information
+  // about this descriptor, please go to:
+  // https://www.bluetooth.com/specifications/Gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.Gatt.client_characteristic_configuration.xml
+  virtual std::optional<GattCharacteristic> CreateCharacteristic(
+      absl::string_view service_uuid, absl::string_view characteristic_uuid,
+      const std::set<GattCharacteristic::Permission>& permissions,
+      const std::set<GattCharacteristic::Property>& properties) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic.html#setValue(byte[])
+  //
+  // Locally updates the value of a characteristic and returns whether or not it
+  // was successful.
+  // Takes ownership of (and is responsible for destroying) the passed-in
+  // 'value'.
+  virtual bool UpdateCharacteristic(const GattCharacteristic& characteristic,
+                                    const ByteArray& value) = 0;
+
+  // Stops a GATT server.
+  virtual void Stop() = 0;
+};
+
+// A BLE socket representation.
+class BleSocket {
+ public:
+  virtual ~BleSocket() {}
+
+  // Returns the remote BLE peripheral tied to this socket.
+  virtual BlePeripheral& GetRemotePeripheral() = 0;
+
+  // Writes a message on the socket and blocks until finished. Returns
+  // Exception::kIo upon error, and Exception::kSuccess otherwise.
+  virtual Exception Write(const ByteArray& message) = 0;
+
+  // Closes the socket and blocks until finished. Returns Exception::kIo upon
+  // error, and Exception::kSuccess otherwise.
+  virtual Exception Close() = 0;
+};
+
+// Callback for asynchronous events on a BleSocket object.
+class BleSocketLifeCycleCallback {
+ public:
+  virtual ~BleSocketLifeCycleCallback() {}
+
+  // Called when a message arrives on a socket.
+  virtual void OnMessageReceived(BleSocket* socket,
+                                 const ByteArray& message) = 0;
+
+  // Called when a socket gets disconnected.
+  virtual void OnDisconnected(BleSocket* socket) = 0;
+};
+
+// Callback for asynchronous events on the server side of a BleSocket object.
+class ServerBleSocketLifeCycleCallback : public BleSocketLifeCycleCallback {
+ public:
+  ~ServerBleSocketLifeCycleCallback() override {}
+
+  // Called when a new incoming socket has been established.
+  virtual void OnSocketEstablished(BleSocket* socket) = 0;
+};
+
+// The main BLE medium used inside of Nearby. This serves as the entry point for
+// all BLE and GATT related operations.
+class BleMedium {
+ public:
+  using Mtu = uint32_t;
+
+  virtual ~BleMedium() {}
+
+  // Coarse representation of power settings throughout all BLE operations.
+  enum class PowerMode {
+    kUnknown = 0,
+    kLow = 1,
+    kHigh = 2,
+    kLast,
+  };
+
+  // https://developer.android.com/reference/android/bluetooth/le/BluetoothLeAdvertiser.html#startAdvertising(android.bluetooth.le.AdvertiseSettings,%20android.bluetooth.le.AdvertiseData,%20android.bluetooth.le.AdvertiseData,%20android.bluetooth.le.AdvertiseCallback)
+  //
+  // Starts BLE advertising and returns whether or not it was successful.
+  //
+  // Power mode should be interpreted in the following way:
+  //   LOW:
+  //     - Advertising interval = ~1000ms
+  //     - TX power = low
+  //   HIGH:
+  //     - Advertising interval = ~100ms
+  //     - TX power = high
+  virtual bool StartAdvertising(const BleAdvertisementData& advertisement_data,
+                                const BleAdvertisementData& scan_response,
+                                PowerMode power_mode) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/le/BluetoothLeAdvertiser.html#stopAdvertising(android.bluetooth.le.AdvertiseCallback)
+  //
+  // Stops advertising.
+  virtual void StopAdvertising() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/le/ScanCallback
+  //
+  // Callback for BLE scan results.
+  class ScanCallback {
+   public:
+    virtual ~ScanCallback() {}
+
+    // https://developer.android.com/reference/android/bluetooth/le/ScanCallback.html#onScanResult(int,%20android.bluetooth.le.ScanResult)
+    //
+    // Called when a BLE advertisement is discovered.
+    //
+    // The passed in advertisement_data is the merged combination of both
+    // advertisement data and scan response.
+    //
+    // Every discovery of an advertisement should be reported, even if the
+    // advertisement was discovered before.
+    //
+    // Ownership of the BleAdvertisementData transfers to the caller at this
+    // point.
+    virtual void OnAdvertisementFound(
+        BlePeripheral* peripheral,
+        const BleAdvertisementData& advertisement_data) = 0;
+  };
+
+  // https://developer.android.com/reference/android/bluetooth/le/BluetoothLeScanner.html#startScan(java.util.List%3Candroid.bluetooth.le.ScanFilter%3E,%20android.bluetooth.le.ScanSettings,%20android.bluetooth.le.ScanCallback)
+  //
+  // Starts scanning and returns whether or not it was successful.
+  //
+  // Power mode should be interpreted in the following way:
+  //   LOW:
+  //     - Scan window = ~512ms
+  //     - Scan interval = ~5120ms
+  //   HIGH:
+  //     - Scan window = ~4096ms
+  //     - Scan interval = ~4096ms
+  virtual bool StartScanning(const std::set<std::string>& service_uuids,
+                             PowerMode power_mode,
+                             const ScanCallback& scan_callback) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/le/BluetoothLeScanner.html#stopScan(android.bluetooth.le.ScanCallback)
+  //
+  // Stops scanning.
+  virtual void StopScanning() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothManager#openGattServer(android.content.Context,%20android.bluetooth.BluetoothGattServerCallback)
+  //
+  // Starts a GATT server. Returns a nullptr upon error.
+  virtual std::unique_ptr<GattServer> StartGattServer(
+      const ServerGattConnectionLifeCycleCallback& callback) = 0;
+
+  // Starts listening for incoming BLE sockets and returns false upon error.
+  virtual bool StartListeningForIncomingBleSockets(
+      const ServerBleSocketLifeCycleCallback& callback) = 0;
+
+  // Stops listening for incoming BLE sockets.
+  virtual void StopListeningForIncomingBleSockets() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#connectGatt(android.content.Context,%20boolean,%20android.bluetooth.BluetoothGattCallback)
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#requestConnectionPriority(int)
+  // https://developer.android.com/reference/android/bluetooth/BluetoothGatt.html#requestMtu(int)
+  //
+  // Connects to a GATT server and negotiates the specified connection
+  // parameters. Returns nullptr upon error.
+  //
+  // Both connection interval and MTU can be negotiated on a best-effort basis.
+  //
+  // Power mode should be interpreted in the following way:
+  //   LOW:
+  //     - Connection interval = ~11.25ms - 15ms
+  //   HIGH:
+  //     - Connection interval = ~100ms - 125ms
+  virtual std::unique_ptr<ClientGattConnection> ConnectToGattServer(
+      BlePeripheral* peripheral, Mtu mtu, PowerMode power_mode,
+      const ClientGattConnectionLifeCycleCallback& callback) = 0;
+
+  // Establishes a BLE socket to the specified remote peripheral. Returns
+  // nullptr on error.
+  virtual std::unique_ptr<BleSocket> EstablishBleSocket(
+      BlePeripheral* peripheral,
+      const BleSocketLifeCycleCallback& callback) = 0;
+};
+
+}  // namespace ble_v2
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_BLE_V2_H_

cpp/platform_v2/api/bluetooth_adapter.h

@@ -0,0 +1,58 @@
+#ifndef PLATFORM_V2_API_BLUETOOTH_ADAPTER_H_
+#define PLATFORM_V2_API_BLUETOOTH_ADAPTER_H_
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html
+class BluetoothAdapter {
+ public:
+  virtual ~BluetoothAdapter() = default;
+
+  // Eligible statuses of the BluetoothAdapter.
+  enum class Status {
+    kDisabled,
+    kEnabled,
+  };
+
+  // Synchronously sets the status of the BluetoothAdapter to 'status', and
+  // returns true if the operation was a success.
+  virtual bool SetStatus(Status status) = 0;
+  // Returns true if the BluetoothAdapter's current status is
+  // Status::Value::kEnabled.
+  virtual bool IsEnabled() const = 0;
+
+  // Scan modes of a BluetoothAdapter, as described at
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#getScanMode().
+  enum class ScanMode {
+    kUnknown,
+    kNone,
+    kConnectable,
+    kConnectableDiscoverable,
+  };
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#getScanMode()
+  //
+  // Returns ScanMode::kUnknown on error.
+  virtual ScanMode GetScanMode() const = 0;
+  // Synchronously sets the scan mode of the adapter, and returns true if the
+  // operation was a success.
+  virtual bool SetScanMode(ScanMode scan_mode) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#getName()
+  // Returns an empty string on error
+  virtual std::string GetName() const = 0;
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#setName(java.lang.String)
+  virtual bool SetName(absl::string_view name) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_BLUETOOTH_ADAPTER_H_

cpp/platform_v2/api/bluetooth_classic.h

@@ -0,0 +1,126 @@
+#ifndef PLATFORM_V2_API_BLUETOOTH_CLASSIC_H_
+#define PLATFORM_V2_API_BLUETOOTH_CLASSIC_H_
+
+#include <memory>
+#include <string>
+
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/output_stream.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html.
+class BluetoothDevice {
+ public:
+  virtual ~BluetoothDevice() {}
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#getName()
+  virtual std::string GetName() const = 0;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html.
+class BluetoothSocket {
+ public:
+  virtual ~BluetoothSocket() {}
+
+  // Returns the InputStream of the BluetoothSocket.
+  virtual InputStream& GetInputStream() = 0;
+
+  // Returns the OutputStream of the BluetoothSocket.
+  virtual OutputStream& GetOutputStream() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#close()
+  //
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  virtual Exception Close() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#getRemoteDevice()
+  virtual BluetoothDevice& GetRemoteDevice() = 0;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html.
+class BluetoothServerSocket {
+ public:
+  virtual ~BluetoothServerSocket() {}
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html#accept()
+  //
+  // returns Exception::kIo on error.
+  virtual ExceptionOr<std::unique_ptr<BluetoothSocket>> Accept() = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html#close()
+  //
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  virtual Exception Close() = 0;
+};
+
+// Container of operations that can be performed over the Bluetooth Classic
+// medium.
+class BluetoothClassicMedium {
+ public:
+  virtual ~BluetoothClassicMedium() {}
+
+  class DiscoveryCallback {
+   public:
+    virtual ~DiscoveryCallback() {}
+
+    // BluetoothDevice* is not owned by callbacks.
+    // Pointer is guaranteed to remain valid for the duration of a call.
+    virtual void OnDeviceDiscovered(BluetoothDevice* device) = 0;
+    virtual void OnDeviceNameChanged(BluetoothDevice* device) = 0;
+    virtual void OnDeviceLost(BluetoothDevice* device) = 0;
+  };
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#startDiscovery()
+  //
+  // Returns true once the process of discovery has been initiated.
+  //
+  // Does not take ownership of the passed-in discovery_callback -- destroying
+  // that is up to the caller.
+  virtual bool StartDiscovery(const DiscoveryCallback& discovery_callback) = 0;
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#cancelDiscovery()
+  //
+  // Returns true once discovery is well and truly stopped; after this returns,
+  // there must be no more invocations of the DiscoveryCallback passed in to
+  // startDiscovery().
+  virtual bool StopDiscovery() = 0;
+
+  // A combination of
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#createInsecureRfcommSocketToServiceRecord
+  // followed by
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#connect().
+  //
+  // service_uuid is the canonical textual representation
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) of a
+  // type 3 name-based
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based))
+  // UUID.
+  //
+  // On success, returns a new BluetoothSocket, wrapped in a ExceptionOr object.
+  // On error, returns Exception object.
+  virtual ExceptionOr<std::unique_ptr<BluetoothSocket>> ConnectToService(
+      BluetoothDevice* remote_device, absl::string_view service_uuid) = 0;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#listenUsingInsecureRfcommWithServiceRecord
+  //
+  // service_uuid is the canonical textual representation
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) of a
+  // type 3 name-based
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based))
+  // UUID.
+  //
+  //  Returns Exception::kIo on error.
+  virtual ExceptionOr<std::unique_ptr<BluetoothServerSocket>> ListenForService(
+      absl::string_view service_name, absl::string_view service_uuid) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_BLUETOOTH_CLASSIC_H_

cpp/platform_v2/api/cancelable.h

@@ -0,0 +1,21 @@
+#ifndef PLATFORM_V2_API_CANCELABLE_H_
+#define PLATFORM_V2_API_CANCELABLE_H_
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// An interface to provide a cancellation mechanism for objects that represent
+// long-running operations.
+class Cancelable {
+ public:
+  virtual ~Cancelable() = default;
+
+  virtual bool Cancel() = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_CANCELABLE_H_

cpp/platform_v2/api/condition_variable.h

@@ -0,0 +1,28 @@
+#ifndef PLATFORM_V2_API_CONDITION_VARIABLE_H_
+#define PLATFORM_V2_API_CONDITION_VARIABLE_H_
+
+#include "platform_v2/base/exception.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// The ConditionVariable class is a synchronization primitive that can be used
+// to block a thread, or multiple threads at the same time, until another thread
+// both modifies a shared variable (the condition), and notifies the
+// ConditionVariable.
+class ConditionVariable {
+ public:
+  virtual ~ConditionVariable() {}
+
+  // https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#notify--
+  virtual void Notify() = 0;
+  // https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait--
+  virtual Exception Wait() = 0;  // throws Exception::kInterrupted
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_CONDITION_VARIABLE_H_

cpp/platform_v2/api/count_down_latch.h

@@ -0,0 +1,31 @@
+#ifndef PLATFORM_V2_API_COUNT_DOWN_LATCH_H_
+#define PLATFORM_V2_API_COUNT_DOWN_LATCH_H_
+
+#include <cstdint>
+
+#include "platform_v2/base/exception.h"
+#include "absl/time/time.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// A synchronization aid that allows one or more threads to wait until a set of
+// operations being performed in other threads completes.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CountDownLatch.html
+class CountDownLatch {
+ public:
+  virtual ~CountDownLatch() = default;
+
+  virtual Exception Await() = 0;  // throws Exception::kInterrupted
+  virtual ExceptionOr<bool> Await(
+      absl::Duration timeout) = 0;  // throws Exception::kInterrupted
+  virtual void CountDown() = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_COUNT_DOWN_LATCH_H_

cpp/platform_v2/api/crypto.h

@@ -0,0 +1,24 @@
+#ifndef PLATFORM_V2_API_CRYPTO_H_
+#define PLATFORM_V2_API_CRYPTO_H_
+
+#include "platform_v2/base/byte_array.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+
+// A provider of standard hashing algorithms.
+class Crypto {
+ public:
+  // Initialize global crypto state.
+  static void Init();
+  // Return MD5 hash of input.
+  static ByteArray Md5(absl::string_view input);
+  // Return SHA256 hash of input.
+  static ByteArray Sha256(absl::string_view input);
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_CRYPTO_H_

cpp/platform_v2/api/executor.h

@@ -0,0 +1,28 @@
+#ifndef PLATFORM_V2_API_EXECUTOR_H_
+#define PLATFORM_V2_API_EXECUTOR_H_
+
+#include "platform_v2/base/runnable.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// This abstract class is the superclass of all classes representing an
+// Executor.
+class Executor {
+ public:
+  // Before returning from destructor, executor must wait for all pending
+  // jobs to finish.
+  virtual ~Executor() = default;
+  // https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-
+  virtual void Execute(Runnable&& runnable) = 0;
+
+  // https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html#shutdown--
+  virtual void Shutdown() = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_EXECUTOR_H_

cpp/platform_v2/api/future.h

@@ -0,0 +1,32 @@
+#ifndef PLATFORM_V2_API_FUTURE_H_
+#define PLATFORM_V2_API_FUTURE_H_
+
+#include "platform_v2/base/exception.h"
+#include "absl/time/clock.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// A Future represents the result of an asynchronous computation.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html
+template <typename T>
+class Future {
+ public:
+  virtual ~Future() = default;
+
+  // throws Exception::kInterrupted, Exception::kExecution
+  virtual ExceptionOr<T> Get() = 0;
+
+  // throws Exception::kInterrupted, Exception::kExecution
+  // throws Exception::kTimeout if timeout is exceeded while waiting for
+  // result.
+  virtual ExceptionOr<T> Get(absl::Duration timeout) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_FUTURE_H_

cpp/platform_v2/api/input_file.h

@@ -0,0 +1,26 @@
+#ifndef PLATFORM_V2_API_INPUT_FILE_H_
+#define PLATFORM_V2_API_INPUT_FILE_H_
+
+#include <cstdint>
+
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/input_stream.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// An InputFile represents a readable file on the system.
+class InputFile : public InputStream {
+ public:
+  ~InputFile() override = default;
+  virtual std::string GetFilePath() const = 0;
+  virtual std::int64_t GetTotalSize() const = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_INPUT_FILE_H_

cpp/platform_v2/api/listenable_future.h

@@ -0,0 +1,32 @@
+#ifndef PLATFORM_V2_API_LISTENABLE_FUTURE_H_
+#define PLATFORM_V2_API_LISTENABLE_FUTURE_H_
+
+#include <functional>
+#include <memory>
+
+#include "platform_v2/api/executor.h"
+#include "platform_v2/api/future.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/runnable.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// A Future that accepts completion listeners.
+//
+// https://guava.dev/releases/20.0/api/docs/com/google/common/util/concurrent/ListenableFuture.html
+template <typename T>
+class ListenableFuture : public Future<T> {
+ public:
+  ~ListenableFuture() override = default;
+
+  virtual void AddListener(Runnable runnable,
+                           Executor* executor) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_LISTENABLE_FUTURE_H_

cpp/platform_v2/api/mutex.h

@@ -0,0 +1,41 @@
+#ifndef PLATFORM_V2_API_MUTEX_H_
+#define PLATFORM_V2_API_MUTEX_H_
+
+#include "absl/base/thread_annotations.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// A lock is a tool for controlling access to a shared resource by multiple
+// threads.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Lock.html
+class ABSL_LOCKABLE Mutex {
+ public:
+  // Mode to pass to implementation constructor.
+  // kRegular        - produces a regular mutex: disallows multiple locks from
+  //                   the same thread; optionally, detects double locks in
+  //                   debug mode.
+  //                   This is the default option.
+  // kRecursive      - produces recursive mutex: allows multiple locks from the
+  //                   same thread.
+  // kRegularNoCheck - produces a regular mutex: disallows double locks,
+  //                   but does not check for deadlocks.
+  enum class Mode {
+    kRegular = 0,
+    kRecursive = 1,
+    kRegularNoCheck = 2,
+  };
+
+  virtual ~Mutex() {}
+
+  virtual void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() = 0;
+  virtual void Unlock()  ABSL_UNLOCK_FUNCTION() = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_MUTEX_H_

cpp/platform_v2/api/output_file.h

@@ -0,0 +1,22 @@
+#ifndef PLATFORM_V2_API_OUTPUT_FILE_H_
+#define PLATFORM_V2_API_OUTPUT_FILE_H_
+
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/output_stream.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// An OutputFile represents a writable file on the system.
+class OutputFile : public OutputStream {
+ public:
+  ~OutputFile() override = default;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_OUTPUT_FILE_H_

cpp/platform_v2/api/platform.h

@@ -0,0 +1,78 @@
+#ifndef PLATFORM_V2_API_PLATFORM_H_
+#define PLATFORM_V2_API_PLATFORM_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "platform_v2/api/atomic_boolean.h"
+#include "platform_v2/api/atomic_reference.h"
+#include "platform_v2/api/ble.h"
+#include "platform_v2/api/ble_v2.h"
+#include "platform_v2/api/bluetooth_adapter.h"
+#include "platform_v2/api/bluetooth_classic.h"
+#include "platform_v2/api/condition_variable.h"
+#include "platform_v2/api/count_down_latch.h"
+#include "platform_v2/api/crypto.h"
+#include "platform_v2/api/mutex.h"
+#include "platform_v2/api/scheduled_executor.h"
+#include "platform_v2/api/server_sync.h"
+#include "platform_v2/api/settable_future.h"
+#include "platform_v2/api/submittable_executor.h"
+#include "platform_v2/api/system_clock.h"
+#include "platform_v2/api/webrtc.h"
+#include "platform_v2/api/wifi.h"
+#include "platform_v2/api/wifi_lan.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/any.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// API rework notes:
+// https://docs.google.com/spreadsheets/d/1erZNkX7pX8s5jWTHdxgjntxTMor3BGiY2H_fC_ldtoQ/edit#gid=381357998
+class ImplementationPlatform {
+ public:
+  // General platform support:
+  // - atomic variables (boolean, and any other copyable type)
+  // - synchronization primitives:
+  //   - mutex (regular, and recursive)
+  //   - condition variable (must work with regular mutex only)
+  //   - Future<T> : to synchronize on Callable<T> schduled to execute.
+  //   - CountDownLatch : to ensure at least N threads are waiting.
+  static std::unique_ptr<AtomicReference<absl::any>> CreateAtomicReferenceAny(
+      absl::any initial_value);
+  static std::unique_ptr<SettableFuture<absl::any>> CreateSettableFutureAny();
+  static std::unique_ptr<AtomicBoolean> CreateAtomicBoolean(bool initial_value);
+  static std::unique_ptr<CountDownLatch> CreateCountDownLatch(
+      std::int32_t count);
+  static std::unique_ptr<Mutex> CreateMutex(Mutex::Mode mode);
+  static std::unique_ptr<ConditionVariable> CreateConditionVariable(
+      Mutex* mutex);
+
+  // Java-like Executors
+  static std::unique_ptr<SubmittableExecutor> CreateSingleThreadExecutor();
+  static std::unique_ptr<SubmittableExecutor> CreateMultiThreadExecutor(
+      std::int32_t max_concurrency);
+  static std::unique_ptr<ScheduledExecutor> CreateScheduledExecutor();
+
+  // Protocol implementations, domain-specific support
+  static std::unique_ptr<BluetoothAdapter> CreateBluetoothAdapter();
+  static std::unique_ptr<BluetoothClassicMedium> CreateBluetoothClassicMedium();
+  static std::unique_ptr<BleMedium> CreateBleMedium();
+  static std::unique_ptr<ble_v2::BleMedium> CreateBleV2Medium();
+  static std::unique_ptr<ServerSyncMedium> CreateServerSyncMedium();
+  static std::unique_ptr<WifiMedium> CreateWifiMedium();
+  static std::unique_ptr<WifiLanMedium> CreateWifiLanMedium();
+  static std::unique_ptr<WebRtcSignalingMessenger>
+  CreateWebRtcSignalingMessenger(absl::string_view self_id);
+  static std::string GetDeviceId();
+  static std::string GetPayloadPath(std::int64_t payload_id);
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_PLATFORM_H_

cpp/platform_v2/api/scheduled_executor.h

@@ -0,0 +1,36 @@
+#ifndef PLATFORM_V2_API_SCHEDULED_EXECUTOR_H_
+#define PLATFORM_V2_API_SCHEDULED_EXECUTOR_H_
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+#include "platform_v2/api/cancelable.h"
+#include "platform_v2/api/executor.h"
+#include "platform_v2/base/runnable.h"
+#include "absl/time/time.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// An Executor that can schedule commands to run after a given delay, or to
+// execute periodically.
+//
+// https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html
+class ScheduledExecutor : public Executor {
+ public:
+  ~ScheduledExecutor() override = default;
+  // Cancelable is kept both in the executor context, and in the caller context.
+  // We want Cancelable to live until both caller and executor are done with it.
+  // Exclusive ownership model does not work for this case;
+  // using std:shared_ptr<> instead if std::unique_ptr<>.
+  virtual std::shared_ptr<Cancelable> Schedule(Runnable&& runnable,
+                                               absl::Duration duration) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_SCHEDULED_EXECUTOR_H_

cpp/platform_v2/api/server_sync.h

@@ -0,0 +1,62 @@
+#ifndef PLATFORM_V2_API_SERVER_SYNC_H_
+#define PLATFORM_V2_API_SERVER_SYNC_H_
+
+#include <string>
+
+#include "platform_v2/base/byte_array.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// Abstraction that represents a Nearby endpoint exchanging data through
+// ServerSync Medium.
+class ServerSyncDevice {
+ public:
+  virtual ~ServerSyncDevice() = default;
+
+  virtual std::string GetName() const = 0;
+  virtual std::string GetGuid() const = 0;
+  virtual std::string GetOwnGuid() const = 0;
+};
+
+// Container of operations that can be performed over the Chrome Sync medium.
+class ServerSyncMedium {
+ public:
+  virtual ~ServerSyncMedium() = default;
+
+  virtual bool StartAdvertising(absl::string_view service_id,
+                                absl::string_view endpoint_id,
+                                const ByteArray& endpoint_info) = 0;
+  virtual void StopAdvertising(absl::string_view service_id) = 0;
+
+  class DiscoveredDeviceCallback {
+   public:
+    virtual ~DiscoveredDeviceCallback() = default;
+
+    // Called on a new ServerSyncDevice discovery.
+    virtual void OnDeviceDiscovered(ServerSyncDevice* device,
+                                    absl::string_view service_id,
+                                    absl::string_view endpoint_id,
+                                    const ByteArray& endpoint_info) = 0;
+    // Called when ServerSyncDevice is no longer reachable.
+    virtual void OnDeviceLost(ServerSyncDevice* device,
+                              absl::string_view service_id) = 0;
+  };
+
+  // Returns true once the Chrome Sync scan has been initiated.
+  virtual bool StartDiscovery(
+      absl::string_view service_id,
+      const DiscoveredDeviceCallback& discovered_device_callback) = 0;
+  // Returns true once Chrome Sync scan for service_id is well and truly
+  // stopped; after this returns, there must be no more invocations of the
+  // DiscoveredDeviceCallback passed in to startScanning() for service_id.
+  virtual void StopDiscovery(absl::string_view service_id) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_SERVER_SYNC_H_

cpp/platform_v2/api/settable_future.h

@@ -0,0 +1,28 @@
+#ifndef PLATFORM_V2_API_SETTABLE_FUTURE_H_
+#define PLATFORM_V2_API_SETTABLE_FUTURE_H_
+
+#include "platform_v2/api/listenable_future.h"
+#include "platform_v2/base/exception.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// A SettableFuture is a type of Future whose result can be set.
+//
+// https://google.github.io/guava/releases/20.0/api/docs/com/google/common/util/concurrent/SettableFuture.html
+template <typename T>
+class SettableFuture : public ListenableFuture<T> {
+ public:
+  ~SettableFuture() override = default;
+
+  virtual bool Set(const T& value) = 0;
+  virtual bool Set(T&& value) = 0;
+  virtual bool SetException(Exception exception) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_SETTABLE_FUTURE_H_

cpp/platform_v2/api/submittable_executor.h

@@ -0,0 +1,33 @@
+#ifndef PLATFORM_V2_API_SUBMITTABLE_EXECUTOR_H_
+#define PLATFORM_V2_API_SUBMITTABLE_EXECUTOR_H_
+
+#include <functional>
+#include <memory>
+
+#include "platform_v2/api/executor.h"
+#include "platform_v2/api/future.h"
+#include "platform_v2/base/runnable.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// Main interface to be used by platform as a base class for
+// - MultiThreadExecutorWrapper
+// - SingleThreadExecutorWrapper
+// Platform must override bool submit(std::function<void()>) method.
+class SubmittableExecutor : public Executor {
+ public:
+  ~SubmittableExecutor() override = default;
+
+  // Submit a callable (with no delay).
+  // Returns true, if callable was submitted, false otherwise.
+  // Callable is not submitted if shutdown is in progress.
+  virtual bool DoSubmit(Runnable&& wrapped_callable) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_SUBMITTABLE_EXECUTOR_H_

cpp/platform_v2/api/system_clock.h

@@ -0,0 +1,23 @@
+#ifndef PLATFORM_V2_API_SYSTEM_CLOCK_H_
+#define PLATFORM_V2_API_SYSTEM_CLOCK_H_
+
+#include "platform_v2/base/exception.h"
+#include "absl/time/clock.h"
+
+namespace location {
+namespace nearby {
+
+class SystemClock final {
+ public:
+  // Initialize global system state.
+  static void Init();
+  // Returns current absolute time. It is guaranteed to be monotonic.
+  static absl::Time ElapsedRealtime();
+  // Pauses current thread for the specified duration.
+  static Exception Sleep(absl::Duration duration);
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_SYSTEM_CLOCK_H_

cpp/platform_v2/api/webrtc.h

@@ -0,0 +1,48 @@
+#ifndef PLATFORM_V2_API_WEBRTC_H_
+#define PLATFORM_V2_API_WEBRTC_H_
+
+#include <vector>
+
+#include "platform_v2/base/byte_array.h"
+#include "webrtc/files/stable/webrtc/api/peer_connection_interface.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+class WebRtcSignalingMessenger {
+ public:
+  virtual ~WebRtcSignalingMessenger() = default;
+
+  /** Called whenever we receive an inbox message from tachyon. */
+  class SignalingMessageListener {
+   public:
+    virtual ~SignalingMessageListener() = default;
+
+    virtual void OnSignalingMessage(const ByteArray& message) = 0;
+  };
+
+  class IceServersListener {
+   public:
+    virtual ~IceServersListener() = default;
+
+    virtual void OnIceServersFetched(
+        std::vector<webrtc::PeerConnectionInterface::IceServer>
+            ice_servers) = 0;
+  };
+
+  virtual bool RegisterSignaling() = 0;
+  virtual bool UnregisterSignaling() = 0;
+  virtual bool SendMessage(std::string_view peer_id,
+                           const ByteArray& message) = 0;
+  virtual bool StartReceivingMessages(
+      const SignalingMessageListener& listener) = 0;
+  virtual void GetIceServers(
+      const IceServersListener& ice_servers_listener) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_WEBRTC_H_

cpp/platform_v2/api/wifi.h

@@ -0,0 +1,90 @@
+#ifndef PLATFORM_V2_API_WIFI_H_
+#define PLATFORM_V2_API_WIFI_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// Possible authentication types for a WiFi network.
+enum class WifiAuthType {
+  // WiFi Authentication type; either none (non-secured a.k.a. open) link, or
+  // WPA PSK (WiFi Protected Access PreShared Key), or
+  //   see https://en.wikipedia.org/wiki/Wi-Fi_Protected_Access
+  // WEP (Wired Equivalent Privacy);
+  //   see https://en.wikipedia.org/wiki/Wired_Equivalent_Privacy
+  kUnknown = 0,
+  kOpen = 1,
+  kWpaPsk = 2,
+  kWep = 3,
+};
+
+// Possible statuses of a device's connection to a WiFi network.
+enum class WifiConnectionStatus {
+  kUnknown = 0,
+  kConnected = 1,
+  kConnectionFailure = 2,
+  kAuthFailure = 3,
+};
+
+// Represents a WiFi network found during a call to WifiMedium#scan().
+class WifiScanResult {
+ public:
+  virtual ~WifiScanResult() = default;
+
+  // Gets the SSID of this WiFi network.
+  virtual std::string GetSsid() const = 0;
+  // Gets the signal strength of this WiFi network in dBm.
+  virtual std::int32_t GetSignalStrengthDbm() const = 0;
+  // Gets the frequency band of this WiFi network in MHz.
+  virtual std::int32_t GetFrequencyMhz() const = 0;
+  // Gets the authentication type of this WiFi network.
+  virtual WifiAuthType GetAuthType() const = 0;
+};
+
+// Container of operations that can be performed over the WiFi medium.
+class WifiMedium {
+ public:
+  virtual ~WifiMedium() {}
+
+  class ScanResultCallback {
+   public:
+    virtual ~ScanResultCallback() = default;
+
+    virtual void OnScanResults(
+        const std::vector<WifiScanResult>& scan_results) = 0;
+  };
+
+  // Does not take ownership of the passed-in scan_result_callback -- destroying
+  // that is up to the caller.
+  virtual bool Scan(const ScanResultCallback& scan_result_callback) = 0;
+
+  // If 'password' is an empty string, none has been provided. Returns
+  // WifiConnectionStatus::CONNECTED on success, or the appropriate failure code
+  // otherwise.
+  virtual WifiConnectionStatus ConnectToNetwork(absl::string_view ssid,
+                                                absl::string_view password,
+                                                WifiAuthType auth_type) = 0;
+
+  // Blocks until it's certain of there being a connection to the internet, or
+  // returns false if it fails to do so.
+  //
+  // How this method wants to verify said connection is totally up to it (so it
+  // can feel free to ping whatever server, download whatever resource, etc.
+  // that it needs to gain confidence that the internet is reachable hereon in).
+  virtual bool VerifyInternetConnectivity() = 0;
+
+  // Returns the local device's IP address in the IPv4 dotted-quad format.
+  virtual std::string GetIpAddress() = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_WIFI_H_

cpp/platform_v2/api/wifi_lan.h

@@ -0,0 +1,87 @@
+#ifndef PLATFORM_V2_API_WIFI_LAN_H_
+#define PLATFORM_V2_API_WIFI_LAN_H_
+
+#include <string>
+
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/output_stream.h"
+#include "absl/strings/string_view.h"
+
+namespace location {
+namespace nearby {
+namespace api {
+
+// Opaque wrapper over a WifiLan service which contains encoded service name.
+class WifiLanService {
+ public:
+  virtual ~WifiLanService() = default;
+
+  virtual std::string GetName() = 0;
+};
+
+class WifiLanSocket {
+ public:
+  virtual ~WifiLanSocket() = default;
+
+  // Returns the InputStream of the WifiLanSocket, empty std::unique_ptr<>
+  // on error.
+  virtual std::unique_ptr<InputStream> GetInputStream() = 0;
+
+  // Returns the OutputStream of the WifiLanSocket, empty std::unique_ptr<>
+  // on error.
+  virtual std::unique_ptr<OutputStream> GetOutputStream() = 0;
+
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  virtual Exception::Value Close() = 0;
+
+  virtual WifiLanService& GetRemoteWifiLanService() = 0;
+};
+
+// Container of operations that can be performed over the WifiLan medium.
+class WifiLanMedium {
+ public:
+  virtual ~WifiLanMedium() = default;
+
+  virtual bool StartAdvertising(
+      absl::string_view service_id,
+      absl::string_view wifi_lan_service_info_name) = 0;
+  virtual void StopAdvertising(absl::string_view service_id) = 0;
+
+  // Callback for WifiLan discover results.
+  class DiscoveredServiceCallback {
+   public:
+    virtual ~DiscoveredServiceCallback() = default;
+
+    virtual void OnServiceDiscovered(WifiLanService* wifi_lan_service) = 0;
+    virtual void OnServiceLost(WifiLanService* wifi_lan_service) = 0;
+  };
+
+  virtual bool StartDiscovery(
+      absl::string_view service_id,
+      DiscoveredServiceCallback* discovered_service_callback) = 0;
+  virtual void StopDiscovery(absl::string_view service_id) = 0;
+
+  class AcceptedConnectionCallback {
+   public:
+    virtual ~AcceptedConnectionCallback() = default;
+
+    virtual void OnConnectionAccepted(WifiLanSocket* socket,
+                                      absl::string_view service_id) = 0;
+  };
+
+  virtual bool StartAcceptingConnections(
+      absl::string_view service_id,
+      AcceptedConnectionCallback* accepted_connection_callback) = 0;
+  virtual void StopAcceptingConnections(absl::string_view service_id) = 0;
+
+  virtual WifiLanSocket* Connect(WifiLanService* wifi_lan_service,
+                                 absl::string_view service_id) = 0;
+};
+
+}  // namespace api
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_API_WIFI_LAN_H_