Chain scan & broadcast invokes from PresenceClient to ServiceController

PiperOrigin-RevId: 483496670

presence/BUILD

@@ -19,6 +19,7 @@ cc_library(
     name = "presence",
     srcs = [
         "presence_client.cc",
+        "presence_service.cc",
     ],
     hdrs = [
         "presence_client.h",

presence/implementation/BUILD

@@ -22,6 +22,7 @@ cc_library(
         "base_broadcast_request.cc",
         "credential_manager_impl.cc",
         "encryption.cc",
+        "service_controller_impl.cc",
     ],
     hdrs = [
         "action_factory.h",
@@ -32,7 +33,6 @@ cc_library(
         "credential_manager.h",
         "credential_manager_impl.h",
         "encryption.h",
-        "mock_service_controller.h",
         "scan_manager.h",
         "service_controller.h",
         "service_controller_impl.h",
@@ -74,6 +74,25 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "internal_test",
+    testonly = True,
+    srcs = [
+    ],
+    hdrs = [
+        "mock_service_controller.h",
+    ],
+    visibility = [
+        "//presence:__subpackages__",
+    ],
+    deps = [
+        ":internal",
+        "//presence",
+        "@com_github_protobuf_matchers//protobuf-matchers",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_test(
     name = "advertisement_decoder_test",
     size = "small",

presence/implementation/mediums/mediums.h

@@ -16,6 +16,7 @@
 #define THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_MEDIUMS_MEDIUMS_H_
 
 #include "internal/platform/ble_v2.h"
+#include "internal/platform/bluetooth_adapter.h"
 #include "presence/implementation/mediums/ble.h"
 
 namespace nearby {
@@ -34,7 +35,8 @@ class Mediums {
   Ble<location::nearby::BleV2Medium>& GetBle();
 
  private:
-  Ble<location::nearby::BleV2Medium> ble_;
+  location::nearby::BluetoothAdapter adapter_;
+  Ble<location::nearby::BleV2Medium> ble_{adapter_};
 };
 
 }  // namespace presence

presence/implementation/mock_service_controller.h

@@ -15,6 +15,9 @@
 #ifndef THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_MOCK_SERVICE_CONTROLLER_H_
 #define THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_MOCK_SERVICE_CONTROLLER_H_
 
+#include <memory>
+
+#include "gmock/gmock.h"
 #include "presence/implementation/service_controller.h"
 
 namespace nearby {
@@ -28,6 +31,12 @@ class MockServiceController : public ServiceController {
   MockServiceController() = default;
   ~MockServiceController() override = default;
 
+  MOCK_METHOD(std::unique_ptr<ScanSession>, StartScan,
+              (ScanRequest scan_request, ScanCallback callback), (override));
+  MOCK_METHOD(std::unique_ptr<BroadcastSession>, StartBroadcast,
+              (BroadcastRequest broadcast_request, BroadcastCallback callback),
+              (override));
+
  private:
 };
 

presence/implementation/service_controller.h

@@ -15,6 +15,12 @@
 #ifndef THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_SERVICE_CONTROLLER_H_
 #define THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_SERVICE_CONTROLLER_H_
 
+#include <memory>
+
+#include "presence/broadcast_request.h"
+#include "presence/data_types.h"
+#include "presence/scan_request.h"
+
 namespace nearby {
 namespace presence {
 
@@ -25,7 +31,12 @@ namespace presence {
  */
 class ServiceController {
  public:
+  ServiceController() = default;
   virtual ~ServiceController() = default;
+  virtual std::unique_ptr<ScanSession> StartScan(ScanRequest scan_request,
+                                                 ScanCallback callback) = 0;
+  virtual std::unique_ptr<BroadcastSession> StartBroadcast(
+      BroadcastRequest broadcast_request, BroadcastCallback callback) = 0;
 };
 
 }  // namespace presence

presence/implementation/service_controller_impl.cc

@@ -0,0 +1,34 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "presence/implementation/service_controller_impl.h"
+
+#include <memory>
+
+namespace nearby {
+namespace presence {
+
+std::unique_ptr<ScanSession> ServiceControllerImpl::StartScan(
+    ScanRequest scan_request, ScanCallback callback) {
+  callback.start_scan_cb({Status::Value::kError});
+  return nullptr;
+}
+std::unique_ptr<BroadcastSession> ServiceControllerImpl::StartBroadcast(
+    BroadcastRequest broadcast_request, BroadcastCallback callback) {
+  callback.start_broadcast_cb({Status::Value::kError});
+  return nullptr;
+}
+
+}  // namespace presence
+}  // namespace nearby

presence/implementation/service_controller_impl.h

@@ -15,10 +15,14 @@
 #ifndef THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_SERVICE_CONTROLLER_IMPL_H_
 #define THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_SERVICE_CONTROLLER_IMPL_H_
 
+#include <memory>
+
+#include "presence/broadcast_request.h"
+#include "presence/data_types.h"
 #include "presence/implementation/credential_manager_impl.h"
 #include "presence/implementation/mediums/mediums.h"
 #include "presence/implementation/service_controller.h"
-
+#include "presence/scan_request.h"
 /*
  * This class implements {@code ServiceController} functions. Owns mediums and
  * other managers instances.
@@ -27,6 +31,13 @@ namespace nearby {
 namespace presence {
 
 class ServiceControllerImpl : public ServiceController {
+ public:
+  ServiceControllerImpl() = default;
+  std::unique_ptr<ScanSession> StartScan(ScanRequest scan_request,
+                                         ScanCallback callback) override;
+  std::unique_ptr<BroadcastSession> StartBroadcast(
+      BroadcastRequest broadcast_request, BroadcastCallback callback) override;
+
  private:
   Mediums mediums_;  // NOLINT: further impl will use it.
   CredentialManagerImpl

presence/presence_client.cc

@@ -17,21 +17,21 @@
 #include <memory>
 #include <vector>
 
-#include "presence/presence_device.h"
-#include "presence/status.h"
+#include "presence/presence_service.h"
 
 namespace nearby {
 namespace presence {
 
+PresenceClient::PresenceClient(PresenceService* service)
+    : service_(*ABSL_DIE_IF_NULL(service)) {}
+
 std::unique_ptr<ScanSession> PresenceClient::StartScan(ScanRequest scan_request,
                                                        ScanCallback callback) {
-  callback.start_scan_cb({Status::Value::kError});
-  return nullptr;
+  return service_.StartScan(scan_request, callback);
 }
 std::unique_ptr<BroadcastSession> PresenceClient::StartBroadcast(
     BroadcastRequest broadcast_request, BroadcastCallback callback) {
-  callback.start_broadcast_cb({Status::Value::kError});
-  return nullptr;
+  return service_.StartBroadcast(broadcast_request, callback);
 }
 
 }  // namespace presence

presence/presence_client.h

@@ -26,12 +26,17 @@
 namespace nearby {
 namespace presence {
 
+class PresenceService;
 /**
  * Interface for detecting and interacting with nearby devices that are also
  * part of the Presence ecosystem.
  */
 class PresenceClient {
  public:
+  explicit PresenceClient(PresenceService* service);
+  PresenceClient(const PresenceClient&) = delete;
+  PresenceClient& operator=(const PresenceClient&) = delete;
+  ~PresenceClient() = default;
   /**
    * Starts a Nearby Presence scan and registers {@link ScanCallback}
    * which will be invoked when a matching {@link PresenceDevice} is detected,
@@ -45,7 +50,6 @@ class PresenceClient {
    * and type; the filters including credentials, actions and extended
    * properties.
    */
-
   std::unique_ptr<ScanSession> StartScan(ScanRequest scan_request,
                                          ScanCallback callback);
 
@@ -63,6 +67,9 @@ class PresenceClient {
    */
   std::unique_ptr<BroadcastSession> StartBroadcast(
       BroadcastRequest broadcast_request, BroadcastCallback callback);
+
+ private:
+  PresenceService& service_;
 };
 
 }  // namespace presence

presence/presence_client_test.cc

@@ -16,6 +16,7 @@
 
 #include "gtest/gtest.h"
 #include "presence/data_types.h"
+#include "presence/presence_service.h"
 #include "presence/status.h"
 
 namespace nearby {
@@ -28,7 +29,8 @@ TEST(PresenceClientTest, StartBroadcastWithDefaultConstructor) {
       .start_broadcast_cb = [&](Status status) { broadcast_result = status; },
   };
 
-  PresenceClient presence_client;
+  PresenceService presence_service;
+  PresenceClient presence_client = presence_service.CreatePresenceClient();
   presence_client.StartBroadcast({}, broadcast_callback);
 
   EXPECT_FALSE(broadcast_result.Ok());
@@ -40,7 +42,8 @@ TEST(PresenceClientTest, StartScanWithDefaultConstructor) {
       .start_scan_cb = [&](Status status) { scan_result = status; },
   };
 
-  PresenceClient presence_client;
+  PresenceService presence_service;
+  PresenceClient presence_client = presence_service.CreatePresenceClient();
   presence_client.StartScan({}, scan_callback);
 
   EXPECT_FALSE(scan_result.Ok());

presence/presence_service.cc

@@ -0,0 +1,43 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "presence/presence_service.h"
+
+#include <memory>
+
+#include "presence/data_types.h"
+#include "presence/implementation/service_controller_impl.h"
+
+namespace nearby {
+namespace presence {
+PresenceService::PresenceService() {
+  this->service_controller_ = std::make_unique<ServiceControllerImpl>();
+}
+
+PresenceClient PresenceService::CreatePresenceClient() {
+  return PresenceClient(this);
+}
+
+std::unique_ptr<ScanSession> PresenceService::StartScan(
+    ScanRequest scan_request, ScanCallback callback) {
+  return service_controller_->StartScan(scan_request, callback);
+}
+
+std::unique_ptr<BroadcastSession> PresenceService::StartBroadcast(
+    BroadcastRequest broadcast_request, BroadcastCallback callback) {
+  return service_controller_->StartBroadcast(broadcast_request, callback);
+}
+
+}  // namespace presence
+}  // namespace nearby

presence/presence_service.h

@@ -17,7 +17,9 @@
 
 #include <memory>
 
+#include "presence/data_types.h"
 #include "presence/implementation/service_controller.h"
+#include "presence/presence_client.h"
 
 namespace nearby {
 namespace presence {
@@ -29,9 +31,16 @@ namespace presence {
  */
 class PresenceService {
  public:
-  PresenceService() = default;
+  PresenceService();
   ~PresenceService() = default;
 
+  PresenceClient CreatePresenceClient();
+
+  std::unique_ptr<ScanSession> StartScan(ScanRequest scan_request,
+                                         ScanCallback callback);
+  std::unique_ptr<BroadcastSession> StartBroadcast(
+      BroadcastRequest broadcast_request, BroadcastCallback callback);
+
  private:
   std::unique_ptr<ServiceController> service_controller_;
 };

presence/presence_service_test.cc

@@ -15,6 +15,7 @@
 #include "presence/presence_service.h"
 
 #include "gtest/gtest.h"
+#include "presence/presence_client.h"
 
 namespace nearby {
 namespace presence {
@@ -24,6 +25,21 @@ TEST(PresenceServiceTest, DefaultConstructorWorks) {
   PresenceService presence_service;
 }
 
+TEST(PresenceServiceTest, StartScan) {
+  Status scan_result = {Status::Value::kSuccess};
+  ScanCallback scan_callback = {
+      .start_scan_cb = [&](Status status) { scan_result = status; },
+  };
+  PresenceService presence_service;
+  PresenceClient client = presence_service.CreatePresenceClient();
+
+  auto scan_session = client.StartScan({}, {
+      .start_scan_cb = [&](Status status) { scan_result = status; },
+  });
+
+  ASSERT_EQ(scan_session, nullptr);
+}
+
 }  // namespace
 }  // namespace presence
 }  // namespace nearby