nearby: snapshot as of cl/296436629

Signed-off-by: Alexey Polyudov <apolyudov@google.com> Change-Id: I2cf5bf225b76f4c1541954651f3a7544a14e0cec
2026-09-16 15:36:12 -04:00 · 2020-04-04 12:52:31 -07:00
parent 598516303b
commit 204f76077d
195 changed files with 27318 additions and 0 deletions
@@ -0,0 +1,137 @@
+#include "core/core.h"
+
+#include <cassert>
+
+namespace location {
+namespace nearby {
+namespace connections {
+
+template <typename Platform>
+Core<Platform>::Core()
+    : client_proxy_(new ClientProxy<Platform>()),
+      service_controller_router_(new ServiceControllerRouter<Platform>()) {}
+
+template <typename Platform>
+Core<Platform>::~Core() {
+  service_controller_router_->clientDisconnecting(client_proxy_.get());
+}
+
+template <typename Platform>
+void Core<Platform>::startAdvertising(
+    ConstPtr<StartAdvertisingParams> start_advertising_params) {
+  assert(!start_advertising_params->result_listener.isNull());
+  assert(!start_advertising_params->connection_lifecycle_listener.isNull());
+  assert(!start_advertising_params->service_id.empty());
+  assert(start_advertising_params->advertising_options.strategy.isValid());
+
+  service_controller_router_->startAdvertising(client_proxy_.get(),
+                                               start_advertising_params);
+}
+
+template <typename Platform>
+void Core<Platform>::stopAdvertising(
+    ConstPtr<StopAdvertisingParams> stop_advertising_params) {
+  service_controller_router_->stopAdvertising(client_proxy_.get(),
+                                              stop_advertising_params);
+}
+
+template <typename Platform>
+void Core<Platform>::startDiscovery(
+    ConstPtr<StartDiscoveryParams> start_discovery_params) {
+  assert(!start_discovery_params->result_listener.isNull());
+  assert(!start_discovery_params->discovery_listener.isNull());
+  assert(!start_discovery_params->service_id.empty());
+  assert(start_discovery_params->discovery_options.strategy.isValid());
+
+  service_controller_router_->startDiscovery(client_proxy_.get(),
+                                             start_discovery_params);
+}
+
+template <typename Platform>
+void Core<Platform>::stopDiscovery(
+    ConstPtr<StopDiscoveryParams> stop_discovery_params) {
+  service_controller_router_->stopDiscovery(client_proxy_.get(),
+                                            stop_discovery_params);
+}
+
+template <typename Platform>
+void Core<Platform>::requestConnection(
+    ConstPtr<RequestConnectionParams> request_connection_params) {
+  assert(!request_connection_params->result_listener.isNull());
+  assert(!request_connection_params->connection_lifecycle_listener.isNull());
+  assert(!request_connection_params->remote_endpoint_id.empty());
+
+  service_controller_router_->requestConnection(client_proxy_.get(),
+                                                request_connection_params);
+}
+
+template <typename Platform>
+void Core<Platform>::acceptConnection(
+    ConstPtr<AcceptConnectionParams> accept_connection_params) {
+  assert(!accept_connection_params->result_listener.isNull());
+  assert(!accept_connection_params->payload_listener.isNull());
+  assert(!accept_connection_params->remote_endpoint_id.empty());
+
+  service_controller_router_->acceptConnection(client_proxy_.get(),
+                                               accept_connection_params);
+}
+
+template <typename Platform>
+void Core<Platform>::rejectConnection(
+    ConstPtr<RejectConnectionParams> reject_connection_params) {
+  assert(!reject_connection_params->result_listener.isNull());
+  assert(!reject_connection_params->remote_endpoint_id.empty());
+
+  service_controller_router_->rejectConnection(client_proxy_.get(),
+                                               reject_connection_params);
+}
+
+template <typename Platform>
+void Core<Platform>::initiateBandwidthUpgrade(
+    ConstPtr<InitiateBandwidthUpgradeParams>
+        initiate_bandwidth_upgrade_params) {
+  service_controller_router_->initiateBandwidthUpgrade(
+      client_proxy_.get(), initiate_bandwidth_upgrade_params);
+}
+
+template <typename Platform>
+void Core<Platform>::sendPayload(
+    ConstPtr<SendPayloadParams> send_payload_params) {
+  assert(!send_payload_params->result_listener.isNull());
+  assert(!send_payload_params->remote_endpoint_ids.empty());
+  assert(!send_payload_params->payload.isNull());
+  // TODO(tracyzhou): Do sanity check on payload based on payload type.
+
+  service_controller_router_->sendPayload(client_proxy_.get(),
+                                          send_payload_params);
+}
+
+template <typename Platform>
+void Core<Platform>::cancelPayload(
+    ConstPtr<CancelPayloadParams> cancel_payload_params) {
+  assert(!cancel_payload_params->result_listener.isNull());
+  assert(cancel_payload_params->payload_id != 0);
+
+  service_controller_router_->cancelPayload(client_proxy_.get(),
+                                            cancel_payload_params);
+}
+
+template <typename Platform>
+void Core<Platform>::disconnectFromEndpoint(
+    ConstPtr<DisconnectFromEndpointParams> disconnect_from_endpoint_params) {
+  assert(!disconnect_from_endpoint_params->remote_endpoint_id.empty());
+
+  service_controller_router_->disconnectFromEndpoint(
+      client_proxy_.get(), disconnect_from_endpoint_params);
+}
+
+template <typename Platform>
+void Core<Platform>::stopAllEndpoints(
+    ConstPtr<StopAllEndpointsParams> stop_all_endpoints_params) {
+  service_controller_router_->stopAllEndpoints(client_proxy_.get(),
+                                               stop_all_endpoints_params);
+}
+
+}  // namespace connections
+}  // namespace nearby
+}  // namespace location