[BLE Refactor] Removes fast advertisement uuid in StartAdvertising and StartScanning.

PiperOrigin-RevId: 448426759

connections/implementation/mediums/ble_v2.cc

@@ -77,12 +77,10 @@ bool BleV2::IsAvailable() const {
 }
 
 // TODO(edwinwu): Break down the function.
-// TODO(b/229927044): Use bool: is_fast_advertisement, not
-// fast_advertisement_service_uuid.
-bool BleV2::StartAdvertising(
-    const std::string& service_id, const ByteArray& advertisement_bytes,
-    PowerLevel power_level,
-    const std::string& fast_advertisement_service_uuid) {
+bool BleV2::StartAdvertising(const std::string& service_id,
+                             const ByteArray& advertisement_bytes,
+                             PowerLevel power_level,
+                             bool is_fast_advertisement) {
   MutexLock lock(&mutex_);
 
   if (advertisement_bytes.Empty()) {
@@ -117,7 +115,6 @@ bool BleV2::StartAdvertising(
   }
 
   // Wrap the connections advertisement to the medium advertisement.
-  const bool is_fast_advertisement = !fast_advertisement_service_uuid.empty();
   ByteArray service_id_hash = mediums::bleutils::GenerateHash(
       service_id, mediums::BleAdvertisement::kServiceIdHashLength);
   ByteArray medium_advertisement_bytes{mediums::BleAdvertisement{
@@ -139,13 +136,15 @@ bool BleV2::StartAdvertising(
     advertising_data.is_connectable = true;
     advertising_data.tx_power_level =
         BleAdvertisementData::kUnspecifiedTxPowerLevel;
-    advertising_data.service_uuids.insert(fast_advertisement_service_uuid);
+    advertising_data.service_uuids.insert(
+        std::string(mediums::bleutils::kCopresenceServiceUuid));
 
     scan_response_data.is_connectable = true;
     scan_response_data.tx_power_level =
         BleAdvertisementData::kUnspecifiedTxPowerLevel;
     scan_response_data.service_data.insert(
-        {fast_advertisement_service_uuid, medium_advertisement_bytes});
+        {std::string(mediums::bleutils::kCopresenceServiceUuid),
+         medium_advertisement_bytes});
   } else {
     // Stop the current advertisement GATT server if there are no incoming
     // sockets connected to this device.
@@ -209,10 +208,7 @@ bool BleV2::StartAdvertising(
     NEARBY_LOGS(ERROR)
         << "Failed to turn on BLE advertising with advertisement bytes="
         << absl::BytesToHexString(advertisement_bytes.data())
-        << ", is_fast_advertisement=" << is_fast_advertisement
-        << ", fast advertisement service uuid="
-        << (is_fast_advertisement ? fast_advertisement_service_uuid
-                                  : "[empty]");
+        << ", is_fast_advertisement=" << is_fast_advertisement;
 
     // If BLE advertising was not successful, stop the advertisement GATT
     // server.
@@ -275,10 +271,8 @@ bool BleV2::IsAdvertising(const std::string& service_id) const {
   return IsAdvertisingLocked(service_id);
 }
 
-// TODO(b/229927044): Remove param: fast_advertisement_service_uuid.
 bool BleV2::StartScanning(const std::string& service_id, PowerLevel power_level,
-                          DiscoveredPeripheralCallback callback,
-                          const std::string& fast_advertisement_service_uuid) {
+                          DiscoveredPeripheralCallback callback) {
   MutexLock lock(&mutex_);
 
   if (service_id.empty()) {
@@ -305,17 +299,9 @@ bool BleV2::StartScanning(const std::string& service_id, PowerLevel power_level,
   }
 
   // Start to track the advertisement found for specific `service_id`.
-  discovered_peripheral_tracker_.StartTracking(service_id, std::move(callback),
-                                               fast_advertisement_service_uuid);
-
-  // Check if scan has been activated, if yes, no need to notify client
-  // to scan again.
-  if (!scanned_service_ids_.empty()) {
-    scanned_service_ids_.insert(service_id);
-    NEARBY_LOGS(INFO) << "Turned on BLE scanning with service id=" << service_id
-                      << " without start client scanning";
-    return true;
-  }
+  discovered_peripheral_tracker_.StartTracking(
+      service_id, std::move(callback),
+      std::string(mediums::bleutils::kCopresenceServiceUuid));
 
   // Check if scan has been activated, if yes, no need to notify client
   // to scan again.
@@ -329,15 +315,9 @@ bool BleV2::StartScanning(const std::string& service_id, PowerLevel power_level,
   scanned_service_ids_.insert(service_id);
   // TODO(b/213835576): We should re-start scanning once the power level is
   // changed.
-  std::vector<std::string> scanning_service_uuids;
-  if (!fast_advertisement_service_uuid.empty()) {
-    scanning_service_uuids.push_back(fast_advertisement_service_uuid);
-  } else {
-    scanning_service_uuids.push_back(
-        std::string(mediums::bleutils::kCopresenceServiceUuid));
-  }
   if (!medium_.StartScanning(
-          scanning_service_uuids, PowerLevelToPowerMode(power_level),
+          std::string(mediums::bleutils::kCopresenceServiceUuid),
+          PowerLevelToPowerMode(power_level),
           {
               .advertisement_found_cb =
                   [this](BleV2Peripheral peripheral,

connections/implementation/mediums/ble_v2.h

@@ -55,19 +55,16 @@ class BleV2 final {
   // Starts BLE advertising, delivering additional information if the platform
   // supports it.
   //
-  // service_id           - The service ID to track.
-  // advertisement_bytes  - The connections BLE Advertisement used in
-  //                        advertising.
-  // power_level          - The power level to use for the advertisement.
-  // fast_advertisement_service_uuid - The service UUID to look for fast
-  //                                   advertisements on.
-  // Note: fast_advertisement_service_uuid can be an empty string to indicate
-  // that `fast_advertisement_service_uuid` will be ignored for regular
-  // advertisement.
+  // service_id            - The service ID to track.
+  // advertisement_bytes   - The connections BLE Advertisement used in
+  //                         advertising.
+  // power_level           - The power level to use for the advertisement.
+  // is_fast_advertisement - True to use fast advertisements, which are smaller
+  //                         but much more efficient to discover.
   bool StartAdvertising(const std::string& service_id,
                         const ByteArray& advertisement_bytes,
                         PowerLevel power_level,
-                        const std::string& fast_advertisement_service_uuid)
+                        bool is_fast_advertisement)
       ABSL_LOCKS_EXCLUDED(mutex_);
 
   // Disables BLE advertising.
@@ -85,12 +82,8 @@ class BleV2 final {
   // power_level - The power level to use for the discovery.
   // discovered_peripheral_callback - The callback to invoke for discovery
   //                                  events.
-  // Note: fast_advertisement_service_uuid can be emptry string to indicate that
-  // `fast_advertisement_service_uuid` will be ignored for regular
-  // advertisement.
   bool StartScanning(const std::string& service_id, PowerLevel power_level,
-                     DiscoveredPeripheralCallback callback,
-                     const std::string& fast_advertisement_service_uuid)
+                     DiscoveredPeripheralCallback callback)
       ABSL_LOCKS_EXCLUDED(mutex_);
 
   // Disables BLE scanning for a service ID.

connections/implementation/mediums/ble_v2_test.cc

@@ -33,8 +33,6 @@ constexpr absl::string_view kServiceIDA =
 constexpr absl::string_view kServiceIDB =
     "com.google.location.nearby.apps.test.b";
 constexpr absl::string_view kAdvertisementString = "\x0a\x0b\x0c\x0d";
-constexpr absl::string_view kFastAdvertisementServiceUuid =
-    "0000FE2C-0000-1000-8000-00805F9B34FB";
 
 class BleV2Test : public testing::Test {
  protected:
@@ -80,12 +78,11 @@ TEST_F(BleV2Test, CanStartFastAdvertising) {
                 EXPECT_TRUE(fast_advertisement);
                 found_latch.CountDown();
               },
-      },
-      std::string(kFastAdvertisementServiceUuid));
+      });
 
   EXPECT_TRUE(ble_a.StartAdvertising(
       std::string(kServiceIDA), advertisement_bytes, PowerLevel::kHighPower,
-      std::string(kFastAdvertisementServiceUuid)));
+      /*is_fast_advertisement=*/true));
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
   EXPECT_TRUE(ble_a.StopAdvertising(std::string(kServiceIDA)));
   ble_b.StopScanning(std::string(kServiceIDA));
@@ -105,7 +102,7 @@ TEST_F(BleV2Test, CanStartFastScanning) {
 
   ble_b.StartAdvertising(std::string(kServiceIDA), advertisement_bytes,
                          PowerLevel::kHighPower,
-                         std::string(kFastAdvertisementServiceUuid));
+                         /*is_fast_advertisement=*/true);
 
   EXPECT_TRUE(ble_a.StartScanning(
       std::string(kServiceIDA), PowerLevel::kHighPower,
@@ -118,8 +115,7 @@ TEST_F(BleV2Test, CanStartFastScanning) {
                 EXPECT_TRUE(fast_advertisement);
                 found_latch.CountDown();
               },
-      },
-      std::string(kFastAdvertisementServiceUuid)));
+      }));
 
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
   ble_b.StopAdvertising(std::string(kServiceIDA));
@@ -149,12 +145,11 @@ TEST_F(BleV2Test, CanStartAdvertising) {
                 EXPECT_FALSE(fast_advertisement);
                 found_latch.CountDown();
               },
-      },
-      /*fast_advertisement_service_uuid=*/"");
+      });
 
   EXPECT_TRUE(ble_a.StartAdvertising(
       std::string(kServiceIDA), advertisement_bytes, PowerLevel::kHighPower,
-      /*fast_advertisement_service_uuid=*/""));
+      /*is_fast_advertisement=*/false));
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
   EXPECT_TRUE(ble_a.StopAdvertising(std::string(kServiceIDA)));
   ble_b.StopScanning(std::string(kServiceIDA));
@@ -174,7 +169,7 @@ TEST_F(BleV2Test, CanStartScanning) {
 
   ble_b.StartAdvertising(std::string(kServiceIDA), advertisement_bytes,
                          PowerLevel::kHighPower,
-                         /*fast_advertisement_service_uuid=*/"");
+                         /*is_fast_advertisement=*/false);
 
   EXPECT_TRUE(ble_a.StartScanning(
       std::string(kServiceIDA), PowerLevel::kHighPower,
@@ -187,8 +182,7 @@ TEST_F(BleV2Test, CanStartScanning) {
                 EXPECT_FALSE(fast_advertisement);
                 found_latch.CountDown();
               },
-      },
-      /*fast_advertisement_service_uuid=*/""));
+      }));
 
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
   ble_b.StopAdvertising(std::string(kServiceIDA));
@@ -204,18 +198,15 @@ TEST_F(BleV2Test, CanStartStopMultipleScanningWithDifferentServiceIds) {
 
   EXPECT_TRUE(ble.StartScanning(std::string(kServiceIDA),
                                 PowerLevel::kHighPower,
-                                mediums::DiscoveredPeripheralCallback{},
-                                std::string(kFastAdvertisementServiceUuid)));
+                                mediums::DiscoveredPeripheralCallback{}));
   EXPECT_TRUE(ble.StartScanning(std::string(kServiceIDB),
                                 PowerLevel::kHighPower,
-                                mediums::DiscoveredPeripheralCallback{},
-                                std::string(kFastAdvertisementServiceUuid)));
+                                mediums::DiscoveredPeripheralCallback{}));
   EXPECT_TRUE(ble.StopScanning(std::string(kServiceIDA)));
 
   EXPECT_TRUE(ble.StartScanning(std::string(kServiceIDA),
                                 PowerLevel::kHighPower,
-                                mediums::DiscoveredPeripheralCallback{},
-                                std::string(kFastAdvertisementServiceUuid)));
+                                mediums::DiscoveredPeripheralCallback{}));
   EXPECT_TRUE(ble.StopScanning(std::string(kServiceIDA)));
   EXPECT_TRUE(ble.StopScanning(std::string(kServiceIDB)));
   env_.Stop();
@@ -235,20 +226,18 @@ TEST_F(BleV2Test, DestructWorksForStartAdvertisingAndScanningWithoutStop) {
   // Device A starts advertising with service IDA and IDB.
   EXPECT_TRUE(ble_a.StartAdvertising(
       std::string(kServiceIDA), advertisement_bytes, PowerLevel::kHighPower,
-      std::string(kFastAdvertisementServiceUuid)));
+      /*is_fast_advertisement=*/true));
   EXPECT_TRUE(ble_a.StartAdvertising(
       std::string(kServiceIDB), advertisement_bytes, PowerLevel::kHighPower,
-      std::string(kFastAdvertisementServiceUuid)));
+      /*is_fast_advertisement=*/true));
 
   // Device B starts scanning with service IDA and IDB
   EXPECT_TRUE(ble_b.StartScanning(std::string(kServiceIDA),
                                   PowerLevel::kHighPower,
-                                  mediums::DiscoveredPeripheralCallback{},
-                                  std::string(kFastAdvertisementServiceUuid)));
+                                  mediums::DiscoveredPeripheralCallback{}));
   EXPECT_TRUE(ble_b.StartScanning(std::string(kServiceIDB),
                                   PowerLevel::kHighPower,
-                                  mediums::DiscoveredPeripheralCallback{},
-                                  std::string(kFastAdvertisementServiceUuid)));
+                                  mediums::DiscoveredPeripheralCallback{}));
   env_.Stop();
 }
 
@@ -266,7 +255,7 @@ TEST_F(BleV2Test, StartFastScanningDiscoverAndLostPeripheral) {
 
   ble_b.StartAdvertising(std::string(kServiceIDA), advertisement_bytes,
                          PowerLevel::kHighPower,
-                         std::string(kFastAdvertisementServiceUuid));
+                         /*is_fast_advertisement=*/true);
 
   ble_a.StartScanning(
       std::string(kServiceIDA), PowerLevel::kHighPower,
@@ -284,8 +273,7 @@ TEST_F(BleV2Test, StartFastScanningDiscoverAndLostPeripheral) {
                             const std::string& service_id) {
                 lost_latch.CountDown();
               },
-      },
-      std::string(kFastAdvertisementServiceUuid));
+      });
 
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
 
@@ -316,7 +304,7 @@ TEST_F(BleV2Test,
 
   ble_b.StartAdvertising(std::string(kServiceIDA), advertisement_bytes,
                          PowerLevel::kHighPower,
-                         std::string(kFastAdvertisementServiceUuid));
+                         /*is_fast_advertisement=*/true);
 
   ble_a.StartScanning(
       std::string(kServiceIDA), PowerLevel::kHighPower,
@@ -334,8 +322,7 @@ TEST_F(BleV2Test,
                             const std::string& service_id) {
                 lost_latch.CountDown();
               },
-      },
-      std::string(kFastAdvertisementServiceUuid));
+      });
 
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
 
@@ -363,7 +350,7 @@ TEST_F(BleV2Test, StartScanningDiscoverAndLostPeripheral) {
 
   ble_b.StartAdvertising(std::string(kServiceIDA), advertisement_bytes,
                          PowerLevel::kHighPower,
-                         /*fast_advertisement_service_uuid=*/"");
+                         /*is_fast_advertisement=*/false);
 
   ble_a.StartScanning(
       std::string(kServiceIDA), PowerLevel::kHighPower,
@@ -381,8 +368,7 @@ TEST_F(BleV2Test, StartScanningDiscoverAndLostPeripheral) {
                             const std::string& service_id) {
                 lost_latch.CountDown();
               },
-      },
-      /*fast_advertisement_service_uuid=*/"");
+      });
 
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
 
@@ -411,7 +397,8 @@ TEST_F(BleV2Test, StartScanningDiscoverButNoPeripheralLostAfterStopScanning) {
   CountDownLatch lost_latch(1);
 
   ble_b.StartAdvertising(std::string(kServiceIDA), advertisement_bytes,
-                         PowerLevel::kHighPower, "");
+                         PowerLevel::kHighPower,
+                         /*is_fast_advertisement=*/false);
 
   ble_a.StartScanning(
       std::string(kServiceIDA), PowerLevel::kHighPower,
@@ -429,8 +416,7 @@ TEST_F(BleV2Test, StartScanningDiscoverButNoPeripheralLostAfterStopScanning) {
                             const std::string& service_id) {
                 lost_latch.CountDown();
               },
-      },
-      /*fast_advertisement_service_uuid=*/"");
+      });
 
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());