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

Add UX to show pairing result

Browse Source 
PiperOrigin-RevId: 551027791
This commit is contained in:
Qin Wang
2023-07-25 16:18:35 -07:00
committed by Copybara-Service
parent dfdb5a6405
commit 2bdafe926c
18 changed files with 239 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fastpair/keyed_service/fast_pair_mediator.cc
+15 -35
View File
@@ -21,14 +21,15 @@
#include <utility>
#include "absl/status/status.h"
#include "fastpair/common/fast_pair_device.h"
#include "fastpair/common/fast_pair_prefs.h"
#include "fastpair/common/protocol.h"
#include "fastpair/internal/mediums/mediums.h"
#include "fastpair/pairing/pairer_broker_impl.h"
#include "fastpair/repository/fast_pair_device_repository.h"
#include "fastpair/repository/fast_pair_repository_impl.h"
#include "fastpair/scanning/scanner_broker_impl.h"
#include "fastpair/server_access/fast_pair_client_impl.h"
#include "fastpair/repository/fast_pair_repository_impl.h"
#include "fastpair/ui/actions.h"
#include "fastpair/ui/fast_pair/fast_pair_notification_controller.h"
#include "fastpair/ui/ui_broker_impl.h"
@@ -98,21 +99,14 @@ void Mediator::OnDeviceFound(FastPairDevice& device) {
NEARBY_LOGS(INFO) << __func__ << ": Ignoring because show UI flag is false";
return;
}
if (IsDeviceCurrentlyShowingNotification(device)) {
NEARBY_LOGS(VERBOSE) << __func__
<< ": Extending notification for re-discovered device="
<< *device_currently_showing_notification_;
// TODO(b/278768167): Add ui_broker_->ExtendNotification();
return;
} else if (device_currently_showing_notification_) {
if (foreground_currently_showing_notification_) {
NEARBY_LOGS(VERBOSE)
<< __func__
<< ": Already showing a notification for a different device= "
<< *device_currently_showing_notification_;
<< ": Already showing a notification for a different device= ";
return;
}
// Show discovery notification
device_currently_showing_notification_ = &device;
foreground_currently_showing_notification_ = true;
ui_broker_->ShowDiscovery(device, *notification_controller_);
}
@@ -125,8 +119,6 @@ void Mediator::OnDiscoveryAction(FastPairDevice& device,
switch (action) {
case DiscoveryAction::kPairToDevice:
NEARBY_LOGS(INFO) << __func__ << ": Action = kPairToDevice";
// TODO(285451051): Adding show pairing for higher than v1 version in ui
// broker
pairer_broker_->PairDevice(device);
break;
case DiscoveryAction::kDismissedByOs:
@@ -136,23 +128,29 @@ void Mediator::OnDiscoveryAction(FastPairDevice& device,
// When the user explicitly dismisses the discovery notification, update
// the device's block-list value accordingly.
NEARBY_LOGS(INFO) << __func__ << ": Action = kDismissedByUser";
// TODO(285453663): update discovery block list
foreground_currently_showing_notification_ = false;
// TODO(b/285453663): update discovery block list
[[fallthrough]];
case DiscoveryAction::kDismissedByTimeout:
NEARBY_LOGS(INFO) << __func__ << ": Action = kDismissedByTimeout";
device_currently_showing_notification_ = nullptr;
foreground_currently_showing_notification_ = false;
break;
case DiscoveryAction::kLearnMore:
NEARBY_LOGS(INFO) << __func__ << ": Action = kLearnMore";
break;
case DiscoveryAction::kDone:
NEARBY_LOGS(INFO) << __func__ << ": Action = kDone";
foreground_currently_showing_notification_ = false;
break;
default:
NEARBY_LOGS(INFO) << __func__ << ": Action = kUnknow";
NEARBY_LOGS(INFO) << __func__ << ": Action = Unknown";
break;
}
}
void Mediator::OnDevicePaired(FastPairDevice& device) {
NEARBY_LOGS(INFO) << __func__ << ": " << device;
ui_broker_->ShowPairingResult(device, *notification_controller_, true);
}
void Mediator::OnAccountKeyWrite(FastPairDevice& device,
@@ -176,7 +174,7 @@ void Mediator::OnPairingComplete(FastPairDevice& device) {
void Mediator::OnPairFailure(FastPairDevice& device, PairFailure failure) {
NEARBY_LOGS(INFO) << __func__ << ": " << device
<< " with PairFailure: " << failure;
// TODO: UI showPairingFailed
ui_broker_->ShowPairingResult(device, *notification_controller_, false);
}
void Mediator::StartScanning() {
@@ -212,24 +210,6 @@ bool Mediator::IsFastPairEnabled() {
return true;
}
bool Mediator::IsDeviceCurrentlyShowingNotification(
const FastPairDevice& device) {
// BLE addresses could have rotated, causing this check to return false for
// the same device. Fast Pair considers a device different if they have
// different BLE addresses. Similarly, the this check will fail if it is the
// same physical device under different scenarios: for example, if a device
// is found via the initial scenario and via the subsequent scenario, Fast
// Pair does not consider them the same device.
return device_currently_showing_notification_ &&
device_currently_showing_notification_->GetModelId() ==
device.GetModelId() &&
device_currently_showing_notification_->GetBleAddress() ==
device.GetBleAddress() &&
device_currently_showing_notification_->GetProtocol() !=
device.GetProtocol();
}
void Mediator::SetIsScreenLocked(bool locked) {
executor_->Execute(
"on_lock_state_changed",
fastpair/keyed_service/fast_pair_mediator.h
+1 -3
View File
@@ -102,9 +102,7 @@ class Mediator final : public ScannerBroker::Observer,
void InvalidateScanningState() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
bool IsDeviceCurrentlyShowingNotification(const FastPairDevice& device);
// |device_currently_showing_notification_| can be null if there is no
// notification currently displayed to the user.
FastPairDevice* device_currently_showing_notification_ = nullptr;
bool foreground_currently_showing_notification_ = false;
FastPairHttpNotifier fast_pair_http_notifier_;
std::unique_ptr<SingleThreadExecutor> executor_;
std::unique_ptr<Mediums> mediums_;
fastpair/ui/BUILD
+1
View File
@@ -88,6 +88,7 @@ cc_test(
":fake_fast_pair_ui",
":fast_pair_ui",
"//fastpair/common",
"//internal/platform:types",
"//internal/platform/implementation/g3", # build_cleaner: keep
"@com_github_protobuf_matchers//protobuf-matchers",
"@com_google_googletest//:gtest_main",
fastpair/ui/actions.h
+2 -1
View File
@@ -24,7 +24,8 @@ enum class DiscoveryAction {
kDismissedByUser = 2,
kDismissedByOs = 3,
kLearnMore = 4,
kDismissedByTimeout = 5,
kDone = 5,
kDismissedByTimeout = 6,
};
} // namespace fastpair
fastpair/ui/fast_pair/fake_fast_pair_notification_controller_observer.h
+28 -17
View File
@@ -23,6 +23,7 @@
#include "fastpair/common/device_metadata.h"
#include "fastpair/ui/fast_pair/fast_pair_notification_controller.h"
#include "internal/platform/count_down_latch.h"
#include "internal/platform/mutex_lock.h"
namespace nearby {
namespace fastpair {
@@ -30,35 +31,45 @@ class FakeFastPairNotificationControllerObserver
: public FastPairNotificationController::Observer {
public:
explicit FakeFastPairNotificationControllerObserver(
std::optional<CountDownLatch> latch) {
latch_ = latch;
CountDownLatch* on_device_updated_latch,
CountDownLatch* on_pairing_result_latch) {
on_device_updated_latch_ = on_device_updated_latch;
on_pairing_result_latch_ = on_pairing_result_latch;
}
void OnUpdateDevice(const DeviceMetadata& device) override {
device_metadata_name_list_.push_back(device.GetDetails().name());
on_update_device_count_++;
if (latch_.has_value()) {
latch_->CountDown();
MutexLock lock(&mutex_);
device_ = &const_cast<DeviceMetadata&>(device);
if (on_device_updated_latch_) {
on_device_updated_latch_->CountDown();
}
}
bool CheckDeviceMetadataListContainTestDevice(
const std::string& device_name) {
auto it = std::find(device_metadata_name_list_.begin(),
device_metadata_name_list_.end(), device_name);
return it != device_metadata_name_list_.end();
void OnPairingResult(const DeviceMetadata& device, bool success) override {
MutexLock lock(&mutex_);
pairing_result_ = success;
device_ = &const_cast<DeviceMetadata&>(device);
if (on_pairing_result_latch_) {
on_pairing_result_latch_->CountDown();
}
}
int on_update_device_count() { return on_update_device_count_; }
DeviceMetadata* GetDevice() {
MutexLock lock(&mutex_);
return device_;
}
std::vector<std::string> device_metadata_name_list() {
return device_metadata_name_list_;
std::optional<bool> GetPairingResult() {
MutexLock lock(&mutex_);
return pairing_result_;
}
private:
std::vector<std::string> device_metadata_name_list_;
int on_update_device_count_ = 0;
std::optional<CountDownLatch> latch_;
Mutex mutex_;
CountDownLatch* on_device_updated_latch_;
CountDownLatch* on_pairing_result_latch_;
DeviceMetadata* device_ ABSL_GUARDED_BY(mutex_) = nullptr;
std::optional<bool> pairing_result_ ABSL_GUARDED_BY(mutex_);
};
} // namespace fastpair
} // namespace nearby
fastpair/ui/fast_pair/fake_fast_pair_presenter.h
+11
View File
@@ -35,13 +35,24 @@ class FakeFastPairPresenter : public FastPairPresenter {
version_changed_ = true;
callback(DiscoveryAction::kPairToDevice);
}
void ShowPairingResult(
FastPairDevice& device,
FastPairNotificationController& notification_controller,
bool success) override {
pairing_result_changed_ = true;
}
bool show_discovery() { return show_discovery_; }
bool version_changed() { return version_changed_; }
bool pairing_result_changed() { return pairing_result_changed_; }
private:
bool show_discovery_ = false;
bool version_changed_ = false;
bool pairing_result_changed_ = false;
};
class FakeFastPairPresenterFactory : public FastPairPresenterImpl::Factory {
fastpair/ui/fast_pair/fast_pair_notification_controller.cc
+14
View File
@@ -39,6 +39,14 @@ void FastPairNotificationController::NotifyShowDiscovery(
}
}
void FastPairNotificationController::NotifyShowPairingResult(
const DeviceMetadata& device, bool success) {
NEARBY_LOGS(INFO) << __func__;
for (Observer* observer : observers_.GetObservers()) {
observer->OnPairingResult(device, success);
}
}
void FastPairNotificationController::ShowGuestDiscoveryNotification(
const DeviceMetadata& device, DiscoveryCallback callback) {
callback_ = std::move(callback);
@@ -46,6 +54,12 @@ void FastPairNotificationController::ShowGuestDiscoveryNotification(
NotifyShowDiscovery(device);
}
void FastPairNotificationController::ShowPairingResultNotification(
const DeviceMetadata& device, bool success) {
NEARBY_LOGS(INFO) << __func__ << "Notify show pairing result notification. ";
NotifyShowPairingResult(device, success);
}
void FastPairNotificationController::OnDiscoveryClicked(
DiscoveryAction action) {
NEARBY_LOGS(INFO) << __func__
fastpair/ui/fast_pair/fast_pair_notification_controller.h
+6
View File
@@ -39,6 +39,8 @@ class FastPairNotificationController {
public:
virtual ~Observer() = default;
virtual void OnUpdateDevice(const DeviceMetadata& device) = 0;
virtual void OnPairingResult(const DeviceMetadata& device,
bool success) = 0;
};
FastPairNotificationController() = default;
@@ -52,11 +54,15 @@ class FastPairNotificationController {
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
void NotifyShowDiscovery(const DeviceMetadata& device);
void NotifyShowPairingResult(const DeviceMetadata& device, bool success);
// Creates and displays corresponding notification.
void ShowGuestDiscoveryNotification(const DeviceMetadata& device_metadata,
DiscoveryCallback callback);
void ShowPairingResultNotification(const DeviceMetadata& device_metadata,
bool success);
// Triggers callback when the related action is clicked.
void OnDiscoveryClicked(DiscoveryAction action);
fastpair/ui/fast_pair/fast_pair_notification_controller_test.cc
+38 -37
View File
@@ -25,6 +25,7 @@
#include "fastpair/common/device_metadata.h"
#include "fastpair/ui/actions.h"
#include "fastpair/ui/fast_pair/fake_fast_pair_notification_controller_observer.h"
#include "internal/platform/count_down_latch.h"
namespace nearby {
namespace fastpair {
@@ -34,46 +35,46 @@ const int64_t kDeviceId = 10148625;
const char kModelId[] = "9adb11";
const char kDeviceName[] = "Pixel Buds Pro";
class FastPairNotificationControllerTest : public ::testing::Test {
protected:
FastPairNotificationControllerTest() {
notification_controller_obsesrver_ =
std::make_unique<FakeFastPairNotificationControllerObserver>(
std::nullopt);
notification_controller_.AddObserver(
notification_controller_obsesrver_.get());
}
void TriggerOnUpdateDevice(DeviceMetadata& device,
DiscoveryCallback callback) {
notification_controller_.ShowGuestDiscoveryNotification(
device, std::move(callback));
}
void DiscoveryActionClicked(DiscoveryAction action) {
discovery_action_ = action;
}
FastPairNotificationController notification_controller_;
std::unique_ptr<FakeFastPairNotificationControllerObserver>
notification_controller_obsesrver_;
DiscoveryAction discovery_action_;
};
TEST_F(FastPairNotificationControllerTest, ShowGuestDiscoveryNotification) {
TEST(FastPairNotificationControllerTest, ShowGuestDiscoveryNotification) {
FastPairNotificationController notification_controller;
proto::GetObservedDeviceResponse response;
response.mutable_device()->set_id(kDeviceId);
response.mutable_device()->set_name(kDeviceName);
DeviceMetadata device_metadata(response);
TriggerOnUpdateDevice(device_metadata, [this](DiscoveryAction action) {
DiscoveryActionClicked(action);
});
EXPECT_TRUE(notification_controller_obsesrver_
->CheckDeviceMetadataListContainTestDevice(kDeviceName));
EXPECT_EQ(1, notification_controller_obsesrver_->on_update_device_count());
notification_controller_.OnDiscoveryClicked(DiscoveryAction::kPairToDevice);
EXPECT_EQ(DiscoveryAction::kPairToDevice, discovery_action_);
CountDownLatch on_update_device_latch(1);
CountDownLatch on_click_latch(1);
FakeFastPairNotificationControllerObserver observer(&on_update_device_latch,
nullptr);
notification_controller.AddObserver(&observer);
EXPECT_EQ(observer.GetDevice(), nullptr);
DiscoveryAction discovery_action = DiscoveryAction::kUnknown;
notification_controller.ShowGuestDiscoveryNotification(
device_metadata, [&](DiscoveryAction action) {
on_click_latch.CountDown();
discovery_action = action;
});
on_update_device_latch.Await();
EXPECT_EQ(observer.GetDevice(), &device_metadata);
notification_controller.OnDiscoveryClicked(DiscoveryAction::kPairToDevice);
on_click_latch.Await();
EXPECT_EQ(discovery_action, DiscoveryAction::kPairToDevice);
}
TEST(FastPairNotificationControllerTest, ShowPairingResultNotification) {
FastPairNotificationController notification_controller;
proto::GetObservedDeviceResponse response;
DeviceMetadata device_metadata(response);
CountDownLatch on_pairing_result_latch(1);
FakeFastPairNotificationControllerObserver observer(nullptr,
&on_pairing_result_latch);
notification_controller.AddObserver(&observer);
EXPECT_FALSE(observer.GetPairingResult().has_value());
EXPECT_EQ(observer.GetDevice(), nullptr);
notification_controller.ShowPairingResultNotification(device_metadata, true);
on_pairing_result_latch.Await();
EXPECT_EQ(observer.GetDevice(), &device_metadata);
EXPECT_TRUE(observer.GetPairingResult().has_value());
EXPECT_TRUE(observer.GetPairingResult().value());
}
} // namespace
fastpair/ui/fast_pair/fast_pair_presenter.h
+5 -1
View File
@@ -24,11 +24,15 @@ namespace fastpair {
// This Presenter creates and manages UI component with Notification Controller.
class FastPairPresenter {
public:
// observer_list of notification_controller is updated
virtual void ShowDiscovery(
FastPairDevice& device,
FastPairNotificationController& notification_controller,
DiscoveryCallback callback) = 0;
virtual void ShowPairingResult(
FastPairDevice& device,
FastPairNotificationController& notification_controller,
bool success) = 0;
virtual ~FastPairPresenter() = default;
};
fastpair/ui/fast_pair/fast_pair_presenter_impl.cc
+7
View File
@@ -54,5 +54,12 @@ void FastPairPresenterImpl::ShowDiscovery(
notification_controller.ShowGuestDiscoveryNotification(*device.GetMetadata(),
std::move(callback));
}
void FastPairPresenterImpl::ShowPairingResult(
FastPairDevice& device,
FastPairNotificationController& notification_controller, bool success) {
notification_controller.ShowPairingResultNotification(*device.GetMetadata(),
success);
}
} // namespace fastpair
} // namespace nearby
fastpair/ui/fast_pair/fast_pair_presenter_impl.h
+4
View File
@@ -48,6 +48,10 @@ class FastPairPresenterImpl : public FastPairPresenter {
void ShowDiscovery(FastPairDevice& device,
FastPairNotificationController& notification_controller,
DiscoveryCallback callback) override;
void ShowPairingResult(
FastPairDevice& device,
FastPairNotificationController& notification_controller,
bool success) override;
};
} // namespace fastpair
} // namespace nearby
fastpair/ui/fast_pair/fast_pair_presenter_impl_test.cc
+69 -59
View File
@@ -14,8 +14,8 @@
#include "fastpair/ui/fast_pair/fast_pair_presenter_impl.h"
#include <optional>
#include "gmock/gmock.h"
#include "protobuf-matchers/protocol-buffer-matchers.h"
#include "gtest/gtest.h"
#include "fastpair/common/fast_pair_device.h"
#include "fastpair/proto/fastpair_rpcs.proto.h"
@@ -26,78 +26,88 @@
namespace nearby {
namespace fastpair {
const int64_t kDeviceId = 10148625;
constexpr absl::string_view kModelId = "000000";
constexpr absl::string_view kAddress = "00:00:00:00:00:00";
constexpr absl::string_view kPublicKey = "test public key";
constexpr absl::string_view kInitialPairingdescription =
"InitialPairingdescription";
namespace {
TEST(FastPairPresenterImplTest, ShowDiscoveryForV1Version) {
// Setup repository with v1 version device metadata
FastPairDevice device(kModelId, kAddress, Protocol::kFastPairInitialPairing);
proto::GetObservedDeviceResponse response;
DeviceMetadata device_metadata(response);
device.SetMetadata(device_metadata);
// Register FastPairNotificationControllerObserver
auto latch_1 = std::make_optional<CountDownLatch>(1);
FastPairNotificationController controller;
FakeFastPairNotificationControllerObserver notification_controller_observer(
latch_1);
controller.AddObserver(&notification_controller_observer);
EXPECT_EQ(notification_controller_observer.on_update_device_count(), 0);
// FastPairPresenter ShowDiscovery
CountDownLatch latch_2(1);
FastPairPresenterImpl fast_pair_presenter;
DiscoveryAction discovery_action = DiscoveryAction::kUnknown;
fast_pair_presenter.ShowDiscovery(device, controller,
[&](DiscoveryAction action) {
discovery_action = action;
latch_2.CountDown();
});
latch_1->Await();
EXPECT_EQ(notification_controller_observer.on_update_device_count(), 1);
EXPECT_EQ(device.GetVersion(), DeviceFastPairVersion::kV1);
controller.OnDiscoveryClicked(DiscoveryAction::kPairToDevice);
latch_2.Await();
EXPECT_EQ(discovery_action, DiscoveryAction::kPairToDevice);
// A gMock matcher to match proto values. Use this matcher like:
// request/response proto, expected_proto;
// EXPECT_THAT(proto, MatchesProto(expected_proto));
MATCHER_P(
MatchesProto, expected_proto,
absl::StrCat(negation ? "does not match" : "matches",
testing::PrintToString(expected_proto.SerializeAsString()))) {
return arg.SerializeAsString() == expected_proto.SerializeAsString();
}
TEST(FastPairPresenterImplTest, ShowDiscoveryForHigherThanV1Version) {
// Setup repository with HigherThanV1Version device metadata
FastPairDevice device(kModelId, kAddress, Protocol::kFastPairInitialPairing);
proto::GetObservedDeviceResponse response;
auto* higher_than_v1_version_device = response.mutable_device();
higher_than_v1_version_device->mutable_anti_spoofing_key_pair()
->set_public_key(kPublicKey);
DeviceMetadata device_metadata(response);
device.SetMetadata(device_metadata);
TEST(FastPairPresenterImplTest, ShowDiscovery) {
// Sets up proto::GetObservedDeviceResponse
proto::GetObservedDeviceResponse response_proto;
auto* device = response_proto.mutable_device();
device->set_id(kDeviceId);
auto* observed_device_strings = response_proto.mutable_strings();
observed_device_strings->set_initial_pairing_description(
kInitialPairingdescription);
DeviceMetadata device_metadata(response_proto);
FastPairDevice fast_pair_device(kModelId, kAddress,
Protocol::kFastPairInitialPairing);
// Register FastPairNotificationControllerObserver
auto latch_1 = std::make_optional<CountDownLatch>(1);
FastPairNotificationController controller;
FakeFastPairNotificationControllerObserver notification_controller_observer(
latch_1);
controller.AddObserver(&notification_controller_observer);
EXPECT_EQ(notification_controller_observer.on_update_device_count(), 0);
fast_pair_device.SetMetadata(device_metadata);
// FastPairPresenter ShowDiscovery
CountDownLatch latch_2(1);
FastPairPresenterImpl fast_pair_presenter;
FastPairNotificationController notification_controller;
CountDownLatch on_update_device_latch(1);
CountDownLatch on_click_latch(1);
FakeFastPairNotificationControllerObserver observer(&on_update_device_latch,
nullptr);
notification_controller.AddObserver(&observer);
DiscoveryAction discovery_action = DiscoveryAction::kUnknown;
fast_pair_presenter.ShowDiscovery(device, controller,
FastPairPresenterImpl fast_pair_presenter;
fast_pair_presenter.ShowDiscovery(fast_pair_device, notification_controller,
[&](DiscoveryAction action) {
on_click_latch.CountDown();
discovery_action = action;
latch_2.CountDown();
});
latch_1->Await();
EXPECT_EQ(notification_controller_observer.on_update_device_count(), 1);
EXPECT_EQ(device.GetVersion(), DeviceFastPairVersion::kHigherThanV1);
controller.OnDiscoveryClicked(DiscoveryAction::kDismissedByUser);
latch_2.Await();
EXPECT_EQ(discovery_action, DiscoveryAction::kDismissedByUser);
on_update_device_latch.Await();
EXPECT_EQ(observer.GetDevice()->GetFastPairVersion(),
DeviceFastPairVersion::kV1);
EXPECT_THAT(observer.GetDevice()->GetResponse(),
MatchesProto(response_proto));
}
TEST(FastPairPresenterImplTest, ShowPairingResult) {
// Sets up proto::GetObservedDeviceResponse
proto::GetObservedDeviceResponse response_proto;
auto* device = response_proto.mutable_device();
device->set_id(kDeviceId);
auto* observed_device_strings = response_proto.mutable_strings();
observed_device_strings->set_initial_pairing_description(
kInitialPairingdescription);
DeviceMetadata device_metadata(response_proto);
FastPairDevice fast_pair_device(kModelId, kAddress,
Protocol::kFastPairInitialPairing);
fast_pair_device.SetMetadata(device_metadata);
FastPairNotificationController notification_controller;
CountDownLatch on_pairing_result_latch(1);
FakeFastPairNotificationControllerObserver observer(nullptr,
&on_pairing_result_latch);
notification_controller.AddObserver(&observer);
FastPairPresenterImpl fast_pair_presenter;
fast_pair_presenter.ShowPairingResult(fast_pair_device,
notification_controller, true);
on_pairing_result_latch.Await();
EXPECT_EQ(observer.GetDevice()->GetFastPairVersion(),
DeviceFastPairVersion::kV1);
EXPECT_THAT(observer.GetDevice()->GetResponse(),
MatchesProto(response_proto));
EXPECT_TRUE(observer.GetPairingResult().has_value());
EXPECT_TRUE(observer.GetPairingResult().value());
}
} // namespace
} // namespace fastpair
} // namespace nearby
fastpair/ui/mock_ui_broker.h
+4
View File
@@ -29,6 +29,10 @@ class MockUIBroker : public UIBroker {
MOCK_METHOD(void, ShowDiscovery,
(FastPairDevice&, FastPairNotificationController&), (override));
MOCK_METHOD(void, ShowPairingResult,
(FastPairDevice&, FastPairNotificationController&, bool),
(override));
void AddObserver(Observer* observer) override {
observers_.AddObserver(observer);
}
fastpair/ui/ui_broker.h
+5
View File
@@ -43,6 +43,11 @@ class UIBroker {
virtual void ShowDiscovery(
FastPairDevice& device,
FastPairNotificationController& notification_controller) = 0;
virtual void ShowPairingResult(
FastPairDevice& device,
FastPairNotificationController& notification_controller,
bool success) = 0;
};
} // namespace fastpair
fastpair/ui/ui_broker_impl.cc
+17
View File
@@ -60,6 +60,23 @@ void UIBrokerImpl::ShowDiscovery(
}
}
void UIBrokerImpl::ShowPairingResult(
FastPairDevice& device,
FastPairNotificationController& notification_controller, bool success) {
NEARBY_LOGS(VERBOSE) << __func__;
switch (device.GetProtocol()) {
case Protocol::kFastPairInitialPairing:
case Protocol::kFastPairSubsequentPairing:
fast_pair_presenter_->ShowPairingResult(device, notification_controller,
success);
break;
case Protocol::kFastPairRetroactivePairing:
// In this scenario, we don't show the error UI because it would be
// misleading, since a pair failure is a retroactive pair failure.
break;
}
}
void UIBrokerImpl::NotifyDiscoveryAction(FastPairDevice& device,
DiscoveryAction action) {
for (auto& observer : observers_.GetObservers())
fastpair/ui/ui_broker_impl.h
+4
View File
@@ -37,6 +37,10 @@ class UIBrokerImpl : public UIBroker {
void ShowDiscovery(
FastPairDevice &device,
FastPairNotificationController &notification_controller) override;
void ShowPairingResult(
FastPairDevice &device,
FastPairNotificationController &notification_controller,
bool success) override;
private:
void NotifyDiscoveryAction(FastPairDevice &device, DiscoveryAction action);
fastpair/ui/ui_broker_impl_test.cc
+8 -1
View File
@@ -31,7 +31,7 @@ constexpr absl::string_view kAddress = "74:74:46:01:6C:21";
class UIBrokerImplTest : public ::testing::Test, public UIBroker::Observer {
protected:
UIBrokerImplTest() {
void SetUp() override {
presenter_factory_ = std::make_unique<FakeFastPairPresenterFactory>();
FastPairPresenterImpl::Factory::SetFactoryForTesting(
presenter_factory_.get());
@@ -68,6 +68,13 @@ TEST_F(UIBrokerImplTest, ShowDiscoveryWithoutObserver) {
EXPECT_FALSE(on_discovery_action_notified_);
}
TEST_F(UIBrokerImplTest, ShowPairingResult) {
FastPairDevice device(kModelId, kAddress, Protocol::kFastPairInitialPairing);
ui_broker_->ShowPairingResult(device, notification_controller_, true);
EXPECT_TRUE(
presenter_factory_->fake_fast_pair_presenter()->pairing_result_changed());
}
} // namespace
} // namespace fastpair
} // namespace nearby