Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(58)

Side by Side Diff: chromeos/audio/cras_audio_handler.cc

Issue 2831443002: Simplify CrasAudioHandler code. (Closed)
Patch Set: Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "chromeos/audio/cras_audio_handler.h" 5 #include "chromeos/audio/cras_audio_handler.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 #include <stdint.h> 8 #include <stdint.h>
9 9
10 #include <algorithm> 10 #include <algorithm>
(...skipping 23 matching lines...) Expand all
34 const int kMuteThresholdPercent = 1; 34 const int kMuteThresholdPercent = 1;
35 35
36 // The duration of HDMI output re-discover grace period in milliseconds. 36 // The duration of HDMI output re-discover grace period in milliseconds.
37 const int kHDMIRediscoverGracePeriodDurationInMs = 2000; 37 const int kHDMIRediscoverGracePeriodDurationInMs = 2000;
38 38
39 // Mixer matrix, [0.5, 0.5; 0.5, 0.5] 39 // Mixer matrix, [0.5, 0.5; 0.5, 0.5]
40 const double kStereoToMono[] = {0.5, 0.5, 0.5, 0.5}; 40 const double kStereoToMono[] = {0.5, 0.5, 0.5, 0.5};
41 // Mixer matrix, [1, 0; 0, 1] 41 // Mixer matrix, [1, 0; 0, 1]
42 const double kStereoToStereo[] = {1, 0, 0, 1}; 42 const double kStereoToStereo[] = {1, 0, 0, 1};
43 43
44 static CrasAudioHandler* g_cras_audio_handler = nullptr; 44 CrasAudioHandler* g_cras_audio_handler = nullptr;
45 45
46 bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) { 46 bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) {
47 return a.stable_device_id == b.stable_device_id && a.is_input == b.is_input && 47 return a.stable_device_id == b.stable_device_id && a.is_input == b.is_input &&
48 a.type == b.type && a.device_name == b.device_name; 48 a.type == b.type && a.device_name == b.device_name;
49 } 49 }
50 50
51 bool IsDeviceInList(const AudioDevice& device, const AudioNodeList& node_list) { 51 bool IsDeviceInList(const AudioDevice& device, const AudioNodeList& node_list) {
52 for (const AudioNode& node : node_list) { 52 for (const AudioNode& node : node_list) {
53 if (device.stable_device_id == node.StableDeviceId()) 53 if (device.stable_device_id == node.StableDeviceId())
54 return true; 54 return true;
55 } 55 }
56 return false; 56 return false;
57 } 57 }
58 58
59 CrasAudioClient* GetCrasAudioClient() {
60 return DBusThreadManager::Get()->GetCrasAudioClient();
61 }
62
63 bool HasCrasAudioClient() {
64 return DBusThreadManager::IsInitialized() && DBusThreadManager::Get() &&
65 DBusThreadManager::Get()->GetCrasAudioClient();
66 }
67
59 } // namespace 68 } // namespace
60 69
61 CrasAudioHandler::AudioObserver::AudioObserver() { 70 CrasAudioHandler::AudioObserver::AudioObserver() {
62 } 71 }
63 72
64 CrasAudioHandler::AudioObserver::~AudioObserver() { 73 CrasAudioHandler::AudioObserver::~AudioObserver() {
65 } 74 }
66 75
67 void CrasAudioHandler::AudioObserver::OnOutputNodeVolumeChanged( 76 void CrasAudioHandler::AudioObserver::OnOutputNodeVolumeChanged(
68 uint64_t /* node_id */, 77 uint64_t /* node_id */,
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after
249 258
250 int CrasAudioHandler::GetOutputDefaultVolumeMuteThreshold() { 259 int CrasAudioHandler::GetOutputDefaultVolumeMuteThreshold() {
251 return kMuteThresholdPercent; 260 return kMuteThresholdPercent;
252 } 261 }
253 262
254 int CrasAudioHandler::GetOutputVolumePercent() { 263 int CrasAudioHandler::GetOutputVolumePercent() {
255 return output_volume_; 264 return output_volume_;
256 } 265 }
257 266
258 int CrasAudioHandler::GetOutputVolumePercentForDevice(uint64_t device_id) { 267 int CrasAudioHandler::GetOutputVolumePercentForDevice(uint64_t device_id) {
259 if (device_id == active_output_node_id_) { 268 if (device_id == active_output_node_id_)
260 return output_volume_; 269 return output_volume_;
261 } else { 270 const AudioDevice* device = GetDeviceFromId(device_id);
262 const AudioDevice* device = GetDeviceFromId(device_id); 271 return static_cast<int>(audio_pref_handler_->GetOutputVolumeValue(device));
263 return static_cast<int>(audio_pref_handler_->GetOutputVolumeValue(device));
264 }
265 } 272 }
266 273
267 int CrasAudioHandler::GetInputGainPercent() { 274 int CrasAudioHandler::GetInputGainPercent() {
268 return input_gain_; 275 return input_gain_;
269 } 276 }
270 277
271 int CrasAudioHandler::GetInputGainPercentForDevice(uint64_t device_id) { 278 int CrasAudioHandler::GetInputGainPercentForDevice(uint64_t device_id) {
272 if (device_id == active_input_node_id_) { 279 if (device_id == active_input_node_id_)
273 return input_gain_; 280 return input_gain_;
274 } else { 281 const AudioDevice* device = GetDeviceFromId(device_id);
275 const AudioDevice* device = GetDeviceFromId(device_id); 282 return static_cast<int>(audio_pref_handler_->GetInputGainValue(device));
276 return static_cast<int>(audio_pref_handler_->GetInputGainValue(device));
277 }
278 } 283 }
279 284
280 uint64_t CrasAudioHandler::GetPrimaryActiveOutputNode() const { 285 uint64_t CrasAudioHandler::GetPrimaryActiveOutputNode() const {
281 return active_output_node_id_; 286 return active_output_node_id_;
282 } 287 }
283 288
284 uint64_t CrasAudioHandler::GetPrimaryActiveInputNode() const { 289 uint64_t CrasAudioHandler::GetPrimaryActiveInputNode() const {
285 return active_input_node_id_; 290 return active_input_node_id_;
286 } 291 }
287 292
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
326 if ((device->is_input && !active_input_node_id_) || 331 if ((device->is_input && !active_input_node_id_) ||
327 (!device->is_input && !active_output_node_id_)) { 332 (!device->is_input && !active_output_node_id_)) {
328 SwitchToDevice(*device, notify, ACTIVATE_BY_USER); 333 SwitchToDevice(*device, notify, ACTIVATE_BY_USER);
329 return; 334 return;
330 } 335 }
331 336
332 AddAdditionalActiveNode(node_id, notify); 337 AddAdditionalActiveNode(node_id, notify);
333 } 338 }
334 339
335 void CrasAudioHandler::ChangeActiveNodes(const NodeIdList& new_active_ids) { 340 void CrasAudioHandler::ChangeActiveNodes(const NodeIdList& new_active_ids) {
336 chromeos::AudioDeviceList input_devices; 341 AudioDeviceList input_devices;
337 chromeos::AudioDeviceList output_devices; 342 AudioDeviceList output_devices;
338 343
339 for (uint64_t id : new_active_ids) { 344 for (uint64_t id : new_active_ids) {
340 const chromeos::AudioDevice* device = GetDeviceFromId(id); 345 const AudioDevice* device = GetDeviceFromId(id);
341 if (!device) 346 if (!device)
342 continue; 347 continue;
343 if (device->is_input) 348 if (device->is_input)
344 input_devices.push_back(*device); 349 input_devices.push_back(*device);
345 else 350 else
346 output_devices.push_back(*device); 351 output_devices.push_back(*device);
347 } 352 }
348 if (!input_devices.empty()) 353 if (!input_devices.empty())
349 SetActiveDevices(input_devices, true /* is_input */); 354 SetActiveDevices(input_devices, true /* is_input */);
350 if (!output_devices.empty()) 355 if (!output_devices.empty())
351 SetActiveDevices(output_devices, false /* is_input */); 356 SetActiveDevices(output_devices, false /* is_input */);
352 } 357 }
353 358
354 bool CrasAudioHandler::SetActiveInputNodes(const NodeIdList& node_ids) { 359 bool CrasAudioHandler::SetActiveInputNodes(const NodeIdList& node_ids) {
355 return SetActiveNodes(node_ids, true /* is_input */); 360 return SetActiveNodes(node_ids, true /* is_input */);
356 } 361 }
357 362
358 bool CrasAudioHandler::SetActiveOutputNodes(const NodeIdList& node_ids) { 363 bool CrasAudioHandler::SetActiveOutputNodes(const NodeIdList& node_ids) {
359 return SetActiveNodes(node_ids, false /* is_input */); 364 return SetActiveNodes(node_ids, false /* is_input */);
360 } 365 }
361 366
362 bool CrasAudioHandler::SetActiveNodes(const NodeIdList& node_ids, 367 bool CrasAudioHandler::SetActiveNodes(const NodeIdList& node_ids,
363 bool is_input) { 368 bool is_input) {
364 chromeos::AudioDeviceList devices; 369 AudioDeviceList devices;
365 for (uint64_t id : node_ids) { 370 for (uint64_t id : node_ids) {
366 const chromeos::AudioDevice* device = GetDeviceFromId(id); 371 const AudioDevice* device = GetDeviceFromId(id);
367 if (!device || device->is_input != is_input) 372 if (!device || device->is_input != is_input)
368 return false; 373 return false;
369 374
370 devices.push_back(*device); 375 devices.push_back(*device);
371 } 376 }
372 377
373 SetActiveDevices(devices, is_input); 378 SetActiveDevices(devices, is_input);
374 return true; 379 return true;
375 } 380 }
376 381
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
413 } 418 }
414 419
415 if (active_devices_changed) 420 if (active_devices_changed)
416 NotifyActiveNodeChanged(is_input); 421 NotifyActiveNodeChanged(is_input);
417 } 422 }
418 423
419 void CrasAudioHandler::SwapInternalSpeakerLeftRightChannel(bool swap) { 424 void CrasAudioHandler::SwapInternalSpeakerLeftRightChannel(bool swap) {
420 for (const auto& item : audio_devices_) { 425 for (const auto& item : audio_devices_) {
421 const AudioDevice& device = item.second; 426 const AudioDevice& device = item.second;
422 if (!device.is_input && device.type == AUDIO_TYPE_INTERNAL_SPEAKER) { 427 if (!device.is_input && device.type == AUDIO_TYPE_INTERNAL_SPEAKER) {
423 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->SwapLeftRight( 428 GetCrasAudioClient()->SwapLeftRight(device.id, swap);
424 device.id, swap);
425 break; 429 break;
426 } 430 }
427 } 431 }
428 } 432 }
429 433
430 void CrasAudioHandler::SetOutputMono(bool mono_on) { 434 void CrasAudioHandler::SetOutputMono(bool mono_on) {
431 output_mono_on_ = mono_on; 435 output_mono_on_ = mono_on;
432 if (mono_on) { 436 if (mono_on) {
433 chromeos::DBusThreadManager::Get() 437 GetCrasAudioClient()->SetGlobalOutputChannelRemix(
434 ->GetCrasAudioClient() 438 output_channels_,
435 ->SetGlobalOutputChannelRemix( 439 std::vector<double>(kStereoToMono, std::end(kStereoToMono)));
436 output_channels_,
437 std::vector<double>(kStereoToMono, std::end(kStereoToMono)));
438 } else { 440 } else {
439 chromeos::DBusThreadManager::Get() 441 GetCrasAudioClient()->SetGlobalOutputChannelRemix(
440 ->GetCrasAudioClient() 442 output_channels_,
441 ->SetGlobalOutputChannelRemix( 443 std::vector<double>(kStereoToStereo, std::end(kStereoToStereo)));
442 output_channels_,
443 std::vector<double>(kStereoToStereo, std::end(kStereoToStereo)));
444 } 444 }
445 445
446 for (auto& observer : observers_) 446 for (auto& observer : observers_)
447 observer.OnOuputChannelRemixingChanged(mono_on); 447 observer.OnOuputChannelRemixingChanged(mono_on);
448 } 448 }
449 449
450 bool CrasAudioHandler::IsOutputMonoEnabled() const { 450 bool CrasAudioHandler::IsOutputMonoEnabled() const {
451 return output_mono_on_; 451 return output_mono_on_;
452 } 452 }
453 453
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
515 515
516 void CrasAudioHandler::SetInputMute(bool mute_on) { 516 void CrasAudioHandler::SetInputMute(bool mute_on) {
517 SetInputMuteInternal(mute_on); 517 SetInputMuteInternal(mute_on);
518 for (auto& observer : observers_) 518 for (auto& observer : observers_)
519 observer.OnInputMuteChanged(input_mute_on_); 519 observer.OnInputMuteChanged(input_mute_on_);
520 } 520 }
521 521
522 void CrasAudioHandler::SetActiveDevice(const AudioDevice& active_device, 522 void CrasAudioHandler::SetActiveDevice(const AudioDevice& active_device,
523 bool notify, 523 bool notify,
524 DeviceActivateType activate_by) { 524 DeviceActivateType activate_by) {
525 if (active_device.is_input) { 525 if (active_device.is_input)
526 chromeos::DBusThreadManager::Get() 526 GetCrasAudioClient()->SetActiveInputNode(active_device.id);
527 ->GetCrasAudioClient() 527 else
528 ->SetActiveInputNode(active_device.id); 528 GetCrasAudioClient()->SetActiveOutputNode(active_device.id);
529 } else {
530 chromeos::DBusThreadManager::Get()
531 ->GetCrasAudioClient()
532 ->SetActiveOutputNode(active_device.id);
533 }
534 529
535 if (notify) 530 if (notify)
536 NotifyActiveNodeChanged(active_device.is_input); 531 NotifyActiveNodeChanged(active_device.is_input);
537 532
538 // Save active state for the nodes. 533 // Save active state for the nodes.
539 for (const auto& item : audio_devices_) { 534 for (const auto& item : audio_devices_) {
540 const AudioDevice& device = item.second; 535 const AudioDevice& device = item.second;
541 if (device.is_input != active_device.is_input) 536 if (device.is_input != active_device.is_input)
542 continue; 537 continue;
543 SaveDeviceState(device, device.active, activate_by); 538 SaveDeviceState(device, device.active, activate_by);
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
579 if (device->is_input) 574 if (device->is_input)
580 SetInputNodeGainPercent(device_id, value); 575 SetInputNodeGainPercent(device_id, value);
581 else 576 else
582 SetOutputNodeVolumePercent(device_id, value); 577 SetOutputNodeVolumePercent(device_id, value);
583 } 578 }
584 579
585 void CrasAudioHandler::SetMuteForDevice(uint64_t device_id, bool mute_on) { 580 void CrasAudioHandler::SetMuteForDevice(uint64_t device_id, bool mute_on) {
586 if (device_id == active_output_node_id_) { 581 if (device_id == active_output_node_id_) {
587 SetOutputMute(mute_on); 582 SetOutputMute(mute_on);
588 return; 583 return;
589 } else if (device_id == active_input_node_id_) { 584 }
585 if (device_id == active_input_node_id_) {
590 VLOG(1) << "SetMuteForDevice sets active input device id=" 586 VLOG(1) << "SetMuteForDevice sets active input device id="
591 << "0x" << std::hex << device_id << " mute=" << mute_on; 587 << "0x" << std::hex << device_id << " mute=" << mute_on;
592 SetInputMute(mute_on); 588 SetInputMute(mute_on);
593 return; 589 return;
594 } 590 }
595 591
596 const AudioDevice* device = GetDeviceFromId(device_id); 592 const AudioDevice* device = GetDeviceFromId(device_id);
597 // Input device's mute state is not recorded in the pref. crbug.com/365050. 593 // Input device's mute state is not recorded in the pref. crbug.com/365050.
598 if (device && !device->is_input) 594 if (device && !device->is_input)
599 audio_pref_handler_->SetMuteValue(*device, mute_on); 595 audio_pref_handler_->SetMuteValue(*device, mute_on);
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
639 output_mono_on_(false), 635 output_mono_on_(false),
640 log_errors_(false), 636 log_errors_(false),
641 hdmi_rediscover_grace_period_duration_in_ms_( 637 hdmi_rediscover_grace_period_duration_in_ms_(
642 kHDMIRediscoverGracePeriodDurationInMs), 638 kHDMIRediscoverGracePeriodDurationInMs),
643 hdmi_rediscovering_(false), 639 hdmi_rediscovering_(false),
644 weak_ptr_factory_(this) { 640 weak_ptr_factory_(this) {
645 if (!audio_pref_handler.get()) 641 if (!audio_pref_handler.get())
646 return; 642 return;
647 // If the DBusThreadManager or the CrasAudioClient aren't available, there 643 // If the DBusThreadManager or the CrasAudioClient aren't available, there
648 // isn't much we can do. This should only happen when running tests. 644 // isn't much we can do. This should only happen when running tests.
649 if (!chromeos::DBusThreadManager::IsInitialized() || 645 if (!HasCrasAudioClient())
650 !chromeos::DBusThreadManager::Get() ||
651 !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
652 return; 646 return;
653 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->AddObserver(this); 647 GetCrasAudioClient()->AddObserver(this);
654 audio_pref_handler_->AddAudioPrefObserver(this); 648 audio_pref_handler_->AddAudioPrefObserver(this);
655 if (chromeos::DBusThreadManager::Get()->GetSessionManagerClient()) { 649 if (DBusThreadManager::Get()->GetSessionManagerClient())
656 chromeos::DBusThreadManager::Get()->GetSessionManagerClient()-> 650 DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(this);
657 AddObserver(this);
658 }
659 InitializeAudioState(); 651 InitializeAudioState();
660 } 652 }
661 653
662 CrasAudioHandler::~CrasAudioHandler() { 654 CrasAudioHandler::~CrasAudioHandler() {
663 hdmi_rediscover_timer_.Stop(); 655 hdmi_rediscover_timer_.Stop();
664 if (!chromeos::DBusThreadManager::IsInitialized() || 656 if (!HasCrasAudioClient())
665 !chromeos::DBusThreadManager::Get() ||
666 !chromeos::DBusThreadManager::Get()->GetCrasAudioClient())
667 return; 657 return;
668 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()-> 658 GetCrasAudioClient()->RemoveObserver(this);
669 RemoveObserver(this); 659 if (DBusThreadManager::Get()->GetSessionManagerClient())
670 chromeos::DBusThreadManager::Get()->GetSessionManagerClient()-> 660 DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
671 RemoveObserver(this);
672 if (audio_pref_handler_.get()) 661 if (audio_pref_handler_.get())
673 audio_pref_handler_->RemoveAudioPrefObserver(this); 662 audio_pref_handler_->RemoveAudioPrefObserver(this);
674 audio_pref_handler_ = nullptr; 663 audio_pref_handler_ = nullptr;
675 } 664 }
676 665
677 void CrasAudioHandler::AudioClientRestarted() { 666 void CrasAudioHandler::AudioClientRestarted() {
678 // Make sure the logging is enabled in case cras server 667 // Make sure the logging is enabled in case cras server
679 // restarts after crashing. 668 // restarts after crashing.
680 LogErrors(); 669 LogErrors();
681 InitializeAudioState(); 670 InitializeAudioState();
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
773 void CrasAudioHandler::EmitLoginPromptVisibleCalled() { 762 void CrasAudioHandler::EmitLoginPromptVisibleCalled() {
774 // Enable logging after cras server is started, which will be after 763 // Enable logging after cras server is started, which will be after
775 // EmitLoginPromptVisible. 764 // EmitLoginPromptVisible.
776 LogErrors(); 765 LogErrors();
777 } 766 }
778 767
779 const AudioDevice* CrasAudioHandler::GetDeviceFromId(uint64_t device_id) const { 768 const AudioDevice* CrasAudioHandler::GetDeviceFromId(uint64_t device_id) const {
780 AudioDeviceMap::const_iterator it = audio_devices_.find(device_id); 769 AudioDeviceMap::const_iterator it = audio_devices_.find(device_id);
781 if (it == audio_devices_.end()) 770 if (it == audio_devices_.end())
782 return nullptr; 771 return nullptr;
783 772 return &it->second;
784 return &(it->second);
785 } 773 }
786 774
787 const AudioDevice* CrasAudioHandler::GetDeviceFromStableDeviceId( 775 const AudioDevice* CrasAudioHandler::GetDeviceFromStableDeviceId(
788 uint64_t stable_device_id) const { 776 uint64_t stable_device_id) const {
789 for (const auto& item : audio_devices_) { 777 for (const auto& item : audio_devices_) {
790 const AudioDevice& device = item.second; 778 const AudioDevice& device = item.second;
791 if (device.stable_device_id == stable_device_id) 779 if (device.stable_device_id == stable_device_id)
792 return &device; 780 return &device;
793 } 781 }
794 return nullptr; 782 return nullptr;
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after
876 SetOutputNodeVolumePercent(node_id, GetOutputVolumePercent()); 864 SetOutputNodeVolumePercent(node_id, GetOutputVolumePercent());
877 } 865 }
878 } 866 }
879 867
880 void CrasAudioHandler::InitializeAudioState() { 868 void CrasAudioHandler::InitializeAudioState() {
881 initializing_audio_state_ = true; 869 initializing_audio_state_ = true;
882 ApplyAudioPolicy(); 870 ApplyAudioPolicy();
883 871
884 // Defer querying cras for GetNodes until cras service becomes available. 872 // Defer querying cras for GetNodes until cras service becomes available.
885 cras_service_available_ = false; 873 cras_service_available_ = false;
886 chromeos::DBusThreadManager::Get() 874 GetCrasAudioClient()->WaitForServiceToBeAvailable(
887 ->GetCrasAudioClient() 875 base::Bind(&CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable,
888 ->WaitForServiceToBeAvailable(base::Bind( 876 weak_ptr_factory_.GetWeakPtr()));
889 &CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable,
890 weak_ptr_factory_.GetWeakPtr()));
891 } 877 }
892 878
893 void CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable( 879 void CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable(
894 bool service_is_available) { 880 bool service_is_available) {
895 if (!service_is_available) { 881 if (!service_is_available) {
896 LOG(ERROR) << "Cras service is not available"; 882 LOG(ERROR) << "Cras service is not available";
897 cras_service_available_ = false; 883 cras_service_available_ = false;
898 return; 884 return;
899 } 885 }
900 886
(...skipping 12 matching lines...) Expand all
913 const AudioDevice* device = GetDeviceFromId(active_output_node_id_); 899 const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
914 if (device) 900 if (device)
915 SetOutputMuteInternal(audio_pref_handler_->GetMuteValue(*device)); 901 SetOutputMuteInternal(audio_pref_handler_->GetMuteValue(*device));
916 } 902 }
917 903
918 // Policy for audio input is handled by kAudioCaptureAllowed in the Chrome 904 // Policy for audio input is handled by kAudioCaptureAllowed in the Chrome
919 // media system. 905 // media system.
920 } 906 }
921 907
922 void CrasAudioHandler::SetOutputNodeVolume(uint64_t node_id, int volume) { 908 void CrasAudioHandler::SetOutputNodeVolume(uint64_t node_id, int volume) {
923 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()-> 909 GetCrasAudioClient()->SetOutputNodeVolume(node_id, volume);
924 SetOutputNodeVolume(node_id, volume);
925 } 910 }
926 911
927 void CrasAudioHandler::SetOutputNodeVolumePercent(uint64_t node_id, 912 void CrasAudioHandler::SetOutputNodeVolumePercent(uint64_t node_id,
928 int volume_percent) { 913 int volume_percent) {
929 const AudioDevice* device = GetDeviceFromId(node_id); 914 const AudioDevice* device = GetDeviceFromId(node_id);
930 if (!device || device->is_input) 915 if (!device || device->is_input)
931 return; 916 return;
932 917
933 volume_percent = min(max(volume_percent, 0), 100); 918 volume_percent = min(max(volume_percent, 0), 100);
934 if (volume_percent <= kMuteThresholdPercent) 919 if (volume_percent <= kMuteThresholdPercent)
935 volume_percent = 0; 920 volume_percent = 0;
936 921
937 // Save the volume setting in pref in case this is called on non-active 922 // Save the volume setting in pref in case this is called on non-active
938 // node for configuration. 923 // node for configuration.
939 audio_pref_handler_->SetVolumeGainValue(*device, volume_percent); 924 audio_pref_handler_->SetVolumeGainValue(*device, volume_percent);
940 925
941 if (device->active) 926 if (device->active)
942 SetOutputNodeVolume(node_id, volume_percent); 927 SetOutputNodeVolume(node_id, volume_percent);
943 } 928 }
944 929
945 bool CrasAudioHandler::SetOutputMuteInternal(bool mute_on) { 930 bool CrasAudioHandler::SetOutputMuteInternal(bool mute_on) {
946 if (output_mute_locked_) 931 if (output_mute_locked_)
947 return false; 932 return false;
948 933
949 output_mute_on_ = mute_on; 934 output_mute_on_ = mute_on;
950 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()-> 935 GetCrasAudioClient()->SetOutputUserMute(mute_on);
951 SetOutputUserMute(mute_on);
952 return true; 936 return true;
953 } 937 }
954 938
955 void CrasAudioHandler::SetInputNodeGain(uint64_t node_id, int gain) { 939 void CrasAudioHandler::SetInputNodeGain(uint64_t node_id, int gain) {
956 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()-> 940 GetCrasAudioClient()->SetInputNodeGain(node_id, gain);
957 SetInputNodeGain(node_id, gain);
958 } 941 }
959 942
960 void CrasAudioHandler::SetInputNodeGainPercent(uint64_t node_id, 943 void CrasAudioHandler::SetInputNodeGainPercent(uint64_t node_id,
961 int gain_percent) { 944 int gain_percent) {
962 const AudioDevice* device = GetDeviceFromId(node_id); 945 const AudioDevice* device = GetDeviceFromId(node_id);
963 if (!device || !device->is_input) 946 if (!device || !device->is_input)
964 return; 947 return;
965 948
966 // NOTE: We do not sanitize input gain values since the range is completely 949 // NOTE: We do not sanitize input gain values since the range is completely
967 // dependent on the device. 950 // dependent on the device.
968 if (active_input_node_id_ == node_id) 951 if (active_input_node_id_ == node_id)
969 input_gain_ = gain_percent; 952 input_gain_ = gain_percent;
970 953
971 audio_pref_handler_->SetVolumeGainValue(*device, gain_percent); 954 audio_pref_handler_->SetVolumeGainValue(*device, gain_percent);
972 955
973 if (device->active) { 956 if (device->active) {
974 SetInputNodeGain(node_id, gain_percent); 957 SetInputNodeGain(node_id, gain_percent);
975 for (auto& observer : observers_) 958 for (auto& observer : observers_)
976 observer.OnInputNodeGainChanged(node_id, gain_percent); 959 observer.OnInputNodeGainChanged(node_id, gain_percent);
977 } 960 }
978 } 961 }
979 962
980 void CrasAudioHandler::SetInputMuteInternal(bool mute_on) { 963 void CrasAudioHandler::SetInputMuteInternal(bool mute_on) {
981 input_mute_on_ = mute_on; 964 input_mute_on_ = mute_on;
982 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()-> 965 GetCrasAudioClient()->SetInputMute(mute_on);
983 SetInputMute(mute_on);
984 } 966 }
985 967
986 void CrasAudioHandler::GetNodes() { 968 void CrasAudioHandler::GetNodes() {
987 chromeos::DBusThreadManager::Get()->GetCrasAudioClient()->GetNodes( 969 GetCrasAudioClient()->GetNodes(
988 base::Bind(&CrasAudioHandler::HandleGetNodes, 970 base::Bind(&CrasAudioHandler::HandleGetNodes,
989 weak_ptr_factory_.GetWeakPtr()), 971 weak_ptr_factory_.GetWeakPtr()),
990 base::Bind(&CrasAudioHandler::HandleGetNodesError, 972 base::Bind(&CrasAudioHandler::HandleGetNodesError,
991 weak_ptr_factory_.GetWeakPtr())); 973 weak_ptr_factory_.GetWeakPtr()));
992 } 974 }
993 975
994 bool CrasAudioHandler::ChangeActiveDevice( 976 bool CrasAudioHandler::ChangeActiveDevice(
995 const AudioDevice& new_active_device) { 977 const AudioDevice& new_active_device) {
996 uint64_t& current_active_node_id = new_active_device.is_input 978 uint64_t& current_active_node_id = new_active_device.is_input
997 ? active_input_node_id_ 979 ? active_input_node_id_
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
1086 const AudioDevice* device_found = 1068 const AudioDevice* device_found =
1087 GetDeviceFromStableDeviceId(device.stable_device_id); 1069 GetDeviceFromStableDeviceId(device.stable_device_id);
1088 if (!device_found) 1070 if (!device_found)
1089 return NEW_DEVICE; 1071 return NEW_DEVICE;
1090 1072
1091 if (!IsSameAudioDevice(device, *device_found)) { 1073 if (!IsSameAudioDevice(device, *device_found)) {
1092 LOG(ERROR) << "Different Audio devices with same stable device id:" 1074 LOG(ERROR) << "Different Audio devices with same stable device id:"
1093 << " new device: " << device.ToString() 1075 << " new device: " << device.ToString()
1094 << " old device: " << device_found->ToString(); 1076 << " old device: " << device_found->ToString();
1095 return CHANGED_DEVICE; 1077 return CHANGED_DEVICE;
1096 } else if (device.active != device_found->active) { 1078 }
1079 if (device.active != device_found->active)
1097 return CHANGED_DEVICE; 1080 return CHANGED_DEVICE;
1098 }
1099
1100 return OLD_DEVICE; 1081 return OLD_DEVICE;
1101 } 1082 }
1102 1083
1103 void CrasAudioHandler::NotifyActiveNodeChanged(bool is_input) { 1084 void CrasAudioHandler::NotifyActiveNodeChanged(bool is_input) {
1104 if (is_input) 1085 if (is_input) {
1105 for (auto& observer : observers_) 1086 for (auto& observer : observers_)
1106 observer.OnActiveInputNodeChanged(); 1087 observer.OnActiveInputNodeChanged();
1107 else 1088 } else {
1108 for (auto& observer : observers_) 1089 for (auto& observer : observers_)
1109 observer.OnActiveOutputNodeChanged(); 1090 observer.OnActiveOutputNodeChanged();
1091 }
1110 } 1092 }
1111 1093
1112 bool CrasAudioHandler::GetActiveDeviceFromUserPref(bool is_input, 1094 bool CrasAudioHandler::GetActiveDeviceFromUserPref(bool is_input,
1113 AudioDevice* active_device) { 1095 AudioDevice* active_device) {
1114 bool found_active_device = false; 1096 bool found_active_device = false;
1115 bool last_active_device_activate_by_user = false; 1097 bool last_active_device_activate_by_user = false;
1116 for (const auto& item : audio_devices_) { 1098 for (const auto& item : audio_devices_) {
1117 const AudioDevice& device = item.second; 1099 const AudioDevice& device = item.second;
1118 if (device.is_input != is_input || !device.is_for_simple_usage()) 1100 if (device.is_input != is_input || !device.is_for_simple_usage())
1119 continue; 1101 continue;
(...skipping 14 matching lines...) Expand all
1134 1116
1135 if (!found_active_device) { 1117 if (!found_active_device) {
1136 found_active_device = true; 1118 found_active_device = true;
1137 *active_device = device; 1119 *active_device = device;
1138 last_active_device_activate_by_user = activate_by_user; 1120 last_active_device_activate_by_user = activate_by_user;
1139 continue; 1121 continue;
1140 } 1122 }
1141 1123
1142 // Choose the best one among multiple active devices from prefs. 1124 // Choose the best one among multiple active devices from prefs.
1143 if (activate_by_user) { 1125 if (activate_by_user) {
1144 if (!last_active_device_activate_by_user) { 1126 if (last_active_device_activate_by_user) {
1145 // Device activated by user has higher priority than the one
1146 // is not activated by user.
1147 *active_device = device;
1148 last_active_device_activate_by_user = true;
1149 } else {
1150 // If there are more than one active devices activated by user in the 1127 // If there are more than one active devices activated by user in the
1151 // prefs, most likely, after the device was shut down, and before it 1128 // prefs, most likely, after the device was shut down, and before it
1152 // is rebooted, user has plugged in some previously unplugged audio 1129 // is rebooted, user has plugged in some previously unplugged audio
1153 // devices. For such case, it does not make sense to honor the active 1130 // devices. For such case, it does not make sense to honor the active
1154 // states in the prefs. 1131 // states in the prefs.
1155 VLOG(1) << "Found more than one user activated devices in the prefs."; 1132 VLOG(1) << "Found more than one user activated devices in the prefs.";
1156 return false; 1133 return false;
1157 } 1134 }
1135 // Device activated by user has higher priority than the one
1136 // is not activated by user.
1137 *active_device = device;
1138 last_active_device_activate_by_user = true;
1158 } else if (!last_active_device_activate_by_user) { 1139 } else if (!last_active_device_activate_by_user) {
1159 // If there are more than one active devices activated by priority in the 1140 // If there are more than one active devices activated by priority in the
1160 // prefs, most likely, cras is still enumerating the audio devices 1141 // prefs, most likely, cras is still enumerating the audio devices
1161 // progressively. For such case, it does not make sense to honor the 1142 // progressively. For such case, it does not make sense to honor the
1162 // active states in the prefs. 1143 // active states in the prefs.
1163 VLOG(1) << "Found more than one active devices by priority in the prefs."; 1144 VLOG(1) << "Found more than one active devices by priority in the prefs.";
1164 return false; 1145 return false;
1165 } 1146 }
1166 } 1147 }
1167 1148
(...skipping 254 matching lines...) Expand 10 before | Expand all | Expand 10 after
1422 VLOG(1) << "AddActiveInputNode: Cannot find device id=" 1403 VLOG(1) << "AddActiveInputNode: Cannot find device id="
1423 << "0x" << std::hex << node_id; 1404 << "0x" << std::hex << node_id;
1424 return; 1405 return;
1425 } 1406 }
1426 1407
1427 audio_devices_[node_id].active = true; 1408 audio_devices_[node_id].active = true;
1428 SetupAdditionalActiveAudioNodeState(node_id); 1409 SetupAdditionalActiveAudioNodeState(node_id);
1429 1410
1430 if (device->is_input) { 1411 if (device->is_input) {
1431 DCHECK(node_id != active_input_node_id_); 1412 DCHECK(node_id != active_input_node_id_);
1432 chromeos::DBusThreadManager::Get() 1413 GetCrasAudioClient()->AddActiveInputNode(node_id);
1433 ->GetCrasAudioClient()
1434 ->AddActiveInputNode(node_id);
1435 if (notify) 1414 if (notify)
1436 NotifyActiveNodeChanged(true); 1415 NotifyActiveNodeChanged(true);
1437 } else { 1416 } else {
1438 DCHECK(node_id != active_output_node_id_); 1417 DCHECK(node_id != active_output_node_id_);
1439 chromeos::DBusThreadManager::Get() 1418 GetCrasAudioClient()->AddActiveOutputNode(node_id);
1440 ->GetCrasAudioClient()
1441 ->AddActiveOutputNode(node_id);
1442 if (notify) 1419 if (notify)
1443 NotifyActiveNodeChanged(false); 1420 NotifyActiveNodeChanged(false);
1444 } 1421 }
1445 } 1422 }
1446 1423
1447 void CrasAudioHandler::RemoveActiveNodeInternal(uint64_t node_id, bool notify) { 1424 void CrasAudioHandler::RemoveActiveNodeInternal(uint64_t node_id, bool notify) {
1448 const AudioDevice* device = GetDeviceFromId(node_id); 1425 const AudioDevice* device = GetDeviceFromId(node_id);
1449 if (!device) { 1426 if (!device) {
1450 VLOG(1) << "RemoveActiveInputNode: Cannot find device id=" 1427 VLOG(1) << "RemoveActiveInputNode: Cannot find device id="
1451 << "0x" << std::hex << node_id; 1428 << "0x" << std::hex << node_id;
1452 return; 1429 return;
1453 } 1430 }
1454 1431
1455 audio_devices_[node_id].active = false; 1432 audio_devices_[node_id].active = false;
1456 if (device->is_input) { 1433 if (device->is_input) {
1457 if (node_id == active_input_node_id_) 1434 if (node_id == active_input_node_id_)
1458 active_input_node_id_ = 0; 1435 active_input_node_id_ = 0;
1459 chromeos::DBusThreadManager::Get() 1436 GetCrasAudioClient()->RemoveActiveInputNode(node_id);
1460 ->GetCrasAudioClient()
1461 ->RemoveActiveInputNode(node_id);
1462 if (notify) 1437 if (notify)
1463 NotifyActiveNodeChanged(true); 1438 NotifyActiveNodeChanged(true);
1464 } else { 1439 } else {
1465 if (node_id == active_output_node_id_) 1440 if (node_id == active_output_node_id_)
1466 active_output_node_id_ = 0; 1441 active_output_node_id_ = 0;
1467 chromeos::DBusThreadManager::Get() 1442 GetCrasAudioClient()->RemoveActiveOutputNode(node_id);
1468 ->GetCrasAudioClient()
1469 ->RemoveActiveOutputNode(node_id);
1470 if (notify) 1443 if (notify)
1471 NotifyActiveNodeChanged(false); 1444 NotifyActiveNodeChanged(false);
1472 } 1445 }
1473 } 1446 }
1474 1447
1475 void CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod() { 1448 void CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod() {
1476 VLOG(1) << "HDMI output re-discover grace period ends."; 1449 VLOG(1) << "HDMI output re-discover grace period ends.";
1477 hdmi_rediscovering_ = false; 1450 hdmi_rediscovering_ = false;
1478 if (!IsOutputMutedForDevice(active_output_node_id_)) { 1451 if (!IsOutputMutedForDevice(active_output_node_id_)) {
1479 // Unmute the audio output after the HDMI transition period. 1452 // Unmute the audio output after the HDMI transition period.
1480 VLOG(1) << "Unmute output after HDMI rediscovering grace period."; 1453 VLOG(1) << "Unmute output after HDMI rediscovering grace period.";
1481 SetOutputMuteInternal(false); 1454 SetOutputMuteInternal(false);
1482 1455
1483 // Notify UI about the mute state change. 1456 // Notify UI about the mute state change.
1484 for (auto& observer : observers_) { 1457 for (auto& observer : observers_) {
1485 observer.OnOutputMuteChanged(output_mute_on_, 1458 observer.OnOutputMuteChanged(output_mute_on_,
1486 true /* system adjustment */); 1459 true /* system adjustment */);
1487 } 1460 }
1488 } 1461 }
1489 } 1462 }
1490 1463
1491 bool CrasAudioHandler::IsHDMIPrimaryOutputDevice() const { 1464 bool CrasAudioHandler::IsHDMIPrimaryOutputDevice() const {
1492 const AudioDevice* device = GetDeviceFromId(active_output_node_id_); 1465 const AudioDevice* device = GetDeviceFromId(active_output_node_id_);
1493 return (device && device->type == chromeos::AUDIO_TYPE_HDMI); 1466 return device && device->type == AUDIO_TYPE_HDMI;
1494 } 1467 }
1495 1468
1496 void CrasAudioHandler::StartHDMIRediscoverGracePeriod() { 1469 void CrasAudioHandler::StartHDMIRediscoverGracePeriod() {
1497 VLOG(1) << "Start HDMI rediscovering grace period."; 1470 VLOG(1) << "Start HDMI rediscovering grace period.";
1498 hdmi_rediscovering_ = true; 1471 hdmi_rediscovering_ = true;
1499 hdmi_rediscover_timer_.Stop(); 1472 hdmi_rediscover_timer_.Stop();
1500 hdmi_rediscover_timer_.Start( 1473 hdmi_rediscover_timer_.Start(
1501 FROM_HERE, base::TimeDelta::FromMilliseconds( 1474 FROM_HERE, base::TimeDelta::FromMilliseconds(
1502 hdmi_rediscover_grace_period_duration_in_ms_), 1475 hdmi_rediscover_grace_period_duration_in_ms_),
1503 this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod); 1476 this, &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod);
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
1592 bool CrasAudioHandler::HasExternalDevice(bool is_input) const { 1565 bool CrasAudioHandler::HasExternalDevice(bool is_input) const {
1593 for (const auto& item : audio_devices_) { 1566 for (const auto& item : audio_devices_) {
1594 const AudioDevice& device = item.second; 1567 const AudioDevice& device = item.second;
1595 if (is_input == device.is_input && device.IsExternalDevice()) 1568 if (is_input == device.is_input && device.IsExternalDevice())
1596 return true; 1569 return true;
1597 } 1570 }
1598 return false; 1571 return false;
1599 } 1572 }
1600 1573
1601 } // namespace chromeos 1574 } // namespace chromeos
OLDNEW
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698