Merge branch 'master' into release.

Change-Id: Id627ceca5ef60281e024ff80fc1848b3ccb6c14d
2026-09-14 22:56:12 -04:00 · 2020-06-04 12:01:48 -07:00
parent 7e19ffbab7 3e7bf3074f
commit 04473705f8
98 changed files with 4136 additions and 718 deletions
@@ -13,14 +13,10 @@
 # limitations under the License.

 cc_library(
-    name = "api",
+    name = "types",
    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",
@@ -31,12 +27,32 @@ cc_library(
        "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",
+    ],
+    visibility = [
+        "//platform_v2/base:__pkg__",
+        "//platform_v2/impl:__subpackages__",
+        "//platform_v2/public:__pkg__",
+    ],
+    deps = [
+        "//platform_v2/base",
+        "//absl/base:core_headers",
+        "//absl/strings",
+        "//absl/time",
+    ],
+)
+
+cc_library(
+    name = "comm",
+    hdrs = [
+        "ble.h",
+        "ble_v2.h",
+        "bluetooth_adapter.h",
+        "bluetooth_classic.h",
+        "server_sync.h",
        "webrtc.h",
        "wifi.h",
        "wifi_lan.h",
@@ -44,14 +60,29 @@ cc_library(
    visibility = [
        "//platform_v2/base:__pkg__",
        "//platform_v2/impl:__subpackages__",
-        "//platform_v2/public:__subpackages__",
+        "//platform_v2/public:__pkg__",
    ],
    deps = [
        "//platform_v2/base",
-        "//absl/base:core_headers",
        "//absl/strings",
-        "//absl/time",
-        "//absl/types:any",
+        "//absl/types:optional",
        "//webrtc/api:libjingle_peerconnection_api",
    ],
 )
+
+cc_library(
+    name = "platform",
+    hdrs = [
+        "platform.h",
+    ],
+    visibility = [
+        "//platform_v2/impl:__subpackages__",
+        "//platform_v2/public:__pkg__",
+    ],
+    deps = [
+        ":comm",
+        ":types",
+        "//absl/strings",
+        "//absl/types:any",
+    ],
+)
@@ -19,13 +19,13 @@
 #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"
+#include "absl/types/optional.h"

 namespace location {
 namespace nearby {
@@ -133,7 +133,7 @@ class ClientGattConnection {
  //
  // 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(
+  virtual absl::optional<GattCharacteristic> GetCharacteristic(
      absl::string_view service_uuid,
      absl::string_view characteristic_uuid) = 0;

@@ -141,7 +141,7 @@ class ClientGattConnection {
  // 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(
+  virtual absl::optional<ByteArray> ReadCharacteristic(
      const GattCharacteristic& characteristic) = 0;

  // https://developer.android.com/reference/android/bluetooth/BluetoothGattCharacteristic.html#setValue(byte[])
@@ -223,7 +223,7 @@ class GattServer {
  // 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(
+  virtual absl::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;
@@ -21,8 +21,8 @@
 #include "platform_v2/base/byte_array.h"
 #include "platform_v2/base/exception.h"
 #include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/listeners.h"
 #include "platform_v2/base/output_stream.h"
-#include "absl/strings/string_view.h"

 namespace location {
 namespace nearby {
@@ -31,7 +31,7 @@ namespace api {
 // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html.
 class BluetoothDevice {
 public:
-  virtual ~BluetoothDevice() {}
+  virtual ~BluetoothDevice() = default;

  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#getName()
  virtual std::string GetName() const = 0;
@@ -40,32 +40,45 @@ class BluetoothDevice {
 // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html.
 class BluetoothSocket {
 public:
-  virtual ~BluetoothSocket() {}
+  virtual ~BluetoothSocket() = default;

-  // Returns the InputStream of the BluetoothSocket.
+  // NOTE:
+  // It is an undefined behavior if GetInputStream() or GetOutputStream() is
+  // called for a not-connected BluetoothSocket, i.e. any object that is not
+  // returned by BluetoothClassicMedium::ConnectToService() for client side or
+  // BluetoothServerSocket::Accept() for server side of connection.
+
+  // Returns the InputStream of this connected BluetoothSocket.
  virtual InputStream& GetInputStream() = 0;

-  // Returns the OutputStream of the BluetoothSocket.
+  // Returns the OutputStream of this connected BluetoothSocket.
  virtual OutputStream& GetOutputStream() = 0;

-  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#close()
-  //
+  // Closes both input and output streams, marks Socket as closed.
+  // After this call object should be treated as not connected.
  // 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;
+  // Returns valid BluetoothDevice pointer if there is a connection, and
+  // nullptr otherwise.
+  virtual BluetoothDevice* GetRemoteDevice() = 0;
 };

 // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html.
 class BluetoothServerSocket {
 public:
-  virtual ~BluetoothServerSocket() {}
+  virtual ~BluetoothServerSocket() = default;

  // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html#accept()
  //
-  // returns Exception::kIo on error.
-  virtual ExceptionOr<std::unique_ptr<BluetoothSocket>> Accept() = 0;
+  // Blocks until either:
+  // - at least one incoming connection request is available, or
+  // - ServerSocket is closed.
+  // On success, returns connected socket, ready to exchange data.
+  // Returns nullptr on error.
+  // Once error is reported, it is permanent, and ServerSocket has to be closed.
+  virtual std::unique_ptr<BluetoothSocket> Accept() = 0;

  // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html#close()
  //
@@ -77,31 +90,33 @@ class BluetoothServerSocket {
 // medium.
 class BluetoothClassicMedium {
 public:
-  virtual ~BluetoothClassicMedium() {}
+  virtual ~BluetoothClassicMedium() = default;

-  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;
+  struct DiscoveryCallback {
+    // BluetoothDevice is a proxy object created as a result of BT discovery.
+    // Its lifetime spans between calls to device_discovered_cb and
+    // device_lost_cb.
+    // It is safe to use BluetoothDevice in device_discovered_cb() callback
+    // and at any time afterwards, until device_lost_cb() is called.
+    // It is not safe to use BluetoothDevice after returning from
+    // device_lost_cb() callback.
+    std::function<void(BluetoothDevice& device)> device_discovered_cb =
+        DefaultCallback<BluetoothDevice&>();
+    std::function<void(BluetoothDevice& device)> device_name_changed_cb =
+        DefaultCallback<BluetoothDevice&>();
+    std::function<void(BluetoothDevice& device)> device_lost_cb =
+        DefaultCallback<BluetoothDevice&>();
  };

  // 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;
+  virtual bool StartDiscovery(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().
+  // StartDiscovery().
  virtual bool StopDiscovery() = 0;

  // A combination of
@@ -115,10 +130,10 @@ class BluetoothClassicMedium {
  // (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;
+  // On success, returns a new BluetoothSocket.
+  // On error, returns nullptr.
+  virtual std::unique_ptr<BluetoothSocket> ConnectToService(
+      BluetoothDevice& remote_device, const std::string& service_uuid) = 0;

  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#listenUsingInsecureRfcommWithServiceRecord
  //
@@ -128,9 +143,9 @@ class BluetoothClassicMedium {
  // (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;
+  //  Returns nullptr error.
+  virtual std::unique_ptr<BluetoothServerSocket> ListenForService(
+      const std::string& service_name, const std::string& service_uuid) = 0;
 };

 }  // namespace api
@@ -28,7 +28,9 @@
 #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/input_file.h"
 #include "platform_v2/api/mutex.h"
+#include "platform_v2/api/output_file.h"
 #include "platform_v2/api/scheduled_executor.h"
 #include "platform_v2/api/server_sync.h"
 #include "platform_v2/api/settable_future.h"
@@ -55,6 +57,7 @@ class ImplementationPlatform {
  //   - 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.
+  // - file I/O
  static std::unique_ptr<AtomicReference<absl::any>> CreateAtomicReferenceAny(
      absl::any initial_value);
  static std::unique_ptr<SettableFuture<absl::any>> CreateSettableFutureAny();
@@ -64,6 +67,9 @@ class ImplementationPlatform {
  static std::unique_ptr<Mutex> CreateMutex(Mutex::Mode mode);
  static std::unique_ptr<ConditionVariable> CreateConditionVariable(
      Mutex* mutex);
+  static std::unique_ptr<InputFile> CreateInputFile(std::int64_t payload_id,
+                                                    std::int64_t total_size);
+  static std::unique_ptr<OutputFile> CreateOutputFile(std::int64_t payload_id);

  // Java-like Executors
  static std::unique_ptr<SubmittableExecutor> CreateSingleThreadExecutor();
@@ -79,10 +85,8 @@ class ImplementationPlatform {
  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::unique_ptr<WebRtcMedium> CreateWebRtcMedium();
  static std::string GetDeviceId();
-  static std::string GetPayloadPath(std::int64_t payload_id);
 };

 }  // namespace api
@@ -15,9 +15,10 @@
 #ifndef PLATFORM_V2_API_WEBRTC_H_
 #define PLATFORM_V2_API_WEBRTC_H_

-#include <vector>
+#include <memory>

 #include "platform_v2/base/byte_array.h"
+#include "absl/strings/string_view.h"
 #include "webrtc/api/peer_connection_interface.h"

 namespace location {
@@ -26,33 +27,32 @@ namespace api {

 class WebRtcSignalingMessenger {
 public:
+  using OnSignalingMessageCallback = std::function<void(const ByteArray&)>;
+
  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,
+  virtual bool SendMessage(absl::string_view peer_id,
                           const ByteArray& message) = 0;
-  virtual bool StartReceivingMessages(
-      const SignalingMessageListener& listener) = 0;
-  virtual void GetIceServers(
-      const IceServersListener& ice_servers_listener) = 0;
+
+  virtual bool StartReceivingMessages(OnSignalingMessageCallback listener) = 0;
+  virtual void StopReceivingMessages() = 0;
+};
+
+class WebRtcMedium {
+ public:
+  using PeerConnectionCallback =
+      std::function<void(rtc::scoped_refptr<webrtc::PeerConnectionInterface>)>;
+
+  virtual ~WebRtcMedium() = default;
+
+  // Creates and returns a new webrtc::PeerConnectionInterface object via
+  // |callback|.
+  virtual void CreatePeerConnection(webrtc::PeerConnectionObserver* observer,
+                                    PeerConnectionCallback callback) = 0;
+
+  // Returns a signaling messenger for sending WebRTC signaling messages.
+  virtual std::unique_ptr<WebRtcSignalingMessenger> GetSignalingMessenger(
+      absl::string_view self_id) = 0;
 };

 }  // namespace api