Convert from public to internal broadcast request

Add conversion from public BroadcastRequest to internal BLE 4.2 broadcast request.

PiperOrigin-RevId: 473338534

presence/broadcast_request.h

@@ -16,10 +16,10 @@
 #define THIRD_PARTY_NEARBY_PRESENCE_BROADCAST_REQUEST_H_
 
 #include <string>
-#include <variant>
 #include <vector>
 
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "internal/proto/credential.pb.h"
 #include "presence/data_element.h"
 #include "presence/power_mode.h"
@@ -67,7 +67,7 @@ struct BroadcastRequest {
   // The broadcast frequency hint.
   PowerMode power_mode;
 
-  std::variant<PresenceBroadcast, LegacyPresenceBroadcast> variant;
+  absl::variant<PresenceBroadcast, LegacyPresenceBroadcast> variant;
 };
 
 }  // namespace presence

presence/implementation/BUILD

@@ -122,6 +122,7 @@ cc_test(
     deps = [
         ":internal",
         "//internal/platform/implementation/g3",  # build_cleaner: keep
+        "//presence:types",
         "@com_github_protobuf_matchers//protobuf-matchers",
         "@com_google_absl//absl/types:variant",
         "@com_google_googletest//:gtest_main",

presence/implementation/base_broadcast_request.cc

@@ -15,9 +15,13 @@
 #include "presence/implementation/base_broadcast_request.h"
 
 #include <string>
+#include <variant>
 
+#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "internal/platform/logging.h"
+#include "presence/broadcast_request.h"
+#include "presence/implementation/action_factory.h"
 #include "presence/implementation/encryption.h"
 
 namespace nearby {
@@ -45,6 +49,12 @@ BasePresenceRequestBuilder& BasePresenceRequestBuilder::SetAction(
   return *this;
 }
 
+BasePresenceRequestBuilder& BasePresenceRequestBuilder::SetPowerMode(
+    PowerMode power_mode) {
+  power_mode_ = power_mode;
+  return *this;
+}
+
 BasePresenceRequestBuilder::operator BaseBroadcastRequest() const {
   BaseBroadcastRequest::BasePresence presence{.identity = identity_,
                                               .action = action_};
@@ -53,9 +63,33 @@ BasePresenceRequestBuilder::operator BaseBroadcastRequest() const {
       .salt = salt_.size() == kSaltSize
                   ? salt_
                   : Encryption::GenerateRandomByteArray(kSaltSize),
-      .tx_power = tx_power_};
+      .tx_power = tx_power_,
+      .power_mode = power_mode_};
   return broadcast_request;
 }
 
+absl::StatusOr<BaseBroadcastRequest> BaseBroadcastRequest::Create(
+    const BroadcastRequest& request) {
+  if (absl::holds_alternative<PresenceBroadcast>(request.variant)) {
+    const auto& presence_request =
+        absl::get<PresenceBroadcast>(request.variant);
+    if (presence_request.sections.empty()) {
+      return absl::InvalidArgumentError("Missing broadcast sections");
+    }
+    if (presence_request.sections.size() > 1) {
+      NEARBY_LOG(WARNING,
+                 "Only first section is used in BLE 4.2 advertisement");
+    }
+    const PresenceBroadcast::BroadcastSection& section =
+        presence_request.sections.front();
+    return BaseBroadcastRequest(
+        BasePresenceRequestBuilder(section.identity)
+            .SetTxPower(request.tx_power)
+            .SetAction(ActionFactory::CreateAction(section.extended_properties))
+            .SetPowerMode(request.power_mode));
+  }
+  return absl::UnimplementedError("Request not supported");
+}
+
 }  // namespace presence
 }  // namespace nearby

presence/implementation/base_broadcast_request.h

@@ -19,9 +19,12 @@
 
 #include <string>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 #include "internal/proto/credential.pb.h"
+#include "presence/broadcast_request.h"
+#include "presence/power_mode.h"
 
 namespace nearby {
 namespace presence {
@@ -35,6 +38,11 @@ struct Action {
 
 /** Defines a Nearby Presence broadcast request */
 struct BaseBroadcastRequest {
+  // Creates `BaseBroadcastRequest` from the public API request in
+  // `BroadcastRequest`.
+  static absl::StatusOr<BaseBroadcastRequest> Create(
+      const BroadcastRequest& request);
+
   struct BasePresence {
     nearby::internal::IdentityType identity;
     Action action;
@@ -56,6 +64,7 @@ struct BaseBroadcastRequest {
   std::string salt;
   int8_t tx_power;
   unsigned int interval_ms;
+  PowerMode power_mode;
 };
 
 /** Builds a brodacast request variant with NP identity for BLE 4.2 */
@@ -67,6 +76,7 @@ class BasePresenceRequestBuilder {
   BasePresenceRequestBuilder& SetSalt(absl::string_view salt);
   BasePresenceRequestBuilder& SetTxPower(int8_t tx_power);
   BasePresenceRequestBuilder& SetAction(const Action& action);
+  BasePresenceRequestBuilder& SetPowerMode(PowerMode power_mode);
 
   explicit operator BaseBroadcastRequest() const;
 
@@ -75,6 +85,7 @@ class BasePresenceRequestBuilder {
   std::string salt_;
   int8_t tx_power_ = kUnspecifiedTxPower;
   Action action_;
+  PowerMode power_mode_ = PowerMode::kNoPower;
 };
 
 }  // namespace presence

presence/implementation/base_broadcast_request_test.cc

@@ -18,22 +18,63 @@
 #include "protobuf-matchers/protocol-buffer-matchers.h"
 #include "gtest/gtest.h"
 #include "absl/types/variant.h"
+#include "presence/broadcast_request.h"
+#include "presence/data_element.h"
 
 namespace nearby {
 namespace presence {
 namespace {
 
+using ::testing::status::StatusIs;
+
 TEST(BroadcastRequestTest, CreateBasePresenceRequest) {
   nearby::internal::IdentityType identity;
   constexpr int8_t kTxPower = -13;
 
   BaseBroadcastRequest request = BaseBroadcastRequest(
-      BasePresenceRequestBuilder(identity).SetTxPower(kTxPower));
+      BasePresenceRequestBuilder(identity).SetTxPower(kTxPower).SetPowerMode(
+          PowerMode::kBalanced));
 
   EXPECT_TRUE(absl::holds_alternative<BaseBroadcastRequest::BasePresence>(
       request.variant));
   EXPECT_EQ(request.salt.size(), 2);
   EXPECT_EQ(request.tx_power, kTxPower);
+  EXPECT_EQ(request.power_mode, PowerMode::kBalanced);
+}
+
+TEST(BroadcastRequestTest, CreateFromPresenceRequest) {
+  constexpr int8_t kTxPower = 30;
+  constexpr uint16_t kExpectedAction = 128;  // encoded kActiveUnlockAction
+  PresenceBroadcast::BroadcastSection section = {
+      .identity = internal::IDENTITY_TYPE_PUBLIC,
+      .extended_properties = {DataElement(DataElement::kActionFieldType,
+                                          action::kActiveUnlockAction)}};
+  PresenceBroadcast presence_request = {.sections = {section}};
+  BroadcastRequest input = {
+      .tx_power = kTxPower,
+      .variant = presence_request,
+  };
+
+  absl::StatusOr<BaseBroadcastRequest> request =
+      BaseBroadcastRequest::Create(input);
+
+  ASSERT_OK(request);
+  EXPECT_THAT(request->tx_power, kTxPower);
+  EXPECT_THAT(
+      absl::get<BaseBroadcastRequest::BasePresence>(request->variant).identity,
+      internal::IDENTITY_TYPE_PUBLIC);
+  EXPECT_THAT(absl::get<BaseBroadcastRequest::BasePresence>(request->variant)
+                  .action.action,
+              kExpectedAction);
+}
+
+TEST(BroadcastRequestTest, CreateFromEmptyPresenceRequestFails) {
+  BroadcastRequest empty = {
+      .variant = PresenceBroadcast(),
+  };
+
+  EXPECT_THAT(BaseBroadcastRequest::Create(empty),
+              StatusIs(absl::StatusCode::kInvalidArgument));
 }
 
 }  // namespace