Remove device from local repository when user forget a device

PiperOrigin-RevId: 553269983

fastpair/internal/BUILD

@@ -14,6 +14,7 @@ cc_library(
         "//fastpair:fast_pair_controller",
         "//fastpair:fast_pair_events",
         "//fastpair:fast_pair_seeker",
+        "//fastpair/common",
         "//fastpair/internal/mediums",
         "//fastpair/pairing",
         "//fastpair/repository",
@@ -39,6 +40,9 @@ cc_test(
         "//fastpair/common",
         "//fastpair/message_stream:fake_gatt_callbacks",
         "//fastpair/message_stream:fake_provider",
+        "//fastpair/proto:fastpair_cc_proto",
+        "//fastpair/repository",
+        "//fastpair/repository:device_repository",
         "//fastpair/repository:test_support",
         "//internal/account:test_support",
         "//internal/platform:test_util",
@@ -46,7 +50,8 @@ cc_test(
         "//internal/platform/implementation/g3",  # build_cleaner: keep
         "//internal/test/google3_only:test",
         "@com_github_protobuf_matchers//protobuf-matchers",
-        "@com_google_absl//absl/time",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/strings",
         "@com_google_googletest//:gtest_main",
     ],
 )

fastpair/internal/fast_pair_seeker_impl.cc

@@ -21,11 +21,13 @@
 
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "fastpair/common/account_key.h"
 #include "fastpair/fast_pair_controller.h"
 #include "fastpair/fast_pair_events.h"
 #include "fastpair/pairing/pairer_broker_impl.h"
 #include "fastpair/scanning/scanner_broker_impl.h"
 #include "internal/platform/count_down_latch.h"
+#include "internal/platform/logging.h"
 #include "internal/platform/pending_job_registry.h"
 #include "internal/platform/single_thread_executor.h"
 
@@ -303,5 +305,23 @@ void FastPairSeekerImpl::OnRetroactivePairFound(FastPairDevice& device) {
   callbacks_.on_pair_event(device, PairEvent{.is_paired = true});
 }
 
+void FastPairSeekerImpl::ForgetDeviceByAccountKey(
+    const AccountKey& account_key) {
+  NEARBY_LOGS(VERBOSE) << __func__;
+  auto opt_device = devices_->FindDevice(account_key);
+  if (!opt_device.has_value()) {
+    NEARBY_LOGS(INFO) << __func__ << "No FP device matching the account key.";
+  } else {
+    devices_->RemoveDevice(opt_device.value());
+  }
+
+  repository_->DeleteAssociatedDeviceByAccountKey(
+      account_key, [&](absl::Status success) {
+        if (!success.ok()) return;
+        NEARBY_LOGS(VERBOSE) << "Deleted associated devcie by account key";
+        // Temporary solution to refresh the saved_devices_sheet.
+        repository_->GetUserSavedDevices();
+      });
+}
 }  // namespace fastpair
 }  // namespace nearby

fastpair/internal/fast_pair_seeker_impl.h

@@ -43,6 +43,7 @@ class FastPairSeekerExt : public FastPairSeeker {
 
   // Handle the state changes of screen lock.
   virtual void SetIsScreenLocked(bool is_locked) = 0;
+  virtual void ForgetDeviceByAccountKey(const AccountKey& account_key) = 0;
 };
 
 class FastPairSeekerImpl : public FastPairSeekerExt,
@@ -91,6 +92,7 @@ class FastPairSeekerImpl : public FastPairSeekerExt,
   absl::Status StartFastPairScan() override;
   absl::Status StopFastPairScan() override;
   void SetIsScreenLocked(bool is_locked) override;
+  void ForgetDeviceByAccountKey(const AccountKey& account_key) override;
 
   // From BluetoothClassicMedium::Observer.
   void DeviceAdded(BluetoothDevice& device) override;

fastpair/internal/fast_pair_seeker_impl_test.cc

@@ -18,18 +18,27 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "gmock/gmock.h"
 #include "protobuf-matchers/protocol-buffer-matchers.h"
 #include "gtest/gtest.h"
+#include "absl/status/status.h"
+#include "absl/strings/escaping.h"
+#include "fastpair/common/fast_pair_device.h"
 #include "fastpair/common/fast_pair_prefs.h"
 #include "fastpair/fast_pair_events.h"
 #include "fastpair/fast_pair_seeker.h"
 #include "fastpair/message_stream/fake_gatt_callbacks.h"
 #include "fastpair/message_stream/fake_provider.h"
+#include "fastpair/proto/data.proto.h"
+#include "fastpair/proto/enum.proto.h"
 #include "fastpair/repository/fake_fast_pair_repository.h"
+#include "fastpair/repository/fast_pair_device_repository.h"
+#include "fastpair/repository/fast_pair_repository.h"
 #include "internal/account/fake_account_manager.h"
 #include "internal/platform/count_down_latch.h"
+#include "internal/platform/logging.h"
 #include "internal/platform/medium_environment.h"
 #include "internal/platform/single_thread_executor.h"
 #include "internal/platform/task_runner_impl.h"
@@ -61,6 +70,19 @@ class MediumEnvironmentStarter {
   ~MediumEnvironmentStarter() { MediumEnvironment::Instance().Stop(); }
 };
 
+class FastPairRepositoryObserver : public FastPairRepository::Observer {
+ public:
+  explicit FastPairRepositoryObserver(CountDownLatch* latch) { latch_ = latch; }
+
+  void OnGetUserSavedDevices(
+      const proto::OptInStatus& opt_in_status,
+      const std::vector<proto::FastPairDevice>& devices) override {
+    latch_->CountDown();
+  }
+
+  CountDownLatch* latch_ = nullptr;
+};
+
 class FastPairSeekerImplTest : public testing::Test {
  protected:
   FastPairSeekerImplTest() {
@@ -222,6 +244,63 @@ TEST_F(FastPairSeekerImplTest, InitialPairing) {
   fast_pair_seeker_.reset();
 }
 
+TEST_F(FastPairSeekerImplTest, ForgetDeviceByAccountKey) {
+  NEARBY_LOG_SET_SEVERITY(VERBOSE);
+  FakeProvider provider;
+  CountDownLatch discover_latch(1);
+  CountDownLatch pair_latch(1);
+  fast_pair_seeker_ = std::make_unique<FastPairSeekerImpl>(
+      FastPairSeekerImpl::ServiceCallbacks{
+          .on_initial_discovery =
+              [&](const FastPairDevice& device, InitialDiscoveryEvent event) {
+                EXPECT_EQ(device.GetModelId(), kModelId);
+                EXPECT_OK(fast_pair_seeker_->StartInitialPairing(
+                    device, {},
+                    {.on_pairing_result = [&](const FastPairDevice& device,
+                                              absl::Status status) {
+                      EXPECT_EQ(device.GetBleAddress(),
+                                provider.GetMacAddress());
+                      EXPECT_OK(status);
+                      pair_latch.CountDown();
+                    }}));
+                discover_latch.CountDown();
+              }},
+      &executor_, account_manager_.get(), &devices_, repository_.get());
+
+  EXPECT_OK(fast_pair_seeker_->StartFastPairScan());
+  provider.PrepareForInitialPairing(
+      {
+          .private_key = absl::HexStringToBytes(kBobPrivateKey),
+          .public_key = absl::HexStringToBytes(kBobPublicKey),
+          .model_id = std::string(kModelId),
+          .pass_key = std::string(kPasskey),
+      },
+      &fake_gatt_callbacks_);
+
+  discover_latch.Await();
+  pair_latch.Await();
+  auto fp_device = devices_.FindDevice(provider.GetMacAddress());
+  ASSERT_TRUE(fp_device.has_value());
+  EXPECT_EQ(provider.GetAccountKey(), fp_device.value()->GetAccountKey());
+
+  // Adds FastPairRepository observer.
+  CountDownLatch repository_latch(1);
+  FastPairRepositoryObserver observer(&repository_latch);
+  repository_->AddObserver(&observer);
+  // Adds FastPairDeviceRepository observer.
+  CountDownLatch devices_latch(1);
+  FastPairDeviceRepository::RemoveDeviceCallback callback =
+      [&](const FastPairDevice& device) { devices_latch.CountDown(); };
+  devices_.AddObserver(&callback);
+
+  fast_pair_seeker_->ForgetDeviceByAccountKey(
+      fp_device.value()->GetAccountKey());
+  repository_latch.Await();
+  devices_latch.Await();
+  EXPECT_FALSE(devices_.FindDevice(provider.GetMacAddress()).has_value());
+  fast_pair_seeker_.reset();
+}
+
 TEST_F(FastPairSeekerImplTest, RetroactivePairingWithUserConsent) {
   NEARBY_LOG_SET_SEVERITY(VERBOSE);
   FakeProvider provider;