peripheral_battery_listener_unittest.cc 78 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/system/power/peripheral_battery_listener.h"
  5. #include <memory>
  6. #include <ostream>
  7. #include <string>
  8. #include "ash/shell.h"
  9. #include "ash/system/power/peripheral_battery_tests.h"
  10. #include "ash/test/ash_test_base.h"
  11. #include "base/scoped_observation.h"
  12. #include "base/strings/string_number_conversions.h"
  13. #include "base/strings/string_piece.h"
  14. #include "base/strings/string_util.h"
  15. #include "base/strings/utf_string_conversions.h"
  16. #include "base/test/task_environment.h"
  17. #include "chromeos/dbus/power/fake_power_manager_client.h"
  18. #include "device/bluetooth/bluetooth_adapter_factory.h"
  19. #include "device/bluetooth/bluetooth_device.h"
  20. #include "device/bluetooth/test/mock_bluetooth_adapter.h"
  21. #include "device/bluetooth/test/mock_bluetooth_device.h"
  22. #include "testing/gmock/include/gmock/gmock.h"
  23. #include "third_party/abseil-cpp/absl/types/optional.h"
  24. #include "ui/events/devices/device_data_manager.h"
  25. #include "ui/events/devices/device_data_manager_test_api.h"
  26. #include "ui/events/devices/touchscreen_device.h"
  27. #include "ui/message_center/public/cpp/notification.h"
  28. using testing::_;
  29. using testing::AllOf;
  30. using testing::AnyNumber;
  31. using testing::Eq;
  32. using testing::Expectation;
  33. using testing::Field;
  34. using testing::Ge;
  35. using testing::Gt;
  36. using testing::InSequence;
  37. using testing::Le;
  38. using testing::Lt;
  39. using testing::NiceMock;
  40. using testing::Optional;
  41. using testing::Sequence;
  42. using testing::StrictMock;
  43. using BI = ash::PeripheralBatteryListener::BatteryInfo;
  44. using BatteryInfo = device::BluetoothDevice::BatteryInfo;
  45. using BatteryType = device::BluetoothDevice::BatteryType;
  46. // Annotate testing::Field invocations to improve feedback.
  47. #define AFIELD(element, test) testing::Field(#element, element, test)
  48. namespace {
  49. class MockPeripheralBatteryObserver
  50. : public ash::PeripheralBatteryListener::Observer {
  51. public:
  52. MockPeripheralBatteryObserver() {}
  53. // ash::PeripheralBatteryListener::Observer:
  54. MOCK_METHOD(void,
  55. OnAddingBattery,
  56. (const ash::PeripheralBatteryListener::BatteryInfo& battery));
  57. MOCK_METHOD(void,
  58. OnRemovingBattery,
  59. (const ash::PeripheralBatteryListener::BatteryInfo& battery));
  60. MOCK_METHOD(void,
  61. OnUpdatedBatteryLevel,
  62. (const ash::PeripheralBatteryListener::BatteryInfo& battery));
  63. };
  64. } // namespace
  65. namespace ash {
  66. class PeripheralBatteryListenerTest : public AshTestBase {
  67. public:
  68. // Constants for active field of PeripheralBatteryStylusReceived().
  69. const bool kBluetoothBatteryUpdate = true;
  70. const bool kBatteryPolledUpdate = false;
  71. const bool kBatteryEventUpdate = true;
  72. PeripheralBatteryListenerTest()
  73. : AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
  74. PeripheralBatteryListenerTest(const PeripheralBatteryListenerTest&) = delete;
  75. PeripheralBatteryListenerTest& operator=(
  76. const PeripheralBatteryListenerTest&) = delete;
  77. ~PeripheralBatteryListenerTest() override = default;
  78. void SetUp() override {
  79. chromeos::PowerManagerClient::InitializeFake();
  80. AshTestBase::SetUp();
  81. ASSERT_TRUE(ui::DeviceDataManager::HasInstance());
  82. // Simulate the complete listing of input devices, required by the listener.
  83. if (complete_devices_)
  84. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  85. mock_adapter_ =
  86. base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
  87. mock_device_1_ = std::make_unique<NiceMock<device::MockBluetoothDevice>>(
  88. mock_adapter_.get(), /*bluetooth_class=*/0, kBluetoothDeviceName1,
  89. kBluetoothDeviceAddress1, /*paired=*/true, /*connected=*/true);
  90. mock_device_2_ = std::make_unique<NiceMock<device::MockBluetoothDevice>>(
  91. mock_adapter_.get(), /*bluetooth_class=*/0, kBluetoothDeviceName2,
  92. kBluetoothDeviceAddress2, /*paired=*/true, /*connected=*/true);
  93. device::BluetoothAdapterFactory::SetAdapterForTesting(mock_adapter_);
  94. battery_listener_ = std::make_unique<PeripheralBatteryListener>();
  95. }
  96. void TearDown() override {
  97. battery_listener_.reset();
  98. AshTestBase::TearDown();
  99. chromeos::PowerManagerClient::Shutdown();
  100. }
  101. base::TimeTicks GetTestingClock() { return base::TimeTicks::Now(); }
  102. void ClockAdvance(base::TimeDelta delta) {
  103. task_environment()->AdvanceClock(delta);
  104. }
  105. void CreateInternalTouchscreen(bool garage) {
  106. // Add an internal stylus to our test device manager.
  107. ui::TouchscreenDevice stylus(/*id=*/0, ui::INPUT_DEVICE_INTERNAL,
  108. kTestStylusName, gfx::Size(),
  109. /*touch_points=*/1, /*has_stylus=*/true,
  110. /*has_stylus_garage_switch=*/garage);
  111. stylus.sys_path = base::FilePath(kTestStylusBatteryPath);
  112. ui::DeviceDataManagerTestApi().SetTouchscreenDevices({stylus});
  113. }
  114. void CreateExternalTouchscreen() {
  115. // Add an external stylus to our test device manager.
  116. ui::TouchscreenDevice stylus(/*id=*/0, ui::INPUT_DEVICE_USB,
  117. kTestStylusName, gfx::Size(),
  118. /*touch_points=*/1, /*has_stylus=*/true);
  119. stylus.sys_path = base::FilePath(kTestStylusBatteryPath);
  120. ui::DeviceDataManagerTestApi().SetTouchscreenDevices({stylus});
  121. }
  122. protected:
  123. scoped_refptr<NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
  124. std::unique_ptr<device::MockBluetoothDevice> mock_device_1_;
  125. std::unique_ptr<device::MockBluetoothDevice> mock_device_2_;
  126. std::unique_ptr<PeripheralBatteryListener> battery_listener_;
  127. void set_complete_devices(bool complete_devices) {
  128. complete_devices_ = complete_devices;
  129. }
  130. // SetUp() doesn't complete devices if this is set to false.
  131. bool complete_devices_ = true;
  132. };
  133. class PeripheralBatteryListenerIncompleteDevicesTest
  134. : public PeripheralBatteryListenerTest {
  135. public:
  136. PeripheralBatteryListenerIncompleteDevicesTest() {
  137. set_complete_devices(false);
  138. }
  139. PeripheralBatteryListenerIncompleteDevicesTest(
  140. const PeripheralBatteryListenerIncompleteDevicesTest&) = delete;
  141. PeripheralBatteryListenerIncompleteDevicesTest& operator=(
  142. const PeripheralBatteryListenerIncompleteDevicesTest&) = delete;
  143. ~PeripheralBatteryListenerIncompleteDevicesTest() override {}
  144. };
  145. TEST_F(PeripheralBatteryListenerTest, Basic) {
  146. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  147. base::ScopedObservation<PeripheralBatteryListener,
  148. PeripheralBatteryListener::Observer>
  149. scoped_listener_obs{&listener_observer_mock};
  150. scoped_listener_obs.Observe(battery_listener_.get());
  151. // Level 50 at time 100, listener should be notified.
  152. ClockAdvance(base::Seconds(100));
  153. testing::InSequence sequence;
  154. EXPECT_CALL(listener_observer_mock,
  155. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  156. EXPECT_CALL(listener_observer_mock,
  157. OnUpdatedBatteryLevel(AllOf(
  158. AFIELD(&BI::key, Eq(kTestBatteryId)),
  159. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  160. AFIELD(&BI::last_active_update_timestamp, Eq(absl::nullopt)),
  161. AFIELD(&BI::level, Eq(50)),
  162. AFIELD(&BI::charge_status, Eq(kTestBatteryStatusOut)))));
  163. battery_listener_->PeripheralBatteryStatusReceived(
  164. kTestBatteryPath, kTestDeviceName, 50, kTestBatteryStatusIn,
  165. /*serial_number=*/"", kBatteryPolledUpdate);
  166. // Level 5 at time 110, listener should be notified.
  167. ClockAdvance(base::Seconds(10));
  168. EXPECT_CALL(listener_observer_mock,
  169. OnUpdatedBatteryLevel(AllOf(
  170. AFIELD(&BI::key, Eq(kTestBatteryId)),
  171. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  172. AFIELD(&BI::last_active_update_timestamp, Eq(absl::nullopt)),
  173. AFIELD(&BI::level, Eq(5)))));
  174. battery_listener_->PeripheralBatteryStatusReceived(
  175. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  176. /*serial_number=*/"", kBatteryPolledUpdate);
  177. // Level -1 at time 115, listener should be notified.
  178. ClockAdvance(base::Seconds(5));
  179. EXPECT_CALL(listener_observer_mock,
  180. OnUpdatedBatteryLevel(AllOf(
  181. AFIELD(&BI::key, Eq(kTestBatteryId)),
  182. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  183. AFIELD(&BI::last_active_update_timestamp, Eq(absl::nullopt)),
  184. AFIELD(&BI::level, Eq(absl::nullopt)))));
  185. battery_listener_->PeripheralBatteryStatusReceived(
  186. kTestBatteryPath, kTestDeviceName, -1, kTestBatteryStatusIn,
  187. /*serial_number=*/"", kBatteryPolledUpdate);
  188. // Level 50 at time 120, listener should be notified.
  189. ClockAdvance(base::Seconds(5));
  190. EXPECT_CALL(listener_observer_mock,
  191. OnUpdatedBatteryLevel(AllOf(
  192. AFIELD(&BI::key, Eq(kTestBatteryId)),
  193. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  194. AFIELD(&BI::last_active_update_timestamp, Eq(absl::nullopt)),
  195. AFIELD(&BI::level, Eq(50)))));
  196. battery_listener_->PeripheralBatteryStatusReceived(
  197. kTestBatteryPath, kTestDeviceName, 50, kTestBatteryStatusIn,
  198. /*serial_number=*/"", kBatteryPolledUpdate);
  199. }
  200. TEST_F(PeripheralBatteryListenerTest, ActiveUpdates) {
  201. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  202. base::ScopedObservation<PeripheralBatteryListener,
  203. PeripheralBatteryListener::Observer>
  204. scoped_listener_obs{&listener_observer_mock};
  205. scoped_listener_obs.Observe(battery_listener_.get());
  206. // Level 50 at time 100, listener should be notified.
  207. ClockAdvance(base::Seconds(100));
  208. testing::InSequence sequence;
  209. EXPECT_CALL(listener_observer_mock,
  210. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  211. EXPECT_CALL(
  212. listener_observer_mock,
  213. OnUpdatedBatteryLevel(
  214. AllOf(AFIELD(&BI::key, Eq(kTestBatteryId)),
  215. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  216. AFIELD(&BI::charge_status, Eq(kTestBatteryStatusOut)),
  217. AFIELD(&BI::last_active_update_timestamp, Eq(absl::nullopt)))));
  218. battery_listener_->PeripheralBatteryStatusReceived(
  219. kTestBatteryPath, kTestDeviceName, 50, kTestBatteryStatusIn,
  220. /*serial_number=*/"", kBatteryPolledUpdate);
  221. // Level 5 at time 110, listener should be notified.
  222. ClockAdvance(base::Seconds(10));
  223. EXPECT_CALL(listener_observer_mock,
  224. OnUpdatedBatteryLevel(AllOf(
  225. AFIELD(&BI::key, Eq(kTestBatteryId)),
  226. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  227. AFIELD(&BI::last_active_update_timestamp,
  228. Optional(GetTestingClock())))));
  229. battery_listener_->PeripheralBatteryStatusReceived(
  230. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  231. /*serial_number=*/"", kBatteryEventUpdate);
  232. // Level -1 at time 115, listener should be notified.
  233. ClockAdvance(base::Seconds(5));
  234. EXPECT_CALL(listener_observer_mock,
  235. OnUpdatedBatteryLevel(AllOf(
  236. AFIELD(&BI::key, Eq(kTestBatteryId)),
  237. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  238. AFIELD(&BI::last_active_update_timestamp,
  239. Optional(GetTestingClock())))));
  240. battery_listener_->PeripheralBatteryStatusReceived(
  241. kTestBatteryPath, kTestDeviceName, -1, kTestBatteryStatusIn,
  242. /*serial_number=*/"", kBatteryEventUpdate);
  243. auto prior_active_update_time = GetTestingClock();
  244. // Level 50 at time 120, listener should be notified.
  245. ClockAdvance(base::Seconds(5));
  246. EXPECT_CALL(listener_observer_mock,
  247. OnUpdatedBatteryLevel(AllOf(
  248. AFIELD(&BI::key, Eq(kTestBatteryId)),
  249. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  250. AFIELD(&BI::last_active_update_timestamp,
  251. Optional(prior_active_update_time)))));
  252. battery_listener_->PeripheralBatteryStatusReceived(
  253. kTestBatteryPath, kTestDeviceName, 50, kTestBatteryStatusIn,
  254. /*serial_number=*/"", kBatteryPolledUpdate);
  255. }
  256. TEST_F(PeripheralBatteryListenerTest, FirstActiveUpdates) {
  257. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  258. base::ScopedObservation<PeripheralBatteryListener,
  259. PeripheralBatteryListener::Observer>
  260. scoped_listener_obs{&listener_observer_mock};
  261. scoped_listener_obs.Observe(battery_listener_.get());
  262. // Level 50 at time 100, listener should be notified.
  263. ClockAdvance(base::Seconds(100));
  264. testing::InSequence sequence;
  265. EXPECT_CALL(listener_observer_mock,
  266. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  267. EXPECT_CALL(listener_observer_mock,
  268. OnUpdatedBatteryLevel(AllOf(
  269. AFIELD(&BI::key, Eq(kTestBatteryId)),
  270. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  271. AFIELD(&BI::last_active_update_timestamp,
  272. Optional(GetTestingClock())))));
  273. battery_listener_->PeripheralBatteryStatusReceived(
  274. kTestBatteryPath, kTestDeviceName, 50, kTestBatteryStatusIn,
  275. /*serial_number=*/"", kBatteryEventUpdate);
  276. }
  277. TEST_F(PeripheralBatteryListenerTest, InvalidBatteryInfo) {
  278. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  279. base::ScopedObservation<PeripheralBatteryListener,
  280. PeripheralBatteryListener::Observer>
  281. scoped_listener_obs{&listener_observer_mock};
  282. scoped_listener_obs.Observe(battery_listener_.get());
  283. const std::string invalid_path1 = "invalid-path";
  284. const std::string invalid_path2 = "/sys/class/power_supply/hid-battery";
  285. EXPECT_CALL(listener_observer_mock, OnAddingBattery(_)).Times(0);
  286. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_)).Times(0);
  287. battery_listener_->PeripheralBatteryStatusReceived(
  288. invalid_path1, kTestDeviceName, 10, kTestBatteryStatusIn,
  289. /*serial_number=*/"", kBatteryPolledUpdate);
  290. battery_listener_->PeripheralBatteryStatusReceived(
  291. invalid_path2, kTestDeviceName, 10, kTestBatteryStatusIn,
  292. /*serial_number=*/"", kBatteryPolledUpdate);
  293. battery_listener_->PeripheralBatteryStatusReceived(
  294. kTestBatteryPath, kTestDeviceName, -2, kTestBatteryStatusIn,
  295. /*serial_number=*/"", kBatteryPolledUpdate);
  296. battery_listener_->PeripheralBatteryStatusReceived(
  297. kTestBatteryPath, kTestDeviceName, 101, kTestBatteryStatusIn,
  298. /*serial_number=*/"", kBatteryPolledUpdate);
  299. // Note that -1 is a valid battery level for the Listener, so not checked.
  300. }
  301. // Verify that for Bluetooth devices, the correct address gets stored in the
  302. // BatteryInfo's bluetooth_address member, and for non-Bluetooth devices, that
  303. // bluetooth_address member is empty.
  304. TEST_F(PeripheralBatteryListenerTest, ExtractBluetoothAddress) {
  305. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  306. base::ScopedObservation<PeripheralBatteryListener,
  307. PeripheralBatteryListener::Observer>
  308. scoped_listener_obs{&listener_observer_mock};
  309. scoped_listener_obs.Observe(battery_listener_.get());
  310. const std::string bluetooth_path =
  311. "/sys/class/power_supply/hid-A0:b1:C2:d3:E4:f5-battery";
  312. const std::string expected_bluetooth_address = "a0:b1:c2:d3:e4:f5";
  313. const std::string expected_bluetooth_id =
  314. "battery_bluetooth-a0:b1:c2:d3:e4:f5";
  315. const std::string non_bluetooth_path =
  316. "/sys/class/power_supply/hid-notbluetooth-battery";
  317. testing::InSequence sequence;
  318. EXPECT_CALL(listener_observer_mock,
  319. OnAddingBattery(AFIELD(&BI::key, Eq(expected_bluetooth_id))));
  320. EXPECT_CALL(
  321. listener_observer_mock,
  322. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(expected_bluetooth_id)),
  323. AFIELD(&BI::level, Eq(10)))));
  324. battery_listener_->PeripheralBatteryStatusReceived(
  325. bluetooth_path, kTestDeviceName, 10, kTestBatteryStatusIn,
  326. /*serial_number=*/"", kBluetoothBatteryUpdate);
  327. EXPECT_CALL(listener_observer_mock,
  328. OnAddingBattery(AFIELD(&BI::key, Eq(non_bluetooth_path))));
  329. EXPECT_CALL(
  330. listener_observer_mock,
  331. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(non_bluetooth_path)),
  332. AFIELD(&BI::bluetooth_address, Eq("")))));
  333. battery_listener_->PeripheralBatteryStatusReceived(
  334. non_bluetooth_path, kTestDeviceName, 10, kTestBatteryStatusIn,
  335. /*serial_number=*/"", kBatteryPolledUpdate);
  336. }
  337. TEST_F(PeripheralBatteryListenerTest, DeviceRemove) {
  338. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  339. base::ScopedObservation<PeripheralBatteryListener,
  340. PeripheralBatteryListener::Observer>
  341. scoped_listener_obs{&listener_observer_mock};
  342. scoped_listener_obs.Observe(battery_listener_.get());
  343. testing::InSequence sequence;
  344. EXPECT_CALL(listener_observer_mock,
  345. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  346. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_));
  347. battery_listener_->PeripheralBatteryStatusReceived(
  348. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  349. /*serial_number=*/"", kBatteryPolledUpdate);
  350. EXPECT_CALL(listener_observer_mock,
  351. OnRemovingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  352. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  353. }
  354. TEST_F(PeripheralBatteryListenerTest, StylusNotification) {
  355. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  356. base::ScopedObservation<PeripheralBatteryListener,
  357. PeripheralBatteryListener::Observer>
  358. scoped_listener_obs{&listener_observer_mock};
  359. scoped_listener_obs.Observe(battery_listener_.get());
  360. const std::string kTestStylusBatteryPath =
  361. "/sys/class/power_supply/hid-AAAA:BBBB:CCCC.DDDD-battery";
  362. const std::string kTestStylusName = "test_stylus";
  363. const auto kTestStylusBatteryStatusDischargingIn = power_manager::
  364. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_DISCHARGING;
  365. const auto kTestStylusBatteryStatusDischargingOut =
  366. BI::ChargeStatus::kDischarging;
  367. // Add an external stylus to our test device manager.
  368. ui::TouchscreenDevice stylus(/*id=*/0, ui::INPUT_DEVICE_USB, kTestStylusName,
  369. gfx::Size(),
  370. /*touch_points=*/1, /*has_stylus=*/true);
  371. stylus.sys_path = base::FilePath(kTestStylusBatteryPath);
  372. ui::DeviceDataManagerTestApi().SetTouchscreenDevices({stylus});
  373. testing::InSequence sequence;
  374. EXPECT_CALL(listener_observer_mock,
  375. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))));
  376. EXPECT_CALL(listener_observer_mock,
  377. OnUpdatedBatteryLevel(AllOf(
  378. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  379. AFIELD(&BI::level, Eq(50)),
  380. AFIELD(&BI::charge_status,
  381. Eq(kTestStylusBatteryStatusDischargingOut)),
  382. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  383. AFIELD(&BI::bluetooth_address, Eq("")))));
  384. battery_listener_->PeripheralBatteryStatusReceived(
  385. kTestStylusBatteryPath, kTestStylusName, 50,
  386. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  387. kBatteryPolledUpdate);
  388. EXPECT_CALL(
  389. listener_observer_mock,
  390. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  391. AFIELD(&BI::level, Eq(5)))));
  392. battery_listener_->PeripheralBatteryStatusReceived(
  393. kTestStylusBatteryPath, kTestStylusName, 5,
  394. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  395. kBatteryEventUpdate);
  396. EXPECT_CALL(
  397. listener_observer_mock,
  398. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  399. AFIELD(&BI::level, Eq(absl::nullopt)))));
  400. battery_listener_->PeripheralBatteryStatusReceived(
  401. kTestStylusBatteryPath, kTestStylusName, -1,
  402. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  403. kBatteryEventUpdate);
  404. }
  405. TEST_F(PeripheralBatteryListenerTest,
  406. Bluetooth_CreatesANotificationForEachDevice) {
  407. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  408. base::ScopedObservation<PeripheralBatteryListener,
  409. PeripheralBatteryListener::Observer>
  410. scoped_listener_obs{&listener_observer_mock};
  411. scoped_listener_obs.Observe(battery_listener_.get());
  412. testing::InSequence sequence;
  413. EXPECT_CALL(listener_observer_mock,
  414. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  415. EXPECT_CALL(
  416. listener_observer_mock,
  417. OnUpdatedBatteryLevel(AllOf(
  418. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)), AFIELD(&BI::level, Eq(5)),
  419. AFIELD(&BI::type, Eq(BI::PeripheralType::kOther)),
  420. AFIELD(&BI::name, Eq(kBluetoothDeviceName116)),
  421. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))));
  422. EXPECT_CALL(listener_observer_mock,
  423. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId2))));
  424. EXPECT_CALL(
  425. listener_observer_mock,
  426. OnUpdatedBatteryLevel(AllOf(
  427. AFIELD(&BI::key, Eq(kBluetoothDeviceId2)), AFIELD(&BI::level, Eq(0)),
  428. AFIELD(&BI::type, Eq(BI::PeripheralType::kOther)),
  429. AFIELD(&BI::name, Eq(kBluetoothDeviceName216)),
  430. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress2)))));
  431. mock_device_1_->SetBatteryInfo(
  432. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  433. mock_device_2_->SetBatteryInfo(
  434. BatteryInfo(BatteryType::kDefault, /*percentage=*/0));
  435. }
  436. TEST_F(PeripheralBatteryListenerTest,
  437. Bluetooth_RemovesNotificationForDisconnectedDevices) {
  438. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  439. base::ScopedObservation<PeripheralBatteryListener,
  440. PeripheralBatteryListener::Observer>
  441. scoped_listener_obs{&listener_observer_mock};
  442. scoped_listener_obs.Observe(battery_listener_.get());
  443. testing::InSequence sequence;
  444. EXPECT_CALL(listener_observer_mock,
  445. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  446. EXPECT_CALL(
  447. listener_observer_mock,
  448. OnUpdatedBatteryLevel(AllOf(
  449. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)), AFIELD(&BI::level, Eq(5)),
  450. AFIELD(&BI::type, Eq(BI::PeripheralType::kOther)),
  451. AFIELD(&BI::name, Eq(kBluetoothDeviceName116)),
  452. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))));
  453. EXPECT_CALL(listener_observer_mock,
  454. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId2))));
  455. EXPECT_CALL(
  456. listener_observer_mock,
  457. OnUpdatedBatteryLevel(AllOf(
  458. AFIELD(&BI::key, Eq(kBluetoothDeviceId2)), AFIELD(&BI::level, Eq(0)),
  459. AFIELD(&BI::type, Eq(BI::PeripheralType::kOther)),
  460. AFIELD(&BI::name, Eq(kBluetoothDeviceName216)),
  461. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress2)))));
  462. mock_device_1_->SetBatteryInfo(
  463. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  464. mock_device_2_->SetBatteryInfo(
  465. BatteryInfo(BatteryType::kDefault, /*percentage=*/0));
  466. EXPECT_CALL(listener_observer_mock,
  467. OnRemovingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  468. // Verify only the notification for device 1 gets removed.
  469. battery_listener_->DeviceConnectedStateChanged(mock_adapter_.get(),
  470. mock_device_1_.get(), false);
  471. EXPECT_CALL(listener_observer_mock,
  472. OnRemovingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId2))));
  473. // Remove the second notification.
  474. battery_listener_->DeviceRemoved(mock_adapter_.get(), mock_device_2_.get());
  475. }
  476. TEST_F(PeripheralBatteryListenerTest,
  477. Bluetooth_RemovesNotificationForDisconnectedDevicesInOtherOrder) {
  478. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  479. base::ScopedObservation<PeripheralBatteryListener,
  480. PeripheralBatteryListener::Observer>
  481. scoped_listener_obs{&listener_observer_mock};
  482. scoped_listener_obs.Observe(battery_listener_.get());
  483. testing::InSequence sequence;
  484. EXPECT_CALL(listener_observer_mock,
  485. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  486. EXPECT_CALL(
  487. listener_observer_mock,
  488. OnUpdatedBatteryLevel(
  489. AllOf(AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  490. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))));
  491. EXPECT_CALL(listener_observer_mock,
  492. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId2))));
  493. EXPECT_CALL(
  494. listener_observer_mock,
  495. OnUpdatedBatteryLevel(
  496. AllOf(AFIELD(&BI::key, Eq(kBluetoothDeviceId2)),
  497. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress2)))));
  498. mock_device_1_->SetBatteryInfo(
  499. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  500. mock_device_2_->SetBatteryInfo(
  501. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  502. EXPECT_CALL(listener_observer_mock,
  503. OnRemovingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId2))));
  504. // Remove the second notification.
  505. battery_listener_->DeviceRemoved(mock_adapter_.get(), mock_device_2_.get());
  506. EXPECT_CALL(listener_observer_mock,
  507. OnRemovingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  508. // Verify only the notification for device 1 gets removed.
  509. battery_listener_->DeviceConnectedStateChanged(mock_adapter_.get(),
  510. mock_device_1_.get(), false);
  511. }
  512. TEST_F(PeripheralBatteryListenerTest, Bluetooth_RemoveAndReconnect) {
  513. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  514. base::ScopedObservation<PeripheralBatteryListener,
  515. PeripheralBatteryListener::Observer>
  516. scoped_listener_obs{&listener_observer_mock};
  517. scoped_listener_obs.Observe(battery_listener_.get());
  518. testing::InSequence sequence;
  519. EXPECT_CALL(listener_observer_mock,
  520. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  521. EXPECT_CALL(
  522. listener_observer_mock,
  523. OnUpdatedBatteryLevel(
  524. AllOf(AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  525. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))));
  526. mock_device_1_->SetBatteryInfo(
  527. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  528. EXPECT_CALL(listener_observer_mock,
  529. OnRemovingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  530. battery_listener_->DeviceConnectedStateChanged(mock_adapter_.get(),
  531. mock_device_1_.get(), false);
  532. EXPECT_CALL(listener_observer_mock,
  533. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  534. EXPECT_CALL(
  535. listener_observer_mock,
  536. OnUpdatedBatteryLevel(
  537. AllOf(AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  538. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))));
  539. mock_device_1_->SetBatteryInfo(
  540. BatteryInfo(BatteryType::kDefault, /*percentage=*/1));
  541. }
  542. TEST_F(PeripheralBatteryListenerTest,
  543. Bluetooth_CancelNotificationForInvalidBatteryLevel) {
  544. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  545. base::ScopedObservation<PeripheralBatteryListener,
  546. PeripheralBatteryListener::Observer>
  547. scoped_listener_obs{&listener_observer_mock};
  548. scoped_listener_obs.Observe(battery_listener_.get());
  549. testing::InSequence sequence;
  550. EXPECT_CALL(listener_observer_mock,
  551. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  552. EXPECT_CALL(
  553. listener_observer_mock,
  554. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  555. AFIELD(&BI::level, Eq(1)))));
  556. mock_device_1_->SetBatteryInfo(
  557. BatteryInfo(BatteryType::kDefault, /*percentage=*/1));
  558. EXPECT_CALL(
  559. listener_observer_mock,
  560. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  561. AFIELD(&BI::level, Eq(absl::nullopt)))));
  562. mock_device_1_->RemoveBatteryInfo(BatteryType::kDefault);
  563. }
  564. // Do notify observer if the battery level drops again under the
  565. // threshold before kNotificationInterval is completed.
  566. TEST_F(PeripheralBatteryListenerTest, EnsureUpdatesWithinSmallTimeIntervals) {
  567. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  568. base::ScopedObservation<PeripheralBatteryListener,
  569. PeripheralBatteryListener::Observer>
  570. scoped_listener_obs{&listener_observer_mock};
  571. scoped_listener_obs.Observe(battery_listener_.get());
  572. ClockAdvance(base::Seconds(100));
  573. testing::InSequence sequence;
  574. EXPECT_CALL(listener_observer_mock,
  575. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  576. EXPECT_CALL(listener_observer_mock,
  577. OnUpdatedBatteryLevel(AllOf(
  578. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  579. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  580. AFIELD(&BI::level, Eq(1)))));
  581. mock_device_1_->SetBatteryInfo(
  582. BatteryInfo(BatteryType::kDefault, /*percentage=*/1));
  583. ClockAdvance(base::Seconds(1));
  584. EXPECT_CALL(listener_observer_mock,
  585. OnUpdatedBatteryLevel(AllOf(
  586. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  587. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  588. AFIELD(&BI::level, Eq(absl::nullopt)))));
  589. mock_device_1_->RemoveBatteryInfo(BatteryType::kDefault);
  590. ClockAdvance(base::Seconds(1));
  591. EXPECT_CALL(listener_observer_mock,
  592. OnUpdatedBatteryLevel(AllOf(
  593. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  594. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  595. AFIELD(&BI::level, Eq(1)))));
  596. mock_device_1_->SetBatteryInfo(
  597. BatteryInfo(BatteryType::kDefault, /*percentage=*/1));
  598. }
  599. // Notify observer if the battery is under threshold, then unknown level and
  600. // then is again under the threshold after kNotificationInterval is completed.
  601. // (Listener should not pay attention to kNotificationInterval anyway.)
  602. TEST_F(PeripheralBatteryListenerTest,
  603. PostNotificationIfBatteryGoesFromUnknownLevelToBelowThreshold) {
  604. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  605. base::ScopedObservation<PeripheralBatteryListener,
  606. PeripheralBatteryListener::Observer>
  607. scoped_listener_obs{&listener_observer_mock};
  608. scoped_listener_obs.Observe(battery_listener_.get());
  609. ClockAdvance(base::Seconds(100));
  610. testing::InSequence sequence;
  611. EXPECT_CALL(listener_observer_mock,
  612. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  613. EXPECT_CALL(listener_observer_mock,
  614. OnUpdatedBatteryLevel(AllOf(
  615. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  616. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  617. AFIELD(&BI::level, Eq(1)))));
  618. mock_device_1_->SetBatteryInfo(
  619. BatteryInfo(BatteryType::kDefault, /*percentage=*/1));
  620. ClockAdvance(base::Seconds(1));
  621. EXPECT_CALL(listener_observer_mock,
  622. OnUpdatedBatteryLevel(AllOf(
  623. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  624. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  625. AFIELD(&BI::level, Eq(absl::nullopt)))));
  626. mock_device_1_->RemoveBatteryInfo(BatteryType::kDefault);
  627. ClockAdvance(base::Seconds(100));
  628. EXPECT_CALL(listener_observer_mock,
  629. OnUpdatedBatteryLevel(AllOf(
  630. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  631. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  632. AFIELD(&BI::level, Eq(1)))));
  633. mock_device_1_->SetBatteryInfo(
  634. BatteryInfo(BatteryType::kDefault, /*percentage=*/1));
  635. }
  636. // If there is an existing notification and the battery level remains low,
  637. // update its content.
  638. TEST_F(PeripheralBatteryListenerTest, UpdateNotificationIfVisible) {
  639. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  640. base::ScopedObservation<PeripheralBatteryListener,
  641. PeripheralBatteryListener::Observer>
  642. scoped_listener_obs{&listener_observer_mock};
  643. scoped_listener_obs.Observe(battery_listener_.get());
  644. testing::InSequence sequence;
  645. ClockAdvance(base::Seconds(100));
  646. EXPECT_CALL(listener_observer_mock,
  647. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  648. EXPECT_CALL(listener_observer_mock,
  649. OnUpdatedBatteryLevel(AllOf(
  650. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  651. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  652. AFIELD(&BI::level, Eq(5)))));
  653. mock_device_1_->SetBatteryInfo(
  654. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  655. // The battery level remains low, should update the notification.
  656. ClockAdvance(base::Seconds(100));
  657. EXPECT_CALL(listener_observer_mock,
  658. OnUpdatedBatteryLevel(AllOf(
  659. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)),
  660. AFIELD(&BI::last_update_timestamp, Eq(GetTestingClock())),
  661. AFIELD(&BI::level, Eq(3)))));
  662. mock_device_1_->SetBatteryInfo(
  663. BatteryInfo(BatteryType::kDefault, /*percentage=*/3));
  664. }
  665. TEST_F(PeripheralBatteryListenerTest, MultipleObserversCoexist) {
  666. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock_1;
  667. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock_2;
  668. base::ScopedObservation<PeripheralBatteryListener,
  669. PeripheralBatteryListener::Observer>
  670. scoped_listener_obs_1{&listener_observer_mock_1};
  671. base::ScopedObservation<PeripheralBatteryListener,
  672. PeripheralBatteryListener::Observer>
  673. scoped_listener_obs_2{&listener_observer_mock_2};
  674. scoped_listener_obs_1.Observe(battery_listener_.get());
  675. scoped_listener_obs_2.Observe(battery_listener_.get());
  676. EXPECT_CALL(listener_observer_mock_1,
  677. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  678. EXPECT_CALL(listener_observer_mock_2,
  679. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  680. EXPECT_CALL(listener_observer_mock_1,
  681. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(kTestBatteryId)),
  682. AFIELD(&BI::level, Eq(50)))));
  683. EXPECT_CALL(listener_observer_mock_2,
  684. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::key, Eq(kTestBatteryId)),
  685. AFIELD(&BI::level, Eq(50)))));
  686. battery_listener_->PeripheralBatteryStatusReceived(
  687. kTestBatteryPath, kTestDeviceName, 50, kTestBatteryStatusIn,
  688. /*serial_number=*/"", kBatteryPolledUpdate);
  689. }
  690. TEST_F(PeripheralBatteryListenerTest, ObserverationLifetimeObeyed) {
  691. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  692. base::ScopedObservation<PeripheralBatteryListener,
  693. PeripheralBatteryListener::Observer>
  694. scoped_listener_obs{&listener_observer_mock};
  695. testing::InSequence sequence;
  696. // Connect observer, add and remove battery
  697. scoped_listener_obs.Observe(battery_listener_.get());
  698. EXPECT_CALL(listener_observer_mock,
  699. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  700. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_));
  701. battery_listener_->PeripheralBatteryStatusReceived(
  702. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  703. /*serial_number=*/"", kBatteryPolledUpdate);
  704. EXPECT_CALL(listener_observer_mock,
  705. OnRemovingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  706. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  707. // Disconnect observer, add and remove battery
  708. scoped_listener_obs.Reset();
  709. battery_listener_->PeripheralBatteryStatusReceived(
  710. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  711. /*serial_number=*/"", kBatteryPolledUpdate);
  712. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  713. // Reconnect observer, add and remove battery
  714. scoped_listener_obs.Observe(battery_listener_.get());
  715. EXPECT_CALL(listener_observer_mock,
  716. OnAddingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  717. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_));
  718. battery_listener_->PeripheralBatteryStatusReceived(
  719. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  720. /*serial_number=*/"", kBatteryPolledUpdate);
  721. EXPECT_CALL(listener_observer_mock,
  722. OnRemovingBattery(AFIELD(&BI::key, Eq(kTestBatteryId))));
  723. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  724. }
  725. // Check that observers only see events occuring while they are connected.
  726. TEST_F(PeripheralBatteryListenerTest, PartialObserverationLifetimeObeyed) {
  727. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  728. base::ScopedObservation<PeripheralBatteryListener,
  729. PeripheralBatteryListener::Observer>
  730. scoped_listener_obs{&listener_observer_mock};
  731. testing::InSequence sequence;
  732. // Connect observer, add and remove battery.
  733. scoped_listener_obs.Observe(battery_listener_.get());
  734. EXPECT_CALL(listener_observer_mock, OnAddingBattery(_));
  735. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_));
  736. battery_listener_->PeripheralBatteryStatusReceived(
  737. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  738. /*serial_number=*/"", kBatteryPolledUpdate);
  739. // Disconnect observer before we remove battery.
  740. scoped_listener_obs.Reset();
  741. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  742. // Reconnect battery.
  743. battery_listener_->PeripheralBatteryStatusReceived(
  744. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  745. /*serial_number=*/"", true);
  746. // Reconnect observer, add and remove battery.
  747. EXPECT_CALL(listener_observer_mock, OnAddingBattery(_));
  748. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_));
  749. scoped_listener_obs.Observe(battery_listener_.get());
  750. EXPECT_CALL(listener_observer_mock, OnRemovingBattery(_));
  751. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  752. }
  753. // Check that observers will get events to 'catch up' on batteries they missed.
  754. TEST_F(PeripheralBatteryListenerTest, PartialObserverationLifetimeCatchUp) {
  755. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  756. base::ScopedObservation<PeripheralBatteryListener,
  757. PeripheralBatteryListener::Observer>
  758. scoped_listener_obs{&listener_observer_mock};
  759. testing::InSequence sequence;
  760. // Connect battery.
  761. battery_listener_->PeripheralBatteryStatusReceived(
  762. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  763. /*serial_number=*/"", kBatteryEventUpdate);
  764. EXPECT_CALL(listener_observer_mock, OnAddingBattery(_));
  765. EXPECT_CALL(listener_observer_mock, OnUpdatedBatteryLevel(_));
  766. scoped_listener_obs.Observe(battery_listener_.get());
  767. EXPECT_CALL(listener_observer_mock, OnRemovingBattery(_));
  768. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  769. }
  770. TEST_F(PeripheralBatteryListenerTest, MultipleObserverationLifetimeObeyed) {
  771. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock_1;
  772. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock_2;
  773. base::ScopedObservation<PeripheralBatteryListener,
  774. PeripheralBatteryListener::Observer>
  775. scoped_listener_obs_1{&listener_observer_mock_1};
  776. base::ScopedObservation<PeripheralBatteryListener,
  777. PeripheralBatteryListener::Observer>
  778. scoped_listener_obs_2{&listener_observer_mock_2};
  779. testing::InSequence sequence;
  780. scoped_listener_obs_1.Observe(battery_listener_.get());
  781. EXPECT_CALL(listener_observer_mock_1, OnAddingBattery(_));
  782. EXPECT_CALL(listener_observer_mock_1, OnUpdatedBatteryLevel(_));
  783. battery_listener_->PeripheralBatteryStatusReceived(
  784. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  785. /*serial_number=*/"", kBatteryPolledUpdate);
  786. EXPECT_CALL(listener_observer_mock_2, OnAddingBattery(_));
  787. EXPECT_CALL(listener_observer_mock_2, OnUpdatedBatteryLevel(_));
  788. scoped_listener_obs_2.Observe(battery_listener_.get());
  789. EXPECT_CALL(listener_observer_mock_1, OnRemovingBattery(_));
  790. EXPECT_CALL(listener_observer_mock_2, OnRemovingBattery(_));
  791. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  792. scoped_listener_obs_1.Reset();
  793. EXPECT_CALL(listener_observer_mock_2, OnAddingBattery(_));
  794. EXPECT_CALL(listener_observer_mock_2, OnUpdatedBatteryLevel(_));
  795. battery_listener_->PeripheralBatteryStatusReceived(
  796. kTestBatteryPath, kTestDeviceName, 5, kTestBatteryStatusIn,
  797. /*serial_number=*/"", kBatteryPolledUpdate);
  798. EXPECT_CALL(listener_observer_mock_2, OnRemovingBattery(_));
  799. battery_listener_->RemoveBluetoothBattery(kTestBatteryAddress);
  800. }
  801. TEST_F(PeripheralBatteryListenerTest, Charger) {
  802. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  803. base::ScopedObservation<PeripheralBatteryListener,
  804. PeripheralBatteryListener::Observer>
  805. scoped_listener_obs{&listener_observer_mock};
  806. scoped_listener_obs.Observe(battery_listener_.get());
  807. testing::InSequence sequence;
  808. EXPECT_CALL(listener_observer_mock,
  809. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  810. EXPECT_CALL(
  811. listener_observer_mock,
  812. OnUpdatedBatteryLevel(
  813. AllOf(AFIELD(&BI::key, Eq(kTestChargerId)),
  814. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  815. AFIELD(&BI::level, Eq(50)),
  816. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)))));
  817. battery_listener_->PeripheralBatteryStatusReceived(
  818. kTestChargerPath, kTestChargerName, 50,
  819. power_manager::
  820. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_CHARGING,
  821. /*serial_number=*/"", kBatteryEventUpdate);
  822. }
  823. // TODO(b/215381232): Temporarily support both 'PCHG' name and 'peripheral' name
  824. // till upstream kernel driver is merged. Remove test case when upstream kernel
  825. // driver is merged.
  826. TEST_F(PeripheralBatteryListenerTest, Charger_PCHG) {
  827. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  828. base::ScopedObservation<PeripheralBatteryListener,
  829. PeripheralBatteryListener::Observer>
  830. scoped_listener_obs{&listener_observer_mock};
  831. scoped_listener_obs.Observe(battery_listener_.get());
  832. testing::InSequence sequence;
  833. EXPECT_CALL(listener_observer_mock,
  834. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  835. EXPECT_CALL(
  836. listener_observer_mock,
  837. OnUpdatedBatteryLevel(
  838. AllOf(AFIELD(&BI::key, Eq(kTestChargerId)),
  839. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  840. AFIELD(&BI::level, Eq(50)),
  841. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)))));
  842. battery_listener_->PeripheralBatteryStatusReceived(
  843. kTestPCHGChargerPath, kTestChargerName, 50,
  844. power_manager::
  845. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_CHARGING,
  846. /*serial_number=*/"", kBatteryEventUpdate);
  847. }
  848. TEST_F(PeripheralBatteryListenerTest, ChargerError) {
  849. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  850. base::ScopedObservation<PeripheralBatteryListener,
  851. PeripheralBatteryListener::Observer>
  852. scoped_listener_obs{&listener_observer_mock};
  853. scoped_listener_obs.Observe(battery_listener_.get());
  854. testing::InSequence sequence;
  855. EXPECT_CALL(listener_observer_mock,
  856. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  857. EXPECT_CALL(
  858. listener_observer_mock,
  859. OnUpdatedBatteryLevel(AllOf(
  860. AFIELD(&BI::key, Eq(kTestChargerId)), AFIELD(&BI::level, Eq(50)),
  861. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kError)))));
  862. battery_listener_->PeripheralBatteryStatusReceived(
  863. kTestChargerPath, kTestChargerName, 50,
  864. power_manager::PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_ERROR,
  865. /*serial_number=*/"", kBatteryPolledUpdate);
  866. }
  867. // Check that zero value from charger is accepted, this may happen
  868. // if it is charging from a deep discharge.
  869. TEST_F(PeripheralBatteryListenerTest, StylusChargingFromDeepDischarge) {
  870. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  871. base::ScopedObservation<PeripheralBatteryListener,
  872. PeripheralBatteryListener::Observer>
  873. scoped_listener_obs{&listener_observer_mock};
  874. scoped_listener_obs.Observe(battery_listener_.get());
  875. testing::InSequence sequence;
  876. EXPECT_CALL(listener_observer_mock,
  877. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  878. EXPECT_CALL(
  879. listener_observer_mock,
  880. OnUpdatedBatteryLevel(AllOf(
  881. AFIELD(&BI::key, Eq(kTestChargerId)),
  882. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  883. AFIELD(&BI::level, Eq(0)),
  884. AFIELD(&BI::charge_status, Eq(PeripheralBatteryListener::BatteryInfo::
  885. ChargeStatus::kCharging)))));
  886. battery_listener_->PeripheralBatteryStatusReceived(
  887. kTestChargerPath, kTestChargerName, 0,
  888. power_manager::
  889. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_CHARGING,
  890. /*serial_number=*/"", kBatteryEventUpdate);
  891. }
  892. // Check that zero value from charger is accepted, even if there was
  893. // an existing non-zero value from another stylus.
  894. TEST_F(PeripheralBatteryListenerTest, StylusChargingFromDeepDischarge2) {
  895. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  896. base::ScopedObservation<PeripheralBatteryListener,
  897. PeripheralBatteryListener::Observer>
  898. scoped_listener_obs{&listener_observer_mock};
  899. scoped_listener_obs.Observe(battery_listener_.get());
  900. const int nonZeroBatteryLevel = 74;
  901. testing::InSequence sequence;
  902. EXPECT_CALL(listener_observer_mock,
  903. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  904. // First establish a stylus is charging at a normal level
  905. EXPECT_CALL(
  906. listener_observer_mock,
  907. OnUpdatedBatteryLevel(AllOf(
  908. AFIELD(&BI::key, Eq(kTestChargerId)),
  909. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  910. AFIELD(&BI::level, Eq(nonZeroBatteryLevel)),
  911. AFIELD(&BI::charge_status, Eq(PeripheralBatteryListener::BatteryInfo::
  912. ChargeStatus::kCharging)))));
  913. battery_listener_->PeripheralBatteryStatusReceived(
  914. kTestChargerPath, kTestChargerName, nonZeroBatteryLevel,
  915. power_manager::
  916. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_CHARGING,
  917. /*serial_number=*/"", kBatteryEventUpdate);
  918. // Then put on a stylus that is in deep discharge
  919. EXPECT_CALL(listener_observer_mock,
  920. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::level, Eq(0)))));
  921. battery_listener_->PeripheralBatteryStatusReceived(
  922. kTestChargerPath, kTestChargerName, 0,
  923. power_manager::
  924. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_CHARGING,
  925. /*serial_number=*/"", kBatteryEventUpdate);
  926. }
  927. TEST_F(PeripheralBatteryListenerTest, ChargerErrorTransition) {
  928. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  929. base::ScopedObservation<PeripheralBatteryListener,
  930. PeripheralBatteryListener::Observer>
  931. scoped_listener_obs{&listener_observer_mock};
  932. scoped_listener_obs.Observe(battery_listener_.get());
  933. testing::InSequence sequence;
  934. EXPECT_CALL(listener_observer_mock,
  935. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  936. EXPECT_CALL(
  937. listener_observer_mock,
  938. OnUpdatedBatteryLevel(AllOf(
  939. AFIELD(&BI::key, Eq(kTestChargerId)), AFIELD(&BI::level, Eq(50)),
  940. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)))));
  941. battery_listener_->PeripheralBatteryStatusReceived(
  942. kTestChargerPath, kTestChargerName, 50,
  943. power_manager::
  944. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_CHARGING,
  945. /*serial_number=*/"", kBatteryPolledUpdate);
  946. EXPECT_CALL(
  947. listener_observer_mock,
  948. OnUpdatedBatteryLevel(AllOf(
  949. AFIELD(&BI::key, Eq(kTestChargerId)), AFIELD(&BI::level, Eq(50)),
  950. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kError)))));
  951. battery_listener_->PeripheralBatteryStatusReceived(
  952. kTestChargerPath, kTestChargerName, 50,
  953. power_manager::PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_ERROR,
  954. /*serial_number=*/"", kBatteryEventUpdate);
  955. }
  956. // Stylus-via-screen updates of level zero should be translated to
  957. // nullopt as zero is not a valid level, but may come through during
  958. // boot or other device creation scenarios.
  959. TEST_F(PeripheralBatteryListenerTest, StylusDiscardsZeros) {
  960. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  961. base::ScopedObservation<PeripheralBatteryListener,
  962. PeripheralBatteryListener::Observer>
  963. scoped_listener_obs{&listener_observer_mock};
  964. scoped_listener_obs.Observe(battery_listener_.get());
  965. CreateExternalTouchscreen();
  966. testing::InSequence sequence;
  967. EXPECT_CALL(listener_observer_mock,
  968. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))));
  969. EXPECT_CALL(listener_observer_mock,
  970. OnUpdatedBatteryLevel(AllOf(
  971. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  972. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  973. AFIELD(&BI::level, Eq(absl::nullopt)),
  974. AFIELD(&BI::charge_status,
  975. Eq(kTestStylusBatteryStatusDischargingOut)))));
  976. battery_listener_->PeripheralBatteryStatusReceived(
  977. kTestStylusBatteryPath, kTestStylusName, 0,
  978. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  979. kBatteryEventUpdate);
  980. EXPECT_CALL(listener_observer_mock,
  981. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::level, Eq(50)))));
  982. battery_listener_->PeripheralBatteryStatusReceived(
  983. kTestStylusBatteryPath, kTestStylusName, 50,
  984. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  985. kBatteryEventUpdate);
  986. EXPECT_CALL(
  987. listener_observer_mock,
  988. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::level, Eq(absl::nullopt)))));
  989. battery_listener_->PeripheralBatteryStatusReceived(
  990. kTestStylusBatteryPath, kTestStylusName, 0,
  991. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  992. kBatteryEventUpdate);
  993. }
  994. // Stylus-via-charger updates of level zero should translate to nullopt if
  995. // no value is known; otherwise they should be ignored as not providing
  996. // information.
  997. TEST_F(PeripheralBatteryListenerTest, StylusChargerDoesNullZeros) {
  998. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  999. base::ScopedObservation<PeripheralBatteryListener,
  1000. PeripheralBatteryListener::Observer>
  1001. scoped_listener_obs{&listener_observer_mock};
  1002. scoped_listener_obs.Observe(battery_listener_.get());
  1003. testing::InSequence sequence;
  1004. EXPECT_CALL(listener_observer_mock,
  1005. OnAddingBattery(AFIELD(&BI::key, Eq(kTestChargerId))));
  1006. EXPECT_CALL(listener_observer_mock,
  1007. OnUpdatedBatteryLevel(AllOf(
  1008. AFIELD(&BI::key, Eq(kTestChargerId)),
  1009. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1010. AFIELD(&BI::level, Eq(absl::nullopt)),
  1011. AFIELD(&BI::charge_status, Eq(kTestBatteryStatusOut)))));
  1012. battery_listener_->PeripheralBatteryStatusReceived(
  1013. kTestChargerPath, kTestChargerName, 0, kTestBatteryStatusIn,
  1014. /*serial_number=*/"", kBatteryEventUpdate);
  1015. EXPECT_CALL(listener_observer_mock,
  1016. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::level, Eq(50)))));
  1017. battery_listener_->PeripheralBatteryStatusReceived(
  1018. kTestChargerPath, kTestChargerName, 50, kTestBatteryStatusIn,
  1019. /*serial_number=*/"", kBatteryEventUpdate);
  1020. EXPECT_CALL(listener_observer_mock,
  1021. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::level, Eq(50)))));
  1022. battery_listener_->PeripheralBatteryStatusReceived(
  1023. kTestChargerPath, kTestChargerName, 0, kTestBatteryStatusIn,
  1024. /*serial_number=*/"", kBatteryEventUpdate);
  1025. }
  1026. // Bluetooth/other HID updates of level zero should come through as expected, as
  1027. // we don't know that 0 is invalid.
  1028. TEST_F(PeripheralBatteryListenerTest, BluetoothDoesNotDiscardZeros) {
  1029. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1030. base::ScopedObservation<PeripheralBatteryListener,
  1031. PeripheralBatteryListener::Observer>
  1032. scoped_listener_obs{&listener_observer_mock};
  1033. scoped_listener_obs.Observe(battery_listener_.get());
  1034. testing::InSequence sequence;
  1035. EXPECT_CALL(listener_observer_mock,
  1036. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  1037. EXPECT_CALL(
  1038. listener_observer_mock,
  1039. OnUpdatedBatteryLevel(AllOf(
  1040. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)), AFIELD(&BI::level, Eq(0)),
  1041. AFIELD(&BI::type, Eq(BI::PeripheralType::kOther)),
  1042. AFIELD(&BI::name, Eq(kBluetoothDeviceName116)),
  1043. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))));
  1044. mock_device_1_->SetBatteryInfo(
  1045. BatteryInfo(BatteryType::kDefault, /*percentage=*/0));
  1046. EXPECT_CALL(listener_observer_mock,
  1047. OnUpdatedBatteryLevel(AllOf(AFIELD(&BI::level, Eq(5)))));
  1048. mock_device_1_->SetBatteryInfo(
  1049. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  1050. }
  1051. // Stylus garage charging
  1052. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest,
  1053. DoNotSynthesizeGarageCharger) {
  1054. // Create touchscreen w/ stylus, w/o dockswitch
  1055. // Verify Stylus Garage does not exist
  1056. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1057. base::ScopedObservation<PeripheralBatteryListener,
  1058. PeripheralBatteryListener::Observer>
  1059. scoped_listener_obs{&listener_observer_mock};
  1060. testing::InSequence sequence;
  1061. CreateInternalTouchscreen(false);
  1062. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1063. scoped_listener_obs.Observe(battery_listener_.get());
  1064. // Level 50 at time 100, listener should be notified.
  1065. ClockAdvance(base::Seconds(100));
  1066. EXPECT_CALL(listener_observer_mock,
  1067. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))));
  1068. EXPECT_CALL(listener_observer_mock,
  1069. OnUpdatedBatteryLevel(AllOf(
  1070. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1071. AFIELD(&BI::level, Eq(50)),
  1072. AFIELD(&BI::charge_status,
  1073. Eq(kTestStylusBatteryStatusDischargingOut)),
  1074. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1075. AFIELD(&BI::bluetooth_address, Eq("")))));
  1076. battery_listener_->PeripheralBatteryStatusReceived(
  1077. kTestStylusBatteryPath, kTestStylusName, 50,
  1078. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1079. kBatteryPolledUpdate);
  1080. }
  1081. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest,
  1082. DoSynthesizeGarageCharger) {
  1083. // Create touchscreen w/ stylus, w/ dockswitch
  1084. // Stylus is not garaged at start
  1085. // Trigger touchscreen stylus update event
  1086. // Verify Stylus Garage does exist
  1087. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1088. base::ScopedObservation<PeripheralBatteryListener,
  1089. PeripheralBatteryListener::Observer>
  1090. scoped_listener_obs{&listener_observer_mock};
  1091. CreateInternalTouchscreen(true);
  1092. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1093. scoped_listener_obs.Observe(battery_listener_.get());
  1094. // Level 50 at time 100, listener should be notified.
  1095. ClockAdvance(base::Seconds(100));
  1096. Expectation a = EXPECT_CALL(
  1097. listener_observer_mock,
  1098. OnAddingBattery(AFIELD(&BI::key, Eq(kStylusChargerDeviceName))));
  1099. Expectation b = EXPECT_CALL(
  1100. listener_observer_mock,
  1101. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))));
  1102. EXPECT_CALL(listener_observer_mock,
  1103. OnUpdatedBatteryLevel(AllOf(
  1104. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1105. AFIELD(&BI::level, Eq(absl::nullopt)),
  1106. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1107. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1108. AFIELD(&BI::bluetooth_address, Eq("")))))
  1109. .After(a);
  1110. EXPECT_CALL(listener_observer_mock,
  1111. OnUpdatedBatteryLevel(AllOf(
  1112. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1113. AFIELD(&BI::level, Eq(50)),
  1114. AFIELD(&BI::charge_status,
  1115. Eq(kTestStylusBatteryStatusDischargingOut)),
  1116. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1117. AFIELD(&BI::bluetooth_address, Eq("")))))
  1118. .After(b);
  1119. battery_listener_->PeripheralBatteryStatusReceived(
  1120. kTestStylusBatteryPath, kTestStylusName, 50,
  1121. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1122. kBatteryPolledUpdate);
  1123. }
  1124. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest, GarageCharging) {
  1125. // Create touchscreen w/ stylus, w/ dockswitch
  1126. // Stylus not in dock at beginning
  1127. // Put stylus on charger, do not have it touch screen
  1128. // Wait for it to come to a full charge
  1129. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1130. base::ScopedObservation<PeripheralBatteryListener,
  1131. PeripheralBatteryListener::Observer>
  1132. scoped_listener_obs{&listener_observer_mock};
  1133. CreateInternalTouchscreen(true);
  1134. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1135. scoped_listener_obs.Observe(battery_listener_.get());
  1136. // Level 50 at time 100, listener should be notified.
  1137. ClockAdvance(base::Seconds(100));
  1138. Sequence a, b;
  1139. EXPECT_CALL(listener_observer_mock,
  1140. OnAddingBattery(AFIELD(&BI::key, Eq(kStylusChargerDeviceName))))
  1141. .InSequence(a);
  1142. EXPECT_CALL(listener_observer_mock,
  1143. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))))
  1144. .InSequence(b);
  1145. EXPECT_CALL(listener_observer_mock,
  1146. OnUpdatedBatteryLevel(AllOf(
  1147. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1148. AFIELD(&BI::level, Eq(absl::nullopt)),
  1149. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1150. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1151. AFIELD(&BI::bluetooth_address, Eq("")))))
  1152. .InSequence(a);
  1153. EXPECT_CALL(listener_observer_mock,
  1154. OnUpdatedBatteryLevel(AllOf(
  1155. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1156. AFIELD(&BI::level, Eq(50)),
  1157. AFIELD(&BI::charge_status,
  1158. Eq(kTestStylusBatteryStatusDischargingOut)),
  1159. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1160. AFIELD(&BI::bluetooth_address, Eq("")))))
  1161. .InSequence(b);
  1162. battery_listener_->PeripheralBatteryStatusReceived(
  1163. kTestStylusBatteryPath, kTestStylusName, 50,
  1164. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1165. kBatteryPolledUpdate);
  1166. EXPECT_CALL(listener_observer_mock,
  1167. OnUpdatedBatteryLevel(AllOf(
  1168. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1169. AFIELD(&BI::level, Eq(absl::nullopt)),
  1170. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)),
  1171. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1172. AFIELD(&BI::bluetooth_address, Eq("")))))
  1173. .InSequence(a, b);
  1174. battery_listener_->OnStylusStateChanged(ui::StylusState::INSERTED);
  1175. }
  1176. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest, GarageChargesFully) {
  1177. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1178. base::ScopedObservation<PeripheralBatteryListener,
  1179. PeripheralBatteryListener::Observer>
  1180. scoped_listener_obs{&listener_observer_mock};
  1181. CreateInternalTouchscreen(true);
  1182. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1183. scoped_listener_obs.Observe(battery_listener_.get());
  1184. // Level 50 at time 100, listener should be notified.
  1185. ClockAdvance(base::Seconds(100));
  1186. Sequence a, b;
  1187. EXPECT_CALL(listener_observer_mock,
  1188. OnAddingBattery(AFIELD(&BI::key, Eq(kStylusChargerDeviceName))))
  1189. .InSequence(a);
  1190. EXPECT_CALL(listener_observer_mock,
  1191. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))))
  1192. .InSequence(b);
  1193. EXPECT_CALL(listener_observer_mock,
  1194. OnUpdatedBatteryLevel(AllOf(
  1195. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1196. AFIELD(&BI::level, Eq(absl::nullopt)),
  1197. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1198. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1199. AFIELD(&BI::bluetooth_address, Eq("")))))
  1200. .InSequence(a);
  1201. EXPECT_CALL(listener_observer_mock,
  1202. OnUpdatedBatteryLevel(AllOf(
  1203. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1204. AFIELD(&BI::level, Eq(50)),
  1205. AFIELD(&BI::charge_status,
  1206. Eq(kTestStylusBatteryStatusDischargingOut)),
  1207. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1208. AFIELD(&BI::bluetooth_address, Eq("")))))
  1209. .InSequence(b);
  1210. // This is a polled update, so it doesn't count as timely information
  1211. battery_listener_->PeripheralBatteryStatusReceived(
  1212. kTestStylusBatteryPath, kTestStylusName, 50,
  1213. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1214. kBatteryPolledUpdate);
  1215. // This will be called once the stylus is inserted, and called repeatedly
  1216. // until the stylus is estimated to be fully charged. Since we started
  1217. // without a known level for the stylus, the level will start from 1, counting
  1218. // up to 99 until the charge is believed complete.
  1219. EXPECT_CALL(
  1220. listener_observer_mock,
  1221. OnUpdatedBatteryLevel(
  1222. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1223. AFIELD(&BI::level, Lt(100)),
  1224. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)),
  1225. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))))
  1226. .Times(AnyNumber())
  1227. .InSequence(a, b);
  1228. battery_listener_->OnStylusStateChanged(ui::StylusState::INSERTED);
  1229. // Then we should have one update at 100% charge.
  1230. EXPECT_CALL(listener_observer_mock,
  1231. OnUpdatedBatteryLevel(AllOf(
  1232. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1233. AFIELD(&BI::level, Eq(100)),
  1234. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kFull)))))
  1235. .InSequence(a, b);
  1236. // Move time forward more than enough to fully charge, ensuring timers fire.
  1237. task_environment()->FastForwardBy(base::Seconds(kFullGarageChargeTime));
  1238. }
  1239. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest,
  1240. GarageChargesFullyFromFiftyPercent) {
  1241. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1242. base::ScopedObservation<PeripheralBatteryListener,
  1243. PeripheralBatteryListener::Observer>
  1244. scoped_listener_obs{&listener_observer_mock};
  1245. CreateInternalTouchscreen(true);
  1246. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1247. scoped_listener_obs.Observe(battery_listener_.get());
  1248. // Level 50 at time 100, listener should be notified.
  1249. ClockAdvance(base::Seconds(100));
  1250. Sequence a, b;
  1251. EXPECT_CALL(listener_observer_mock,
  1252. OnAddingBattery(AFIELD(&BI::key, Eq(kStylusChargerDeviceName))))
  1253. .InSequence(a);
  1254. EXPECT_CALL(listener_observer_mock,
  1255. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))))
  1256. .InSequence(b);
  1257. EXPECT_CALL(listener_observer_mock,
  1258. OnUpdatedBatteryLevel(AllOf(
  1259. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1260. AFIELD(&BI::level, Eq(absl::nullopt)),
  1261. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1262. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1263. AFIELD(&BI::bluetooth_address, Eq("")))))
  1264. .InSequence(a);
  1265. EXPECT_CALL(listener_observer_mock,
  1266. OnUpdatedBatteryLevel(AllOf(
  1267. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1268. AFIELD(&BI::level, Eq(50)),
  1269. AFIELD(&BI::charge_status,
  1270. Eq(kTestStylusBatteryStatusDischargingOut)),
  1271. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1272. AFIELD(&BI::bluetooth_address, Eq("")))))
  1273. .InSequence(b);
  1274. // This is an active update, so states that the stylus level is definitely
  1275. // 50%.
  1276. battery_listener_->PeripheralBatteryStatusReceived(
  1277. kTestStylusBatteryPath, kTestStylusName, 50,
  1278. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1279. kBatteryEventUpdate);
  1280. // The rest of these are strictly sequential
  1281. testing::InSequence sequence;
  1282. // This will be called once the stylus is inserted, and called repeatedly
  1283. // until the stylus is estimated to be fully charged. Since we started
  1284. // with a known level for the stylus the level start there, indicating that
  1285. // original level until the charge is complete.
  1286. EXPECT_CALL(
  1287. listener_observer_mock,
  1288. OnUpdatedBatteryLevel(
  1289. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1290. AFIELD(&BI::level, Ge(50)), AFIELD(&BI::level, Le(99)),
  1291. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)),
  1292. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))))
  1293. .Times(AnyNumber());
  1294. battery_listener_->OnStylusStateChanged(ui::StylusState::INSERTED);
  1295. // Then we should have one update at 100% charge.
  1296. EXPECT_CALL(listener_observer_mock,
  1297. OnUpdatedBatteryLevel(AllOf(
  1298. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1299. AFIELD(&BI::level, Eq(100)),
  1300. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kFull)))));
  1301. // Move time forward more than enough to fully charge, ensuring timers fire.
  1302. task_environment()->FastForwardBy(base::Seconds(kFullGarageChargeTime));
  1303. }
  1304. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest,
  1305. GarageChargingInterrupted) {
  1306. // Create touchscreen w/ stylus, w/ dockswitch, w/o stylus in garage
  1307. // Put stylus on in garage
  1308. // Wait for it to start charging
  1309. // Remove from charger
  1310. // Ensure it stops charging
  1311. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1312. base::ScopedObservation<PeripheralBatteryListener,
  1313. PeripheralBatteryListener::Observer>
  1314. scoped_listener_obs{&listener_observer_mock};
  1315. CreateInternalTouchscreen(true);
  1316. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1317. scoped_listener_obs.Observe(battery_listener_.get());
  1318. Sequence a, b;
  1319. EXPECT_CALL(listener_observer_mock,
  1320. OnAddingBattery(AFIELD(&BI::key, Eq(kStylusChargerDeviceName))))
  1321. .InSequence(a);
  1322. EXPECT_CALL(listener_observer_mock,
  1323. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))))
  1324. .InSequence(b);
  1325. EXPECT_CALL(listener_observer_mock,
  1326. OnUpdatedBatteryLevel(AllOf(
  1327. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1328. AFIELD(&BI::level, Eq(absl::nullopt)),
  1329. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1330. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1331. AFIELD(&BI::bluetooth_address, Eq("")))))
  1332. .InSequence(a);
  1333. EXPECT_CALL(listener_observer_mock,
  1334. OnUpdatedBatteryLevel(AllOf(
  1335. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1336. AFIELD(&BI::level, Eq(1)),
  1337. AFIELD(&BI::charge_status,
  1338. Eq(kTestStylusBatteryStatusDischargingOut)),
  1339. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1340. AFIELD(&BI::bluetooth_address, Eq("")))))
  1341. .InSequence(b);
  1342. battery_listener_->PeripheralBatteryStatusReceived(
  1343. kTestStylusBatteryPath, kTestStylusName, 1,
  1344. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1345. kBatteryEventUpdate);
  1346. ClockAdvance(base::Seconds(100));
  1347. // The rest of these are strictly sequential
  1348. testing::InSequence sequence;
  1349. EXPECT_CALL(
  1350. listener_observer_mock,
  1351. OnUpdatedBatteryLevel(
  1352. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1353. AFIELD(&BI::level, Eq(1)),
  1354. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)),
  1355. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))))
  1356. .Times(AnyNumber());
  1357. battery_listener_->OnStylusStateChanged(ui::StylusState::INSERTED);
  1358. // Move time forward more than enough to start charging.
  1359. task_environment()->FastForwardBy(base::Seconds(3));
  1360. // Remove stylus from garage
  1361. EXPECT_CALL(
  1362. listener_observer_mock,
  1363. OnUpdatedBatteryLevel(
  1364. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1365. AFIELD(&BI::level, Eq(1)),
  1366. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1367. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))));
  1368. battery_listener_->OnStylusStateChanged(ui::StylusState::REMOVED);
  1369. // Move time forward enough for anything to go wrong with the timers.
  1370. task_environment()->FastForwardBy(base::Seconds(kPartialGarageChargeTime));
  1371. }
  1372. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest, GarageChargingResumed) {
  1373. // Create touchscreen w/ stylus, w/ dockswitch, w/o stylus in garage
  1374. // Put stylus on in garage
  1375. // Wait for it to start charging
  1376. // Remove from charger
  1377. // Replace on charger
  1378. // Ensure it finishes charging
  1379. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1380. base::ScopedObservation<PeripheralBatteryListener,
  1381. PeripheralBatteryListener::Observer>
  1382. scoped_listener_obs{&listener_observer_mock};
  1383. CreateInternalTouchscreen(true);
  1384. ui::DeviceDataManagerTestApi().OnDeviceListsComplete();
  1385. scoped_listener_obs.Observe(battery_listener_.get());
  1386. Sequence a, b;
  1387. EXPECT_CALL(listener_observer_mock,
  1388. OnAddingBattery(AFIELD(&BI::key, Eq(kStylusChargerDeviceName))))
  1389. .InSequence(a);
  1390. EXPECT_CALL(listener_observer_mock,
  1391. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))))
  1392. .InSequence(b);
  1393. EXPECT_CALL(listener_observer_mock,
  1394. OnUpdatedBatteryLevel(AllOf(
  1395. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1396. AFIELD(&BI::level, Eq(absl::nullopt)),
  1397. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1398. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)),
  1399. AFIELD(&BI::bluetooth_address, Eq("")))))
  1400. .InSequence(a);
  1401. EXPECT_CALL(listener_observer_mock,
  1402. OnUpdatedBatteryLevel(AllOf(
  1403. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1404. AFIELD(&BI::level, Eq(1)),
  1405. AFIELD(&BI::charge_status,
  1406. Eq(kTestStylusBatteryStatusDischargingOut)),
  1407. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1408. AFIELD(&BI::bluetooth_address, Eq("")))))
  1409. .InSequence(b);
  1410. battery_listener_->PeripheralBatteryStatusReceived(
  1411. kTestStylusBatteryPath, kTestStylusName, 1,
  1412. kTestStylusBatteryStatusDischargingIn, /*serial_number=*/"",
  1413. kBatteryEventUpdate);
  1414. ClockAdvance(base::Seconds(100));
  1415. // The rest of these are strictly sequential
  1416. testing::InSequence sequence;
  1417. EXPECT_CALL(
  1418. listener_observer_mock,
  1419. OnUpdatedBatteryLevel(
  1420. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1421. AFIELD(&BI::level, Eq(1)),
  1422. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)),
  1423. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))))
  1424. .Times(AnyNumber());
  1425. battery_listener_->OnStylusStateChanged(ui::StylusState::INSERTED);
  1426. // Move time forward more than enough to start charging.
  1427. task_environment()->FastForwardBy(base::Seconds(kPartialGarageChargeTime));
  1428. // Remove stylus from garage
  1429. EXPECT_CALL(
  1430. listener_observer_mock,
  1431. OnUpdatedBatteryLevel(
  1432. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1433. AFIELD(&BI::level, Eq(1)),
  1434. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kUnknown)),
  1435. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))));
  1436. battery_listener_->OnStylusStateChanged(ui::StylusState::REMOVED);
  1437. // Move time forward enough for anything to go wrong with the timers.
  1438. task_environment()->FastForwardBy(base::Seconds(kPartialGarageChargeTime));
  1439. // Replace stylus, let run to full charge.
  1440. // The level at the start should be unchanged, it's still the last known
  1441. // level and it won't update until charge is definitely complete.
  1442. EXPECT_CALL(
  1443. listener_observer_mock,
  1444. OnUpdatedBatteryLevel(
  1445. AllOf(AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1446. AFIELD(&BI::level, Eq(1)),
  1447. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kCharging)),
  1448. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaCharger)))))
  1449. .Times(AnyNumber());
  1450. // Then we should have one update at 100% charge.
  1451. EXPECT_CALL(listener_observer_mock,
  1452. OnUpdatedBatteryLevel(AllOf(
  1453. AFIELD(&BI::key, Eq(kStylusChargerDeviceName)),
  1454. AFIELD(&BI::level, Eq(100)),
  1455. AFIELD(&BI::charge_status, Eq(BI::ChargeStatus::kFull)))));
  1456. battery_listener_->OnStylusStateChanged(ui::StylusState::INSERTED);
  1457. // Move time forward more than enough to fully charge.
  1458. task_environment()->FastForwardBy(base::Seconds(kFullGarageChargeTime));
  1459. }
  1460. // NOTE: Cannot yet mock OzonePlatform::GetInstance()->GetInputController(),
  1461. // so cannot test scenarios involving stylus on charger from 'boot'.
  1462. #if 0
  1463. TEST_F(PeripheralBatteryListenerIncompleteDevicesTest,
  1464. StylusGaragedOnBoot) {
  1465. // Create touchscreen w/ stylus, w/ dockswitch
  1466. // Have stylus on charger from boot
  1467. // Ensure that it starts on full charge
  1468. }
  1469. #endif
  1470. TEST_F(PeripheralBatteryListenerTest, StylusBatteryEligibility) {
  1471. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1472. base::ScopedObservation<PeripheralBatteryListener,
  1473. PeripheralBatteryListener::Observer>
  1474. scoped_listener_obs{&listener_observer_mock};
  1475. scoped_listener_obs.Observe(battery_listener_.get());
  1476. const std::string kTestStylusBatteryPath =
  1477. "/sys/class/power_supply/hid-AAAA:BBBB:CCCC.DDDD-battery";
  1478. const std::string kTestStylusName = "test_stylus";
  1479. const auto kTestStylusBatteryStatusDischargingIn = power_manager::
  1480. PeripheralBatteryStatus_ChargeStatus_CHARGE_STATUS_DISCHARGING;
  1481. const auto kTestStylusBatteryStatusDischargingOut =
  1482. BI::ChargeStatus::kDischarging;
  1483. // Add an external stylus to our test device manager.
  1484. ui::TouchscreenDevice stylus(/*id=*/0, ui::INPUT_DEVICE_USB, kTestStylusName,
  1485. gfx::Size(),
  1486. /*touch_points=*/1, /*has_stylus=*/true);
  1487. stylus.sys_path = base::FilePath(kTestStylusBatteryPath);
  1488. ui::DeviceDataManagerTestApi().SetTouchscreenDevices({stylus});
  1489. testing::InSequence sequence;
  1490. EXPECT_CALL(listener_observer_mock,
  1491. OnAddingBattery(AFIELD(&BI::key, Eq(kTestStylusBatteryPath))));
  1492. for (const char* sn : kStylusEligibleSerialNumbers) {
  1493. EXPECT_CALL(listener_observer_mock,
  1494. OnUpdatedBatteryLevel(AllOf(
  1495. AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1496. AFIELD(&BI::battery_report_eligible, Eq(true)),
  1497. AFIELD(&BI::level, Eq(50)),
  1498. AFIELD(&BI::charge_status,
  1499. Eq(kTestStylusBatteryStatusDischargingOut)),
  1500. AFIELD(&BI::type, Eq(BI::PeripheralType::kStylusViaScreen)),
  1501. AFIELD(&BI::bluetooth_address, Eq("")))));
  1502. battery_listener_->PeripheralBatteryStatusReceived(
  1503. kTestStylusBatteryPath, kTestStylusName, 50,
  1504. kTestStylusBatteryStatusDischargingIn, sn, kBatteryPolledUpdate);
  1505. }
  1506. for (const char* sn : kStylusIneligibleSerialNumbers) {
  1507. EXPECT_CALL(listener_observer_mock,
  1508. OnUpdatedBatteryLevel(
  1509. AllOf(AFIELD(&BI::key, Eq(kTestStylusBatteryPath)),
  1510. AFIELD(&BI::level, Eq(5)),
  1511. AFIELD(&BI::battery_report_eligible, Eq(false)))));
  1512. battery_listener_->PeripheralBatteryStatusReceived(
  1513. kTestStylusBatteryPath, kTestStylusName, 5,
  1514. kTestStylusBatteryStatusDischargingIn, sn, kBatteryEventUpdate);
  1515. }
  1516. }
  1517. TEST_F(PeripheralBatteryListenerTest,
  1518. PostNofiticationWhenDeviceIsConnectedWithLowBattery) {
  1519. testing::StrictMock<MockPeripheralBatteryObserver> listener_observer_mock;
  1520. base::ScopedObservation<PeripheralBatteryListener,
  1521. PeripheralBatteryListener::Observer>
  1522. scoped_listener_obs{&listener_observer_mock};
  1523. scoped_listener_obs.Observe(battery_listener_.get());
  1524. Sequence a;
  1525. EXPECT_CALL(
  1526. listener_observer_mock,
  1527. OnUpdatedBatteryLevel(AllOf(
  1528. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)), AFIELD(&BI::level, Eq(5)),
  1529. AFIELD(&BI::battery_report_eligible, Eq(true)),
  1530. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))))
  1531. .InSequence(a);
  1532. EXPECT_CALL(listener_observer_mock,
  1533. OnAddingBattery(AFIELD(&BI::key, Eq(kBluetoothDeviceId1))));
  1534. mock_device_1_->SetBatteryInfo(
  1535. BatteryInfo(BatteryType::kDefault, /*percentage=*/5));
  1536. Sequence b;
  1537. EXPECT_CALL(
  1538. listener_observer_mock,
  1539. OnUpdatedBatteryLevel(AllOf(
  1540. AFIELD(&BI::key, Eq(kBluetoothDeviceId1)), AFIELD(&BI::level, Eq(5)),
  1541. AFIELD(&BI::battery_report_eligible, Eq(true)),
  1542. AFIELD(&BI::bluetooth_address, Eq(kBluetoothDeviceAddress1)))))
  1543. .InSequence(b);
  1544. battery_listener_->DeviceConnectedStateChanged(
  1545. mock_adapter_.get(), mock_device_1_.get(), /*is_now_connected=*/true);
  1546. }
  1547. // TODO: Test needed for eligibility behaviour of stylus chargers.
  1548. } // namespace ash