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

Rename proto fields of the WifiDirectAuthType and WifiDirectCredentials

Browse Source 
PiperOrigin-RevId: 929682564
This commit is contained in:
hai007
2026-06-10 01:36:23 -07:00
committed by Copybara-Service
parent e205d8a08f
commit a8e604bbe4
17 changed files with 91 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
connections/implementation/bwu_manager_test.cc
+1 -1
View File
@@ -925,7 +925,7 @@ TEST_F(BwuManagerTest, InitiateBwu_Revert_OnDisconnect_WifiDirect) {
std::string bytes = parser::ForBwuWifiDirectPathAvailable(
/*ssid=*/"", /*password=*/"", /*port=*/2143,
/*frequency=*/2412, /*supports_disabling_encryption=*/false,
/*gateway=*/"123.234.23.1", /*service_name=*/"NC-WifiDirectTest",
/*gateway=*/"123.234.23.1", /*device_name=*/"NC-WifiDirectTest",
/*pin=*/"b592f7d3");
frame.ParseFromString(bytes);
connections/implementation/fake_bwu_handler.h
+1 -1
View File
@@ -178,7 +178,7 @@ class FakeBwuHandler : public BaseBwuHandler {
return parser::ForBwuWifiDirectPathAvailable(
/*ssid=*/"", /*password=*/"", /*port=*/2143,
/*frequency=*/2412, /*supports_disabling_encryption=*/false,
/*gateway=*/"123.234.23.1", /*service_name=*/"NC-WifiDirectTest",
/*gateway=*/"123.234.23.1", /*device_name=*/"NC-WifiDirectTest",
/*pin=*/"b592f7d3");
case location::nearby::proto::connections::UNKNOWN_MEDIUM:
case location::nearby::proto::connections::MDNS:
connections/implementation/mediums/wifi_direct_bwu_handler.cc
+7 -7
View File
@@ -86,14 +86,14 @@ std::string WifiDirectBwuHandler::HandleInitializeUpgradedMediumForEndpoint(
wifi_direct_medium_.GetCredentials(upgrade_service_id);
std::string ssid = wifi_direct_crendential->GetSSID();
std::string password = wifi_direct_crendential->GetPassword();
std::string service_name = wifi_direct_crendential->GetServiceName();
std::string device_name = wifi_direct_crendential->GetDeviceName();
std::string pin = wifi_direct_crendential->GetPin();
std::string gateway = wifi_direct_crendential->GetGateway();
int port = wifi_direct_crendential->GetPort();
int freq = wifi_direct_crendential->GetFrequency();
if (ssid.empty()) {
LOG(INFO) << "Start WifiDirect GO with ServiceName: " << service_name
LOG(INFO) << "Start WifiDirect GO with DeviceName: " << device_name
<< ", pin: " << masker::Mask(pin) << ", Port: " << port
<< ", Gateway: " << gateway << ", Frequency: " << freq;
} else {
@@ -108,7 +108,7 @@ std::string WifiDirectBwuHandler::HandleInitializeUpgradedMediumForEndpoint(
return parser::ForBwuWifiDirectPathAvailable(
ssid, password, port, freq,
/* supports_disabling_encryption */ disabling_encryption, gateway,
service_name, pin);
device_name, pin);
}
void WifiDirectBwuHandler::HandleRevertInitiatorStateForService(
@@ -138,8 +138,8 @@ WifiDirectBwuHandler::CreateUpgradedEndpointChannel(
const std::string& ssid = upgrade_path_info_credentials.ssid();
const std::string& password = upgrade_path_info_credentials.password();
const std::string& service_name =
upgrade_path_info_credentials.service_name();
const std::string& device_name =
upgrade_path_info_credentials.device_name();
const std::string& pin = upgrade_path_info_credentials.pin();
std::int32_t port = upgrade_path_info_credentials.port();
const std::string& gateway = upgrade_path_info_credentials.gateway();
@@ -148,14 +148,14 @@ WifiDirectBwuHandler::CreateUpgradedEndpointChannel(
WifiDirectCredentials wifi_direct_credentials;
wifi_direct_credentials.SetSSID(ssid);
wifi_direct_credentials.SetPassword(password);
wifi_direct_credentials.SetServiceName(service_name);
wifi_direct_credentials.SetDeviceName(device_name);
wifi_direct_credentials.SetPin(pin);
wifi_direct_credentials.SetPort(port);
wifi_direct_credentials.SetGateway(gateway);
wifi_direct_credentials.SetFrequency(freq);
if (ssid.empty()) {
LOG(INFO) << "Received WifiDirect credential ServiceName: " << service_name
LOG(INFO) << "Received WifiDirect credential DeviceName: " << device_name
<< ", pin: " << masker::Mask(pin) << ", Port: " << port
<< ", Gateway: " << gateway << ", Frequency: " << freq;
} else {
connections/implementation/mediums/wifi_direct_test.cc
+12 -11
View File
@@ -45,7 +45,7 @@ constexpr FeatureFlags kTestCases[] = {
};
constexpr absl::string_view kServiceID{"com.google.location.nearby.apps.test"};
constexpr absl::string_view kServiceName{"NC-WifiDirectTest"};
constexpr absl::string_view kDeviceName{"NC-WifiDirectTest"};
constexpr absl::string_view kPin{"12345678"};
constexpr absl::string_view kIp = "123.234.23.1";
constexpr const size_t kPort = 20;
@@ -93,9 +93,9 @@ TEST_F(WifiDirectTest, CanStartStopGO) {
TEST_F(WifiDirectTest, GCCanConnectDisconnectGO) {
WifiDirectCredentials wifi_direct_credentials;
std::string service_name(kServiceName);
std::string device_name(kDeviceName);
std::string pin(kPin);
wifi_direct_credentials.SetServiceName(service_name);
wifi_direct_credentials.SetDeviceName(device_name);
wifi_direct_credentials.SetPin(pin);
WifiDirect wifi_direct_a;
@@ -187,9 +187,9 @@ TEST_F(WifiDirectTest, CanStartGOTheOtherFailConnect) {
EXPECT_TRUE(wifi_direct_a.StartWifiDirect());
WifiDirectCredentials wifi_direct_credentials;
std::string service_name(kServiceName);
std::string device_name(kDeviceName);
std::string pin(kPin);
wifi_direct_credentials.SetServiceName(service_name);
wifi_direct_credentials.SetDeviceName(device_name);
wifi_direct_credentials.SetPin(pin);
EXPECT_FALSE(wifi_direct_b.ConnectWifiDirect(wifi_direct_credentials));
EXPECT_TRUE(wifi_direct_b.DisconnectWifiDirect());
@@ -201,23 +201,24 @@ TEST_F(WifiDirectTest, GetSupportedWifiDirectAuthTypes) {
auto supported_types = wifi_direct.GetSupportedWifiDirectAuthTypes();
EXPECT_EQ(supported_types.size(), 1);
EXPECT_EQ(supported_types[0],
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_PIN);
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME);
}
TEST_F(WifiDirectTest, GetPreferredWifiDirectAuthType_Default) {
WifiDirect wifi_direct;
// Default should be the first supported type, which is WIFI_DIRECT_WITH_PIN
// Default should be the first supported type, which is
// WIFI_DIRECT_WITH_DEVICE_NAME
EXPECT_EQ(wifi_direct.GetPreferredWifiDirectAuthType(),
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_PIN);
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME);
}
TEST_F(WifiDirectTest, SetPreferredWifiDirectAuthType_Supported) {
WifiDirect wifi_direct;
// Attempt to set the preferred type to the already default/supported type.
EXPECT_TRUE(wifi_direct.SetPreferredWifiDirectAuthType(
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_PIN));
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME));
EXPECT_EQ(wifi_direct.GetPreferredWifiDirectAuthType(),
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_PIN);
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME);
}
TEST_F(WifiDirectTest, SetPreferredWifiDirectAuthType_Unsupported) {
@@ -227,7 +228,7 @@ TEST_F(WifiDirectTest, SetPreferredWifiDirectAuthType_Unsupported) {
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD));
// Preferred type should remain the default.
EXPECT_EQ(wifi_direct.GetPreferredWifiDirectAuthType(),
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_PIN);
WifiDirect::WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME);
}
} // namespace
connections/implementation/offline_frames.cc
+6 -6
View File
@@ -363,7 +363,7 @@ std::string ForBwuWifiAwarePathAvailable(const std::string& service_id,
std::string ForBwuWifiDirectPathAvailable(
const std::string& ssid, const std::string& password, std::int32_t port,
std::int32_t frequency, bool supports_disabling_encryption,
const std::string& gateway, const std::string& service_name,
const std::string& gateway, const std::string& device_name,
const std::string& pin) {
OfflineFrame frame;
@@ -385,7 +385,7 @@ std::string ForBwuWifiDirectPathAvailable(
wifi_direct_credentials->set_port(port);
wifi_direct_credentials->set_frequency(frequency);
wifi_direct_credentials->set_gateway(gateway);
wifi_direct_credentials->set_service_name(service_name);
wifi_direct_credentials->set_device_name(device_name);
wifi_direct_credentials->set_pin(pin);
return frame.SerializeAsString();
@@ -709,8 +709,8 @@ MediumMetadata::WifiDirectAuthType WFDAuthTypeToMediumMetadataWFDAuthType(
switch (wifi_direct_auth_type) {
case WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD:
return MediumMetadata::WIFI_DIRECT_WITH_PASSWORD;
case WifiDirectAuthType::WIFI_DIRECT_WITH_PIN:
return MediumMetadata::WIFI_DIRECT_WITH_PIN;
case WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME:
return MediumMetadata::WIFI_DIRECT_WITH_DEVICE_NAME;
default:
return MediumMetadata::WIFI_DIRECT_TYPE_UNKNOWN;
}
@@ -721,8 +721,8 @@ WifiDirectAuthType MediumMetadataWFDAuthTypeToWFDAuthType(
switch (wifi_direct_auth_type) {
case MediumMetadata::WIFI_DIRECT_WITH_PASSWORD:
return WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD;
case MediumMetadata::WIFI_DIRECT_WITH_PIN:
return WifiDirectAuthType::WIFI_DIRECT_WITH_PIN;
case MediumMetadata::WIFI_DIRECT_WITH_DEVICE_NAME:
return WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME;
default:
return WifiDirectAuthType::WIFI_DIRECT_TYPE_UNKNOWN;
}
connections/implementation/offline_frames.h
+1 -1
View File
@@ -98,7 +98,7 @@ std::string ForBwuWifiDirectPathAvailable(const std::string& ssid,
std::int32_t frequency,
bool supports_disabling_encryption,
const std::string& gateway,
const std::string& service_name,
const std::string& device_name,
const std::string& pin);
std::string ForBwuBluetoothPathAvailable(const std::string& service_id,
MacAddress mac_address);
connections/implementation/offline_frames_test.cc
+9 -9
View File
@@ -289,7 +289,7 @@ TEST(OfflineFramesTest,
supports_5_ghz: true
bssid: "FF:FF:FF:FF:FF:FF"
ap_frequency: 2412
supported_wifi_direct_auth_types: WIFI_DIRECT_WITH_PIN
supported_wifi_direct_auth_types: WIFI_DIRECT_WITH_DEVICE_NAME
supported_wifi_direct_auth_types: WIFI_DIRECT_WITH_PASSWORD
>
mediums: MDNS
@@ -324,7 +324,7 @@ TEST(OfflineFramesTest,
kKeepAliveIntervalMillis,
kKeepAliveTimeoutMillis};
connection_info.supported_wifi_direct_auth_types = {
WifiDirectAuthType::WIFI_DIRECT_WITH_PIN,
WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME,
WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD};
location::nearby::connections::ConnectionsDevice connections_device;
@@ -596,7 +596,7 @@ TEST(OfflineFramesTest, CanGenerateBwuWifiDirectPathAvailable) {
port: 1000
frequency: 2412
gateway: "192.168.1.1"
service_name: "NC-WifiDirectTest"
device_name: "NC-WifiDirectTest"
pin: "b592f7d3"
>
supports_disabling_encryption: false
@@ -756,8 +756,8 @@ TEST(OfflineFramesTest, WFDAuthTypeToMediumMetadataWFDAuthType) {
WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD),
MediumMetadata::WIFI_DIRECT_WITH_PASSWORD);
EXPECT_EQ(WFDAuthTypeToMediumMetadataWFDAuthType(
WifiDirectAuthType::WIFI_DIRECT_WITH_PIN),
MediumMetadata::WIFI_DIRECT_WITH_PIN);
WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME),
MediumMetadata::WIFI_DIRECT_WITH_DEVICE_NAME);
EXPECT_EQ(WFDAuthTypeToMediumMetadataWFDAuthType(
WifiDirectAuthType::WIFI_DIRECT_TYPE_UNKNOWN),
MediumMetadata::WIFI_DIRECT_TYPE_UNKNOWN);
@@ -768,8 +768,8 @@ TEST(OfflineFramesTest, MediumMetadataWFDAuthTypeToWFDAuthType) {
MediumMetadata::WIFI_DIRECT_WITH_PASSWORD),
WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD);
EXPECT_EQ(MediumMetadataWFDAuthTypeToWFDAuthType(
MediumMetadata::WIFI_DIRECT_WITH_PIN),
WifiDirectAuthType::WIFI_DIRECT_WITH_PIN);
MediumMetadata::WIFI_DIRECT_WITH_DEVICE_NAME),
WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME);
EXPECT_EQ(MediumMetadataWFDAuthTypeToWFDAuthType(
MediumMetadata::WIFI_DIRECT_TYPE_UNKNOWN),
WifiDirectAuthType::WIFI_DIRECT_TYPE_UNKNOWN);
@@ -780,11 +780,11 @@ TEST(OfflineFramesTest, MediumMetadataWFDAuthTypesToWFDAuthTypes) {
medium_metadata.add_supported_wifi_direct_auth_types(
MediumMetadata::WIFI_DIRECT_WITH_PASSWORD);
medium_metadata.add_supported_wifi_direct_auth_types(
MediumMetadata::WIFI_DIRECT_WITH_PIN);
MediumMetadata::WIFI_DIRECT_WITH_DEVICE_NAME);
std::vector<WifiDirectAuthType> expected = {
WifiDirectAuthType::WIFI_DIRECT_WITH_PASSWORD,
WifiDirectAuthType::WIFI_DIRECT_WITH_PIN};
WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME};
EXPECT_THAT(MediumMetadataWFDAuthTypesToWFDAuthTypes(medium_metadata),
Pointwise(testing::Eq(), expected));
connections/implementation/offline_frames_validator.cc
+4 -4
View File
@@ -291,16 +291,16 @@ Exception EnsureValidBandwidthUpgradeWifiDirectPathAvailableFrame(
wifi_direct_credentials.has_password() &&
WithinRange(wifi_direct_credentials.password().length(),
kWifiPasswordSsidMinLength, kWifiPasswordSsidMaxLength);
bool service_name_valid =
wifi_direct_credentials.has_service_name() &&
wifi_direct_credentials.service_name().length() <
bool device_name_valid =
wifi_direct_credentials.has_device_name() &&
wifi_direct_credentials.device_name().length() <
kWifiDirectSsidMaxLength;
bool pin_valid =
wifi_direct_credentials.has_pin() &&
WithinRange(wifi_direct_credentials.pin().length(),
kWifiDirectPinMinLength, kWifiDirectPinMaxLength);
if ((ssid_valid && password_valid) || (service_name_valid && pin_valid))
if ((ssid_valid && password_valid) || (device_name_valid && pin_valid))
return {Exception::kSuccess};
return {Exception::kInvalidProtocolBuffer};
connections/implementation/offline_frames_validator_test.cc
+10 -10
View File
@@ -49,7 +49,7 @@ constexpr absl::string_view kPassword = "password";
constexpr absl::string_view kWifiHotspotGateway = "0.0.0.0";
constexpr absl::string_view kWifiDirectSsid = "DIRECT-A0-0123456789AB";
constexpr absl::string_view kWifiDirectPassword = "WIFIDIRECT123456";
constexpr absl::string_view kWifiDirectServiceName = "NC-WifiDirectTest";
constexpr absl::string_view kWifiDirectDeviceName = "NC-WifiDirectTest";
constexpr absl::string_view kWifiDirectPin = "b592f7d3";
constexpr absl::string_view kGateway = "192.168.1.1";
constexpr int kWifiDirectFrequency = 2412;
@@ -723,7 +723,7 @@ TEST(OfflineFramesValidatorTest, ValidatesAsOkBandwidthUpgradeWifiDirect) {
std::string bytes = ForBwuWifiDirectPathAvailable(
std::string(kWifiDirectSsid), std::string(kWifiDirectPassword), kPort,
kWifiDirectFrequency, kSupportsDisablingEncryption, std::string(kGateway),
std::string(kWifiDirectServiceName), std::string(kWifiDirectPin));
std::string(kWifiDirectDeviceName), std::string(kWifiDirectPin));
offline_frame.ParseFromString(bytes);
auto ret_value = EnsureValidOfflineFrame(offline_frame);
@@ -740,7 +740,7 @@ TEST(OfflineFramesValidatorTest,
std::string bytes = ForBwuWifiDirectPathAvailable(
std::string(kWifiDirectSsid), std::string(kWifiDirectPassword), kPort, -2,
kSupportsDisablingEncryption, std::string(kGateway),
std::string(kWifiDirectServiceName), std::string(kWifiDirectPin));
std::string(kWifiDirectDeviceName), std::string(kWifiDirectPin));
offline_frame_1.ParseFromString(bytes);
auto ret_value = EnsureValidOfflineFrame(offline_frame_1);
@@ -751,7 +751,7 @@ TEST(OfflineFramesValidatorTest,
bytes = ForBwuWifiDirectPathAvailable(
std::string(kWifiDirectSsid), std::string(kWifiDirectPassword), kPort, -1,
kSupportsDisablingEncryption, std::string(kGateway),
std::string(kWifiDirectServiceName), std::string(kWifiDirectPin));
std::string(kWifiDirectDeviceName), std::string(kWifiDirectPin));
offline_frame_2.ParseFromString(bytes);
ret_value = EnsureValidOfflineFrame(offline_frame_2);
@@ -769,7 +769,7 @@ TEST(OfflineFramesValidatorTest,
std::string bytes = ForBwuWifiDirectPathAvailable(
wifi_direct_ssid, std::string(kWifiDirectPassword), kPort,
kWifiDirectFrequency, kSupportsDisablingEncryption,
std::string(kGateway), std::string(kWifiDirectServiceName),
std::string(kGateway), std::string(kWifiDirectDeviceName),
wifi_direct_pin_wrong_length);
offline_frame_1.ParseFromString(bytes);
@@ -779,13 +779,13 @@ TEST(OfflineFramesValidatorTest,
std::string wifi_direct_ssid_wrong_length =
std::string{kWifiDirectSsid} + "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
std::string wifi_direct_service_name_wrong_length =
std::string{kWifiDirectServiceName} +
std::string wifi_direct_device_name_wrong_length =
std::string{kWifiDirectDeviceName} +
"ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
bytes = ForBwuWifiDirectPathAvailable(
wifi_direct_ssid_wrong_length, std::string(kWifiDirectPassword), kPort,
kWifiDirectFrequency, kSupportsDisablingEncryption,
std::string(kGateway), wifi_direct_service_name_wrong_length,
std::string(kGateway), wifi_direct_device_name_wrong_length,
std::string(kWifiDirectPin));
offline_frame_2.ParseFromString(bytes);
@@ -804,7 +804,7 @@ TEST(OfflineFramesValidatorTest,
std::string bytes = ForBwuWifiDirectPathAvailable(
std::string(kWifiDirectSsid), short_wifi_direct_password, kPort,
kWifiDirectFrequency, kSupportsDisablingEncryption,
std::string(kGateway), std::string(kWifiDirectServiceName),
std::string(kGateway), std::string(kWifiDirectDeviceName),
short_wifi_direct_pin);
offline_frame_1.ParseFromString(bytes);
@@ -821,7 +821,7 @@ TEST(OfflineFramesValidatorTest,
bytes = ForBwuWifiDirectPathAvailable(
std::string(kWifiDirectSsid), long_wifi_direct_password, kPort,
kWifiDirectFrequency, kSupportsDisablingEncryption,
std::string(kGateway), std::string(kWifiDirectServiceName),
std::string(kGateway), std::string(kWifiDirectDeviceName),
long_wifi_direct_pin);
offline_frame_2.ParseFromString(bytes);
internal/platform/implementation/g3/wifi_direct.cc
+6 -6
View File
@@ -135,12 +135,12 @@ bool WifiDirectMedium::StartWifiDirect(
WifiDirectCredentials* wifi_direct_credentials) {
absl::MutexLock lock(mutex_);
std::string service_name = absl::StrCat("NC-", Prng().NextUint32());
wifi_direct_credentials->SetServiceName(service_name);
std::string device_name = absl::StrCat("NC-", Prng().NextUint32());
wifi_direct_credentials->SetDeviceName(device_name);
std::string pin = absl::StrFormat("%04x", Prng().NextUint32());
wifi_direct_credentials->SetPin(pin);
LOG(INFO) << "G3 StartWifiDirect GO: service_name:" << service_name
LOG(INFO) << "G3 StartWifiDirect GO: device_name:" << device_name
<< ", pin:" << pin;
auto& env = MediumEnvironment::Instance();
@@ -165,13 +165,13 @@ bool WifiDirectMedium::ConnectWifiDirect(
const WifiDirectCredentials& wifi_direct_credentials) {
absl::MutexLock lock(mutex_);
LOG(INFO) << "G3 ConnectWifiDirect : service_name:"
<< wifi_direct_credentials.GetServiceName()
LOG(INFO) << "G3 ConnectWifiDirect : device_name:"
<< wifi_direct_credentials.GetDeviceName()
<< ", pin:" << wifi_direct_credentials.GetPin();
auto& env = MediumEnvironment::Instance();
auto* remote_medium = static_cast<WifiDirectMedium*>(
env.GetWifiDirectMedium(wifi_direct_credentials.GetServiceName(), ""));
env.GetWifiDirectMedium(wifi_direct_credentials.GetDeviceName(), ""));
if (!remote_medium) {
env.UpdateWifiDirectMediumForStartOrConnect(*this, &wifi_direct_credentials,
/*is_go=*/false,
internal/platform/implementation/g3/wifi_direct.h
+1 -1
View File
@@ -185,7 +185,7 @@ class WifiDirectMedium : public api::WifiDirectMedium {
// Returns the supported WifiDirect auth types.
std::vector<WifiDirectAuthType> GetSupportedWifiDirectAuthTypes()
const override {
return {WifiDirectAuthType::WIFI_DIRECT_WITH_PIN};
return {WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME};
}
private:
internal/platform/implementation/windows/wifi_direct_medium.cc
+8 -8
View File
@@ -304,13 +304,13 @@ bool WifiDirectMedium::StartWifiDirect(
std::string pin = absl::StrFormat("%04x", prng.NextUint32());
credentials_go_->SetPin(pin);
std::string service_name =
std::string device_name =
absl::StrCat(kServiceNamePrefix, std::to_string(prng.NextUint32()));
credentials_go_->SetServiceName(service_name);
LOG(INFO) << "service_name:pin " << service_name << ":" << pin;
credentials_go_->SetDeviceName(device_name);
LOG(INFO) << "device_name:pin " << device_name << ":" << pin;
// Create Advertiser object
advertiser_ = WiFiDirectServiceAdvertiser(winrt::to_hstring(service_name));
advertiser_ = WiFiDirectServiceAdvertiser(winrt::to_hstring(device_name));
advertisement_status_changed_token_ = advertiser_.AdvertisementStatusChanged(
{this, &WifiDirectMedium::OnAdvertisementStatusChanged});
auto_accept_session_connected_token_ = advertiser_.AutoAcceptSessionConnected(
@@ -572,12 +572,12 @@ bool WifiDirectMedium::ConnectWifiDirect(
}
credentials_gc_ = credentials;
if (credentials_gc_.GetServiceName().empty()) {
LOG(ERROR) << "GC: Service name is empty, return false";
if (credentials_gc_.GetDeviceName().empty()) {
LOG(ERROR) << "GC: Device name is empty, return false";
return false;
}
winrt::hstring device_selector = WiFiDirectService::GetSelector(
winrt::to_hstring(credentials_gc_.GetServiceName()));
winrt::to_hstring(credentials_gc_.GetDeviceName()));
const winrt::param::iterable<winrt::hstring> requested_properties =
winrt::single_threaded_vector<winrt::hstring>({
winrt::to_hstring("System.Devices.WiFiDirectServices.ServiceAddress"),
@@ -762,7 +762,7 @@ bool WifiDirectMedium::DisconnectWifiDirect() {
std::vector<WifiDirectMedium::WifiDirectAuthType>
WifiDirectMedium::GetSupportedWifiDirectAuthTypes() const {
// Windows only supports WifiDirect with Service Discovery, which uses a PIN.
return {WifiDirectAuthType::WIFI_DIRECT_WITH_PIN};
return {WifiDirectAuthType::WIFI_DIRECT_WITH_DEVICE_NAME};
}
} // namespace windows
internal/platform/implementation/windows/wifi_direct_test.cc
+2 -2
View File
@@ -82,7 +82,7 @@ TEST(WifiDirectMedium, DISABLED_ConnectWifiDirect) {
std::cin >> pin;
std::string service_name_with_prefix =
absl::StrCat(kServiceNamePrefix, service_name);
credentials.SetServiceName(service_name_with_prefix);
credentials.SetDeviceName(service_name_with_prefix);
credentials.SetPin(pin);
EXPECT_TRUE(wifi_direct_medium.ConnectWifiDirect(credentials));
@@ -159,7 +159,7 @@ TEST(WifiDirectMedium, DISABLED_WifiDirectConnectToServiceServer) {
std::cin >> pin;
std::string service_name_with_prefix =
absl::StrCat(kServiceNamePrefix, service_name);
credentials.SetServiceName(service_name_with_prefix);
credentials.SetDeviceName(service_name_with_prefix);
credentials.SetPin(pin);
EXPECT_TRUE(wifi_direct_medium.ConnectWifiDirect(credentials));
internal/platform/medium_environment.cc
+4 -4
View File
@@ -983,13 +983,13 @@ void MediumEnvironment::RegisterWifiDirectMedium(
}
api::WifiDirectMedium* MediumEnvironment::GetWifiDirectMedium(
absl::string_view service_name, absl::string_view ip_address) {
absl::string_view device_name, absl::string_view ip_address) {
MutexLock lock(&mutex_);
for (auto& medium_info : wifi_direct_mediums_) {
auto* medium_found = medium_info.first;
auto& info = medium_info.second;
if (info.is_go && info.is_active) {
if ((info.wifi_direct_credentials->GetServiceName() == service_name) ||
if ((info.wifi_direct_credentials->GetDeviceName() == device_name) ||
(!ip_address.empty() &&
(info.wifi_direct_credentials->GetGateway() == ip_address))) {
LOG(INFO) << "Found Remote WifiDirect medium=" << medium_found;
@@ -1020,8 +1020,8 @@ void MediumEnvironment::UpdateWifiDirectMediumForStartOrConnect(
if (wifi_direct_credentials) {
LOG(INFO) << "Update WifiDirect medium for GO: this=" << this
<< "; medium=" << &medium << role_status
<< "; service_name="
<< wifi_direct_credentials->GetServiceName()
<< "; device_name="
<< wifi_direct_credentials->GetDeviceName()
<< "; pin=" << wifi_direct_credentials->GetPin();
} else {
LOG(INFO) << "Reset WifiDirect medium for GO: this=" << this
internal/platform/medium_environment.h
+1 -1
View File
@@ -290,7 +290,7 @@ class MediumEnvironment {
// Returns WifiDirect medium that matches ssid or IP address with the role of
// the Medium. Returns nullptr if not found.
api::WifiDirectMedium* GetWifiDirectMedium(absl::string_view service_name,
api::WifiDirectMedium* GetWifiDirectMedium(absl::string_view device_name,
absl::string_view ip_address);
// Updates credential and Medium role(GO or GC) to indicate the current
internal/platform/wifi_credential.h
+6 -6
View File
@@ -83,10 +83,10 @@ class WifiDirectCredentials {
std::string GetPassword() const { return password_; }
void SetPassword(const std::string& password) { password_ = password; }
// Get/Set Service Name.
std::string GetServiceName() const { return service_name_; }
void SetServiceName(const std::string& service_name) {
service_name_ = service_name;
// Get/Set Device Name.
std::string GetDeviceName() const { return device_name_; }
void SetDeviceName(const std::string& device_name) {
device_name_ = device_name;
}
// Get/Set Pin.
@@ -126,12 +126,12 @@ class WifiDirectCredentials {
private:
// There are 2 types of WifiDirectAuthType.
// 1. Without Service Discovery: the credentials are ssid/password.
// 2. With Service Discovery: the credentials are service_name/pin.
// 2. With Service Discovery: the credentials are device_name/pin.
// Android supports type 1 and 2 in the future, but Windows only supports the
// second type.
std::string ssid_;
std::string password_;
std::string service_name_;
std::string device_name_;
std::string pin_;
std::string ip_address_;
std::string gateway_ = "0.0.0.0";
internal/platform/wifi_direct_test.cc
+12 -12
View File
@@ -47,19 +47,19 @@ constexpr FeatureFlags kTestCases[] = {
},
};
constexpr absl::string_view kServiceName = "NC-WifiDirectTest";
constexpr absl::string_view kDeviceName = "NC-WifiDirectTest";
constexpr absl::string_view kPin = "b592f7d3";
constexpr absl::string_view kIp = "123.234.23.1";
constexpr const size_t kPort = 20;
constexpr absl::string_view kData = "ABCD";
constexpr const size_t kChunkSize = 10;
TEST(WifiDirectCredentialsTest, SetGetServiceName) {
std::string service_name(kServiceName);
TEST(WifiDirectCredentialsTest, SetGetDeviceName) {
std::string device_name(kDeviceName);
WifiDirectCredentials wifi_direct_credentials;
wifi_direct_credentials.SetServiceName(service_name);
wifi_direct_credentials.SetDeviceName(device_name);
EXPECT_EQ(wifi_direct_credentials.GetServiceName(), kServiceName);
EXPECT_EQ(wifi_direct_credentials.GetDeviceName(), kDeviceName);
}
TEST(WifiDirectCredentialsTest, SetGetPin) {
@@ -116,7 +116,7 @@ TEST_F(WifiDirectMediumTest, CanStartStopWifiDirect) {
TEST_F(WifiDirectMediumTest, CanConnectDisconnectWifiDirect) {
WifiDirectMedium wifi_direct_a;
WifiDirectCredentials credentials;
credentials.SetServiceName(std::string(kServiceName));
credentials.SetDeviceName(std::string(kDeviceName));
credentials.SetPin(std::string(kPin));
ASSERT_TRUE(wifi_direct_a.IsInterfaceValid());
@@ -136,7 +136,7 @@ TEST_P(WifiDirectMediumTest, CanStartDirectGOThatOtherCanConnect) {
WifiDirectCredentials* wifi_direct_credentials =
wifi_direct_a.GetCredential();
auto* medium_a =
env_.GetWifiDirectMedium(wifi_direct_credentials->GetServiceName(), {});
env_.GetWifiDirectMedium(wifi_direct_credentials->GetDeviceName(), {});
EXPECT_NE(medium_a, nullptr);
EXPECT_TRUE(wifi_direct_b.ConnectWifiDirect(*wifi_direct_credentials));
@@ -198,7 +198,7 @@ TEST_P(WifiDirectMediumTest, CanStartDirectGOThatOtherCanConnect) {
EXPECT_TRUE(wifi_direct_b.DisconnectWifiDirect());
EXPECT_TRUE(wifi_direct_a.StopWifiDirect());
auto* medium_b =
env_.GetWifiDirectMedium(wifi_direct_credentials->GetServiceName(), {});
env_.GetWifiDirectMedium(wifi_direct_credentials->GetDeviceName(), {});
EXPECT_EQ(medium_b, nullptr);
}
@@ -278,7 +278,7 @@ TEST_F(WifiDirectMediumTest, CanStartDirectGOThatOtherFailConnect) {
ASSERT_TRUE(wifi_direct_b.IsInterfaceValid());
EXPECT_TRUE(wifi_direct_a.StartWifiDirect());
WifiDirectCredentials wifi_direct_credentials;
wifi_direct_credentials.SetServiceName(std::string(kServiceName));
wifi_direct_credentials.SetDeviceName(std::string(kDeviceName));
wifi_direct_credentials.SetPin(std::string(kPin));
EXPECT_FALSE(wifi_direct_b.ConnectWifiDirect(wifi_direct_credentials));
@@ -289,12 +289,12 @@ TEST_F(WifiDirectMediumTest, CanStartDirectGOThatOtherFailConnect) {
TEST_F(WifiDirectMediumTest, GetSupportedWifiDirectAuthTypes) {
WifiDirectMedium wifi_direct_a;
// g3 only supports WifiDirect with auth type of PIN.
// g3 only supports WifiDirect with auth type of Device Name.
auto supported_types = wifi_direct_a.GetSupportedWifiDirectAuthTypes();
EXPECT_EQ(supported_types.size(), 1);
EXPECT_EQ(supported_types[0],
location::nearby::proto::connections::
WifiDirectAuthType::WIFI_DIRECT_WITH_PIN);
location::nearby::proto::connections::WifiDirectAuthType::
WIFI_DIRECT_WITH_DEVICE_NAME);
}
} // namespace