diff --git a/cpp/core_v2/internal/base_pcp_handler.cc b/cpp/core_v2/internal/base_pcp_handler.cc index cd82d899..8fe7c11b 100644 --- a/cpp/core_v2/internal/base_pcp_handler.cc +++ b/cpp/core_v2/internal/base_pcp_handler.cc @@ -335,6 +335,7 @@ Status BasePcpHandler::RequestConnection(ClientProxy* client, OnEndpointFound(client, webrtc_endpoint); } +<<<<<<< HEAD auto discovered_endpoints = GetDiscoveredEndpoints(endpoint_id); std::unique_ptr channel; ConnectImplResult connect_impl_result; @@ -348,6 +349,21 @@ Status BasePcpHandler::RequestConnection(ClientProxy* client, discovered_endpoints.push_back(additional_endpoint.get()); } +======= + auto remote_bluetooth_mac_address = + BluetoothUtils::ToString(options.remote_bluetooth_mac_address); + if (!remote_bluetooth_mac_address.empty()) { + if (AddRemoteBluetoothMacAddressEndpoint(endpoint_id, + remote_bluetooth_mac_address)) + NEARBY_LOGS(INFO) << "Appended remote Bluetooth MAC Address endpoint " + << "[" << remote_bluetooth_mac_address << "]"; + } + + auto discovered_endpoints = GetDiscoveredEndpoints(endpoint_id); + std::unique_ptr channel; + ConnectImplResult connect_impl_result; + +>>>>>>> release for (auto connect_endpoint : discovered_endpoints) { connect_impl_result = ConnectImpl(client, connect_endpoint); if (connect_impl_result.status.Ok()) { @@ -651,7 +667,21 @@ void BasePcpHandler::OnIncomingFrame(OfflineFrame& frame, const ConnectionResponseFrame& connection_response = frame.v1().connection_response(); +<<<<<<< HEAD if (connection_response.status() == Status::kSuccess) { +======= + // For backward compatible, here still check both status and + // response parameters until the response feature is roll out in all + // supported devices. + bool accepted = false; + if (connection_response.has_response()) { + accepted = + connection_response.response() == ConnectionResponseFrame::ACCEPT; + } else { + accepted = connection_response.status() == Status::kSuccess; + } + if (accepted) { +>>>>>>> release NEARBY_LOG(INFO, "OnConnectionResponse: remote accepted; id=%s", endpoint_id.c_str()); client->RemoteEndpointAcceptedConnection(endpoint_id); @@ -992,6 +1022,7 @@ proto::connections::Medium BasePcpHandler::ChooseBestUpgradeMedium( return proto::connections::Medium::UNKNOWN_MEDIUM; } +<<<<<<< HEAD std::unique_ptr BasePcpHandler::GetRemoteBluetoothMacAddressEndpoint( std::string endpoint_id, std::string remote_bluetooth_mac_address, @@ -1005,14 +1036,36 @@ BasePcpHandler::GetRemoteBluetoothMacAddressEndpoint( << "Cannot append remote Bluetooth MAC Address, because endpointId " << endpoint_id << " has not been discovered"; return nullptr; +======= +bool BasePcpHandler::AddRemoteBluetoothMacAddressEndpoint( + std::string endpoint_id, std::string remote_bluetooth_mac_address) { + if (!discovery_options_.allowed.bluetooth) { + return false; + } + + auto endpoints = GetDiscoveredEndpoints(endpoint_id); + if (endpoints.empty()) { + NEARBY_LOGS(INFO) << "Cannot append remote Bluetooth MAC Address endpoint, " + "because endpointId " + << endpoint_id << " has not been discovered " + << "[" << remote_bluetooth_mac_address << "]"; + return false; +>>>>>>> release } for (auto endpoint : endpoints) { if (endpoint->medium == proto::connections::Medium::BLUETOOTH) { NEARBY_LOGS(INFO) +<<<<<<< HEAD << "Cannot append remote Bluetooth MAC Address, because the " "endpoint has already been found over Bluetooth."; return nullptr; +======= + << "Cannot append remote Bluetooth MAC Address endpoint, because the " + "endpoint has already been found over Bluetooth " + << "[" << remote_bluetooth_mac_address << "]"; + return false; +>>>>>>> release } } @@ -1020,6 +1073,7 @@ BasePcpHandler::GetRemoteBluetoothMacAddressEndpoint( mediums_->GetBluetoothClassic().GetRemoteDevice( remote_bluetooth_mac_address); if (!remote_bluetooth_device.IsValid()) { +<<<<<<< HEAD NEARBY_LOGS(INFO) << "Cannot append remote Bluetooth MAC Address, because a valid " "Bluetooth device could not be derived."; @@ -1028,6 +1082,17 @@ BasePcpHandler::GetRemoteBluetoothMacAddressEndpoint( auto bluetooth_endpoint = std::make_unique(BluetoothEndpoint{ +======= + NEARBY_LOGS(INFO) << "Cannot append remote Bluetooth MAC Address endpoint, " + "because a valid " + "Bluetooth device could not be derived " + << "[" << remote_bluetooth_mac_address << "]"; + return false; + } + + auto bluetooth_endpoint = + std::make_shared(BluetoothEndpoint{ +>>>>>>> release { endpoint_id, endpoints[0]->endpoint_info, @@ -1036,9 +1101,15 @@ BasePcpHandler::GetRemoteBluetoothMacAddressEndpoint( }, remote_bluetooth_device, }); +<<<<<<< HEAD NEARBY_LOGS(INFO) << "Appended remote Bluetooth device " << remote_bluetooth_mac_address; return bluetooth_endpoint; +======= + + discovered_endpoints_.emplace(endpoint_id, std::move(bluetooth_endpoint)); + return true; +>>>>>>> release } void BasePcpHandler::EvaluateConnectionResult(ClientProxy* client, diff --git a/cpp/core_v2/internal/base_pcp_handler.h b/cpp/core_v2/internal/base_pcp_handler.h index dfb9bde8..d88d2c72 100644 --- a/cpp/core_v2/internal/base_pcp_handler.h +++ b/cpp/core_v2/internal/base_pcp_handler.h @@ -84,6 +84,16 @@ Swapper MakeSwapper(T* value) { return Swapper(value); } +<<<<<<< HEAD +======= +// Represents the WebRtc state that mediums are connectable or not. +enum class WebRtcState { + kUndefined = 0, + kConnectable = 1, + kUnconnectable = 2, +}; + +>>>>>>> release // A base implementation of the PcpHandler interface that takes care of all // bookkeeping and handshake protocols that are common across all PcpHandler // implementations -- thus, every concrete PcpHandler implementation must extend @@ -412,10 +422,18 @@ class BasePcpHandler : public PcpHandler, proto::connections::Medium ChooseBestUpgradeMedium( const std::vector& supported_mediums); +<<<<<<< HEAD std::unique_ptr GetRemoteBluetoothMacAddressEndpoint( std::string endpoint_id, std::string remote_bluetooth_mac_address, std::vector endpoints); +======= + // Returns true if the bluetooth endpoint based on remote bluetooth mac + // address is created and added into discovered_endpoints_ with key + // endpoint_id. + bool AddRemoteBluetoothMacAddressEndpoint( + std::string endpoint_id, std::string remote_bluetooth_mac_address); +>>>>>>> release void ProcessPreConnectionInitiationFailure(const std::string& endpoint_id, EndpointChannel* channel, diff --git a/cpp/core_v2/internal/ble_advertisement.cc b/cpp/core_v2/internal/ble_advertisement.cc index 741da347..96a4bdd4 100644 --- a/cpp/core_v2/internal/ble_advertisement.cc +++ b/cpp/core_v2/internal/ble_advertisement.cc @@ -16,6 +16,10 @@ #include +<<<<<<< HEAD +======= +#include "core_v2/internal/base_pcp_handler.h" +>>>>>>> release #include "platform_v2/base/base_input_stream.h" #include "platform_v2/public/logging.h" #include "absl/strings/escaping.h" @@ -28,23 +32,45 @@ BleAdvertisement::BleAdvertisement(Version version, Pcp pcp, const ByteArray& service_id_hash, const std::string& endpoint_id, const ByteArray& endpoint_info, +<<<<<<< HEAD const std::string& bluetooth_mac_address) { DoInitialize(/*fast_advertisement=*/false, version, pcp, service_id_hash, endpoint_id, endpoint_info, bluetooth_mac_address); +======= + const std::string& bluetooth_mac_address, + const ByteArray& uwb_address, + WebRtcState web_rtc_state) { + DoInitialize(/*fast_advertisement=*/false, version, pcp, service_id_hash, + endpoint_id, endpoint_info, bluetooth_mac_address, uwb_address, + web_rtc_state); +>>>>>>> release } BleAdvertisement::BleAdvertisement(Version version, Pcp pcp, const std::string& endpoint_id, +<<<<<<< HEAD const ByteArray& endpoint_info) { DoInitialize(/*fast_advertisement=*/true, version, pcp, {}, endpoint_id, endpoint_info, {}); +======= + const ByteArray& endpoint_info, + const ByteArray& uwb_address) { + DoInitialize(/*fast_advertisement=*/true, version, pcp, {}, endpoint_id, + endpoint_info, {}, uwb_address, WebRtcState::kUndefined); +>>>>>>> release } void BleAdvertisement::DoInitialize(bool fast_advertisement, Version version, Pcp pcp, const ByteArray& service_id_hash, const std::string& endpoint_id, const ByteArray& endpoint_info, +<<<<<<< HEAD const std::string& bluetooth_mac_address) { +======= + const std::string& bluetooth_mac_address, + const ByteArray& uwb_address, + WebRtcState web_rtc_state) { +>>>>>>> release fast_advertisement_ = fast_advertisement; if (!fast_advertisement_) { if (service_id_hash.size() != kServiceIdHashLength) return; @@ -71,10 +97,19 @@ void BleAdvertisement::DoInitialize(bool fast_advertisement, Version version, service_id_hash_ = service_id_hash; endpoint_id_ = endpoint_id; endpoint_info_ = endpoint_info; +<<<<<<< HEAD +======= + uwb_address_ = uwb_address; +>>>>>>> release if (!fast_advertisement_) { if (!BluetoothUtils::FromString(bluetooth_mac_address).Empty()) { bluetooth_mac_address_ = bluetooth_mac_address; } +<<<<<<< HEAD +======= + + web_rtc_state_ = web_rtc_state; +>>>>>>> release } } @@ -134,7 +169,11 @@ BleAdvertisement::BleAdvertisement(bool fast_advertisement, // The next 4 bytes are supposed to be the endpoint_id. endpoint_id_ = std::string{base_input_stream.ReadBytes(kEndpointIdLength)}; +<<<<<<< HEAD // The next 1 byte are supposed to be the length of the endpoint_info. +======= + // The next 1 byte is supposed to be the length of the endpoint_info. +>>>>>>> release std::uint32_t expected_endpoint_info_length = base_input_stream.ReadUint8(); // The next x bytes are the endpoint info. (Max length is 131 bytes or 17 @@ -151,7 +190,11 @@ BleAdvertisement::BleAdvertisement(bool fast_advertisement, fast_advertisement_, expected_endpoint_info_length, endpoint_info_.size()); +<<<<<<< HEAD // Clear enpoint_id for validadity. +======= + // Clear enpoint_id for validity. +>>>>>>> release endpoint_id_.clear(); return; } @@ -164,6 +207,38 @@ BleAdvertisement::BleAdvertisement(bool fast_advertisement, BluetoothUtils::ToString(bluetooth_mac_address_bytes); } +<<<<<<< HEAD +======= + // The next 1 byte is supposed to be the length of the uwb_address. + std::uint32_t expected_uwb_address_length = base_input_stream.ReadUint8(); + // If the length of uwb_address is not zero, then retrieve it. + if (expected_uwb_address_length != 0) { + uwb_address_ = base_input_stream.ReadBytes(expected_uwb_address_length); + if (uwb_address_.Empty() || + uwb_address_.size() != expected_uwb_address_length) { + NEARBY_LOG(INFO, + "Cannot deserialize BleAdvertisement: " + "expected uwbAddress size to be %d bytes, got %" PRIu64, + expected_uwb_address_length, uwb_address_.size()); + + // Clear enpoint_id for validity. + endpoint_id_.clear(); + return; + } + } + + // The next 1 byte is extra field. + web_rtc_state_ = WebRtcState::kUndefined; + if (!fast_advertisement_) { + if (base_input_stream.IsAvailable(kExtraFieldLength)) { + auto extra_field = static_cast(base_input_stream.ReadUint8()); + web_rtc_state_ = (extra_field & kWebRtcConnectableFlagBitmask) == 1 + ? WebRtcState::kConnectable + : WebRtcState::kUnconnectable; + } + } + +>>>>>>> release base_input_stream.Close(); } @@ -182,13 +257,20 @@ BleAdvertisement::operator ByteArray() const { if (fast_advertisement_) { // clang-format off out = absl::StrCat(std::string(1, version_and_pcp_byte), +<<<<<<< HEAD endpoint_id_, std::string(1, endpoint_info_.size()), std::string(endpoint_info_)); +======= + endpoint_id_, + std::string(1, endpoint_info_.size()), + std::string(endpoint_info_)); +>>>>>>> release // clang-format on } else { // clang-format off out = absl::StrCat(std::string(1, version_and_pcp_byte), +<<<<<<< HEAD std::string(service_id_hash_), endpoint_id_, std::string(1, endpoint_info_.size()), @@ -197,6 +279,16 @@ BleAdvertisement::operator ByteArray() const { // The next 6 bytes are the bluetooth mac address. If bluetooth_mac_address // is invalid or empty, we get back a null byte array. +======= + std::string(service_id_hash_), + endpoint_id_, + std::string(1, endpoint_info_.size()), + std::string(endpoint_info_)); + // clang-format on + + // The next 6 bytes are the bluetooth mac address. If bluetooth_mac_address + // is invalid or empty, we get back a empty byte array. +>>>>>>> release auto bluetooth_mac_address_bytes{ BluetoothUtils::FromString(bluetooth_mac_address_)}; if (!bluetooth_mac_address_bytes.Empty()) { @@ -204,6 +296,28 @@ BleAdvertisement::operator ByteArray() const { } } +<<<<<<< HEAD +======= + // The next bytes are UWB address field. + if (!uwb_address_.Empty()) { + absl::StrAppend(&out, std::string(1, uwb_address_.size())); + absl::StrAppend(&out, std::string(uwb_address_)); + } else { + // Write UWB address with length 0 to be able to read the next field when + // decode. + absl::StrAppend(&out, std::string(1, uwb_address_.size())); + } + + // The next 1 byte is extra field. + if (!fast_advertisement_) { + int web_rtc_connectable_flag = + (web_rtc_state_ == WebRtcState::kConnectable) ? 1 : 0; + char extra_field_byte = static_cast(web_rtc_connectable_flag) & + kWebRtcConnectableFlagBitmask; + absl::StrAppend(&out, std::string(1, extra_field_byte)); + } + +>>>>>>> release return ByteArray(std::move(out)); } diff --git a/cpp/core_v2/internal/ble_advertisement.h b/cpp/core_v2/internal/ble_advertisement.h index 009c9379..fe7c486a 100644 --- a/cpp/core_v2/internal/ble_advertisement.h +++ b/cpp/core_v2/internal/ble_advertisement.h @@ -15,6 +15,10 @@ #ifndef CORE_V2_INTERNAL_BLE_ADVERTISEMENT_H_ #define CORE_V2_INTERNAL_BLE_ADVERTISEMENT_H_ +<<<<<<< HEAD +======= +#include "core_v2/internal/base_pcp_handler.h" +>>>>>>> release #include "core_v2/internal/pcp.h" #include "platform_v2/base/bluetooth_utils.h" #include "platform_v2/base/byte_array.h" @@ -27,7 +31,11 @@ namespace connections { // Advertising + Discovery. // //

[VERSION][PCP][SERVICE_ID_HASH][ENDPOINT_ID][ENDPOINT_INFO_SIZE] +<<<<<<< HEAD // [ENDPOINT_INFO][BLUETOOTH_MAC] +======= +// [ENDPOINT_INFO][BLUETOOTH_MAC][UWB_ADDRESS_SIZE][UWB_ADDRESS][EXTRA_FIELD] +>>>>>>> release // //

The fast version of this advertisement simply omits SERVICE_ID_HASH and // the Bluetooth MAC address. @@ -49,27 +57,56 @@ class BleAdvertisement { static constexpr int kServiceIdHashLength = 3; static constexpr int kEndpointIdLength = 4; static constexpr int kEndpointInfoSizeLength = 1; +<<<<<<< HEAD static constexpr int kEndpointInfoLengthBitmask = 0x0FF; static constexpr int kMinAdvertisementLength = kVersionAndPcpLength + kServiceIdHashLength + kEndpointIdLength + kEndpointInfoSizeLength + BluetoothUtils::kBluetoothMacAddressLength; +======= + static constexpr int kBluetoothMacAddressLength = + BluetoothUtils::kBluetoothMacAddressLength; + static constexpr int kUwbAddressSizeLength = 1; + static constexpr int kExtraFieldLength = 1; + static constexpr int kEndpointInfoLengthBitmask = 0x0FF; + static constexpr int kWebRtcConnectableFlagBitmask = 0x01; + static constexpr int kMinAdvertisementLength = + kVersionAndPcpLength + kServiceIdHashLength + kEndpointIdLength + + kEndpointInfoSizeLength + kBluetoothMacAddressLength; +>>>>>>> release // The difference between normal and fast advertisements is that the fast one // omits the SERVICE_ID_HASH and Bluetooth MAC address. This is done to save // space. +<<<<<<< HEAD static constexpr int kMinFastAdvertisementLength = kMinAdvertisementLength - kServiceIdHashLength - BluetoothUtils::kBluetoothMacAddressLength; +======= + static constexpr int kMinFastAdvertisementLength = kMinAdvertisementLength - + kServiceIdHashLength - + kBluetoothMacAddressLength; +>>>>>>> release static constexpr int kMaxEndpointInfoLength = 131; static constexpr int kMaxFastEndpointInfoLength = 17; BleAdvertisement() = default; BleAdvertisement(Version version, Pcp pcp, const std::string& endpoint_id, +<<<<<<< HEAD const ByteArray& endpoint_info); BleAdvertisement(Version version, Pcp pcp, const ByteArray& service_id_hash, const std::string& endpoint_id, const ByteArray& endpoint_info, const std::string& bluetooth_mac_address); +======= + const ByteArray& endpoint_info, + const ByteArray& uwb_address); + BleAdvertisement(Version version, Pcp pcp, const ByteArray& service_id_hash, + const std::string& endpoint_id, + const ByteArray& endpoint_info, + const std::string& bluetooth_mac_address, + const ByteArray& uwb_address, + WebRtcState web_rtc_state); +>>>>>>> release BleAdvertisement(bool fast_advertisement, const ByteArray& ble_advertisement_bytes); BleAdvertisement(const BleAdvertisement&) = default; @@ -88,21 +125,41 @@ class BleAdvertisement { std::string GetEndpointId() const { return endpoint_id_; } ByteArray GetEndpointInfo() const { return endpoint_info_; } std::string GetBluetoothMacAddress() const { return bluetooth_mac_address_; } +<<<<<<< HEAD +======= + ByteArray GetUwbAddress() const { return uwb_address_; } + WebRtcState GetWebRtcState() const { return web_rtc_state_; } +>>>>>>> release private: void DoInitialize(bool fast_advertisement, Version version, Pcp pcp, const ByteArray& service_id_hash, const std::string& endpoint_id, const ByteArray& endpoint_info, +<<<<<<< HEAD const std::string& bluetooth_mac_address); bool fast_advertisement_ = false; Version version_ = Version::kUndefined; Pcp pcp_ = Pcp::kUnknown; +======= + const std::string& bluetooth_mac_address, + const ByteArray& uwb_address, WebRtcState web_rtc_state); + + bool fast_advertisement_ = false; + Version version_{Version::kUndefined}; + Pcp pcp_{Pcp::kUnknown}; +>>>>>>> release ByteArray service_id_hash_; std::string endpoint_id_; ByteArray endpoint_info_; std::string bluetooth_mac_address_; +<<<<<<< HEAD +======= + // TODO(b/169550050): Define UWB address field. + ByteArray uwb_address_; + WebRtcState web_rtc_state_{WebRtcState::kUndefined}; +>>>>>>> release }; } // namespace connections diff --git a/cpp/core_v2/internal/ble_advertisement_test.cc b/cpp/core_v2/internal/ble_advertisement_test.cc index 79afdd66..6ed59a4b 100644 --- a/cpp/core_v2/internal/ble_advertisement_test.cc +++ b/cpp/core_v2/internal/ble_advertisement_test.cc @@ -14,6 +14,10 @@ #include "core_v2/internal/ble_advertisement.h" +<<<<<<< HEAD +======= +#include "core_v2/internal/base_pcp_handler.h" +>>>>>>> release #include "gtest/gtest.h" namespace location { @@ -29,6 +33,7 @@ constexpr absl::string_view kEndpointName{ "How much wood can a woodchuck chuck if a wood chuck would chuck wood?"}; constexpr absl::string_view kFastAdvertisementEndpointName{"Fast Advertise"}; constexpr absl::string_view kBluetoothMacAddress{"00:00:E6:88:64:13"}; +<<<<<<< HEAD TEST(BleAdvertisementTest, ConstructionWorks) { ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; @@ -37,6 +42,22 @@ TEST(BleAdvertisementTest, ConstructionWorks) { kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= +constexpr WebRtcState kWebRtcState = WebRtcState::kConnectable; + +// TODO(b/169550050): Implement UWBAddress. +TEST(BleAdvertisementTest, ConstructionWorks) { + ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; + ByteArray endpoint_info{std::string(kEndpointName)}; + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_FALSE(ble_advertisement.IsFastAdvertisement()); @@ -46,12 +67,24 @@ TEST(BleAdvertisementTest, ConstructionWorks) { EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(endpoint_info, ble_advertisement.GetEndpointInfo()); EXPECT_EQ(kBluetoothMacAddress, ble_advertisement.GetBluetoothMacAddress()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionWorksForFastAdvertisement) { ByteArray fast_endpoint_info{std::string(kFastAdvertisementEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{kVersion, kPcp, std::string(kEndpointId), fast_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + fast_endpoint_info, + ByteArray{}}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_TRUE(ble_advertisement.IsFastAdvertisement()); @@ -59,6 +92,10 @@ TEST(BleAdvertisementTest, ConstructionWorksForFastAdvertisement) { EXPECT_EQ(kPcp, ble_advertisement.GetPcp()); EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(fast_endpoint_info, ble_advertisement.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(WebRtcState::kUndefined, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionWorksWithEmptyEndpointInfo) { @@ -70,7 +107,13 @@ TEST(BleAdvertisementTest, ConstructionWorksWithEmptyEndpointInfo) { service_id_hash, std::string(kEndpointId), empty_endpoint_info, +<<<<<<< HEAD std::string(kBluetoothMacAddress)}; +======= + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_FALSE(ble_advertisement.IsFastAdvertisement()); @@ -80,14 +123,26 @@ TEST(BleAdvertisementTest, ConstructionWorksWithEmptyEndpointInfo) { EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(empty_endpoint_info, ble_advertisement.GetEndpointInfo()); EXPECT_EQ(kBluetoothMacAddress, ble_advertisement.GetBluetoothMacAddress()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionWorksWithEmptyEndpointInfoForFastAdvertisement) { ByteArray empty_endpoint_info; +<<<<<<< HEAD BleAdvertisement ble_advertisement{kVersion, kPcp, std::string(kEndpointId), empty_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + empty_endpoint_info, + ByteArray{}}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_TRUE(ble_advertisement.IsFastAdvertisement()); @@ -95,6 +150,10 @@ TEST(BleAdvertisementTest, EXPECT_EQ(kPcp, ble_advertisement.GetPcp()); EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(empty_endpoint_info, ble_advertisement.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(WebRtcState::kUndefined, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionWorksWithEmojiEndpointInfo) { @@ -106,7 +165,13 @@ TEST(BleAdvertisementTest, ConstructionWorksWithEmojiEndpointInfo) { service_id_hash, std::string(kEndpointId), emoji_endpoint_info, +<<<<<<< HEAD std::string(kBluetoothMacAddress)}; +======= + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_FALSE(ble_advertisement.IsFastAdvertisement()); @@ -116,14 +181,26 @@ TEST(BleAdvertisementTest, ConstructionWorksWithEmojiEndpointInfo) { EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(emoji_endpoint_info, ble_advertisement.GetEndpointInfo()); EXPECT_EQ(kBluetoothMacAddress, ble_advertisement.GetBluetoothMacAddress()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionWorksWithEmojiEndpointInfoForFastAdvertisement) { ByteArray emoji_endpoint_info{std::string("\u0001F450 \u0001F450")}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{kVersion, kPcp, std::string(kEndpointId), emoji_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + emoji_endpoint_info, + ByteArray{}}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_TRUE(ble_advertisement.IsFastAdvertisement()); @@ -131,6 +208,10 @@ TEST(BleAdvertisementTest, EXPECT_EQ(kPcp, ble_advertisement.GetPcp()); EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(emoji_endpoint_info, ble_advertisement.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(WebRtcState::kUndefined, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionFailsWithLongEndpointInfo) { @@ -139,10 +220,21 @@ TEST(BleAdvertisementTest, ConstructionFailsWithLongEndpointInfo) { ByteArray long_endpoint_info{long_endpoint_name}; ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), long_endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + long_endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(ble_advertisement.IsValid()); } @@ -153,8 +245,16 @@ TEST(BleAdvertisementTest, BleAdvertisement::kMaxFastEndpointInfoLength + 1, 'x'); ByteArray long_endpoint_info{long_endpoint_name}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{kVersion, kPcp, std::string(kEndpointId), long_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + long_endpoint_info, + ByteArray{}}; +>>>>>>> release EXPECT_FALSE(ble_advertisement.IsValid()); } @@ -164,10 +264,21 @@ TEST(BleAdvertisementTest, ConstructionFailsWithBadVersion) { ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ bad_version, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement ble_advertisement{bad_version, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(ble_advertisement.IsValid()); } @@ -177,8 +288,16 @@ TEST(BleAdvertisementTest, auto bad_version = static_cast(666); ByteArray fast_endpoint_info{std::string(kFastAdvertisementEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ bad_version, kPcp, std::string(kEndpointId), fast_endpoint_info}; +======= + BleAdvertisement ble_advertisement{bad_version, + kPcp, + std::string(kEndpointId), + fast_endpoint_info, + ByteArray{}}; +>>>>>>> release EXPECT_FALSE(ble_advertisement.IsValid()); } @@ -188,10 +307,21 @@ TEST(BleAdvertisementTest, ConstructionFailsWithBadPCP) { ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, bad_pcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement ble_advertisement{kVersion, + bad_pcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(ble_advertisement.IsValid()); } @@ -200,8 +330,16 @@ TEST(BleAdvertisementTest, ConstructionFailsWithBadPCPForFastAdvertisement) { auto bad_pcp = static_cast(666); ByteArray fast_endpoint_info{std::string(kFastAdvertisementEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, bad_pcp, std::string(kEndpointId), fast_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + bad_pcp, + std::string(kEndpointId), + fast_endpoint_info, + ByteArray{}}; +>>>>>>> release EXPECT_FALSE(ble_advertisement.IsValid()); } @@ -211,10 +349,21 @@ TEST(BleAdvertisementTest, ConstructionSucceedsWithEmptyBluetoothMacAddress) { ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, empty_bluetooth_mac_address}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + empty_bluetooth_mac_address, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); } @@ -224,10 +373,21 @@ TEST(BleAdvertisementTest, ConstructionSucceedsWithInvalidBluetoothMacAddress) { ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, bad_bluetooth_mac_address}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + bad_bluetooth_mac_address, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(ble_advertisement.IsValid()); EXPECT_EQ(kVersion, ble_advertisement.GetVersion()); @@ -236,16 +396,31 @@ TEST(BleAdvertisementTest, ConstructionSucceedsWithInvalidBluetoothMacAddress) { EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(endpoint_info, ble_advertisement.GetEndpointInfo()); EXPECT_TRUE(ble_advertisement.GetBluetoothMacAddress().empty()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionFromBytesWorks) { // Serialize good data into a good Ble Advertisement. ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement org_ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement org_ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release ByteArray ble_advertisement_bytes(org_ble_advertisement); BleAdvertisement ble_advertisement{false, ble_advertisement_bytes}; @@ -258,13 +433,25 @@ TEST(BleAdvertisementTest, ConstructionFromBytesWorks) { EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(endpoint_info, ble_advertisement.GetEndpointInfo()); EXPECT_EQ(kBluetoothMacAddress, ble_advertisement.GetBluetoothMacAddress()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionFromBytesWorksForFastAdvertisement) { // Serialize good data into a good Ble Advertisement. ByteArray fast_endpoint_info{std::string(kFastAdvertisementEndpointName)}; +<<<<<<< HEAD BleAdvertisement org_ble_advertisement{ kVersion, kPcp, std::string(kEndpointId), fast_endpoint_info}; +======= + BleAdvertisement org_ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + fast_endpoint_info, + ByteArray{}}; +>>>>>>> release ByteArray ble_advertisement_bytes(org_ble_advertisement); BleAdvertisement ble_advertisement{true, ble_advertisement_bytes}; @@ -275,6 +462,10 @@ TEST(BleAdvertisementTest, ConstructionFromBytesWorksForFastAdvertisement) { EXPECT_EQ(kPcp, ble_advertisement.GetPcp()); EXPECT_EQ(kEndpointId, ble_advertisement.GetEndpointId()); EXPECT_EQ(fast_endpoint_info, ble_advertisement.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(WebRtcState::kUndefined, ble_advertisement.GetWebRtcState()); +>>>>>>> release } // Bytes at the end should be ignored so that they can be used as reserve bytes @@ -283,10 +474,21 @@ TEST(BleAdvertisementTest, ConstructionFromLongLengthBytesWorks) { // Serialize good data into a good Ble Advertisement. ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release ByteArray ble_advertisement_bytes(ble_advertisement); // Add bytes to the end of the valid Ble advertisement. @@ -307,6 +509,10 @@ TEST(BleAdvertisementTest, ConstructionFromLongLengthBytesWorks) { EXPECT_EQ(endpoint_info, long_ble_advertisement.GetEndpointInfo()); EXPECT_EQ(kBluetoothMacAddress, long_ble_advertisement.GetBluetoothMacAddress()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, ble_advertisement.GetWebRtcState()); +>>>>>>> release } TEST(BleAdvertisementTest, ConstructionFromNullBytesFails) { @@ -325,10 +531,21 @@ TEST(BleAdvertisementTest, ConstructionFromShortLengthBytesFails) { // Serialize good data into a good Ble Advertisement. ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release ByteArray ble_advertisement_bytes(ble_advertisement); // Shorten the valid Ble Advertisement. @@ -341,12 +558,24 @@ TEST(BleAdvertisementTest, ConstructionFromShortLengthBytesFails) { EXPECT_FALSE(short_ble_advertisement.IsValid()); } +<<<<<<< HEAD +======= + +>>>>>>> release TEST(BleAdvertisementTest, ConstructionFromShortLengthBytesFailsForFastAdvertisement) { // Serialize good data into a good Ble Advertisement. ByteArray fast_endpoint_info{std::string(kFastAdvertisementEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{kVersion, kPcp, std::string(kEndpointId), fast_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + fast_endpoint_info, + ByteArray{}}; +>>>>>>> release ByteArray ble_advertisement_bytes(ble_advertisement); // Shorten the valid Ble Advertisement. @@ -364,10 +593,21 @@ TEST(BleAdvertisementTest, // Serialize good data into a good Ble Advertisement. ByteArray service_id_hash{std::string(kServiceIdHashBytes)}; ByteArray endpoint_info{std::string(kEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{ kVersion, kPcp, service_id_hash, std::string(kEndpointId), endpoint_info, std::string(kBluetoothMacAddress)}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + service_id_hash, + std::string(kEndpointId), + endpoint_info, + std::string(kBluetoothMacAddress), + ByteArray{}, + kWebRtcState}; +>>>>>>> release ByteArray ble_advertisement_bytes(ble_advertisement); // Corrupt the EndpointNameLength bits. @@ -385,8 +625,16 @@ TEST(BleAdvertisementTest, ConstructionFromByesWithWrongEndpointInfoLengthFailsForFastAdvertisement) { // Serialize good data into a good Ble Advertisement. ByteArray fast_endpoint_info{std::string(kFastAdvertisementEndpointName)}; +<<<<<<< HEAD BleAdvertisement ble_advertisement{kVersion, kPcp, std::string(kEndpointId), fast_endpoint_info}; +======= + BleAdvertisement ble_advertisement{kVersion, + kPcp, + std::string(kEndpointId), + fast_endpoint_info, + ByteArray{}}; +>>>>>>> release ByteArray ble_advertisement_bytes = ByteArray(ble_advertisement); // Corrupt the EndpointInfoLength bits. diff --git a/cpp/core_v2/internal/bluetooth_device_name.cc b/cpp/core_v2/internal/bluetooth_device_name.cc index 465a2ee3..e7504ad4 100644 --- a/cpp/core_v2/internal/bluetooth_device_name.cc +++ b/cpp/core_v2/internal/bluetooth_device_name.cc @@ -32,7 +32,13 @@ namespace connections { BluetoothDeviceName::BluetoothDeviceName(Version version, Pcp pcp, absl::string_view endpoint_id, const ByteArray& service_id_hash, +<<<<<<< HEAD const ByteArray& endpoint_info) { +======= + const ByteArray& endpoint_info, + const ByteArray& uwb_address, + WebRtcState web_rtc_state) { +>>>>>>> release if (version != Version::kV1 || endpoint_id.empty() || endpoint_id.length() != kEndpointIdLength || service_id_hash.size() != kServiceIdHashLength) { @@ -52,6 +58,11 @@ BluetoothDeviceName::BluetoothDeviceName(Version version, Pcp pcp, endpoint_id_ = std::string(endpoint_id); service_id_hash_ = service_id_hash; endpoint_info_ = endpoint_info; +<<<<<<< HEAD +======= + uwb_address_ = uwb_address; + web_rtc_state_ = web_rtc_state; +>>>>>>> release } BluetoothDeviceName::BluetoothDeviceName( @@ -67,6 +78,7 @@ BluetoothDeviceName::BluetoothDeviceName( return; } +<<<<<<< HEAD if (bluetooth_device_name_bytes.size() > kMaxBluetoothDeviceNameLength) { NEARBY_LOG(INFO, "Cannot deserialize BluetoothDeviceName: expecting max %d raw " @@ -76,6 +88,8 @@ BluetoothDeviceName::BluetoothDeviceName( return; } +======= +>>>>>>> release if (bluetooth_device_name_bytes.size() < kMinBluetoothDeviceNameLength) { NEARBY_LOG(INFO, "Cannot deserialize BluetoothDeviceName: expecting min %d raw " @@ -117,11 +131,26 @@ BluetoothDeviceName::BluetoothDeviceName( // The next 3 bytes are supposed to be the service_id_hash. service_id_hash_ = base_input_stream.ReadBytes(kServiceIdHashLength); +<<<<<<< HEAD // The next 7 bytes are supposed to be reserved, and can be left // untouched. base_input_stream.ReadBytes(kReservedLength); // The next 1 byte are supposed to be the length of the endpoint_info. +======= + + // The next 1 byte is field containning WebRtc state. + auto field_byte = static_cast(base_input_stream.ReadUint8()); + web_rtc_state_ = (field_byte & kWebRtcConnectableFlagBitmask) == 1 + ? WebRtcState::kConnectable + : WebRtcState::kUnconnectable; + + // The next 6 bytes are supposed to be reserved, and can be left + // untouched. + base_input_stream.ReadBytes(kReservedLength); + + // The next 1 byte is supposed to be the length of the endpoint_info. +>>>>>>> release std::uint32_t expected_endpoint_info_length = base_input_stream.ReadUint8(); // The rest bytes are supposed to be the endpoint_info @@ -137,6 +166,32 @@ BluetoothDeviceName::BluetoothDeviceName( endpoint_id_.clear(); return; } +<<<<<<< HEAD +======= + + // If the input stream has extra bytes, it's for UWB address. The first byte + // is the address length. It can be 2-byte short address or 8-byte extended + // address. + if (base_input_stream.IsAvailable(1)) { + // The next 1 byte is supposed to be the length of the uwb_address. + std::uint32_t expected_uwb_address_length = base_input_stream.ReadUint8(); + // If the length of usb_address is not zero, then retrieve it. + if (expected_uwb_address_length != 0) { + uwb_address_ = base_input_stream.ReadBytes(expected_uwb_address_length); + if (uwb_address_.Empty() || + uwb_address_.size() != expected_uwb_address_length) { + NEARBY_LOG(INFO, + "Cannot deserialize BluetoothDeviceName: " + "expected uwbAddress size to be %d bytes, got %" PRIu64, + expected_uwb_address_length, uwb_address_.size()); + + // Clear enpoint_id for validadity. + endpoint_id_.clear(); + return; + } + } + } +>>>>>>> release } BluetoothDeviceName::operator std::string() const { @@ -151,6 +206,15 @@ BluetoothDeviceName::operator std::string() const { version_and_pcp_byte |= static_cast(static_cast(pcp_) & kPcpBitmask); +<<<<<<< HEAD +======= + // A byte contains WebRtcState state. + int web_rtc_connectable_flag = + (web_rtc_state_ == WebRtcState::kConnectable) ? 1 : 0; + char field_byte = static_cast(web_rtc_connectable_flag) & + kWebRtcConnectableFlagBitmask; + +>>>>>>> release ByteArray reserved_bytes{kReservedLength}; ByteArray usable_endpoint_info(endpoint_info_); @@ -167,11 +231,24 @@ BluetoothDeviceName::operator std::string() const { std::string out = absl::StrCat(std::string(1, version_and_pcp_byte), endpoint_id_, std::string(service_id_hash_), +<<<<<<< HEAD +======= + std::string(1, field_byte), +>>>>>>> release std::string(reserved_bytes), std::string(1, usable_endpoint_info.size()), std::string(usable_endpoint_info)); // clang-format on +<<<<<<< HEAD +======= + // If UWB address is available, attach it at the end. + if (!uwb_address_.Empty()) { + absl::StrAppend(&out, std::string(1, uwb_address_.size())); + absl::StrAppend(&out, std::string(uwb_address_)); + } + +>>>>>>> release return Base64Utils::Encode(ByteArray{std::move(out)}); } diff --git a/cpp/core_v2/internal/bluetooth_device_name.h b/cpp/core_v2/internal/bluetooth_device_name.h index e81bb21a..818fd18b 100644 --- a/cpp/core_v2/internal/bluetooth_device_name.h +++ b/cpp/core_v2/internal/bluetooth_device_name.h @@ -17,6 +17,10 @@ #include +<<<<<<< HEAD +======= +#include "core_v2/internal/base_pcp_handler.h" +>>>>>>> release #include "core_v2/internal/pcp.h" #include "platform_v2/base/byte_array.h" #include "absl/strings/string_view.h" @@ -44,7 +48,13 @@ class BluetoothDeviceName { BluetoothDeviceName() = default; BluetoothDeviceName(Version version, Pcp pcp, absl::string_view endpoint_id, const ByteArray& service_id_hash, +<<<<<<< HEAD const ByteArray& endpoint_info); +======= + const ByteArray& endpoint_info, + const ByteArray& uwb_address, + WebRtcState web_rtc_state); +>>>>>>> release explicit BluetoothDeviceName(absl::string_view bluetooth_device_name_string); BluetoothDeviceName(const BluetoothDeviceName&) = default; BluetoothDeviceName& operator=(const BluetoothDeviceName&) = default; @@ -60,6 +70,7 @@ class BluetoothDeviceName { std::string GetEndpointId() const { return endpoint_id_; } ByteArray GetServiceIdHash() const { return service_id_hash_; } ByteArray GetEndpointInfo() const { return endpoint_info_; } +<<<<<<< HEAD private: static constexpr int kMaxBluetoothDeviceNameLength = 147; @@ -68,16 +79,36 @@ class BluetoothDeviceName { static constexpr int kMaxEndpointInfoLength = 131; static constexpr int kMinBluetoothDeviceNameLength = kMaxBluetoothDeviceNameLength - kMaxEndpointInfoLength; +======= + ByteArray GetUwbAddress() const { return uwb_address_; } + WebRtcState GetWebRtcState() const { return web_rtc_state_; } + + private: + static constexpr int kEndpointIdLength = 4; + static constexpr int kReservedLength = 6; + static constexpr int kMaxEndpointInfoLength = 131; + static constexpr int kMinBluetoothDeviceNameLength = 16; +>>>>>>> release static constexpr int kVersionBitmask = 0x0E0; static constexpr int kPcpBitmask = 0x01F; static constexpr int kEndpointNameLengthBitmask = 0x0FF; +<<<<<<< HEAD +======= + static constexpr int kWebRtcConnectableFlagBitmask = 0x01; +>>>>>>> release Version version_{Version::kUndefined}; Pcp pcp_{Pcp::kUnknown}; std::string endpoint_id_; ByteArray service_id_hash_; ByteArray endpoint_info_; +<<<<<<< HEAD +======= + // TODO(b/169550050): Define UWB address field. + ByteArray uwb_address_; + WebRtcState web_rtc_state_{WebRtcState::kUndefined}; +>>>>>>> release }; } // namespace connections diff --git a/cpp/core_v2/internal/bluetooth_device_name_test.cc b/cpp/core_v2/internal/bluetooth_device_name_test.cc index a33f3452..e4b762e2 100644 --- a/cpp/core_v2/internal/bluetooth_device_name_test.cc +++ b/cpp/core_v2/internal/bluetooth_device_name_test.cc @@ -31,12 +31,28 @@ constexpr Pcp kPcp = Pcp::kP2pCluster; constexpr absl::string_view kEndPointID{"AB12"}; constexpr absl::string_view kServiceIDHashBytes{"\x0a\x0b\x0c"}; constexpr absl::string_view kEndPointName{"RAWK + ROWL!"}; +<<<<<<< HEAD TEST(BluetoothDeviceNameTest, ConstructionWorks) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; BluetoothDeviceName bluetooth_device_name{kVersion, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= +constexpr WebRtcState kWebRtcState = WebRtcState::kConnectable; + +// TODO(b/169550050): Implement UWBAddress. +TEST(BluetoothDeviceNameTest, ConstructionWorks) { + ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; + ByteArray endpoint_info{std::string(kEndPointName)}; + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(bluetooth_device_name.IsValid()); EXPECT_EQ(kVersion, bluetooth_device_name.GetVersion()); @@ -44,14 +60,28 @@ TEST(BluetoothDeviceNameTest, ConstructionWorks) { EXPECT_EQ(kEndPointID, bluetooth_device_name.GetEndpointId()); EXPECT_EQ(service_id_hash, bluetooth_device_name.GetServiceIdHash()); EXPECT_EQ(endpoint_info, bluetooth_device_name.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, bluetooth_device_name.GetWebRtcState()); +>>>>>>> release } TEST(BluetoothDeviceNameTest, ConstructionWorksWithEmptyEndpointName) { ByteArray empty_endpoint_info; ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{ kVersion, kPcp, kEndPointID, service_id_hash, empty_endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + kEndPointID, + service_id_hash, + empty_endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(bluetooth_device_name.IsValid()); EXPECT_EQ(kVersion, bluetooth_device_name.GetVersion()); @@ -59,6 +89,10 @@ TEST(BluetoothDeviceNameTest, ConstructionWorksWithEmptyEndpointName) { EXPECT_EQ(kEndPointID, bluetooth_device_name.GetEndpointId()); EXPECT_EQ(service_id_hash, bluetooth_device_name.GetServiceIdHash()); EXPECT_EQ(empty_endpoint_info, bluetooth_device_name.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, bluetooth_device_name.GetWebRtcState()); +>>>>>>> release } TEST(BluetoothDeviceNameTest, ConstructionFailsWithBadVersion) { @@ -66,8 +100,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithBadVersion) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{bad_version, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{bad_version, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(bluetooth_device_name.IsValid()); } @@ -77,8 +121,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithBadPcp) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{kVersion, bad_pcp, kEndPointID, service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + bad_pcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(bluetooth_device_name.IsValid()); } @@ -88,8 +142,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithShortEndpointId) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{kVersion, kPcp, short_endpoint_id, service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + short_endpoint_id, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(bluetooth_device_name.IsValid()); } @@ -99,8 +163,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithLongEndpointId) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{kVersion, kPcp, long_endpoint_id, service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + long_endpoint_id, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(bluetooth_device_name.IsValid()); } @@ -110,8 +184,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithShortServiceIdHash) { ByteArray short_service_id_hash{short_service_id_hash_bytes}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{ kVersion, kPcp, kEndPointID, short_service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + kEndPointID, + short_service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(bluetooth_device_name.IsValid()); } @@ -121,8 +205,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithLongServiceIdHash) { ByteArray long_service_id_hash{long_service_id_hash_bytes}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{ kVersion, kPcp, kEndPointID, long_service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + kEndPointID, + long_service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(bluetooth_device_name.IsValid()); } @@ -141,8 +235,18 @@ TEST(BluetoothDeviceNameTest, ConstructionFailsWithWrongEndpointNameLength) { // Serialize good data into a good Bluetooth Device Name. ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD BluetoothDeviceName bluetooth_device_name{kVersion, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= + BluetoothDeviceName bluetooth_device_name{kVersion, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release auto bluetooth_device_name_string = std::string(bluetooth_device_name); // Base64-decode the good Bluetooth Device Name. @@ -169,8 +273,18 @@ TEST(BluetoothDeviceNameTest, CanParseGeneratedName) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; // Build name1 from scratch. +<<<<<<< HEAD BluetoothDeviceName name1{kVersion, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= + BluetoothDeviceName name1{kVersion, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release // Build name2 from string composed from name1. BluetoothDeviceName name2{std::string(name1)}; EXPECT_TRUE(name1.IsValid()); @@ -180,6 +294,10 @@ TEST(BluetoothDeviceNameTest, CanParseGeneratedName) { EXPECT_EQ(name1.GetEndpointId(), name2.GetEndpointId()); EXPECT_EQ(name1.GetServiceIdHash(), name2.GetServiceIdHash()); EXPECT_EQ(name1.GetEndpointInfo(), name2.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(name1.GetWebRtcState(), name2.GetWebRtcState()); +>>>>>>> release } } // namespace diff --git a/cpp/core_v2/internal/bwu_manager.cc b/cpp/core_v2/internal/bwu_manager.cc index 967f3542..45eeaa45 100644 --- a/cpp/core_v2/internal/bwu_manager.cc +++ b/cpp/core_v2/internal/bwu_manager.cc @@ -15,6 +15,10 @@ #include "core_v2/internal/bwu_manager.h" #include +<<<<<<< HEAD +======= +#include +>>>>>>> release #include "core_v2/internal/bwu_handler.h" #include "core_v2/internal/offline_frames.h" @@ -206,7 +210,11 @@ void BwuManager::OnEndpointDisconnect(ClientProxy* client, handler_->OnEndpointDisconnect(client, endpoint_id); } +<<<<<<< HEAD auto item = old_channels_.extract(endpoint_id); +======= + auto item = previous_endpoint_channels_.extract(endpoint_id); +>>>>>>> release if (!item.empty()) { auto old_channel = item.mapped(); @@ -274,7 +282,14 @@ void BwuManager::OnBwuNegotiationFrame(ClientProxy* client, } void BwuManager::OnIncomingConnection( +<<<<<<< HEAD ClientProxy* client, BwuHandler::IncomingSocketConnection* connection) { +======= + ClientProxy* client, + BwuHandler::IncomingSocketConnection* mutable_connection) { + auto connection = std::make_shared( + std::move(*mutable_connection)); +>>>>>>> release RunOnBwuManagerThread([this, client, connection]() { EndpointChannel* channel = connection->channel.get(); if (channel == nullptr) { @@ -343,7 +358,11 @@ void BwuManager::RunUpgradeProtocol( // continue when we receive a corresponding // BANDWIDTH_UPGRADE_NEGOTIATION.LAST_WRITE_TO_PRIOR_CHANNEL OfflineFrame from // the remote device, so for now, just store that previous EndpointChannel. +<<<<<<< HEAD old_channels_.emplace(endpoint_id, old_channel); +======= + previous_endpoint_channels_.emplace(endpoint_id, old_channel); +>>>>>>> release // If we already read LAST_WRITE on the old endpoint channel, then we can // safely close it now. diff --git a/cpp/core_v2/internal/bwu_manager.h b/cpp/core_v2/internal/bwu_manager.h index 3e552222..13f95440 100644 --- a/cpp/core_v2/internal/bwu_manager.h +++ b/cpp/core_v2/internal/bwu_manager.h @@ -170,10 +170,15 @@ class BwuManager : public EndpointManager::FrameProcessor { // Stores each upgraded endpoint's previous EndpointChannel (that was // displaced in favor of a new EndpointChannel) temporarily, until it can // safely be shut down for good in processLastWriteToPriorChannelEvent(). +<<<<<<< HEAD absl::flat_hash_map> previous_endpoint_channels_; absl::flat_hash_map> old_channels_; +======= + absl::flat_hash_map> + previous_endpoint_channels_; +>>>>>>> release absl::flat_hash_set successfully_upgraded_endpoints_; // Maps endpointId -> ClientProxy for which // initiateBwuForEndpoint() has been called but which have not diff --git a/cpp/core_v2/internal/mediums/BUILD b/cpp/core_v2/internal/mediums/BUILD index 5cc797cf..a4f0417b 100644 --- a/cpp/core_v2/internal/mediums/BUILD +++ b/cpp/core_v2/internal/mediums/BUILD @@ -39,7 +39,13 @@ cc_library( "//core_v2/internal:__subpackages__", ], deps = [ +<<<<<<< HEAD "//core_v2:core_types", +======= + ":utils", + "//core_v2:core_types", + "//core_v2/internal/mediums/ble_v2", +>>>>>>> release "//core_v2/internal/mediums/webrtc", "//platform_v2/base", "//platform_v2/public:comm", @@ -63,6 +69,10 @@ cc_library( hdrs = ["utils.h"], visibility = [ "//core_v2/internal:__pkg__", +<<<<<<< HEAD +======= + "//core_v2/internal/mediums:__pkg__", +>>>>>>> release "//core_v2/internal/mediums/ble_v2:__pkg__", "//core_v2/internal/mediums/webrtc:__pkg__", ], diff --git a/cpp/core_v2/internal/mediums/ble.cc b/cpp/core_v2/internal/mediums/ble.cc index 07ee3ad9..1fb6cc8e 100644 --- a/cpp/core_v2/internal/mediums/ble.cc +++ b/cpp/core_v2/internal/mediums/ble.cc @@ -18,6 +18,12 @@ #include #include +<<<<<<< HEAD +======= +#include "core_v2/internal/mediums/ble_v2/ble_advertisement.h" +#include "core_v2/internal/mediums/utils.h" +#include "platform_v2/base/prng.h" +>>>>>>> release #include "platform_v2/public/logging.h" #include "platform_v2/public/mutex_lock.h" @@ -25,6 +31,18 @@ namespace location { namespace nearby { namespace connections { +<<<<<<< HEAD +======= +ByteArray Ble::GenerateHash(const std::string& source, size_t size) { + return Utils::Sha256Hash(source, size); +} + +ByteArray Ble::GenerateDeviceToken() { + return Utils::Sha256Hash(std::to_string(Prng().NextUint32()), + mediums::BleAdvertisement::kDeviceTokenLength); +} + +>>>>>>> release Ble::Ble(BluetoothRadio& radio) : radio_(radio) {} bool Ble::IsAvailable() const { @@ -77,7 +95,27 @@ bool Ble::StartAdvertising(const std::string& service_id, << ", service id=" << service_id << ", fast advertisement service uuid=" << fast_advertisement_service_uuid; +<<<<<<< HEAD if (!medium_.StartAdvertising(service_id, advertisement_bytes, +======= + + // Wrap the connections advertisement to the medium advertisement. + const bool fast_advertisement = !fast_advertisement_service_uuid.empty(); + ByteArray service_id_hash{GenerateHash( + service_id, mediums::BleAdvertisement::kServiceIdHashLength)}; + ByteArray medium_advertisement_bytes{mediums::BleAdvertisement{ + mediums::BleAdvertisement::Version::kV2, + mediums::BleAdvertisement::SocketVersion::kV2, + fast_advertisement ? ByteArray{} : service_id_hash, advertisement_bytes, + GenerateDeviceToken()}}; + if (medium_advertisement_bytes.Empty()) { + NEARBY_LOGS(INFO) << "Failed to BLE advertise because we could not " + "create a medium advertisement."; + return false; + } + + if (!medium_.StartAdvertising(service_id, medium_advertisement_bytes, +>>>>>>> release fast_advertisement_service_uuid)) { NEARBY_LOGS(INFO) << "Failed to turn on BLE advertising with advertisement bytes=" @@ -124,6 +162,11 @@ bool Ble::StartScanning(const std::string& service_id, DiscoveredPeripheralCallback callback) { MutexLock lock(&mutex_); +<<<<<<< HEAD +======= + discovered_peripheral_callback_ = std::move(callback); + +>>>>>>> release if (service_id.empty()) { NEARBY_LOGS(INFO) << "Refusing to start BLE scanning with empty service id."; @@ -148,8 +191,34 @@ bool Ble::StartScanning(const std::string& service_id, return false; } +<<<<<<< HEAD if (!medium_.StartScanning(service_id, fast_advertisement_service_uuid, callback)) { +======= + if (!medium_.StartScanning( + service_id, fast_advertisement_service_uuid, + { + .peripheral_discovered_cb = + [this](BlePeripheral& peripheral, + const std::string& service_id, + const ByteArray& medium_advertisement_bytes, + bool fast_advertisement) { + // Unwrap connection BleAdvertisement from medium + // BleAdvertisement. + auto connection_advertisement_bytes = + UnwrapAdvertisementBytes(medium_advertisement_bytes); + discovered_peripheral_callback_.peripheral_discovered_cb( + peripheral, service_id, connection_advertisement_bytes, + fast_advertisement); + }, + .peripheral_lost_cb = + [this](BlePeripheral& peripheral, + const std::string& service_id) { + discovered_peripheral_callback_.peripheral_lost_cb( + peripheral, service_id); + }, + })) { +>>>>>>> release NEARBY_LOGS(INFO) << "Failed to start scan of BLE services."; return false; } @@ -286,6 +355,19 @@ BleSocket Ble::Connect(BlePeripheral& peripheral, return socket; } +<<<<<<< HEAD +======= +ByteArray Ble::UnwrapAdvertisementBytes( + const ByteArray& medium_advertisement_data) { + mediums::BleAdvertisement medium_ble_advertisement{medium_advertisement_data}; + if (!medium_ble_advertisement.IsValid()) { + return ByteArray{}; + } + + return medium_ble_advertisement.GetData(); +} + +>>>>>>> release } // namespace connections } // namespace nearby } // namespace location diff --git a/cpp/core_v2/internal/mediums/ble.h b/cpp/core_v2/internal/mediums/ble.h index 7f12ceab..5c38e051 100644 --- a/cpp/core_v2/internal/mediums/ble.h +++ b/cpp/core_v2/internal/mediums/ble.h @@ -102,8 +102,11 @@ class Ble { ABSL_LOCKS_EXCLUDED(mutex_); private: +<<<<<<< HEAD static constexpr int kMaxAdvertisementLength = 512; +======= +>>>>>>> release struct AdvertisingInfo { bool Empty() const { return service_ids.empty(); } void Clear() { service_ids.clear(); } @@ -146,6 +149,14 @@ class Ble { absl::flat_hash_set service_ids; }; +<<<<<<< HEAD +======= + static constexpr int kMaxAdvertisementLength = 512; + + static ByteArray GenerateHash(const std::string& source, size_t size); + static ByteArray GenerateDeviceToken(); + +>>>>>>> release // Same as IsAvailable(), but must be called with mutex_ held. bool IsAvailableLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_); @@ -161,6 +172,13 @@ class Ble { bool IsAcceptingConnectionsLocked(const std::string& service_id) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_); +<<<<<<< HEAD +======= + // Extract connection advertisement from medium advertisement. + ByteArray UnwrapAdvertisementBytes( + const ByteArray& medium_advertisement_data); + +>>>>>>> release mutable Mutex mutex_; BluetoothRadio& radio_ ABSL_GUARDED_BY(mutex_); BluetoothAdapter& adapter_ ABSL_GUARDED_BY(mutex_){ @@ -168,6 +186,10 @@ class Ble { BleMedium medium_ ABSL_GUARDED_BY(mutex_){adapter_}; AdvertisingInfo advertising_info_ ABSL_GUARDED_BY(mutex_); ScanningInfo scanning_info_ ABSL_GUARDED_BY(mutex_); +<<<<<<< HEAD +======= + DiscoveredPeripheralCallback discovered_peripheral_callback_; +>>>>>>> release AcceptingConnectionsInfo accepting_connections_info_ ABSL_GUARDED_BY(mutex_); }; diff --git a/cpp/core_v2/internal/mediums/ble_test.cc b/cpp/core_v2/internal/mediums/ble_test.cc index 277c2451..7b85f41a 100644 --- a/cpp/core_v2/internal/mediums/ble_test.cc +++ b/cpp/core_v2/internal/mediums/ble_test.cc @@ -74,12 +74,20 @@ TEST_F(BleTest, CanStartAdvertising) { CountDownLatch found_latch(1); ble_b.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release DiscoveredPeripheralCallback{ .peripheral_discovered_cb = [&found_latch]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { found_latch.CountDown(); }, }); @@ -109,12 +117,20 @@ TEST_F(BleTest, CanStartDiscovery) { fast_advertisement_service_uuid); EXPECT_TRUE(ble_a.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release DiscoveredPeripheralCallback{ .peripheral_discovered_cb = [&accept_latch]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { accept_latch.CountDown(); }, .peripheral_lost_cb = [&lost_latch](BlePeripheral& peripheral, @@ -154,12 +170,20 @@ TEST_F(BleTest, CanStartAcceptingConnectionsAndConnect) { }); BlePeripheral discovered_peripheral; ble_b.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release { .peripheral_discovered_cb = [&found_latch, &discovered_peripheral]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { discovered_peripheral = peripheral; NEARBY_LOG( diff --git a/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.cc b/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.cc index 86a597c1..e2078af1 100644 --- a/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.cc +++ b/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.cc @@ -30,6 +30,7 @@ BleAdvertisement::BleAdvertisement(Version version, const ByteArray &service_id_hash, const ByteArray &data, const ByteArray &device_token) { +<<<<<<< HEAD DoInitialize(/*fast_advertisement=*/false, version, socket_version, service_id_hash, data, device_token); } @@ -40,6 +41,10 @@ BleAdvertisement::BleAdvertisement(Version version, const ByteArray &device_token) { DoInitialize(/*fast_advertisement=*/true, version, socket_version, {}, data, device_token); +======= + DoInitialize(/*fast_advertisement=*/service_id_hash.Empty(), version, + socket_version, service_id_hash, data, device_token); +>>>>>>> release } void BleAdvertisement::DoInitialize(bool fast_advertisement, Version version, diff --git a/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.h b/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.h index add13b72..d5f19e13 100644 --- a/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.h +++ b/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement.h @@ -61,8 +61,11 @@ class BleAdvertisement { BleAdvertisement(Version version, SocketVersion socket_version, const ByteArray &service_id_hash, const ByteArray &data, const ByteArray &device_token); +<<<<<<< HEAD BleAdvertisement(Version version, SocketVersion socket_version, const ByteArray &data, const ByteArray &device_token); +======= +>>>>>>> release explicit BleAdvertisement(const ByteArray &ble_advertisement_bytes); BleAdvertisement(const BleAdvertisement &) = default; BleAdvertisement &operator=(const BleAdvertisement &) = default; diff --git a/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement_test.cc b/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement_test.cc index 17bed204..ed07c6a8 100644 --- a/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement_test.cc +++ b/cpp/core_v2/internal/mediums/ble_v2/ble_advertisement_test.cc @@ -67,6 +67,10 @@ TEST(BleAdvertisementTest, ConstructionWorksV1ForFastAdvertisement) { BleAdvertisement ble_advertisement{BleAdvertisement::Version::kV1, BleAdvertisement::SocketVersion::kV1, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release fast_data, device_token}; @@ -97,6 +101,10 @@ TEST(BleAdvertisementTest, ConstructionFailsWithBadVersion) { BleAdvertisement fast_ble_advertisement{bad_version, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release data, device_token}; EXPECT_FALSE(fast_ble_advertisement.IsValid()); @@ -119,6 +127,10 @@ TEST(BleAdvertisementTest, ConstructionFailsWithBadSocketVersion) { BleAdvertisement fast_ble_advertisement{kVersion, bad_socket_version, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release data, device_token}; EXPECT_FALSE(fast_ble_advertisement.IsValid()); @@ -174,6 +186,10 @@ TEST(BleAdvertisementTest, ConstructionFailsWithLongData) { BleAdvertisement fast_ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release bad_data, device_token}; EXPECT_FALSE(fast_ble_advertisement.IsValid()); @@ -205,6 +221,10 @@ TEST(BleAdvertisementTest, BleAdvertisement ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release fast_data, ByteArray{}}; @@ -242,12 +262,20 @@ TEST(BleAdvertisementTest, ConstructionFailsWithWrongSizeofDeviceToken) { BleAdvertisement fast_ble_advertisement_1{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release data, bad_device_token_1}; EXPECT_FALSE(fast_ble_advertisement_1.IsValid()); BleAdvertisement fast_ble_advertisement_2{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release data, bad_device_token_2}; EXPECT_FALSE(fast_ble_advertisement_2.IsValid()); @@ -284,6 +312,10 @@ TEST(BleAdvertisementTest, BleAdvertisement org_ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release fast_data, device_token}; @@ -326,6 +358,10 @@ TEST(BleAdvertisementTest, BleAdvertisement org_ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release ByteArray(), device_token}; ByteArray ble_advertisement_bytes{org_ble_advertisement}; @@ -380,6 +416,10 @@ TEST(BleAdvertisementTest, BleAdvertisement org_ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release fast_data, device_token}; ByteArray org_ble_advertisement_bytes{org_ble_advertisement}; @@ -438,6 +478,10 @@ TEST(BleAdvertisementTest, BleAdvertisement org_ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release fast_data, device_token}; ByteArray org_ble_advertisement_bytes{org_ble_advertisement}; @@ -489,6 +533,10 @@ TEST(BleAdvertisementTest, BleAdvertisement org_ble_advertisement{kVersion, kSocketVersion, +<<<<<<< HEAD +======= + ByteArray{}, +>>>>>>> release fast_data, device_token}; ByteArray org_ble_advertisement_bytes{org_ble_advertisement}; diff --git a/cpp/core_v2/internal/mediums/webrtc/connection_flow.cc b/cpp/core_v2/internal/mediums/webrtc/connection_flow.cc index ee1f3adb..3e5c7052 100644 --- a/cpp/core_v2/internal/mediums/webrtc/connection_flow.cc +++ b/cpp/core_v2/internal/mediums/webrtc/connection_flow.cc @@ -245,6 +245,13 @@ bool ConnectionFlow::Close() { bool ConnectionFlow::InitPeerConnection(WebRtcMedium& webrtc_medium) { Future success_future; +<<<<<<< HEAD +======= + // CreatePeerConnection callback may be invoked after ConnectionFlow lifetime + // has ended, in case of a timeout. Future is captured by value, and is safe + // to access, but it is not safe to access ConnectionFlow member variables + // unless the Future::Set() returns true. +>>>>>>> release webrtc_medium.CreatePeerConnection( &peer_connection_observer_, [this, success_future](rtc::scoped_refptr @@ -254,6 +261,14 @@ bool ConnectionFlow::InitPeerConnection(WebRtcMedium& webrtc_medium) { return; } +<<<<<<< HEAD +======= + // If this fails, means we have already assigned something to + // success_future; it is either: + // 1) this is the 2nd call of this callback (and this is a bug), or + // 2) Get(timeout) has set the future value as exception already. + if (success_future.IsSet()) return; +>>>>>>> release peer_connection_ = peer_connection; success_future.Set(true); }); diff --git a/cpp/core_v2/internal/offline_frames.cc b/cpp/core_v2/internal/offline_frames.cc index 91dd60bc..4ee25f5f 100644 --- a/cpp/core_v2/internal/offline_frames.cc +++ b/cpp/core_v2/internal/offline_frames.cc @@ -18,6 +18,10 @@ #include #include "core/internal/message_lite.h" +<<<<<<< HEAD +======= +#include "core_v2/status.h" +>>>>>>> release #include "proto/connections/offline_wire_formats.pb.h" #include "platform_v2/base/byte_array.h" @@ -85,7 +89,18 @@ ByteArray ForConnectionResponse(std::int32_t status) { auto* v1_frame = frame.mutable_v1(); v1_frame->set_type(V1Frame::CONNECTION_RESPONSE); auto* sub_frame = v1_frame->mutable_connection_response(); +<<<<<<< HEAD sub_frame->set_status(status); +======= + + // For backward compatiblility, here still sets both status and response + // parameters until the response feature is roll out in all supported + // devices. + sub_frame->set_status(status); + sub_frame->set_response(status == Status::kSuccess + ? ConnectionResponseFrame::ACCEPT + : ConnectionResponseFrame::REJECT); +>>>>>>> release return ToBytes(std::move(frame)); } diff --git a/cpp/core_v2/internal/offline_frames_test.cc b/cpp/core_v2/internal/offline_frames_test.cc index 2cee9b63..0cfd4647 100644 --- a/cpp/core_v2/internal/offline_frames_test.cc +++ b/cpp/core_v2/internal/offline_frames_test.cc @@ -107,7 +107,14 @@ TEST(OfflineFramesTest, CanGenerateConnectionResponse) { version: V1 v1: < type: CONNECTION_RESPONSE +<<<<<<< HEAD connection_response: < status: 1 > +======= + connection_response: < + status: 1 + response: REJECT + > +>>>>>>> release >)pb"; ByteArray bytes = ForConnectionResponse(1); auto response = FromBytes(bytes); diff --git a/cpp/core_v2/internal/p2p_cluster_pcp_handler.cc b/cpp/core_v2/internal/p2p_cluster_pcp_handler.cc index e98d9220..2755fee8 100644 --- a/cpp/core_v2/internal/p2p_cluster_pcp_handler.cc +++ b/cpp/core_v2/internal/p2p_cluster_pcp_handler.cc @@ -328,9 +328,16 @@ bool P2pClusterPcpHandler::IsRecognizedBleEndpoint( void P2pClusterPcpHandler::BlePeripheralDiscoveredHandler( ClientProxy* client, BlePeripheral& peripheral, +<<<<<<< HEAD const std::string& service_id, bool fast_advertisement) { RunOnPcpHandlerThread([this, client, &peripheral, service_id, fast_advertisement]() { +======= + const std::string& service_id, const ByteArray& advertisement_bytes, + bool fast_advertisement) { + RunOnPcpHandlerThread([this, client, &peripheral, service_id, + advertisement_bytes, fast_advertisement]() { +>>>>>>> release // Make sure we are still discovering before proceeding. if (!client->IsDiscovering()) { NEARBY_LOG(INFO, @@ -341,8 +348,12 @@ void P2pClusterPcpHandler::BlePeripheralDiscoveredHandler( } // Parse the BLE advertisement bytes. +<<<<<<< HEAD BleAdvertisement advertisement( fast_advertisement, peripheral.GetAdvertisementBytes(service_id)); +======= + BleAdvertisement advertisement(fast_advertisement, advertisement_bytes); +>>>>>>> release // Make sure the BLE advertisement points to a valid // endpoint we're discovering. @@ -582,6 +593,12 @@ BasePcpHandler::StartOperationResult P2pClusterPcpHandler::StartDiscoveryImpl( .device_discovered_cb = absl::bind_front( &P2pClusterPcpHandler::BluetoothDeviceDiscoveredHandler, this, client, service_id), +<<<<<<< HEAD +======= + .device_name_changed_cb = absl::bind_front( + &P2pClusterPcpHandler::BluetoothDeviceDiscoveredHandler, this, + client, service_id), +>>>>>>> release .device_lost_cb = absl::bind_front( &P2pClusterPcpHandler::BluetoothDeviceLostHandler, this, client, service_id), @@ -728,9 +745,17 @@ proto::connections::Medium P2pClusterPcpHandler::StartBluetoothAdvertising( absl::BytesToHexString(service_id_hash.data()).c_str(), absl::BytesToHexString(local_endpoint_info.data()).c_str()); // Generate a BluetoothDeviceName with which to become Bluetooth discoverable. +<<<<<<< HEAD std::string device_name(BluetoothDeviceName( kBluetoothDeviceNameVersion, GetPcp(), local_endpoint_id, service_id_hash, local_endpoint_info)); +======= + // TODO(b/169550050): Implement UWBAddress. + // TODO(b/169303359): Implement WebRtcState. + std::string device_name(BluetoothDeviceName( + kBluetoothDeviceNameVersion, GetPcp(), local_endpoint_id, service_id_hash, + local_endpoint_info, ByteArray{}, WebRtcState::kUnconnectable)); +>>>>>>> release if (device_name.empty()) { NEARBY_LOG(INFO, "P2pClusterPcpHandler::StartBluetoothAdvertising: generate " @@ -901,10 +926,18 @@ proto::connections::Medium P2pClusterPcpHandler::StartBleAdvertising( // Generate a BleAdvertisement. If a fast advertisement service UUID was // provided, create a fast BleAdvertisement. ByteArray advertisement_bytes; +<<<<<<< HEAD if (fast_advertisement) { advertisement_bytes = ByteArray(BleAdvertisement(kBleAdvertisementVersion, GetPcp(), local_endpoint_id, local_endpoint_info)); +======= + // TODO(b/169550050): Implement UWBAddress. + if (fast_advertisement) { + advertisement_bytes = ByteArray( + BleAdvertisement(kBleAdvertisementVersion, GetPcp(), local_endpoint_id, + local_endpoint_info, ByteArray{})); +>>>>>>> release } else { const ByteArray service_id_hash = GenerateHash(service_id, BleAdvertisement::kServiceIdHashLength); @@ -913,9 +946,17 @@ proto::connections::Medium P2pClusterPcpHandler::StartBleAdvertising( ShouldAdvertiseBluetoothMacOverBle(power_level)) bluetooth_mac_address = bluetooth_medium_.GetMacAddress(); +<<<<<<< HEAD advertisement_bytes = ByteArray(BleAdvertisement( kBleAdvertisementVersion, GetPcp(), service_id_hash, local_endpoint_id, local_endpoint_info, bluetooth_mac_address)); +======= + // TODO(b/169303359): Implement WebRtcState. + advertisement_bytes = ByteArray(BleAdvertisement( + kBleAdvertisementVersion, GetPcp(), service_id_hash, local_endpoint_id, + local_endpoint_info, bluetooth_mac_address, ByteArray{}, + WebRtcState::kUnconnectable)); +>>>>>>> release } if (advertisement_bytes.Empty()) { NEARBY_LOG(INFO, @@ -1036,9 +1077,17 @@ proto::connections::Medium P2pClusterPcpHandler::StartWifiLanAdvertising( absl::BytesToHexString(service_id_hash.data()).c_str(), absl::BytesToHexString(local_endpoint_info.data()).c_str()); // Generate a WifiLanServiceInfo with which to become WifiLan discoverable. +<<<<<<< HEAD std::string service_info_name(WifiLanServiceInfo( kWifiLanServiceInfoVersion, GetPcp(), local_endpoint_id, service_id_hash, local_endpoint_info)); +======= + // TODO(b/169550050): Implement UWBAddress. + // TODO(b/169303359): Implement WebRtcState. + std::string service_info_name(WifiLanServiceInfo( + kWifiLanServiceInfoVersion, GetPcp(), local_endpoint_id, service_id_hash, + local_endpoint_info, ByteArray{}, WebRtcState::kUnconnectable)); +>>>>>>> release if (service_info_name.empty()) { NEARBY_LOG(INFO, "P2pClusterPcpHandler::StartWifiLanAdvertising: generate " diff --git a/cpp/core_v2/internal/p2p_cluster_pcp_handler.h b/cpp/core_v2/internal/p2p_cluster_pcp_handler.h index 680f79f1..00d98ce1 100644 --- a/cpp/core_v2/internal/p2p_cluster_pcp_handler.h +++ b/cpp/core_v2/internal/p2p_cluster_pcp_handler.h @@ -165,6 +165,10 @@ class P2pClusterPcpHandler : public BasePcpHandler { void BlePeripheralDiscoveredHandler(ClientProxy* client, BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement); void BlePeripheralLostHandler(ClientProxy* client, BlePeripheral& peripheral, const std::string& service_id); diff --git a/cpp/core_v2/internal/wifi_lan_service_info.cc b/cpp/core_v2/internal/wifi_lan_service_info.cc index 2eeb9f5b..71f0988e 100644 --- a/cpp/core_v2/internal/wifi_lan_service_info.cc +++ b/cpp/core_v2/internal/wifi_lan_service_info.cc @@ -31,7 +31,13 @@ namespace connections { WifiLanServiceInfo::WifiLanServiceInfo(Version version, Pcp pcp, absl::string_view endpoint_id, const ByteArray& service_id_hash, +<<<<<<< HEAD const ByteArray& endpoint_info) { +======= + const ByteArray& endpoint_info, + const ByteArray& uwb_address, + WebRtcState web_rtc_state) { +>>>>>>> release if (version != Version::kV1 || endpoint_id.empty() || endpoint_id.length() != kEndpointIdLength || service_id_hash.size() != kServiceIdHashLength) { @@ -51,6 +57,11 @@ WifiLanServiceInfo::WifiLanServiceInfo(Version version, Pcp pcp, service_id_hash_ = service_id_hash; endpoint_id_ = std::string(endpoint_id); endpoint_info_ = endpoint_info; +<<<<<<< HEAD +======= + uwb_address_ = uwb_address; + web_rtc_state_ = web_rtc_state; +>>>>>>> release } WifiLanServiceInfo::WifiLanServiceInfo(absl::string_view service_info_string) { @@ -64,6 +75,7 @@ WifiLanServiceInfo::WifiLanServiceInfo(absl::string_view service_info_string) { return; } +<<<<<<< HEAD if (service_info_bytes.size() > kMaxLanServiceNameLength) { NEARBY_LOG(INFO, "Cannot deserialize WifiLanServiceInfo: expecting max %d raw " @@ -72,6 +84,8 @@ WifiLanServiceInfo::WifiLanServiceInfo(absl::string_view service_info_string) { return; } +======= +>>>>>>> release if (service_info_bytes.size() < kMinLanServiceNameLength) { NEARBY_LOG(INFO, "Cannot deserialize WifiLanServiceInfo: expecting min %d raw " @@ -119,6 +133,23 @@ WifiLanServiceInfo::WifiLanServiceInfo(absl::string_view service_info_string) { // The next 3 bytes are supposed to be the service_id_hash. service_id_hash_ = base_input_stream.ReadBytes(kServiceIdHashLength); +<<<<<<< HEAD +======= + // The next 1 byte are supposed to be the length of the UWB address. + std::uint32_t expected_uwb_address_length = base_input_stream.ReadUint8(); + + // The next bytes are supposed to be UWB address if length is not zero. + if (expected_uwb_address_length != 0) { + uwb_address_ = base_input_stream.ReadBytes(expected_uwb_address_length); + } + + // The next 1 byte is extra field. + auto extra_field = static_cast(base_input_stream.ReadUint8()); + web_rtc_state_ = (extra_field & kWebRtcConnectableFlagBitmask) == 1 + ? WebRtcState::kConnectable + : WebRtcState::kUnconnectable; + +>>>>>>> release // The next 1 byte are supposed to be the length of the endpoint_info. std::uint32_t expected_endpoint_info_length = base_input_stream.ReadUint8(); @@ -149,6 +180,15 @@ WifiLanServiceInfo::operator std::string() const { version_and_pcp_byte |= static_cast(static_cast(pcp_) & kPcpBitmask); +<<<<<<< HEAD +======= + // A byte contains WebRtcState state. + int web_rtc_connectable_flag = + (web_rtc_state_ == WebRtcState::kConnectable) ? 1 : 0; + char field_byte = static_cast(web_rtc_connectable_flag) & + kWebRtcConnectableFlagBitmask; + +>>>>>>> release ByteArray usable_endpoint_info(endpoint_info_); if (endpoint_info_.size() > kMaxEndpointInfoLength) { NEARBY_LOG( @@ -160,6 +200,7 @@ WifiLanServiceInfo::operator std::string() const { usable_endpoint_info.SetData(endpoint_info_.data(), kMaxEndpointInfoLength); } +<<<<<<< HEAD // clang-format off std::string out = absl::StrCat(std::string(1, version_and_pcp_byte), endpoint_id_, @@ -167,6 +208,31 @@ WifiLanServiceInfo::operator std::string() const { std::string(1, usable_endpoint_info.size()), std::string(usable_endpoint_info)); // clang-format on +======= + std::string out; + if (!uwb_address_.Empty()) { + // clang-format off + out = absl::StrCat(std::string(1, version_and_pcp_byte), + endpoint_id_, + std::string(service_id_hash_), + std::string(1, uwb_address_.size()), + std::string(uwb_address_), + std::string(1, field_byte), + std::string(1, usable_endpoint_info.size()), + std::string(usable_endpoint_info)); + // clang-format on + } else { + // clang-format off + out = absl::StrCat(std::string(1, version_and_pcp_byte), + endpoint_id_, + std::string(service_id_hash_), + std::string(1, uwb_address_.size()), + std::string(1, field_byte), + std::string(1, usable_endpoint_info.size()), + std::string(usable_endpoint_info)); + // clang-format on + } +>>>>>>> release return Base64Utils::Encode(ByteArray{std::move(out)}); } diff --git a/cpp/core_v2/internal/wifi_lan_service_info.h b/cpp/core_v2/internal/wifi_lan_service_info.h index 36e0955c..c49950fa 100644 --- a/cpp/core_v2/internal/wifi_lan_service_info.h +++ b/cpp/core_v2/internal/wifi_lan_service_info.h @@ -17,6 +17,10 @@ #include +<<<<<<< HEAD +======= +#include "core_v2/internal/base_pcp_handler.h" +>>>>>>> release #include "core_v2/internal/pcp.h" #include "platform_v2/base/byte_array.h" #include "absl/strings/string_view.h" @@ -42,7 +46,13 @@ class WifiLanServiceInfo { WifiLanServiceInfo() = default; WifiLanServiceInfo(Version version, Pcp pcp, absl::string_view endpoint_id, const ByteArray& service_id_hash, +<<<<<<< HEAD const ByteArray& endpoint_info); +======= + const ByteArray& endpoint_info, + const ByteArray& uwb_address, + WebRtcState web_rtc_state); +>>>>>>> release explicit WifiLanServiceInfo(absl::string_view service_info_string); WifiLanServiceInfo(const WifiLanServiceInfo&) = default; WifiLanServiceInfo& operator=(const WifiLanServiceInfo&) = default; @@ -58,6 +68,7 @@ class WifiLanServiceInfo { std::string GetEndpointId() const { return endpoint_id_; } ByteArray GetEndpointInfo() const { return endpoint_info_; } ByteArray GetServiceIdHash() const { return service_id_hash_; } +<<<<<<< HEAD private: // The maximum length of encrypted WifiLanServiceInfo string. @@ -68,10 +79,21 @@ class WifiLanServiceInfo { static constexpr int kEndpointIdLength = 4; // The maximum length for endpoint id in encrypted WifiLanServiceInfo string. static constexpr int kMaxEndpointInfoLength = 131; +======= + ByteArray GetUwbAddress() const { return uwb_address_; } + WebRtcState GetWebRtcState() const { return web_rtc_state_; } + + private: + static constexpr int kMinLanServiceNameLength = 9; + static constexpr int kEndpointIdLength = 4; + static constexpr int kMaxEndpointInfoLength = 131; + static constexpr int kUwbAddressLengthSize = 1; +>>>>>>> release static constexpr int kVersionBitmask = 0x0E0; static constexpr int kPcpBitmask = 0x01F; static constexpr int kVersionShift = 5; +<<<<<<< HEAD // WifiLanServiceInfo version. Version version_ = Version::kUndefined; @@ -83,6 +105,18 @@ class WifiLanServiceInfo { ByteArray service_id_hash_; // Connected endpoint info. ByteArray endpoint_info_; +======= + static constexpr int kWebRtcConnectableFlagBitmask = 0x01; + + Version version_{Version::kUndefined}; + Pcp pcp_{Pcp::kUnknown}; + std::string endpoint_id_; + ByteArray service_id_hash_; + ByteArray endpoint_info_; + // TODO(b/169550050): Define UWB address field. + ByteArray uwb_address_; + WebRtcState web_rtc_state_{WebRtcState::kUndefined}; +>>>>>>> release }; } // namespace connections diff --git a/cpp/core_v2/internal/wifi_lan_service_info_test.cc b/cpp/core_v2/internal/wifi_lan_service_info_test.cc index 9cad9aa3..a20c837b 100644 --- a/cpp/core_v2/internal/wifi_lan_service_info_test.cc +++ b/cpp/core_v2/internal/wifi_lan_service_info_test.cc @@ -31,12 +31,28 @@ constexpr Pcp kPcp = Pcp::kP2pCluster; constexpr absl::string_view kEndPointID{"AB12"}; constexpr absl::string_view kServiceIDHashBytes{"\x0a\x0b\x0c"}; constexpr absl::string_view kEndPointName{"RAWK + ROWL!"}; +<<<<<<< HEAD TEST(WifiLanServiceInfoTest, ConstructionWorks) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; WifiLanServiceInfo wifi_lan_service_info{ kVersion, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= +constexpr WebRtcState kWebRtcState = WebRtcState::kConnectable; + +// TODO(b/169550050): Implement UWBAddress. +TEST(WifiLanServiceInfoTest, ConstructionWorks) { + ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; + ByteArray endpoint_info{std::string(kEndPointName)}; + WifiLanServiceInfo wifi_lan_service_info{kVersion, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_TRUE(wifi_lan_service_info.IsValid()); EXPECT_EQ(kPcp, wifi_lan_service_info.GetPcp()); @@ -49,8 +65,18 @@ TEST(WifiLanServiceInfoTest, ConstructionWorks) { TEST(WifiLanServiceInfoTest, ConstructionFromSerializedStringWorks) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo org_wifi_lan_service_info{kVersion, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo org_wifi_lan_service_info{kVersion, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release std::string wifi_lan_service_info_string{org_wifi_lan_service_info}; WifiLanServiceInfo wifi_lan_service_info{wifi_lan_service_info_string}; @@ -61,6 +87,10 @@ TEST(WifiLanServiceInfoTest, ConstructionFromSerializedStringWorks) { EXPECT_EQ(kEndPointID, wifi_lan_service_info.GetEndpointId()); EXPECT_EQ(service_id_hash, wifi_lan_service_info.GetServiceIdHash()); EXPECT_EQ(endpoint_info, wifi_lan_service_info.GetEndpointInfo()); +<<<<<<< HEAD +======= + EXPECT_EQ(kWebRtcState, wifi_lan_service_info.GetWebRtcState()); +>>>>>>> release } TEST(WifiLanServiceInfoTest, ConstructionFailsWithBadVersion) { @@ -68,8 +98,18 @@ TEST(WifiLanServiceInfoTest, ConstructionFailsWithBadVersion) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo wifi_lan_service_info{bad_version, kPcp, kEndPointID, service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo wifi_lan_service_info{bad_version, + kPcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(wifi_lan_service_info.IsValid()); } @@ -79,8 +119,18 @@ TEST(WifiLanServiceInfoTest, ConstructionFailsWithBadPCP) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo wifi_lan_service_info{kVersion, bad_pcp, kEndPointID, service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo wifi_lan_service_info{kVersion, + bad_pcp, + kEndPointID, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(wifi_lan_service_info.IsValid()); } @@ -90,8 +140,18 @@ TEST(WifiLanServiceInfoTest, ConstructionFailsWithShortEndpointId) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo wifi_lan_service_info{kVersion, kPcp, short_endpoint_id, service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo wifi_lan_service_info{kVersion, + kPcp, + short_endpoint_id, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(wifi_lan_service_info.IsValid()); } @@ -101,8 +161,18 @@ TEST(WifiLanServiceInfoTest, ConstructionFailsWithLongEndpointId) { ByteArray service_id_hash{std::string(kServiceIDHashBytes)}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo wifi_lan_service_info{kVersion, kPcp, long_endpoint_id, service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo wifi_lan_service_info{kVersion, + kPcp, + long_endpoint_id, + service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(wifi_lan_service_info.IsValid()); } @@ -112,8 +182,18 @@ TEST(WifiLanServiceInfoTest, ConstructionFailsWithShortServiceIdHash) { ByteArray short_service_id_hash{short_service_id_hash_bytes}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo wifi_lan_service_info{ kVersion, kPcp, kEndPointID, short_service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo wifi_lan_service_info{kVersion, + kPcp, + kEndPointID, + short_service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(wifi_lan_service_info.IsValid()); } @@ -123,8 +203,18 @@ TEST(WifiLanServiceInfoTest, ConstructionFailsWithLongServiceIdHash) { ByteArray long_service_id_hash{long_service_id_hash_bytes}; ByteArray endpoint_info{std::string(kEndPointName)}; +<<<<<<< HEAD WifiLanServiceInfo wifi_lan_service_info{kVersion, kPcp, kEndPointID, long_service_id_hash, endpoint_info}; +======= + WifiLanServiceInfo wifi_lan_service_info{kVersion, + kPcp, + kEndPointID, + long_service_id_hash, + endpoint_info, + ByteArray{}, + kWebRtcState}; +>>>>>>> release EXPECT_FALSE(wifi_lan_service_info.IsValid()); } diff --git a/cpp/platform_v2/public/ble.cc b/cpp/platform_v2/public/ble.cc index c4ff0532..c163c0ad 100644 --- a/cpp/platform_v2/public/ble.cc +++ b/cpp/platform_v2/public/ble.cc @@ -65,7 +65,13 @@ bool BleMedium::StartScanning( &context.peripheral, &peripheral, peripheral.GetName().c_str()); discovered_peripheral_callback_.peripheral_discovered_cb( +<<<<<<< HEAD context.peripheral, service_id, fast_advertisement); +======= + context.peripheral, service_id, + context.peripheral.GetAdvertisementBytes(service_id), + fast_advertisement); +>>>>>>> release } }, .peripheral_lost_cb = diff --git a/cpp/platform_v2/public/ble.h b/cpp/platform_v2/public/ble.h index 2d25e6de..cdc65b3c 100644 --- a/cpp/platform_v2/public/ble.h +++ b/cpp/platform_v2/public/ble.h @@ -85,11 +85,20 @@ class BleMedium final { public: using Platform = api::ImplementationPlatform; struct DiscoveredPeripheralCallback { +<<<<<<< HEAD std::function peripheral_discovered_cb = DefaultCallback(); +======= + std::function + peripheral_discovered_cb = + DefaultCallback(); +>>>>>>> release std::function peripheral_lost_cb = diff --git a/cpp/platform_v2/public/ble_test.cc b/cpp/platform_v2/public/ble_test.cc index e58cd07e..eb9c74ba 100644 --- a/cpp/platform_v2/public/ble_test.cc +++ b/cpp/platform_v2/public/ble_test.cc @@ -72,12 +72,20 @@ TEST_F(BleMediumTest, CanStartAdvertising) { fast_advertisement_service_uuid); EXPECT_TRUE(ble_b.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release DiscoveredPeripheralCallback{ .peripheral_discovered_cb = [&found_latch]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { found_latch.CountDown(); }, })); EXPECT_TRUE(found_latch.Await(kWaitDuration).result()); @@ -99,12 +107,20 @@ TEST_F(BleMediumTest, CanStartScanning) { CountDownLatch lost_latch(1); ble_a.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release DiscoveredPeripheralCallback{ .peripheral_discovered_cb = [&found_latch]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { found_latch.CountDown(); }, .peripheral_lost_cb = [&lost_latch](BlePeripheral& peripheral, @@ -134,12 +150,20 @@ TEST_F(BleMediumTest, CanStopDiscovery) { CountDownLatch lost_latch(1); ble_a.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release DiscoveredPeripheralCallback{ .peripheral_discovered_cb = [&found_latch]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { found_latch.CountDown(); }, .peripheral_lost_cb = [&lost_latch](BlePeripheral& peripheral, @@ -170,12 +194,20 @@ TEST_F(BleMediumTest, CanStartAcceptingConnectionsAndConnect) { BlePeripheral* discovered_peripheral = nullptr; ble_a.StartScanning( +<<<<<<< HEAD service_id, fast_advertisement_service_uuid, +======= + service_id, fast_advertisement_service_uuid, +>>>>>>> release DiscoveredPeripheralCallback{ .peripheral_discovered_cb = [&found_latch, &discovered_peripheral]( BlePeripheral& peripheral, const std::string& service_id, +<<<<<<< HEAD +======= + const ByteArray& advertisement_bytes, +>>>>>>> release bool fast_advertisement) { NEARBY_LOG( INFO, diff --git a/cpp/platform_v2/public/future.h b/cpp/platform_v2/public/future.h index 21994ef7..c2625765 100644 --- a/cpp/platform_v2/public/future.h +++ b/cpp/platform_v2/public/future.h @@ -34,6 +34,12 @@ class Future final { void AddListener(Runnable runnable, api::Executor* executor) { impl_->AddListener(std::move(runnable), executor); } +<<<<<<< HEAD +======= + bool IsSet() const { + return impl_->IsSet(); + } +>>>>>>> release private: // Instance of future implementation is wrapped in shared_ptr<> to make diff --git a/cpp/platform_v2/public/settable_future.h b/cpp/platform_v2/public/settable_future.h index 20d96d4a..b0cf1b79 100644 --- a/cpp/platform_v2/public/settable_future.h +++ b/cpp/platform_v2/public/settable_future.h @@ -39,8 +39,14 @@ class SettableFuture : public api::SettableFuture { exception_ = {Exception::kSuccess}; completed_.Notify(); InvokeAllLocked(); +<<<<<<< HEAD } return true; +======= + return true; + } + return false; +>>>>>>> release } void AddListener(Runnable runnable, api::Executor* executor) override { @@ -52,6 +58,14 @@ class SettableFuture : public api::SettableFuture { } } +<<<<<<< HEAD +======= + bool IsSet() const { + MutexLock lock(&mutex_); + return done_; + } + +>>>>>>> release bool SetException(Exception exception) override { MutexLock lock(&mutex_); return SetExceptionLocked(exception); @@ -108,7 +122,11 @@ class SettableFuture : public api::SettableFuture { listeners_.clear(); } +<<<<<<< HEAD Mutex mutex_; +======= + mutable Mutex mutex_; +>>>>>>> release ConditionVariable completed_{&mutex_}; std::vector>> listeners_; bool done_{false};