Roll forward to cl/328359974

Change-Id: If2b57ecc852aecf7dea454648f485fd7c08e72a9

cpp/platform_v2/impl/g3/ble.h

@@ -0,0 +1,213 @@
+#ifndef PLATFORM_V2_IMPL_G3_BLE_H_
+#define PLATFORM_V2_IMPL_G3_BLE_H_
+
+#include <memory>
+#include <string>
+
+#include "platform_v2/api/ble.h"
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/output_stream.h"
+#include "platform_v2/impl/g3/bluetooth_adapter.h"
+#include "platform_v2/impl/g3/bluetooth_classic.h"
+#include "platform_v2/impl/g3/multi_thread_executor.h"
+#include "platform_v2/impl/g3/pipe.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/escaping.h"
+#include "absl/synchronization/mutex.h"
+
+namespace location {
+namespace nearby {
+namespace g3 {
+
+class BleMedium;
+
+class BleSocket : public api::BleSocket {
+ public:
+  BleSocket() = default;
+  explicit BleSocket(BlePeripheral* peripheral) : peripheral_(peripheral) {}
+  ~BleSocket() override;
+
+  // Connect to another BleSocket, to form a functional low-level channel.
+  // from this point on, and until Close is called, connection exists.
+  void Connect(BleSocket& other) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns the InputStream of this connected BleSocket.
+  InputStream& GetInputStream() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns the OutputStream of this connected BleSocket.
+  // This stream is for local side to write.
+  OutputStream& GetOutputStream() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns address of a remote BleSocket or nullptr.
+  BleSocket* GetRemoteSocket() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true if connection exists to the (possibly closed) remote socket.
+  bool IsConnected() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true if socket is closed.
+  bool IsClosed() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  Exception Close() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns valid BlePeripheral pointer if there is a connection, and
+  // nullptr otherwise.
+  BlePeripheral* GetRemotePeripheral() override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  void DoClose() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Returns true if connection exists to the (possibly closed) remote socket.
+  bool IsConnectedLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Returns InputStream of our side of a connection.
+  // This is what the remote side is supposed to read from.
+  // This is a helper for GetInputStream() method.
+  InputStream& GetLocalInputStream() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns OutputStream of our side of a connection.
+  // This is what the local size is supposed to write to.
+  // This is a helper for GetOutputStream() method.
+  OutputStream& GetLocalOutputStream() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Output pipe is initialized by constructor, it remains always valid, until
+  // it is closed. it represents output part of a local socket. Input part of a
+  // local socket comes from the peer socket, after connection.
+  std::shared_ptr<Pipe> output_ {new Pipe};
+  std::shared_ptr<Pipe> input_;
+  mutable absl::Mutex mutex_;
+  BlePeripheral* peripheral_;
+  BleSocket* remote_socket_ ABSL_GUARDED_BY(mutex_) = nullptr;
+  bool closed_ ABSL_GUARDED_BY(mutex_) = false;
+};
+
+class BleServerSocket {
+ public:
+  ~BleServerSocket();
+
+  // 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.
+  //
+  // Called by the server side of a connection.
+  // Returns BleSocket to the server side.
+  // If not null, returned socket is connected to its remote (client-side) peer.
+  std::unique_ptr<api::BleSocket> Accept(BlePeripheral* peripheral)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Blocks until either:
+  // - connection is available, or
+  // - server socket is closed, or
+  // - error happens.
+  //
+  // Called by the client side of a connection.
+  // Returns true, if socket is successfully connected.
+  bool Connect(BleSocket& socket) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Called by the server side of a connection before passing ownership of
+  // BleServerSocker to user, to track validity of a pointer to this
+  // server socket,
+  void SetCloseNotifier(std::function<void()> notifier)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  // Calls close_notifier if it was previously set, and marks socket as closed.
+  Exception Close() ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  Exception DoClose() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  absl::Mutex mutex_;
+  absl::CondVar cond_;
+  absl::flat_hash_set<BleSocket*> pending_sockets_ ABSL_GUARDED_BY(mutex_);
+  std::function<void()> close_notifier_ ABSL_GUARDED_BY(mutex_);
+  bool closed_ ABSL_GUARDED_BY(mutex_) = false;
+};
+
+// Container of operations that can be performed over the BLE medium.
+class BleMedium : public api::BleMedium {
+ public:
+  explicit BleMedium(api::BluetoothAdapter& adapter);
+  ~BleMedium() override;
+
+  // Returns true once the Ble advertising has been initiated.
+  bool StartAdvertising(const std::string& service_id,
+                        const ByteArray& advertisement_bytes) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+  bool StopAdvertising(const std::string& service_id) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true once the Ble scanning has been initiated.
+  bool StartScanning(const std::string& service_id,
+                     DiscoveredPeripheralCallback callback) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // 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.
+  bool StopScanning(const std::string& service_id) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true once Ble socket connection requests to service_id can be
+  // accepted.
+  bool StartAcceptingConnections(const std::string& service_id,
+                                 AcceptedConnectionCallback callback)
+      override ABSL_LOCKS_EXCLUDED(mutex_);
+  bool StopAcceptingConnections(const std::string& service_id) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Connects to existing remote Ble peripheral.
+  //
+  // On success, returns a new BleSocket.
+  // On error, returns nullptr.
+  std::unique_ptr<api::BleSocket> Connect(
+      api::BlePeripheral& remote_peripheral,
+      const std::string& service_id) override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  BluetoothAdapter& GetAdapter() { return *adapter_; }
+
+ private:
+  static constexpr int kMaxConcurrentAcceptLoops = 5;
+
+  struct AdvertisingInfo {
+    bool Empty() const { return service_id.empty(); }
+    void Clear() { service_id.clear(); }
+
+    std::string service_id;
+  };
+
+  struct ScanningInfo {
+    bool Empty() const { return service_id.empty(); }
+    void Clear() { service_id.clear(); }
+
+    std::string service_id;
+  };
+
+  absl::Mutex mutex_;
+  BluetoothAdapter* adapter_;  // Our device adapter; read-only.
+
+  // A thread pool dedicated to running all the accept loops from
+  // StartAdvertising().
+  MultiThreadExecutor accept_loops_runner_{kMaxConcurrentAcceptLoops};
+  std::atomic_bool acceptance_thread_running_ = false;
+
+  // A thread pool dedicated to wait to complete the accept_loops_runner_.
+  MultiThreadExecutor close_accept_loops_runner_{kMaxConcurrentAcceptLoops};
+
+  // A server socket is established when start advertising.
+  std::unique_ptr<BleServerSocket> server_socket_;
+  AdvertisingInfo advertising_info_ ABSL_GUARDED_BY(mutex_);
+  ScanningInfo scanning_info_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace g3
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_IMPL_G3_BLE_H_