brillo/audio/audioservice/test/audio_device_handler_test.cpp

   1 // Copyright 2016 The Android Open Source Project
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14 //
  15
  16 // Tests for audio device handler.
  17
  18 #include "audio_device_handler_mock.h"
  19
  20 #include <string>
  21
  22 #include <base/files/file_path.h>
  23 #include <base/files/file_util.h>
  24 #include <base/files/scoped_temp_dir.h>
  25 #include <base/strings/string_number_conversions.h>
  26 #include <gmock/gmock.h>
  27 #include <gtest/gtest.h>
  28
  29 using base::FilePath;
  30 using base::IntToString;
  31 using base::ScopedTempDir;
  32 using base::WriteFile;
  33 using brillo::AudioDeviceHandlerMock;
  34 using testing::_;
  35 using testing::AnyNumber;
  36 using testing::AtLeast;
  37
  38 namespace brillo {
  39
  40 class AudioDeviceHandlerTest : public testing::Test {
  41  public:
  42   void SetUp() override {
  43     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
  44     h2w_file_path_ = temp_dir_.path().Append("h2wstate");
  45   }
  46
  47   void TearDown() override { handler_.Reset(); }
  48
  49   // Method to store the current state of the audio jack to a file.
  50   //
  51   // |value| - Value in the h2w file.
  52   void WriteToH2WFile(int value) {
  53     std::string value_string = IntToString(value);
  54     WriteFile(h2w_file_path_, value_string.c_str(), value_string.length());
  55   }
  56
  57   AudioDeviceHandlerMock handler_;
  58   FilePath h2w_file_path_;
  59
  60  private:
  61   ScopedTempDir temp_dir_;
  62 };
  63
  64 // Test that DisconnectAllSupportedDevices() calls NotifyAudioPolicyService()
  65 // the right number of times.
  66 TEST_F(AudioDeviceHandlerTest, DisconnectAllSupportedDevicesCallsDisconnect) {
  67   EXPECT_CALL(handler_,
  68               NotifyAudioPolicyService(
  69                   _, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)).Times(3);
  70   handler_.DisconnectAllSupportedDevices();
  71   EXPECT_EQ(handler_.changed_devices_.size(), 3);
  72 }
  73
  74 // Test that Init() calls DisconnectAllSupportedDevices().
  75 TEST_F(AudioDeviceHandlerTest, InitCallsDisconnectAllSupportedDevices) {
  76   EXPECT_CALL(handler_,
  77               NotifyAudioPolicyService(
  78                   _, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)).Times(3);
  79   EXPECT_CALL(handler_, TriggerCallback(
  80       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesDisconnected))
  81       .Times(AtLeast(1));
  82   EXPECT_CALL(handler_,
  83               NotifyAudioPolicyService(
  84                   _, AUDIO_POLICY_DEVICE_STATE_AVAILABLE)).Times(AnyNumber());
  85   EXPECT_CALL(handler_, TriggerCallback(
  86       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected))
  87       .Times(AnyNumber());
  88   handler_.Init(nullptr);
  89 }
  90
  91 // Test GetInitialAudioDeviceState() with just a microphone.
  92 TEST_F(AudioDeviceHandlerTest, InitialAudioStateMic) {
  93   WriteToH2WFile(2);
  94   EXPECT_CALL(handler_,
  95               NotifyAudioPolicyService(AUDIO_DEVICE_IN_WIRED_HEADSET,
  96                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
  97   EXPECT_CALL(handler_, TriggerCallback(
  98       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected));
  99   handler_.GetInitialAudioDeviceState(h2w_file_path_);
 100   EXPECT_NE(
 101       handler_.connected_input_devices_.find(AUDIO_DEVICE_IN_WIRED_HEADSET),
 102       handler_.connected_input_devices_.end());
 103   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 104   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 105   EXPECT_EQ(handler_.changed_devices_[0], AUDIO_DEVICE_IN_WIRED_HEADSET);
 106 }
 107
 108 // Test GetInitialAudioDeviceState() with a headphone.
 109 TEST_F(AudioDeviceHandlerTest, InitialAudioStateHeadphone) {
 110   WriteToH2WFile(1);
 111   EXPECT_CALL(handler_,
 112               NotifyAudioPolicyService(AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
 113                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 114   EXPECT_CALL(handler_, TriggerCallback(
 115       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected));
 116   handler_.GetInitialAudioDeviceState(h2w_file_path_);
 117   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 118   EXPECT_NE(
 119       handler_.connected_output_devices_.find(AUDIO_DEVICE_OUT_WIRED_HEADPHONE),
 120       handler_.connected_output_devices_.end());
 121   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 122   EXPECT_EQ(handler_.changed_devices_[0], AUDIO_DEVICE_OUT_WIRED_HEADPHONE);
 123 }
 124
 125 // Test GetInitialAudioDeviceState() with a headset.
 126 TEST_F(AudioDeviceHandlerTest, InitialAudioStateHeadset) {
 127   WriteToH2WFile(3);
 128   EXPECT_CALL(handler_, TriggerCallback(
 129       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected));
 130   EXPECT_CALL(handler_,
 131               NotifyAudioPolicyService(AUDIO_DEVICE_IN_WIRED_HEADSET,
 132                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 133   EXPECT_CALL(handler_,
 134               NotifyAudioPolicyService(AUDIO_DEVICE_OUT_WIRED_HEADSET,
 135                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 136   handler_.GetInitialAudioDeviceState(h2w_file_path_);
 137   EXPECT_NE(
 138       handler_.connected_input_devices_.find(AUDIO_DEVICE_IN_WIRED_HEADSET),
 139       handler_.connected_input_devices_.end());
 140   EXPECT_NE(
 141       handler_.connected_output_devices_.find(AUDIO_DEVICE_OUT_WIRED_HEADSET),
 142       handler_.connected_output_devices_.end());
 143   EXPECT_EQ(handler_.changed_devices_.size(), 2);
 144 }
 145
 146 // Test GetInitialAudioDeviceState() without any devices connected to the audio
 147 // jack. No need to call NotifyAudioPolicyService() since that's already handled
 148 // by Init().
 149 TEST_F(AudioDeviceHandlerTest, InitialAudioStateNone) {
 150   WriteToH2WFile(0);
 151   EXPECT_CALL(handler_, TriggerCallback(_));
 152   handler_.GetInitialAudioDeviceState(h2w_file_path_);
 153   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 154   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 155   EXPECT_EQ(handler_.changed_devices_.size(), 0);
 156 }
 157
 158 // Test GetInitialAudioDeviceState() with an invalid file. The audio handler
 159 // should not fail in this case because it should work on boards that don't
 160 // support audio jacks.
 161 TEST_F(AudioDeviceHandlerTest, InitialAudioStateInvalid) {
 162   FilePath path = h2w_file_path_;
 163   handler_.GetInitialAudioDeviceState(h2w_file_path_);
 164   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 165   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 166 }
 167
 168 // Test ProcessEvent() with an empty input_event arg.
 169 TEST_F(AudioDeviceHandlerTest, ProcessEventEmpty) {
 170   struct input_event event;
 171   event.type = 0;
 172   event.code = 0;
 173   event.value = 0;
 174   EXPECT_CALL(handler_, TriggerCallback(_));
 175   handler_.ProcessEvent(event);
 176   EXPECT_FALSE(handler_.headphone_);
 177   EXPECT_FALSE(handler_.microphone_);
 178 }
 179
 180 // Test ProcessEvent() with a microphone present input_event arg.
 181 TEST_F(AudioDeviceHandlerTest, ProcessEventMicrophonePresent) {
 182   struct input_event event;
 183   event.type = EV_SW;
 184   event.code = SW_MICROPHONE_INSERT;
 185   event.value = 1;
 186   handler_.ProcessEvent(event);
 187   EXPECT_FALSE(handler_.headphone_);
 188   EXPECT_TRUE(handler_.microphone_);
 189 }
 190
 191 // Test ProcessEvent() with a headphone present input_event arg.
 192 TEST_F(AudioDeviceHandlerTest, ProcessEventHeadphonePresent) {
 193   struct input_event event;
 194   event.type = EV_SW;
 195   event.code = SW_HEADPHONE_INSERT;
 196   event.value = 1;
 197   handler_.ProcessEvent(event);
 198   EXPECT_TRUE(handler_.headphone_);
 199   EXPECT_FALSE(handler_.microphone_);
 200 }
 201
 202 // Test ProcessEvent() with a microphone not present input_event arg.
 203 TEST_F(AudioDeviceHandlerTest, ProcessEventMicrophoneNotPresent) {
 204   struct input_event event;
 205   event.type = EV_SW;
 206   event.code = SW_MICROPHONE_INSERT;
 207   event.value = 0;
 208   handler_.ProcessEvent(event);
 209   EXPECT_FALSE(handler_.headphone_);
 210   EXPECT_FALSE(handler_.microphone_);
 211 }
 212
 213 // Test ProcessEvent() with a headphone not preset input_event arg.
 214 TEST_F(AudioDeviceHandlerTest, ProcessEventHeadphoneNotPresent) {
 215   struct input_event event;
 216   event.type = EV_SW;
 217   event.code = SW_HEADPHONE_INSERT;
 218   event.value = 0;
 219   handler_.ProcessEvent(event);
 220   EXPECT_FALSE(handler_.headphone_);
 221   EXPECT_FALSE(handler_.microphone_);
 222 }
 223
 224 // Test ProcessEvent() with an unsupported input_event arg.
 225 TEST_F(AudioDeviceHandlerTest, ProcessEventInvalid) {
 226   struct input_event event;
 227   event.type = EV_SW;
 228   event.code = SW_MAX;
 229   event.value = 0;
 230   handler_.ProcessEvent(event);
 231   EXPECT_FALSE(handler_.headphone_);
 232   EXPECT_FALSE(handler_.microphone_);
 233 }
 234
 235 // Test UpdateAudioSystem() without any devices connected.
 236 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemNone) {
 237   EXPECT_CALL(handler_,
 238               NotifyAudioPolicyService(
 239                   _, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE)).Times(0);
 240   EXPECT_CALL(handler_, TriggerCallback(
 241       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesDisconnected));
 242   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 243   EXPECT_EQ(handler_.changed_devices_.size(), 0);
 244 }
 245
 246 // Test UpdateAudioSystem() when disconnecting a microphone.
 247 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemDisconnectMic) {
 248   audio_devices_t device = AUDIO_DEVICE_IN_WIRED_HEADSET;
 249   handler_.connected_input_devices_.insert(device);
 250   EXPECT_CALL(handler_,
 251               NotifyAudioPolicyService(device,
 252                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 253   EXPECT_CALL(handler_, TriggerCallback(
 254       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesDisconnected));
 255   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 256   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 257   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 258   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 259   EXPECT_EQ(handler_.changed_devices_[0], device);
 260 }
 261
 262 // Test UpdateAudioSystem() when disconnecting a headphone.
 263 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemDisconnectHeadphone) {
 264   audio_devices_t device = AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
 265   handler_.connected_output_devices_.insert(device);
 266   EXPECT_CALL(handler_,
 267               NotifyAudioPolicyService(device,
 268                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 269   EXPECT_CALL(handler_, TriggerCallback(
 270       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesDisconnected));
 271   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 272   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 273   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 274   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 275   EXPECT_EQ(handler_.changed_devices_[0], device);
 276 }
 277
 278 // Test UpdateAudioSystem() when disconnecting a headset & headphones.
 279 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemDisconnectHeadset) {
 280   handler_.connected_input_devices_.insert(AUDIO_DEVICE_IN_WIRED_HEADSET);
 281   handler_.connected_output_devices_.insert(AUDIO_DEVICE_OUT_WIRED_HEADSET);
 282   handler_.connected_output_devices_.insert(AUDIO_DEVICE_OUT_WIRED_HEADPHONE);
 283   EXPECT_CALL(handler_,
 284               NotifyAudioPolicyService(AUDIO_DEVICE_IN_WIRED_HEADSET,
 285                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 286   EXPECT_CALL(handler_,
 287               NotifyAudioPolicyService(AUDIO_DEVICE_OUT_WIRED_HEADSET,
 288                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 289   EXPECT_CALL(handler_,
 290               NotifyAudioPolicyService(AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
 291                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 292   EXPECT_CALL(handler_, TriggerCallback(
 293       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesDisconnected));
 294   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 295   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 296   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 297   EXPECT_EQ(handler_.changed_devices_.size(), 3);
 298 }
 299
 300 // Test UpdateAudioSystem() when connecting a microphone.
 301 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemConnectMic) {
 302   handler_.microphone_ = true;
 303   EXPECT_CALL(handler_,
 304               NotifyAudioPolicyService(AUDIO_DEVICE_IN_WIRED_HEADSET,
 305                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 306   EXPECT_CALL(handler_, TriggerCallback(
 307       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected));
 308   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 309   EXPECT_EQ(handler_.connected_input_devices_.size(), 1);
 310   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 311   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 312   EXPECT_EQ(handler_.changed_devices_[0], AUDIO_DEVICE_IN_WIRED_HEADSET);
 313 }
 314
 315 // Test UpdateAudioSystem() when connecting a headphone.
 316 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemConnectHeadphone) {
 317   handler_.headphone_ = true;
 318   EXPECT_CALL(handler_,
 319               NotifyAudioPolicyService(AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
 320                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 321   EXPECT_CALL(handler_, TriggerCallback(
 322       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected));
 323   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 324   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 325   EXPECT_EQ(handler_.connected_output_devices_.size(), 1);
 326   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 327   EXPECT_EQ(handler_.changed_devices_[0], AUDIO_DEVICE_OUT_WIRED_HEADPHONE);
 328 }
 329
 330 // Test UpdateAudioSystem() when connecting a headset.
 331 TEST_F(AudioDeviceHandlerTest, UpdateAudioSystemConnectHeadset) {
 332   handler_.headphone_ = true;
 333   handler_.microphone_ = true;
 334   EXPECT_CALL(handler_,
 335               NotifyAudioPolicyService(AUDIO_DEVICE_IN_WIRED_HEADSET,
 336                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 337   EXPECT_CALL(handler_,
 338               NotifyAudioPolicyService(AUDIO_DEVICE_OUT_WIRED_HEADSET,
 339                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 340   EXPECT_CALL(handler_, TriggerCallback(
 341       AudioDeviceHandlerMock::DeviceConnectionState::kDevicesConnected));
 342   handler_.UpdateAudioSystem(handler_.headphone_, handler_.microphone_);
 343   EXPECT_EQ(handler_.connected_input_devices_.size(), 1);
 344   EXPECT_EQ(handler_.connected_output_devices_.size(), 1);
 345   EXPECT_EQ(handler_.changed_devices_.size(), 2);
 346 }
 347
 348 // Test ConnectAudioDevice() with an input device.
 349 TEST_F(AudioDeviceHandlerTest, ConnectAudioDeviceInput) {
 350   audio_devices_t device = AUDIO_DEVICE_IN_WIRED_HEADSET;
 351   EXPECT_CALL(handler_,
 352               NotifyAudioPolicyService(device,
 353                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 354   handler_.ConnectAudioDevice(device);
 355   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 356   EXPECT_NE(
 357       handler_.connected_input_devices_.find(device),
 358       handler_.connected_input_devices_.end());
 359   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 360   EXPECT_EQ(handler_.changed_devices_[0], device);
 361 }
 362
 363 // Test ConnectAudioDevice() with an output device.
 364 TEST_F(AudioDeviceHandlerTest, ConnectAudioDeviceOutput) {
 365   audio_devices_t device = AUDIO_DEVICE_OUT_WIRED_HEADSET;
 366   EXPECT_CALL(handler_,
 367               NotifyAudioPolicyService(device,
 368                                        AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
 369   handler_.ConnectAudioDevice(device);
 370   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 371   EXPECT_NE(
 372       handler_.connected_output_devices_.find(device),
 373       handler_.connected_output_devices_.end());
 374   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 375   EXPECT_EQ(handler_.changed_devices_[0], device);
 376 }
 377
 378 // Test DisconnectAudioDevice() with an input device.
 379 TEST_F(AudioDeviceHandlerTest, DisconnectAudioDeviceInput) {
 380   audio_devices_t device = AUDIO_DEVICE_IN_WIRED_HEADSET;
 381   handler_.connected_input_devices_.insert(device);
 382   handler_.connected_output_devices_.insert(device);
 383   EXPECT_CALL(handler_,
 384               NotifyAudioPolicyService(device,
 385                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 386   handler_.DisconnectAudioDevice(device);
 387   EXPECT_EQ(handler_.connected_input_devices_.size(), 0);
 388   EXPECT_EQ(handler_.connected_output_devices_.size(), 1);
 389   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 390   EXPECT_EQ(handler_.changed_devices_[0], device);
 391 }
 392
 393 // Test DisconnectAudioDevice() with an output device.
 394 TEST_F(AudioDeviceHandlerTest, DisconnectAudioDeviceOutput) {
 395   audio_devices_t device = AUDIO_DEVICE_OUT_WIRED_HEADSET;
 396   handler_.connected_input_devices_.insert(device);
 397   handler_.connected_output_devices_.insert(device);
 398   EXPECT_CALL(handler_,
 399               NotifyAudioPolicyService(device,
 400                                        AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
 401   handler_.DisconnectAudioDevice(device);
 402   EXPECT_EQ(handler_.connected_input_devices_.size(), 1);
 403   EXPECT_EQ(handler_.connected_output_devices_.size(), 0);
 404   EXPECT_EQ(handler_.changed_devices_.size(), 1);
 405   EXPECT_EQ(handler_.changed_devices_[0], device);
 406 }
 407
 408 }  // namespace brillo