TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-14 22:56:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Roll forward to cl/321106672

Browse Source 
Signed-off-by: Alexey Polyudov <apolyudov@google.com>
Change-Id: Iabb20e9c7f7487268fa3ebbbeb58540092e10e0e
This commit is contained in:
Alexey Polyudov
2020-07-15 11:16:39 -07:00
parent 999cdd9903
commit 6f9228fa6b
26 changed files with 477 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpp/core_v2/internal/BUILD
-1
View File
@@ -141,7 +141,6 @@ cc_test(
"//testing/base/public:gunit",
"//testing/base/public:gunit_main",
"//absl/container:flat_hash_set",
"//absl/functional:bind_front",
"//absl/strings",
"//absl/synchronization",
"//absl/time",
cpp/core_v2/internal/base_pcp_handler.cc
+33 -3
View File
@@ -288,6 +288,7 @@ Status BasePcpHandler::RequestConnection(ClientProxy* client,
return;
}
std::vector<DiscoveredEndpoint*> endpoints;
auto endpoint = GetDiscoveredEndpoint(endpoint_id);
if (endpoint == nullptr) {
NEARBY_LOG(INFO, "Discovered endpoint not found: id=%s",
@@ -296,9 +297,31 @@ Status BasePcpHandler::RequestConnection(ClientProxy* client,
return;
}
auto connect_impl_result = ConnectImpl(client, endpoint);
std::unique_ptr<EndpointChannel> channel =
std::move(connect_impl_result.endpoint_channel);
auto webrtc_endpoint = absl::make_unique<WebRtcEndpoint>(
DiscoveredEndpoint{endpoint->endpoint_id, endpoint->endpoint_name,
endpoint->service_id,
proto::connections::Medium::WEB_RTC},
CreatePeerIdFromAdvertisement(endpoint->service_id,
endpoint->endpoint_id,
endpoint->endpoint_name));
endpoints.push_back(endpoint);
endpoints.push_back(webrtc_endpoint.get());
std::sort(endpoints.begin(), endpoints.end(),
[this](DiscoveredEndpoint* a, DiscoveredEndpoint* b) -> bool {
return IsPreferred(*a, *b);
});
std::unique_ptr<EndpointChannel> channel;
ConnectImplResult connect_impl_result;
for (auto connect_endpoint : endpoints) {
connect_impl_result = ConnectImpl(client, connect_endpoint);
if (connect_impl_result.status.Ok()) {
channel = std::move(connect_impl_result.endpoint_channel);
break;
}
}
if (channel == nullptr) {
NEARBY_LOG(INFO, "Endpoint channel not available: id=%s",
@@ -1054,6 +1077,13 @@ void BasePcpHandler::PendingConnectionInfo::LocalEndpointRejectedConnection(
client->LocalEndpointRejectedConnection(endpoint_id);
}
mediums::PeerId BasePcpHandler::CreatePeerIdFromAdvertisement(
const std::string& service_id, const std::string& endpoint_id,
const std::string& endpoint_name) {
std::string seed = absl::StrCat(service_id, endpoint_id, endpoint_name);
return mediums::PeerId::FromSeed(ByteArray(std::move(seed)));
}
} // namespace connections
} // namespace nearby
} // namespace location
cpp/core_v2/internal/base_pcp_handler.h
+13
View File
@@ -10,6 +10,7 @@
#include "core_v2/internal/encryption_runner.h"
#include "core_v2/internal/endpoint_channel_manager.h"
#include "core_v2/internal/endpoint_manager.h"
#include "core_v2/internal/mediums/webrtc.h"
#include "core_v2/internal/pcp.h"
#include "core_v2/internal/pcp_handler.h"
#include "core_v2/listeners.h"
@@ -181,6 +182,14 @@ class BasePcpHandler : public PcpHandler,
proto::connections::Medium medium;
};
struct WebRtcEndpoint : public DiscoveredEndpoint {
WebRtcEndpoint(DiscoveredEndpoint endpoint, mediums::PeerId peer_id)
: DiscoveredEndpoint(std::move(endpoint)),
peer_id(std::move(peer_id)) {}
mediums::PeerId peer_id;
};
struct ConnectImplResult {
proto::connections::Medium medium =
proto::connections::Medium::UNKNOWN_MEDIUM;
@@ -235,6 +244,10 @@ class BasePcpHandler : public PcpHandler,
GetConnectionMediumsByPriority() = 0;
virtual proto::connections::Medium GetDefaultUpgradeMedium() = 0;
mediums::PeerId CreatePeerIdFromAdvertisement(const string& service_id,
const string& endpoint_id,
const string& endpoint_name);
EndpointManager* endpoint_manager_;
EndpointChannelManager* channel_manager_;
cpp/core_v2/internal/base_pcp_handler_test.cc
+6 -2
View File
@@ -93,11 +93,15 @@ class MockPcpHandler : public BasePcpHandler {
MOCK_METHOD(Status, StopDiscoveryImpl, (ClientProxy * client), (override));
MOCK_METHOD(ConnectImplResult, ConnectImpl,
(ClientProxy * client, DiscoveredEndpoint* endpoint), (override));
MOCK_METHOD(std::vector<proto::connections::Medium>,
GetConnectionMediumsByPriority, (), (override));
MOCK_METHOD(proto::connections::Medium, GetDefaultUpgradeMedium, (),
(override));
std::vector<proto::connections::Medium> GetConnectionMediumsByPriority()
override {
return {proto::connections::Medium::BLE,
proto::connections::Medium::WEB_RTC};
}
// Mock adapters for protected non-virtual methods of a base class.
void OnEndpointFound(ClientProxy* client,
std::shared_ptr<DiscoveredEndpoint> endpoint) {
cpp/core_v2/internal/endpoint_manager.cc
+1 -1
View File
@@ -227,7 +227,7 @@ EndpointManager::~EndpointManager() {
NEARBY_LOG(INFO, "EndpointManager is down");
}
const EndpointManager::FrameProcessor::Handle
EndpointManager::FrameProcessor::Handle
EndpointManager::RegisterFrameProcessor(
V1Frame::FrameType frame_type, EndpointManager::FrameProcessor* processor) {
const FrameProcessor::Handle handle = processor;
cpp/core_v2/internal/endpoint_manager.h
+1 -1
View File
@@ -81,7 +81,7 @@ class EndpointManager {
// FrameProcessor* instances are of dynamic duration and survive all sessions.
// returns unique handle to be used for unregistering.
// Blocks until registration is complete.
const FrameProcessor::Handle RegisterFrameProcessor(
FrameProcessor::Handle RegisterFrameProcessor(
V1Frame::FrameType frame_type, FrameProcessor* processor);
void UnregisterFrameProcessor(V1Frame::FrameType frame_type,
const void* handle, bool sync = false);
cpp/core_v2/internal/mediums/webrtc/BUILD
+1
View File
@@ -49,6 +49,7 @@ cc_test(
deps = [
":webrtc",
"//platform_v2/base",
"//platform_v2/base:test_util",
"//platform_v2/impl/g3", # buildcleaner: keep
"//platform_v2/public:comm",
"//platform_v2/public:types",
cpp/core_v2/internal/mediums/webrtc/connection_flow_test.cc
+15 -6
View File
@@ -5,6 +5,7 @@
#include "core_v2/internal/mediums/webrtc/session_description_wrapper.h"
#include "platform_v2/base/byte_array.h"
#include "platform_v2/base/medium_environment.h"
#include "platform_v2/public/webrtc.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -20,6 +21,14 @@ namespace connections {
namespace mediums {
namespace {
class ConnectionFlowTest : public ::testing::Test {
protected:
ConnectionFlowTest() {
MediumEnvironment::Instance().Stop();
MediumEnvironment::Instance().Start({.webrtc_enabled = true});
}
};
std::unique_ptr<webrtc::IceCandidateInterface> CopyCandidate(
const webrtc::IceCandidateInterface* candidate) {
return webrtc::CreateIceCandidate(candidate->sdp_mid(),
@@ -29,7 +38,7 @@ std::unique_ptr<webrtc::IceCandidateInterface> CopyCandidate(
// TODO(bfranz) - Add test that deterministically sends answerer_ice_candidates
// before answer is sent.
TEST(ConnectionFlowTest, SuccessfulOfferAnswerFlow) {
TEST_F(ConnectionFlowTest, SuccessfulOfferAnswerFlow) {
WebRtcMedium webrtc_medium_offerer, webrtc_medium_answerer;
Future<ByteArray> message_received_future;
@@ -95,7 +104,7 @@ TEST(ConnectionFlowTest, SuccessfulOfferAnswerFlow) {
EXPECT_EQ(received_message.result(), ByteArray{message});
}
TEST(ConnectionFlowTest, CreateAnswerBeforeOfferReceived) {
TEST_F(ConnectionFlowTest, CreateAnswerBeforeOfferReceived) {
WebRtcMedium webrtc_medium;
std::unique_ptr<ConnectionFlow> answerer = ConnectionFlow::Create(
@@ -106,7 +115,7 @@ TEST(ConnectionFlowTest, CreateAnswerBeforeOfferReceived) {
EXPECT_FALSE(answer.IsValid());
}
TEST(ConnectionFlowTest, SetAnswerBeforeOffer) {
TEST_F(ConnectionFlowTest, SetAnswerBeforeOffer) {
WebRtcMedium webrtc_medium_offerer, webrtc_medium_answerer;
std::unique_ptr<ConnectionFlow> offerer =
@@ -128,7 +137,7 @@ TEST(ConnectionFlowTest, SetAnswerBeforeOffer) {
EXPECT_FALSE(offerer->OnAnswerReceived(answer));
}
TEST(ConnectionFlowTest, CannotCreateOfferAfterClose) {
TEST_F(ConnectionFlowTest, CannotCreateOfferAfterClose) {
WebRtcMedium webrtc_medium;
std::unique_ptr<ConnectionFlow> offerer = ConnectionFlow::Create(
@@ -140,7 +149,7 @@ TEST(ConnectionFlowTest, CannotCreateOfferAfterClose) {
EXPECT_FALSE(offerer->CreateOffer().IsValid());
}
TEST(ConnectionFlowTest, CannotSetSessionDescriptionAfterClose) {
TEST_F(ConnectionFlowTest, CannotSetSessionDescriptionAfterClose) {
WebRtcMedium webrtc_medium;
std::unique_ptr<ConnectionFlow> offerer = ConnectionFlow::Create(
@@ -155,7 +164,7 @@ TEST(ConnectionFlowTest, CannotSetSessionDescriptionAfterClose) {
EXPECT_FALSE(offerer->SetLocalSessionDescription(offer));
}
TEST(ConnectionFlowTest, CannotReceiveOfferAfterClose) {
TEST_F(ConnectionFlowTest, CannotReceiveOfferAfterClose) {
WebRtcMedium webrtc_medium_offerer, webrtc_medium_answerer;
std::unique_ptr<ConnectionFlow> offerer =
cpp/core_v2/internal/mediums/webrtc_test.cc
+18 -9
View File
@@ -2,6 +2,7 @@
#include "core_v2/internal/mediums/webrtc/webrtc_socket_wrapper.h"
#include "platform_v2/base/listeners.h"
#include "platform_v2/base/medium_environment.h"
#include "platform_v2/public/mutex_lock.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -13,8 +14,16 @@ namespace mediums {
namespace {
class WebRtcTest : public ::testing::Test {
protected:
WebRtcTest() {
MediumEnvironment::Instance().Stop();
MediumEnvironment::Instance().Start({.webrtc_enabled = true});
}
};
// Basic test to check that device is accepting connections when initialized.
TEST(WebRtcTest, NotAcceptingConnections) {
TEST_F(WebRtcTest, NotAcceptingConnections) {
WebRtc webrtc;
ASSERT_TRUE(webrtc.IsAvailable());
EXPECT_FALSE(webrtc.IsAcceptingConnections());
@@ -22,7 +31,7 @@ TEST(WebRtcTest, NotAcceptingConnections) {
// Tests the flow when the device tries to accept connections twice. In this
// case, only the first call is successful and subsequent calls fail.
TEST(WebRtcTest, StartAcceptingConnectionTwice) {
TEST_F(WebRtcTest, StartAcceptingConnectionTwice) {
using MockAcceptedCallback =
testing::MockFunction<void(WebRtcSocketWrapper socket)>;
testing::StrictMock<MockAcceptedCallback> mock_accepted_callback_;
@@ -40,7 +49,7 @@ TEST(WebRtcTest, StartAcceptingConnectionTwice) {
// Tests the flow when the device tries to connect but the data channel times
// out.
TEST(WebRtcTest, Connect_DataChannelTimeOut) {
TEST_F(WebRtcTest, Connect_DataChannelTimeOut) {
WebRtc webrtc;
PeerId peer_id("peer_id");
@@ -54,7 +63,7 @@ TEST(WebRtcTest, Connect_DataChannelTimeOut) {
// Tests the flow when the device calls Connect() after calling
// StartAcceptingConnections() without StopAcceptingConnections().
TEST(WebRtcTest, StartAcceptingConnection_ThenConnect) {
TEST_F(WebRtcTest, StartAcceptingConnection_ThenConnect) {
using MockAcceptedCallback =
testing::MockFunction<void(WebRtcSocketWrapper socket)>;
testing::StrictMock<MockAcceptedCallback> mock_accepted_callback_;
@@ -74,7 +83,7 @@ TEST(WebRtcTest, StartAcceptingConnection_ThenConnect) {
// Tests the flow when the device calls StartAcceptingConnections but the medium
// is closed before a peer device can connect to it.
TEST(WebRtcTest, StartAndStopAcceptingConnections) {
TEST_F(WebRtcTest, StartAndStopAcceptingConnections) {
using MockAcceptedCallback =
testing::MockFunction<void(WebRtcSocketWrapper socket)>;
testing::StrictMock<MockAcceptedCallback> mock_accepted_callback_;
@@ -91,7 +100,7 @@ TEST(WebRtcTest, StartAndStopAcceptingConnections) {
// Tests the flow when the device tries to connect to two different peers
// without disconnecting in between.
TEST(WebRtcTest, ConnectTwice) {
TEST_F(WebRtcTest, ConnectTwice) {
WebRtc receiver, sender, device_c;
WebRtcSocketWrapper receiver_socket, sender_socket;
const PeerId self_id("self_id"), other_id("other_id");
@@ -135,7 +144,7 @@ TEST(WebRtcTest, ConnectTwice) {
// Tests the flow when the two devices exchange SDP messages and connect to each
// other but disconnect before being able to send/receive the actual data.
TEST(WebRtcTest, ConnectBothDevicesAndAbort) {
TEST_F(WebRtcTest, ConnectBothDevicesAndAbort) {
WebRtc receiver, sender;
WebRtcSocketWrapper receiver_socket, sender_socket;
const PeerId self_id("self_id");
@@ -161,7 +170,7 @@ TEST(WebRtcTest, ConnectBothDevicesAndAbort) {
// Tests the flow when the two devices exchange SDP messages and connect to each
// other and the actual data is exchanged successfully between the devices.
TEST(WebRtcTest, ConnectBothDevicesAndSendData) {
TEST_F(WebRtcTest, ConnectBothDevicesAndSendData) {
WebRtc receiver, sender;
WebRtcSocketWrapper receiver_socket, sender_socket;
const PeerId self_id("self_id");
@@ -193,7 +202,7 @@ TEST(WebRtcTest, ConnectBothDevicesAndSendData) {
// Tests the flow when the two devices exchange SDP messages and connect to each
// other but the signaling channel is closed before sending the data.
TEST(WebRtcTest, ConnectBothDevices_ShutdownSignaling_SendData) {
TEST_F(WebRtcTest, ConnectBothDevices_ShutdownSignaling_SendData) {
WebRtc receiver, sender;
WebRtcSocketWrapper receiver_socket, sender_socket;
const PeerId self_id("self_id");
cpp/core_v2/internal/mediums/wifi_lan.cc
+19 -20
View File
@@ -20,10 +20,10 @@ bool WifiLan::IsAvailable() const {
bool WifiLan::IsAvailableLocked() const { return medium_.IsValid(); }
bool WifiLan::StartAdvertising(const std::string& service_id,
const std::string& wifi_lan_service_info_name) {
const std::string& service_info_name) {
MutexLock lock(&mutex_);
if (wifi_lan_service_info_name.empty()) {
if (service_info_name.empty()) {
NEARBY_LOG(
INFO,
"Refusing to turn on WifiLan advertising. Empty service info name.");
@@ -36,45 +36,45 @@ bool WifiLan::StartAdvertising(const std::string& service_id,
return false;
}
if (!medium_.StartAdvertising(service_id, wifi_lan_service_info_name)) {
if (!medium_.StartAdvertising(service_id, service_info_name)) {
NEARBY_LOG(
INFO, "Failed to turn on WifiLan advertising with service info name=%s",
wifi_lan_service_info_name.c_str());
service_info_name.c_str());
return false;
}
NEARBY_LOGS(INFO) << "Turned on WifiLan advertising with service info name="
<< wifi_lan_service_info_name
<< service_info_name
<< ", service id=" << service_id;
advertising_info_.service_id = service_id;
advertising_info_.Add(service_id);
return true;
}
bool WifiLan::StopAdvertising(const std::string& service_id) {
MutexLock lock(&mutex_);
if (!IsAdvertisingLocked()) {
if (!IsAdvertisingLocked(service_id)) {
NEARBY_LOG(INFO, "Can't turn off WifiLan advertising; it is already off");
return false;
}
NEARBY_LOG(INFO, "Turned off WifiLan advertising with service id=%s",
service_id.c_str());
bool ret = medium_.StopAdvertising(advertising_info_.service_id);
bool ret = medium_.StopAdvertising(service_id);
// Reset our bundle of advertising state to mark that we're no longer
// advertising.
advertising_info_.Clear();
advertising_info_.Remove(service_id);
return ret;
}
bool WifiLan::IsAdvertising() {
bool WifiLan::IsAdvertising(const std::string& service_id) {
MutexLock lock(&mutex_);
return IsAdvertisingLocked();
return IsAdvertisingLocked(service_id);
}
bool WifiLan::IsAdvertisingLocked() {
return !advertising_info_.Empty();
bool WifiLan::IsAdvertisingLocked(const std::string& service_id) {
return advertising_info_.Existed(service_id);
}
bool WifiLan::StartDiscovery(const std::string& service_id,
@@ -110,7 +110,7 @@ bool WifiLan::StartDiscovery(const std::string& service_id,
NEARBY_LOG(INFO, "Turned on WifiLan discovering with service id=%s",
service_id.c_str());
// Mark the fact that we're currently performing a WifiLan discovering.
discovering_info_.service_id = service_id;
discovering_info_.Add(service_id);
return true;
}
@@ -138,7 +138,7 @@ bool WifiLan::IsDiscovering(const std::string& service_id) {
}
bool WifiLan::IsDiscoveringLocked(const std::string& service_id) {
return !discovering_info_.Empty();
return discovering_info_.Existed(service_id);
}
bool WifiLan::StartAcceptingConnections(const std::string& service_id,
@@ -174,7 +174,7 @@ bool WifiLan::StartAcceptingConnections(const std::string& service_id,
return false;
}
accepting_connections_info_.service_id = service_id;
accepting_connections_info_.Add(service_id);
return true;
}
@@ -188,11 +188,10 @@ bool WifiLan::StopAcceptingConnections(const std::string& service_id) {
return false;
}
bool ret =
medium_.StopAcceptingConnections(accepting_connections_info_.service_id);
bool ret = medium_.StopAcceptingConnections(service_id);
// Reset our bundle of accepting connections state to mark that we're no
// longer accepting connections.
accepting_connections_info_.Clear();
accepting_connections_info_.Remove(service_id);
return ret;
}
@@ -203,7 +202,7 @@ bool WifiLan::IsAcceptingConnections(const std::string& service_id) {
}
bool WifiLan::IsAcceptingConnectionsLocked(const std::string& service_id) {
return !accepting_connections_info_.Empty();
return accepting_connections_info_.Existed(service_id);
}
WifiLanSocket WifiLan::Connect(WifiLanService& wifi_lan_service,
cpp/core_v2/internal/mediums/wifi_lan.h
+35 -12
View File
@@ -9,6 +9,7 @@
#include "platform_v2/public/mutex.h"
#include "platform_v2/public/wifi_lan.h"
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
namespace location {
namespace nearby {
@@ -25,7 +26,7 @@ class WifiLan {
// Sets custom service info name, and then enables WifiLan advertising.
// Returns true, if name is successfully set, and false otherwise.
bool StartAdvertising(const std::string& service_id,
const std::string& wifi_lan_service_info_name)
const std::string& service_info_name)
ABSL_LOCKS_EXCLUDED(mutex_);
// Disables WifiLan advertising, and restores service info name to
@@ -33,7 +34,7 @@ class WifiLan {
bool StopAdvertising(const std::string& service_id)
ABSL_LOCKS_EXCLUDED(mutex_);
bool IsAdvertising() ABSL_LOCKS_EXCLUDED(mutex_);
bool IsAdvertising(const std::string& service_id) ABSL_LOCKS_EXCLUDED(mutex_);
// Enables WifiLan discovery mode. Will report any discoverable services in
// range through a callback. Returns true, if discovery mode was enabled,
@@ -70,31 +71,53 @@ class WifiLan {
private:
struct AdvertisingInfo {
bool Empty() const { return service_id.empty(); }
void Clear() { service_id.clear(); }
bool Empty() const { return service_ids.empty(); }
void Clear() { service_ids.clear(); }
void Add(const std::string& service_id) { service_ids.emplace(service_id); }
void Remove(const std::string& service_id) {
service_ids.erase(service_id);
}
bool Existed(const std::string& service_id) const {
return service_ids.contains(service_id);
}
std::string service_id;
absl::flat_hash_set<std::string> service_ids;
};
struct DiscoveringInfo {
bool Empty() const { return service_id.empty(); }
void Clear() { service_id.clear(); }
bool Empty() const { return service_ids.empty(); }
void Clear() { service_ids.clear(); }
void Add(const std::string& service_id) { service_ids.emplace(service_id); }
void Remove(const std::string& service_id) {
service_ids.erase(service_id);
}
bool Existed(const std::string& service_id) const {
return service_ids.contains(service_id);
}
std::string service_id;
absl::flat_hash_set<std::string> service_ids;
};
struct AcceptingConnectionsInfo {
bool Empty() const { return service_id.empty(); }
void Clear() { service_id.clear(); }
bool Empty() const { return service_ids.empty(); }
void Clear() { service_ids.clear(); }
void Add(const std::string& service_id) { service_ids.emplace(service_id); }
void Remove(const std::string& service_id) {
service_ids.erase(service_id);
}
bool Existed(const std::string& service_id) const {
return service_ids.contains(service_id);
}
std::string service_id;
absl::flat_hash_set<std::string> service_ids;
};
// Same as IsAvailable(), but must be called with mutex_ held.
bool IsAvailableLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
// Same as IsAdvertising(), but must be called with mutex_ held.
bool IsAdvertisingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
bool IsAdvertisingLocked(const std::string& service_id)
ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
// Same as IsDiscovering(), but must be called with mutex_ held.
bool IsDiscoveringLocked(const std::string& service_id)
cpp/core_v2/internal/p2p_cluster_pcp_handler.cc
+30 -40
View File
@@ -233,32 +233,33 @@ P2pClusterPcpHandler::MakeBluetoothDeviceLostHandler(
}
bool P2pClusterPcpHandler::IsRecognizedWifiLanEndpoint(
const std::string& name_string, const std::string& service_id,
const WifiLanServiceInfo& name) const {
if (!name.IsValid()) {
const std::string& service_id,
const WifiLanServiceInfo& service_info) const {
if (!service_info.IsValid()) {
NEARBY_LOG(
INFO,
"P2pClusterPcpHandler::IsRecognizedWifiLanEndpoint: name is invalid");
return false;
}
if (name.GetPcp() != GetPcp()) {
if (service_info.GetPcp() != GetPcp()) {
NEARBY_LOG(INFO,
"P2pClusterPcpHandler::IsRecognizedWifiLanEndpoint: Pcp is "
"not matched; name.Pcp=%d, Pcp=%d",
name.GetPcp(), GetPcp());
service_info.GetPcp(), GetPcp());
return false;
}
ByteArray expected_service_id_hash =
GenerateHash(service_id, BluetoothDeviceName::kServiceIdHashLength);
if (name.GetServiceIdHash() != expected_service_id_hash) {
if (service_info.GetServiceIdHash() != expected_service_id_hash) {
NEARBY_LOG(INFO,
"P2pClusterPcpHandler::IsRecognizedWifiLanEndpoint: service "
"id hash is "
"not matched; name.service_id_hash=%s, expected=%s",
name.GetServiceIdHash().data(), expected_service_id_hash.data());
service_info.GetServiceIdHash().data(),
expected_service_id_hash.data());
return false;
}
@@ -282,25 +283,23 @@ P2pClusterPcpHandler::MakeWifiLanServiceDiscoveredHandler(
}
// Parse the WifiLan service name.
const std::string& service_name_string = service.GetName();
WifiLanServiceInfo service_name(service_name_string);
const std::string& service_info_name = service.GetName();
WifiLanServiceInfo service_info(service_info_name);
// Make sure the WifiLan service name points to a valid
// endpoint we're discovering.
if (!IsRecognizedWifiLanEndpoint(service_name_string, service_id,
service_name))
return;
if (!IsRecognizedWifiLanEndpoint(service_id, service_info)) return;
// Report the discovered endpoint to the client.
NEARBY_LOG(INFO,
"Invoking BasePcpHandler::OnEndpointFound() for WifiLan "
"service=%s; id=%s; name=%s",
service_id.c_str(), service_name.GetEndpointId().c_str(),
service_name.GetEndpointName().c_str());
service_id.c_str(), service_info.GetEndpointId().c_str(),
service_info.GetEndpointName().c_str());
OnEndpointFound(client, std::make_shared<WifiLanEndpoint>(WifiLanEndpoint{
{
service_name.GetEndpointId(),
service_name.GetEndpointName(),
service_info.GetEndpointId(),
service_info.GetEndpointName(),
service_id,
proto::connections::Medium::WIFI_LAN,
},
@@ -327,14 +326,12 @@ P2pClusterPcpHandler::MakeWifiLanServiceLostHandler(
}
// Parse the WifiLan service name.
const std::string& service_name_string = service.GetName();
WifiLanServiceInfo service_name(service_name_string);
const std::string& service_info_name = service.GetName();
WifiLanServiceInfo service_info(service_info_name);
// Make sure the WifiLan service name points to a valid
// endpoint we're discovering.
if (!IsRecognizedWifiLanEndpoint(service_name_string, service_id,
service_name))
return;
if (!IsRecognizedWifiLanEndpoint(service_id, service_info)) return;
// Report the discovered endpoint to the client.
NEARBY_LOG(
@@ -344,8 +341,8 @@ P2pClusterPcpHandler::MakeWifiLanServiceLostHandler(
client, service_id.c_str());
OnEndpointLost(client, WifiLanEndpoint{
{
service_name.GetEndpointId(),
service_name.GetEndpointName(),
service_info.GetEndpointId(),
service_info.GetEndpointName(),
service_id,
proto::connections::Medium::WIFI_LAN,
},
@@ -597,11 +594,11 @@ proto::connections::Medium P2pClusterPcpHandler::StartWifiLanAdvertising(
}
RunOnPcpHandlerThread([this, client, local_endpoint_name,
socket = std::move(socket)]() mutable {
std::string remote_service_name =
std::string remote_service_info_name =
socket.GetRemoteWifiLanService().GetName();
auto channel = absl::make_unique<WifiLanEndpointChannel>(
remote_service_name, socket);
OnIncomingConnection(client, remote_service_name,
remote_service_info_name, socket);
OnIncomingConnection(client, remote_service_info_name,
std::move(channel),
proto::connections::Medium::WIFI_LAN);
});
@@ -618,10 +615,10 @@ proto::connections::Medium P2pClusterPcpHandler::StartWifiLanAdvertising(
service_id.c_str(), local_endpoint_id.c_str(),
std::string(service_id_hash).c_str(), local_endpoint_name.c_str());
// Generate a WifiLanServiceInfo with which to become WifiLan discoverable.
std::string service_name(WifiLanServiceInfo(
std::string service_info_name(WifiLanServiceInfo(
WifiLanServiceInfo::Version::kV1, GetPcp(), local_endpoint_id,
service_id_hash, local_endpoint_name));
if (service_name.empty()) {
if (service_info_name.empty()) {
NEARBY_LOG(INFO,
"P2pClusterPcpHandler::StartWifiLanAdvertising: generate "
"WifiLanServiceInfo failed");
@@ -630,8 +627,8 @@ proto::connections::Medium P2pClusterPcpHandler::StartWifiLanAdvertising(
} else {
NEARBY_LOG(INFO,
"P2pClusterPcpHandler::StartWifiLanAdvertising: generate "
"WifiLanServiceInfo succeeded; service_name=%s",
service_name.c_str());
"WifiLanServiceInfo succeeded; service_info_name=%s",
service_info_name.c_str());
}
NEARBY_LOG(
@@ -639,11 +636,11 @@ proto::connections::Medium P2pClusterPcpHandler::StartWifiLanAdvertising(
"P2pClusterPcpHandler::StartWifiLanAdvertising: service=%s: come up",
service_id.c_str());
if (!wifi_lan_medium_.StartAdvertising(service_id, service_name)) {
if (!wifi_lan_medium_.StartAdvertising(service_id, service_info_name)) {
NEARBY_LOG(INFO,
"P2pClusterPcpHandler::StartWifiLanAdvertising: failed to "
"start advertising, service_name=%s",
service_name.c_str());
"start advertising, service_info_name=%s",
service_info_name.c_str());
wifi_lan_medium_.StopAcceptingConnections(service_id);
return proto::connections::UNKNOWN_MEDIUM;
}
@@ -748,13 +745,6 @@ BasePcpHandler::ConnectImplResult P2pClusterPcpHandler::WebRtcConnectImpl(
.endpoint_channel = std::move(channel)};
}
mediums::PeerId P2pClusterPcpHandler::CreatePeerIdFromAdvertisement(
const std::string& service_id, const std::string& endpoint_id,
const std::string& endpoint_name) {
std::string seed = absl::StrCat(service_id, endpoint_id, endpoint_name);
return mediums::PeerId::FromSeed(ByteArray(seed));
}
} // namespace connections
} // namespace nearby
} // namespace location
cpp/core_v2/internal/p2p_cluster_pcp_handler.h
+5 -14
View File
@@ -83,12 +83,6 @@ class P2pClusterPcpHandler : public BasePcpHandler {
wifi_lan_service(std::move(service)) {}
WifiLanService wifi_lan_service;
};
struct WebRtcEndpoint : public BasePcpHandler::DiscoveredEndpoint {
WebRtcEndpoint(DiscoveredEndpoint endpoint, mediums::PeerId peer_id)
: DiscoveredEndpoint(std::move(endpoint)),
peer_id(std::move(peer_id)) {}
mediums::PeerId peer_id;
};
using BluetoothDiscoveredDeviceCallback =
BluetoothClassic::DiscoveredDeviceCallback;
@@ -101,7 +95,7 @@ class P2pClusterPcpHandler : public BasePcpHandler {
static ByteArray GenerateHash(const std::string& source, size_t size);
// Bluetooth.
// Bluetooth
bool IsRecognizedBluetoothEndpoint(const std::string& name_string,
const std::string& service_id,
const BluetoothDeviceName& name) const;
@@ -119,10 +113,10 @@ class P2pClusterPcpHandler : public BasePcpHandler {
BasePcpHandler::ConnectImplResult BluetoothConnectImpl(
ClientProxy* client, BluetoothEndpoint* endpoint);
// WifiLan.
bool IsRecognizedWifiLanEndpoint(const std::string& name_string,
const std::string& service_id,
const WifiLanServiceInfo& name) const;
// WifiLan
bool IsRecognizedWifiLanEndpoint(
const std::string& service_id,
const WifiLanServiceInfo& service_info) const;
std::function<void(WifiLanService&, const std::string&)>
MakeWifiLanServiceDiscoveredHandler(ClientProxy* client,
const std::string& service_id);
@@ -146,9 +140,6 @@ class P2pClusterPcpHandler : public BasePcpHandler {
const std::string& local_endpoint_name);
BasePcpHandler::ConnectImplResult WebRtcConnectImpl(
ClientProxy* client, WebRtcEndpoint* webrtc_endpoint);
mediums::PeerId CreatePeerIdFromAdvertisement(const string& service_id,
const string& endpoint_id,
const string& endpoint_name);
BluetoothRadio& bluetooth_radio_;
BluetoothClassic& bluetooth_medium_;
cpp/core_v2/internal/wifi_lan_endpoint_channel.h
+1 -1
View File
@@ -13,7 +13,7 @@ class WifiLanEndpointChannel final : public BaseEndpointChannel {
public:
// Creates both outgoing and incoming WifiLan channels.
WifiLanEndpointChannel(const std::string& channel_name,
WifiLanSocket bluetooth_socket);
WifiLanSocket socket);
proto::connections::Medium GetMedium() const override;
cpp/core_v2/options.h
+12
View File
@@ -7,10 +7,22 @@ namespace location {
namespace nearby {
namespace connections {
// Generic type: allows definition of a feature T for every Medium.
template <typename T>
struct MediumSelector {
T bluetooth;
T web_rtc;
T wifi_lan;
};
// Feature On/Off switch for mediums.
using BooleanMediumSelector = MediumSelector<bool>;
// Connection Options: used for both Advertising and Discovery.
// All fields are mutable, to make the type copy-assignable.
struct ConnectionOptions {
Strategy strategy;
BooleanMediumSelector allowed;
bool auto_upgrade_bandwidth;
bool enforce_topology_constraints;
// Verify if ConnectionOptions is in a not-initialized (Empty) state.
cpp/platform_v2/api/wifi_lan.h
+3 -4
View File
@@ -13,7 +13,8 @@ namespace location {
namespace nearby {
namespace api {
// Opaque wrapper over a WifiLan service which contains encoded service name.
// Opaque wrapper over a WifiLan service which contains packed
// |WifiLanServiceInfo| string name.
class WifiLanService {
public:
virtual ~WifiLanService() = default;
@@ -57,10 +58,8 @@ class WifiLanMedium {
const std::string& wifi_lan_service_info_name) = 0;
virtual bool StopAdvertising(const std::string& service_id) = 0;
// Callback that is invoked when a discovered service is found or lost.
struct DiscoveredServiceCallback {
// The WifiLanService* is not owned by callbacks.
// It is passed to give access to its non-const methods.
// It is guaranteed to be valid for the duration of call.
std::function<void(WifiLanService& wifi_lan_service,
const std::string& service_id)>
service_discovered_cb =
cpp/platform_v2/base/medium_environment.cc
+104 -58
View File
@@ -22,9 +22,10 @@ MediumEnvironment& MediumEnvironment::Instance() {
return *env;
}
void MediumEnvironment::Start() {
void MediumEnvironment::Start(EnvironmentConfig config) {
if (!enabled_.exchange(true)) {
NEARBY_LOG(INFO, "MediumEnvironment::Start()");
config_ = std::move(config);
Reset();
}
}
@@ -65,6 +66,10 @@ void MediumEnvironment::Sync(bool enable_notifications) {
NEARBY_LOG(INFO, "MediumEnvironment::Sync(): done [count=%d]", count);
}
const EnvironmentConfig& MediumEnvironment::GetEnvironmentConfig() {
return config_;
}
void MediumEnvironment::OnBluetoothAdapterChangedState(
api::BluetoothAdapter& adapter, api::BluetoothDevice& adapter_device,
std::string name, bool enabled, api::BluetoothAdapter::ScanMode mode) {
@@ -74,7 +79,8 @@ void MediumEnvironment::OnBluetoothAdapterChangedState(
NEARBY_LOG(INFO,
"[adapter=%p, device=%p] update: name=%s, enabled=%d, mode=%d",
&adapter, &adapter_device, name.c_str(), enabled, mode);
for (auto& [medium, info] : bluetooth_mediums_) {
for (auto& medium_info : bluetooth_mediums_) {
auto& info = medium_info.second;
// Do not send notification to medium that owns this adapter.
if (info.adapter == &adapter) continue;
NEARBY_LOG(INFO, "[adapter=%p, device=%p] notify: adapter=%p", &adapter,
@@ -153,19 +159,22 @@ void MediumEnvironment::OnWifiLanServiceStateChanged(
const std::string& service_id, bool enabled) {
if (!enabled_) return;
NEARBY_LOG(INFO,
"G3 OnWifiLanServiceStateChanged [service impl=%p]; context=%p, "
"notify=%d",
&info, &service, enable_notifications_.load());
"G3 OnWifiLanServiceStateChanged [service impl=%p]; context=%p; "
"service_id=%s; notify=%d",
&service, &info, service_id.c_str(), enable_notifications_.load());
if (!enable_notifications_) return;
if (enabled) {
RunOnMediumEnvironmentThread([&info, &service, service_id]() {
info.discovery_callback.service_discovered_cb(service, service_id);
});
} else {
RunOnMediumEnvironmentThread([&info, &service, service_id]() {
info.discovery_callback.service_lost_cb(service, service_id);
});
}
RunOnMediumEnvironmentThread([&info, enabled, &service, service_id]() {
auto service_id_context = info.services.find(service_id);
if (service_id_context == info.services.end()) return;
if (enabled) {
service_id_context->second.discovery_callback.service_discovered_cb(
service, service_id);
} else {
service_id_context->second.discovery_callback.service_lost_cb(service,
service_id);
}
});
}
void MediumEnvironment::RunOnMediumEnvironmentThread(
@@ -188,7 +197,9 @@ void MediumEnvironment::RegisterBluetoothMedium(
auto* owned_adapter = context.adapter;
NEARBY_LOG(INFO, "Registered: medium=%p; adapter=%p", &medium,
owned_adapter);
for (auto& [adapter, device] : bluetooth_adapters_) {
for (auto& adapter_device : bluetooth_adapters_) {
auto& adapter = adapter_device.first;
auto& device = adapter_device.second;
if (adapter == nullptr) continue;
OnBluetoothDeviceStateChanged(context, *device, adapter->GetName(),
adapter->GetScanMode(),
@@ -212,7 +223,9 @@ void MediumEnvironment::UpdateBluetoothMedium(
"Updated: this=%p; medium=%p; adapter=%p; name=%s; enabled=%d; mode=%d",
this, &medium, owned_adapter, owned_adapter->GetName().c_str(),
owned_adapter->IsEnabled(), owned_adapter->GetScanMode());
for (auto& [adapter, device] : bluetooth_adapters_) {
for (auto& adapter_device : bluetooth_adapters_) {
auto& adapter = adapter_device.first;
auto& device = adapter_device.second;
if (adapter == nullptr) continue;
OnBluetoothDeviceStateChanged(context, *device, adapter->GetName(),
adapter->GetScanMode(),
@@ -271,13 +284,10 @@ void MediumEnvironment::SendWebRtcSignalingMessage(absl::string_view peer_id,
});
}
void MediumEnvironment::RegisterWifiLanMedium(api::WifiLanMedium& medium,
api::WifiLanService& service) {
void MediumEnvironment::RegisterWifiLanMedium(api::WifiLanMedium& medium) {
if (!enabled_) return;
RunOnMediumEnvironmentThread([this, &medium, &service]() {
wifi_lan_mediums_.insert({&medium, WifiLanMediumContext{
.service = &service,
}});
RunOnMediumEnvironmentThread([this, &medium]() {
wifi_lan_mediums_.insert({&medium, WifiLanMediumContext{}});
NEARBY_LOG(INFO, "Registered: medium=%p", &medium);
});
}
@@ -290,18 +300,31 @@ void MediumEnvironment::UpdateWifiLanMediumForAdvertising(
enabled]() {
auto item = wifi_lan_mediums_.find(&medium);
if (item == wifi_lan_mediums_.end()) {
NEARBY_LOG(
INFO, "Update WifiLan medium failed. There is no medium registered.");
NEARBY_LOG(INFO,
"UpdateWifiLanMediumForAdvertising failed. There is no medium "
"registered.");
return;
}
auto& context = item->second;
context.advertising = enabled;
NEARBY_LOG(
INFO,
"Update WifiLan medium for advertising: this=%p; medium=%p; name=%s; "
"enabled=%d; advertising=%d",
this, &medium, service.GetName().c_str(), enabled, context.advertising);
for (auto& [local_medium, info] : wifi_lan_mediums_) {
context.wifi_lan_service = &service;
auto service_id_context = context.services.find(service_id);
if (service_id_context == context.services.end()) {
WifiLanServiceIdContext id_context{
.advertising = enabled,
};
context.services.emplace(service_id, std::move(id_context));
} else {
service_id_context->second.advertising = enabled;
}
NEARBY_LOG(INFO,
"Update WifiLan medium for advertising: this=%p; medium=%p; "
"service_id=%s; name=%s; "
"enabled=%d",
this, &medium, service_id.c_str(), service.GetName().c_str(),
enabled);
for (auto& medium_info : wifi_lan_mediums_) {
auto& local_medium = medium_info.first;
auto& info = medium_info.second;
// Do not send notification to the same medium.
if (local_medium == &medium) continue;
OnWifiLanServiceStateChanged(info, service, service_id, enabled);
@@ -310,45 +333,56 @@ void MediumEnvironment::UpdateWifiLanMediumForAdvertising(
}
void MediumEnvironment::UpdateWifiLanMediumForDiscovery(
api::WifiLanMedium& medium, api::WifiLanService& service,
const std::string& service_id, WifiLanDiscoveredServiceCallback callback,
bool enabled) {
api::WifiLanMedium& medium, const std::string& service_id,
WifiLanDiscoveredServiceCallback callback, bool enabled) {
if (!enabled_) return;
RunOnMediumEnvironmentThread([this, &medium, &service, service_id,
RunOnMediumEnvironmentThread([this, &medium, service_id,
callback = std::move(callback), enabled]() {
auto item = wifi_lan_mediums_.find(&medium);
if (item == wifi_lan_mediums_.end()) {
NEARBY_LOG(
INFO, "Update WifiLan medium failed. There is no medium registered.");
NEARBY_LOG(INFO,
"UpdateWifiLanMediumForDiscovery failed. There is no medium "
"registered.");
return;
}
auto& context = item->second;
context.discovery_callback = std::move(callback);
NEARBY_LOG(
INFO,
"Update WifiLan medium for discovery: this=%p; medium=%p; name=%s; "
"enabled=%d; advertising=%d",
this, &medium, service.GetName().c_str(), enabled, context.advertising);
for (auto& [local_medium, info] : wifi_lan_mediums_) {
auto service_id_context = context.services.find(service_id);
if (service_id_context == context.services.end()) {
WifiLanServiceIdContext id_context{
.discovery_callback = std::move(callback),
};
context.services.emplace(service_id, std::move(id_context));
} else {
service_id_context->second.discovery_callback = std::move(callback);
}
NEARBY_LOG(INFO,
"Update WifiLan medium for discovery: this=%p; medium=%p; "
"service_id=%s; enabled=%d; ",
this, &medium, service_id.c_str(), enabled);
for (auto& medium_info : wifi_lan_mediums_) {
auto& local_medium = medium_info.first;
auto& info = medium_info.second;
// Do not send notification to the same medium.
if (local_medium == &medium) continue;
// Search advertising mediums and send notification.
if (info.advertising && enabled) {
OnWifiLanServiceStateChanged(context, *(info.service), service_id,
enabled);
for (auto& service_id_context : info.services) {
auto& service_id = service_id_context.first;
auto& id_context = service_id_context.second;
if (id_context.advertising && enabled) {
OnWifiLanServiceStateChanged(context, *(info.wifi_lan_service),
service_id, enabled);
}
}
}
});
}
void MediumEnvironment::UpdateWifiLanMediumForAcceptedConnection(
api::WifiLanMedium& medium, api::WifiLanService& service,
const std::string& service_id,
WifiLanAcceptedConnectionCallback accepted_connection_callback) {
api::WifiLanMedium& medium, const std::string& service_id,
WifiLanAcceptedConnectionCallback callback) {
if (!enabled_) return;
RunOnMediumEnvironmentThread([this, &medium, &service, service_id,
accepted_connection_callback =
std::move(accepted_connection_callback)]() {
RunOnMediumEnvironmentThread([this, &medium, service_id,
callback = std::move(callback)]() {
auto item = wifi_lan_mediums_.find(&medium);
if (item == wifi_lan_mediums_.end()) {
NEARBY_LOG(
@@ -356,12 +390,20 @@ void MediumEnvironment::UpdateWifiLanMediumForAcceptedConnection(
return;
}
auto& context = item->second;
context.accepted_connection_callback =
std::move(accepted_connection_callback);
auto service_id_context = context.services.find(service_id);
if (service_id_context == context.services.end()) {
WifiLanServiceIdContext id_context{
.accepted_connection_callback = std::move(callback),
};
context.services.emplace(service_id, std::move(id_context));
} else {
service_id_context->second.accepted_connection_callback =
std::move(callback);
}
NEARBY_LOG(INFO,
"Update WifiLan medium for accepted callback: this=%p; "
"medium=%p; name=%s; ",
this, &medium, service.GetName().c_str());
"medium=%p; service_id=%s; ",
this, &medium, service_id.c_str());
});
}
@@ -387,7 +429,11 @@ void MediumEnvironment::CallWifiLanAcceptedConnectionCallback(
return;
}
auto& info = item->second;
info.accepted_connection_callback.accepted_cb(socket, service_id);
auto service_id_context = info.services.find(service_id);
if (service_id_context != info.services.end()) {
service_id_context->second.accepted_connection_callback.accepted_cb(
socket, service_id);
}
});
}
cpp/platform_v2/base/medium_environment.h
+25 -11
View File
@@ -15,6 +15,15 @@
namespace location {
namespace nearby {
// Environment config that can control availability of certain mediums for
// testing.
struct EnvironmentConfig {
// Control whether WEB_RTC medium is enabled in the environment.
// This is currently set to false, due to http://b/139734036 that would lead
// to flaky tests.
bool webrtc_enabled = false;
};
// MediumEnvironment is a simulated environment which allows multiple instances
// of simulated HW devices to "work" together as if they are physical.
// For each medium type it provides necessary methods to implement
@@ -30,6 +39,7 @@ class MediumEnvironment {
api::WifiLanMedium::DiscoveredServiceCallback;
using WifiLanAcceptedConnectionCallback =
api::WifiLanMedium::AcceptedConnectionCallback;
MediumEnvironment(const MediumEnvironment&) = delete;
MediumEnvironment& operator=(const MediumEnvironment&) = delete;
@@ -42,7 +52,7 @@ class MediumEnvironment {
// tests that are already using it and relying on it being ON.
// Enables Medium environment.
void Start();
void Start(EnvironmentConfig config = EnvironmentConfig());
// Disables Medium environment.
void Stop();
@@ -93,6 +103,8 @@ class MediumEnvironment {
// Removes medium-related info. This should correspond to device power off.
void UnregisterBluetoothMedium(api::BluetoothClassicMedium& medium);
const EnvironmentConfig& GetEnvironmentConfig();
// Registers |callback| to receive messages sent to device with id |self_id|.
void RegisterWebRtcSignalingMessenger(absl::string_view self_id,
OnSignalingMessageCallback callback);
@@ -107,8 +119,7 @@ class MediumEnvironment {
// Adds medium-related info to allow for discovery/advertising to work.
// This provides acccess to this medium from other mediums, when protocol
// expects they should communicate.
void RegisterWifiLanMedium(api::WifiLanMedium& medium,
api::WifiLanService& service);
void RegisterWifiLanMedium(api::WifiLanMedium& medium);
// Updates advertising info to indicate the current medium is exposing
// advertising event.
@@ -126,16 +137,14 @@ class MediumEnvironment {
// with user-specified callback when discovery is enabled, and with default
// (empty) callback otherwise.
void UpdateWifiLanMediumForDiscovery(
api::WifiLanMedium& medium, api::WifiLanService& service,
const std::string& service_id,
WifiLanDiscoveredServiceCallback discovery_callback, bool enabled);
api::WifiLanMedium& medium, const std::string& service_id,
WifiLanDiscoveredServiceCallback callback, bool enabled);
// Updates Accepted connection callback info to allow for dispatch of
// advertising events.
void UpdateWifiLanMediumForAcceptedConnection(
api::WifiLanMedium& medium, api::WifiLanService& service,
const std::string& service_id,
WifiLanAcceptedConnectionCallback accepted_connection_callback);
api::WifiLanMedium& medium, const std::string& service_id,
WifiLanAcceptedConnectionCallback callback);
// Removes medium-related info. This should correspond to device power off.
void UnregisterWifiLanMedium(api::WifiLanMedium& medium);
@@ -154,13 +163,17 @@ class MediumEnvironment {
absl::flat_hash_map<api::BluetoothDevice*, std::string> devices;
};
struct WifiLanMediumContext {
struct WifiLanServiceIdContext {
WifiLanDiscoveredServiceCallback discovery_callback;
WifiLanAcceptedConnectionCallback accepted_connection_callback;
api::WifiLanService* service = nullptr;
bool advertising = false;
};
struct WifiLanMediumContext {
api::WifiLanService* wifi_lan_service = nullptr;
absl::flat_hash_map<std::string, WifiLanServiceIdContext> services;
};
// This is a singleton object, for which destructor will never be called.
// Constructor will be invoked once from Instance() static method.
// Object is create in-place (with a placement new) to guarantee that
@@ -185,6 +198,7 @@ class MediumEnvironment {
std::atomic_int job_count_ = 0;
std::atomic_bool enable_notifications_ = false;
SingleThreadExecutor executor_;
EnvironmentConfig config_;
// The following data members are accessed in the context of a private
// executor_ thread.
cpp/platform_v2/impl/g3/BUILD
+1
View File
@@ -105,6 +105,7 @@ cc_library(
"//platform_v2/api:comm",
"//platform_v2/api:platform",
"//platform_v2/api:types",
"//platform_v2/base:test_util",
"//platform_v2/impl/shared:file",
"//absl/base:core_headers",
"//absl/memory",
cpp/platform_v2/impl/g3/platform.cc
+6 -1
View File
@@ -18,6 +18,7 @@
#include "platform_v2/api/submittable_executor.h"
#include "platform_v2/api/webrtc.h"
#include "platform_v2/api/wifi.h"
#include "platform_v2/base/medium_environment.h"
#include "platform_v2/impl/g3/atomic_boolean.h"
#include "platform_v2/impl/g3/atomic_reference.h"
#include "platform_v2/impl/g3/bluetooth_adapter.h"
@@ -133,7 +134,11 @@ std::unique_ptr<WifiLanMedium> ImplementationPlatform::CreateWifiLanMedium() {
}
std::unique_ptr<WebRtcMedium> ImplementationPlatform::CreateWebRtcMedium() {
return absl::make_unique<g3::WebRtcMedium>();
if (MediumEnvironment::Instance().GetEnvironmentConfig().webrtc_enabled) {
return absl::make_unique<g3::WebRtcMedium>();
} else {
return nullptr;
}
}
std::unique_ptr<Mutex> ImplementationPlatform::CreateMutex(Mutex::Mode mode) {
cpp/platform_v2/impl/g3/wifi_lan.cc
+34 -29
View File
@@ -156,7 +156,7 @@ Exception WifiLanServerSocket::DoClose() {
WifiLanMedium::WifiLanMedium() {
service_.SetMedium(this);
auto& env = MediumEnvironment::Instance();
env.RegisterWifiLanMedium(*this, service_);
env.RegisterWifiLanMedium(*this);
}
WifiLanMedium::~WifiLanMedium() {
@@ -167,7 +167,6 @@ WifiLanMedium::~WifiLanMedium() {
StopAdvertising(advertising_info_.service_id);
StopDiscovery(discovering_info_.service_id);
accept_loops_runner_.Shutdown();
NEARBY_LOG(INFO,
"WifiLanMedium dtor advertising_accept_thread_running_ = %d",
acceptance_thread_running_.load());
@@ -181,12 +180,11 @@ WifiLanMedium::~WifiLanMedium() {
}
}
bool WifiLanMedium::StartAdvertising(
const std::string& service_id,
const std::string& wifi_lan_service_info_name) {
bool WifiLanMedium::StartAdvertising(const std::string& service_id,
const std::string& service_info_name) {
NEARBY_LOG(INFO,
"G3 WifiLan StartAdvertising: service_id=%s, service_name=%s",
service_id.c_str(), wifi_lan_service_info_name.c_str());
"G3 WifiLan StartAdvertising: service_id=%s, service_info_name=%s",
service_id.c_str(), service_info_name.c_str());
auto& env = MediumEnvironment::Instance();
env.UpdateWifiLanMediumForAdvertising(*this, service_, service_id, true);
@@ -216,8 +214,9 @@ bool WifiLanMedium::StopAdvertising(const std::string& service_id) {
{
absl::MutexLock lock(&mutex_);
if (advertising_info_.Empty()) {
NEARBY_LOG(
INFO, "Can't stop advertising because we never started advertising.");
NEARBY_LOG(INFO,
"G3 WifiLan StopAdvertising: Can't stop advertising because "
"we never started advertising.");
return false;
}
advertising_info_.Clear();
@@ -227,14 +226,17 @@ bool WifiLanMedium::StopAdvertising(const std::string& service_id) {
env.UpdateWifiLanMediumForAdvertising(*this, service_, service_id, false);
accept_loops_runner_.Shutdown();
if (server_socket_ == nullptr) {
NEARBY_LOG(ERROR, "Failed to find WifiLan Server socket: service_id=%s",
service_id.c_str());
NEARBY_LOGS(ERROR) << "G3 WifiLan StopAdvertising: failed to find WifiLan "
"Server socket: service_id="
<< service_id;
// Fall through for server socket not found.
return true;
}
if (!server_socket_->Close().Ok()) {
NEARBY_LOG(INFO, "Failed to close WifiLan server socket for %s.",
NEARBY_LOG(INFO,
"G3 WifiLan StopAdvertising: Failed to close WifiLan server "
"socket for %s.",
service_id.c_str());
return false;
}
@@ -247,8 +249,8 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_id,
NEARBY_LOG(INFO, "G3 WifiLan StartDiscovery: service_id=%s",
service_id.c_str());
auto& env = MediumEnvironment::Instance();
env.UpdateWifiLanMediumForDiscovery(*this, service_, service_id,
std::move(callback), true);
env.UpdateWifiLanMediumForDiscovery(*this, service_id, std::move(callback),
true);
{
absl::MutexLock lock(&mutex_);
discovering_info_.service_id = service_id;
@@ -262,15 +264,16 @@ bool WifiLanMedium::StopDiscovery(const std::string& service_id) {
{
absl::MutexLock lock(&mutex_);
if (discovering_info_.Empty()) {
NEARBY_LOG(
INFO, "Can't stop discovering because we never started discovering.");
NEARBY_LOG(INFO,
"G3 WifiLan StopDiscovery: Can't stop discovering because we "
"never started discovering.");
return false;
}
discovering_info_.Clear();
}
auto& env = MediumEnvironment::Instance();
env.UpdateWifiLanMediumForDiscovery(*this, service_, service_id, {}, false);
env.UpdateWifiLanMediumForDiscovery(*this, service_id, {}, false);
return true;
}
@@ -279,8 +282,7 @@ bool WifiLanMedium::StartAcceptingConnections(
NEARBY_LOG(INFO, "G3 WifiLan StartAcceptingConnections: service_id=%s",
service_id.c_str());
auto& env = MediumEnvironment::Instance();
env.UpdateWifiLanMediumForAcceptedConnection(*this, service_, service_id,
callback);
env.UpdateWifiLanMediumForAcceptedConnection(*this, service_id, callback);
return true;
}
@@ -288,7 +290,7 @@ bool WifiLanMedium::StopAcceptingConnections(const std::string& service_id) {
NEARBY_LOG(INFO, "G3 WifiLan StopAcceptingConnections: service_id=%s",
service_id.c_str());
auto& env = MediumEnvironment::Instance();
env.UpdateWifiLanMediumForAcceptedConnection(*this, service_, service_id, {});
env.UpdateWifiLanMediumForAcceptedConnection(*this, service_id, {});
return true;
}
@@ -301,28 +303,31 @@ std::unique_ptr<api::WifiLanSocket> WifiLanMedium::Connect(
if (!medium) return {}; // Can't find medium. Bail out.
WifiLanServerSocket* server_socket = nullptr;
WifiLanServerSocket* remote_server_socket = nullptr;
NEARBY_LOG(INFO,
"G3 WifiLan Connect [peer]: medium=%p, service=%p, service_id=%s",
medium, &remote_service, service_id.c_str());
// Then, find our server socket context in this medium.
{
absl::MutexLock medium_lock(&medium->mutex_);
server_socket = medium->server_socket_.get();
if (server_socket == nullptr) {
NEARBY_LOG(ERROR, "Failed to find WifiLan Server socket: service_id=%s",
remote_server_socket = medium->server_socket_.get();
if (remote_server_socket == nullptr) {
NEARBY_LOG(ERROR,
"G3 WifiLan Connect: Failed to find WifiLan Server socket: "
"service_id=%s",
service_id.c_str());
// Fall through for server socket not found.
return {};
}
}
auto socket = std::make_unique<WifiLanSocket>();
// Finally, Request to connect to this socket.
if (!server_socket->Connect(*socket)) {
NEARBY_LOG(
ERROR,
"Failed to connect to existing WifiLan Server socket: service_id=%s",
service_id.c_str());
if (!remote_server_socket->Connect(*socket)) {
NEARBY_LOG(ERROR,
"G3 WifiLan Connect: Failed to connect to existing WifiLan "
"Server socket: service_id=%s",
service_id.c_str());
return {};
}
cpp/platform_v2/impl/g3/wifi_lan.h
+11 -10
View File
@@ -20,21 +20,24 @@ namespace g3 {
class WifiLanMedium;
// Opaque wrapper over a WifiLan service which contains encoded WifiLan service
// info name.
// Opaque wrapper over a WifiLan service which contains packed
// |WifiLanServiceInfo| string name.
class WifiLanService : public api::WifiLanService {
public:
explicit WifiLanService(std::string name) : name_(std::move(name)) {}
explicit WifiLanService(std::string service_info_name)
: service_info_name_(std::move(service_info_name)) {}
~WifiLanService() override = default;
void SetName(std::string name) { name_ = std::move(name); }
std::string GetName() const override { return name_; }
void SetName(std::string service_info_name) {
service_info_name_ = std::move(service_info_name);
}
std::string GetName() const override { return service_info_name_; }
void SetMedium(WifiLanMedium* medium) { medium_ = medium; }
WifiLanMedium* GetMedium() { return medium_; }
private:
std::string name_;
std::string service_info_name_;
WifiLanMedium* medium_ = nullptr;
};
@@ -151,7 +154,7 @@ class WifiLanMedium : public api::WifiLanMedium {
~WifiLanMedium() override;
bool StartAdvertising(const std::string& service_id,
const std::string& wifi_lan_service_info_name) override
const std::string& service_info_name) override
ABSL_LOCKS_EXCLUDED(mutex_);
bool StopAdvertising(const std::string& service_id) override
ABSL_LOCKS_EXCLUDED(mutex_);
@@ -201,7 +204,7 @@ class WifiLanMedium : public api::WifiLanMedium {
};
absl::Mutex mutex_;
WifiLanService service_{"wifi_lan_service_info_name"};
WifiLanService service_{"unknown G3 WifiLan service"};
// A thread pool dedicated to running all the accept loops from
// StartAdvertising().
@@ -211,8 +214,6 @@ class WifiLanMedium : public api::WifiLanMedium {
// A thread pool dedicated to wait to complete the accept_loops_runner_.
MultiThreadExecutor close_accept_loops_runner_{kMaxConcurrentAcceptLoops};
// TODO(edwinwu): Extend it to hashmap to accept multiple sockets for multiple
// entrance.
// A server socket is established when start advertising.
std::unique_ptr<WifiLanServerSocket> server_socket_;
AdvertisingInfo advertising_info_ ABSL_GUARDED_BY(mutex_);
cpp/platform_v2/public/wifi_lan.cc
+15 -9
View File
@@ -8,8 +8,8 @@ namespace nearby {
bool WifiLanMedium::StartAdvertising(
const std::string& service_id,
const std::string& wifi_lan_service_info_name) {
return impl_->StartAdvertising(service_id, wifi_lan_service_info_name);
const std::string& service_info_name) {
return impl_->StartAdvertising(service_id, service_info_name);
}
bool WifiLanMedium::StopAdvertising(const std::string& service_id) {
@@ -34,13 +34,18 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_id,
&service, absl::make_unique<ServiceDiscoveryInfo>());
auto& context = *pair.first->second;
if (!pair.second) {
NEARBY_LOG(INFO, "Adding (again) service=%p, impl=%p",
&context.service, &service);
NEARBY_LOG(INFO,
"Discovering (again) service=%p, impl=%p, "
"service_info_name=%s",
&context.service, &service,
service.GetName().c_str());
return;
}
context.service = WifiLanService(&service);
NEARBY_LOG(INFO, "Adding service=%p, impl=%p", &context.service,
&service);
NEARBY_LOG(
INFO,
"Discovering service=%p, impl=%p, service_info_name=%s",
&context.service, &service, service.GetName().c_str());
discovered_service_callback_.service_discovered_cb(
context.service, service_id);
},
@@ -86,12 +91,13 @@ bool WifiLanMedium::StartAcceptingConnections(
&socket, absl::make_unique<AcceptedConnectionInfo>());
auto& context = *pair.first->second;
if (!pair.second) {
NEARBY_LOG(INFO, "Adding (again) socket=%p, impl=%p",
NEARBY_LOG(INFO, "Accepting (again) socket=%p, impl=%p",
&context.socket, &socket);
context.socket = WifiLanSocket(&socket);
} else {
NEARBY_LOG(INFO, "Accepting socket=%p, impl=%p",
&context.socket, &socket);
}
NEARBY_LOG(INFO, "Adding socket=%p, impl=%p", &context.socket,
&socket);
accepted_connection_callback_.accepted_cb(context.socket,
service_id);
},
cpp/platform_v2/public/wifi_lan.h
+3 -2
View File
@@ -12,7 +12,8 @@
namespace location {
namespace nearby {
// Opaque wrapper over a WifiLan service which contains encoded service name.
// Opaque wrapper over a WifiLan service which contains packed
// |WifiLanServiceInfo| string name.
class WifiLanService final {
public:
WifiLanService() = default;
@@ -113,7 +114,7 @@ class WifiLanMedium final {
~WifiLanMedium() = default;
bool StartAdvertising(const std::string& service_id,
const std::string& wifi_lan_service_info_name);
const std::string& service_info_name);
bool StopAdvertising(const std::string& service_id);
// Returns true once the WifiLan discovery has been initiated.