| // Copyright 2013 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chromeos/ash/components/audio/cras_audio_handler.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <algorithm> |
| #include <cmath> |
| #include <cstdint> |
| #include <optional> |
| #include <set> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "ash/constants/ash_features.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback_helpers.h" |
| #include "base/logging.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/strings/string_split.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/system/sys_info.h" |
| #include "base/system/system_monitor.h" |
| #include "base/task/single_thread_task_runner.h" |
| #include "chromeos/ash/components/audio/audio_device.h" |
| #include "chromeos/ash/components/audio/audio_device_encoding.h" |
| #include "chromeos/ash/components/audio/audio_device_id.h" |
| #include "chromeos/ash/components/audio/audio_devices_pref_handler_stub.h" |
| #include "chromeos/ash/components/dbus/audio/cras_audio_client.h" |
| #include "chromeos/ash/components/dbus/audio/fake_cras_audio_client.h" |
| #include "chromeos/ash/components/dbus/audio/floss_media_client.h" |
| #include "chromeos/ash/components/dbus/audio/voice_isolation_ui_appearance.h" |
| #include "device/bluetooth/floss/floss_features.h" |
| #include "third_party/cros_system_api/dbus/audio/dbus-constants.h" |
| #include "third_party/cros_system_api/dbus/service_constants.h" |
| |
| namespace ash { |
| namespace { |
| |
| using ::std::max; |
| using ::std::min; |
| |
| // Default value for unmuting, as a percent in the range [0, 100]. |
| // Used when sound is unmuted, but volume was less than kMuteThresholdPercent. |
| const int kDefaultUnmuteVolumePercent = 4; |
| |
| // Volume value which should be considered as muted in range [0, 100]. |
| const int kMuteThresholdPercent = 1; |
| |
| // Mixer matrix, [0.5, 0.5; 0.5, 0.5] |
| const double kStereoToMono[] = {0.5, 0.5, 0.5, 0.5}; |
| // Mixer matrix, [1, 0; 0, 1] |
| const double kStereoToStereo[] = {1, 0, 0, 1}; |
| |
| // Number of entries we're willing to store in preferences. |
| const int kMaxDeviceStoredInPref = 100; |
| |
| CrasAudioHandler* g_cras_audio_handler = nullptr; |
| |
| bool IsSameAudioDevice(const AudioDevice& a, const AudioDevice& b) { |
| return a.stable_device_id == b.stable_device_id && a.is_input == b.is_input && |
| a.type == b.type && a.device_name == b.device_name; |
| } |
| |
| bool IsDeviceInList(const AudioDevice& device, const AudioNodeList& node_list) { |
| for (const AudioNode& node : node_list) { |
| if (device.stable_device_id == node.StableDeviceId()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Gets the current state of the microphone mute switch. If the switch is on, |
| // cras will be kept in the muted state. The switch disables the internal audio |
| // input. |
| bool IsMicrophoneMuteSwitchOn() { |
| return ui::MicrophoneMuteSwitchMonitor::Get()->microphone_mute_switch_on(); |
| } |
| |
| } // namespace |
| |
| // TODO(b/277300962): Clean up the default value and handle the unset case. |
| CrasAudioHandler::AudioSurvey::AudioSurvey() : type_(SurveyType::kGeneral) {} |
| |
| CrasAudioHandler::AudioSurvey::~AudioSurvey() = default; |
| |
| CrasAudioHandler::AudioObserver::AudioObserver() = default; |
| |
| CrasAudioHandler::AudioObserver::~AudioObserver() = default; |
| |
| void CrasAudioHandler::AudioObserver::OnOutputNodeVolumeChanged( |
| uint64_t /* node_id */, |
| int /* volume */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnInputNodeGainChanged( |
| uint64_t /* node_id */, |
| int /* gain */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnOutputMuteChanged(bool /* mute_on */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnInputMuteChanged( |
| bool /* mute_on */, |
| InputMuteChangeMethod /* method */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnInputMutedByMicrophoneMuteSwitchChanged( |
| bool /* muted */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnInputMutedBySecurityCurtainChanged( |
| bool /* muted */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnAudioNodesChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnActiveOutputNodeChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnActiveInputNodeChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnOutputChannelRemixingChanged( |
| bool /* mono_on */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnVoiceIsolationUIAppearanceChanged( |
| VoiceIsolationUIAppearance appearance) {} |
| |
| void CrasAudioHandler::AudioObserver::OnNoiseCancellationStateChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnStyleTransferStateChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnForceRespectUiGainsStateChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnHfpMicSrStateChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnSpatialAudioStateChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnHotwordTriggered( |
| uint64_t /* tv_sec */, |
| uint64_t /* tv_nsec */) {} |
| |
| void CrasAudioHandler::AudioObserver::OnBluetoothBatteryChanged( |
| const std::string& /* address */, |
| uint32_t /* level */) {} |
| |
| void CrasAudioHandler::AudioObserver:: |
| OnNumberOfInputStreamsWithPermissionChanged() {} |
| |
| void CrasAudioHandler::AudioObserver::OnOutputStarted() {} |
| |
| void CrasAudioHandler::AudioObserver::OnOutputStopped() {} |
| |
| void CrasAudioHandler::AudioObserver::OnNonChromeOutputStarted() {} |
| |
| void CrasAudioHandler::AudioObserver::OnNonChromeOutputStopped() {} |
| |
| void CrasAudioHandler::AudioObserver::OnSurveyTriggered( |
| const AudioSurvey& /*survey*/) {} |
| |
| void CrasAudioHandler::AudioObserver::OnSpeakOnMuteDetected() {} |
| |
| void CrasAudioHandler::AudioObserver::OnNumStreamIgnoreUiGainsChanged( |
| int32_t num) {} |
| |
| void CrasAudioHandler::AudioObserver::OnNumberOfArcStreamsChanged(int32_t num) { |
| } |
| |
| void CrasAudioHandler::NumberOfNonChromeOutputStreamsChanged() { |
| GetNumberOfNonChromeOutputStreams(); |
| } |
| |
| void CrasAudioHandler::NumberOfArcStreamsChanged() { |
| GetNumberOfArcStreams(); |
| } |
| |
| // static |
| void CrasAudioHandler::Initialize( |
| mojo::PendingRemote<media_session::mojom::MediaControllerManager> |
| media_controller_manager, |
| scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) { |
| g_cras_audio_handler = new CrasAudioHandler( |
| std::move(media_controller_manager), audio_pref_handler); |
| } |
| |
| // static |
| void CrasAudioHandler::InitializeDelegate( |
| mojo::PendingRemote<media_session::mojom::MediaControllerManager> |
| media_controller_manager, |
| scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler, |
| std::unique_ptr<Delegate> delegate) { |
| g_cras_audio_handler = |
| new CrasAudioHandler(std::move(media_controller_manager), |
| audio_pref_handler, std::move(delegate)); |
| } |
| |
| // static |
| void CrasAudioHandler::InitializeForTesting() { |
| CHECK(CrasAudioClient::Get()) << "CrasAudioClient must be initialized."; |
| |
| // Make sure FlossMediaClient has been initialized. |
| // TODO(b/228608730): Remove this after Floss bypasses CRAS to receive media |
| // information directly from the provider. |
| if (floss::features::IsFlossEnabled() && !FlossMediaClient::Get()) { |
| FlossMediaClient::InitializeFake(); |
| } |
| CrasAudioHandler::Initialize(mojo::NullRemote(), |
| new AudioDevicesPrefHandlerStub()); |
| } |
| |
| // static |
| void CrasAudioHandler::Shutdown() { |
| delete g_cras_audio_handler; |
| g_cras_audio_handler = nullptr; |
| } |
| |
| // static |
| CrasAudioHandler* CrasAudioHandler::Get() { |
| return g_cras_audio_handler; |
| } |
| |
| void CrasAudioHandler::OnVideoCaptureStarted(media::VideoFacingMode facing) { |
| DCHECK(main_task_runner_); |
| if (!main_task_runner_->BelongsToCurrentThread()) { |
| main_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&CrasAudioHandler::OnVideoCaptureStartedOnMainThread, |
| weak_ptr_factory_.GetWeakPtr(), facing)); |
| return; |
| } |
| // Unittest may call this from the main thread. |
| OnVideoCaptureStartedOnMainThread(facing); |
| } |
| |
| void CrasAudioHandler::OnVideoCaptureStopped(media::VideoFacingMode facing) { |
| DCHECK(main_task_runner_); |
| if (!main_task_runner_->BelongsToCurrentThread()) { |
| main_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&CrasAudioHandler::OnVideoCaptureStoppedOnMainThread, |
| weak_ptr_factory_.GetWeakPtr(), facing)); |
| return; |
| } |
| // Unittest may call this from the main thread. |
| OnVideoCaptureStoppedOnMainThread(facing); |
| } |
| |
| void CrasAudioHandler::OnVideoCaptureStartedOnMainThread( |
| media::VideoFacingMode facing) { |
| DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| // Do nothing if the device doesn't have both front and rear microphones. |
| if (!HasDualInternalMic()) { |
| return; |
| } |
| |
| bool camera_is_already_on = IsCameraOn(); |
| switch (facing) { |
| case media::MEDIA_VIDEO_FACING_USER: |
| front_camera_on_ = true; |
| break; |
| case media::MEDIA_VIDEO_FACING_ENVIRONMENT: |
| rear_camera_on_ = true; |
| break; |
| default: |
| LOG_IF(WARNING, facing == media::NUM_MEDIA_VIDEO_FACING_MODES) |
| << "On the device with dual microphone, got video capture " |
| << "notification with invalid camera facing mode value"; |
| return; |
| } |
| |
| // If the camera is already on before this notification, don't change active |
| // input. In the case that both cameras are turned on at the same time, we |
| // won't change the active input after the first camera is turned on. We only |
| // support the use case of one camera on at a time. The third party |
| // developer can turn on/off both microphones with extension api if they like |
| // to. |
| if (camera_is_already_on) { |
| return; |
| } |
| |
| // If the current active input is an external device, keep it. |
| const AudioDevice* active_input = GetDeviceFromId(active_input_node_id_); |
| if (active_input && active_input->IsExternalDevice()) { |
| return; |
| } |
| |
| // Activate the correct mic for the current active camera. |
| ActivateMicForCamera(facing); |
| } |
| |
| void CrasAudioHandler::OnVideoCaptureStoppedOnMainThread( |
| media::VideoFacingMode facing) { |
| DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| // Do nothing if the device doesn't have both front and rear microphones. |
| if (!HasDualInternalMic()) { |
| return; |
| } |
| |
| switch (facing) { |
| case media::MEDIA_VIDEO_FACING_USER: |
| front_camera_on_ = false; |
| break; |
| case media::MEDIA_VIDEO_FACING_ENVIRONMENT: |
| rear_camera_on_ = false; |
| break; |
| default: |
| LOG_IF(WARNING, facing == media::NUM_MEDIA_VIDEO_FACING_MODES) |
| << "On the device with dual microphone, got video capture " |
| << "notification with invalid camera facing mode value"; |
| return; |
| } |
| |
| // If not all cameras are turned off, don't change active input. In the case |
| // that both cameras are turned on at the same time before one of them is |
| // stopped, we won't change active input until all of them are stopped. |
| // We only support the use case of one camera on at a time. The third party |
| // developer can turn on/off both microphones with extension api if they like |
| // to. |
| if (IsCameraOn()) { |
| return; |
| } |
| |
| // If the current active input is an external device, keep it. |
| const AudioDevice* active_input = GetDeviceFromId(active_input_node_id_); |
| if (active_input && active_input->IsExternalDevice()) { |
| return; |
| } |
| |
| // Switch to front mic properly. |
| DeviceActivateType activated_by = |
| HasExternalDevice(true) ? DeviceActivateType::kActivateByUser |
| : DeviceActivateType::kActivateByPriority; |
| SwitchToDevice(*GetDeviceByType(AudioDeviceType::kFrontMic), true, |
| activated_by); |
| } |
| |
| void CrasAudioHandler::HandleMediaSessionMetadataReset() { |
| const std::map<std::string, std::string> empty_metadata_map = { |
| {"title", ""}, {"artist", ""}, {"album", ""}}; |
| |
| // TODO(b/228608730): Remove this after Floss bypasses CRAS to receive media |
| // information directly from the provider. |
| if (floss::features::IsFlossEnabled()) { |
| FlossMediaClient::Get()->SetPlayerMetadata(empty_metadata_map); |
| FlossMediaClient::Get()->SetPlayerIdentity(""); |
| FlossMediaClient::Get()->SetPlayerPlaybackStatus("stopped"); |
| } else { |
| CrasAudioClient::Get()->SetPlayerMetadata(empty_metadata_map); |
| CrasAudioClient::Get()->SetPlayerIdentity(""); |
| CrasAudioClient::Get()->SetPlayerPlaybackStatus("stopped"); |
| } |
| } |
| |
| void CrasAudioHandler::MediaSessionInfoChanged( |
| media_session::mojom::MediaSessionInfoPtr session_info) { |
| if (!session_info) { |
| return; |
| } |
| |
| std::string state = session_info->playback_state == |
| media_session::mojom::MediaPlaybackState::kPlaying |
| ? "playing" |
| : "paused"; |
| |
| // TODO(b/228608730): Remove this after Floss bypasses CRAS to receive media |
| // information directly from the provider. |
| if (floss::features::IsFlossEnabled()) { |
| FlossMediaClient::Get()->SetPlayerPlaybackStatus(state); |
| } else { |
| CrasAudioClient::Get()->SetPlayerPlaybackStatus(state); |
| } |
| } |
| |
| void CrasAudioHandler::MediaSessionMetadataChanged( |
| const std::optional<media_session::MediaMetadata>& metadata) { |
| if (!metadata || metadata->IsEmpty()) { |
| HandleMediaSessionMetadataReset(); |
| return; |
| } |
| |
| const std::map<std::string, std::string> metadata_map = { |
| {"title", base::UTF16ToUTF8(metadata->title)}, |
| {"artist", base::UTF16ToUTF8(metadata->artist)}, |
| {"album", base::UTF16ToUTF8(metadata->album)}}; |
| const std::string source_title = base::UTF16ToUTF8(metadata->source_title); |
| |
| // Assume media duration/length should always change with new metadata. |
| fetch_media_session_duration_ = true; |
| |
| // TODO(b/228608730): Remove this after Floss bypasses CRAS to receive media |
| // information directly from the provider. |
| if (floss::features::IsFlossEnabled()) { |
| FlossMediaClient::Get()->SetPlayerMetadata(metadata_map); |
| FlossMediaClient::Get()->SetPlayerIdentity(source_title); |
| } else { |
| CrasAudioClient::Get()->SetPlayerMetadata(metadata_map); |
| CrasAudioClient::Get()->SetPlayerIdentity(source_title); |
| } |
| } |
| |
| void CrasAudioHandler::MediaSessionPositionChanged( |
| const std::optional<media_session::MediaPosition>& position) { |
| if (!position) { |
| return; |
| } |
| |
| int64_t duration = 0; |
| if (fetch_media_session_duration_) { |
| duration = position->duration().InMicroseconds(); |
| if (duration > 0) { |
| // TODO(b/228608730): Remove this after Floss bypasses the media |
| // information from CRAS. |
| if (floss::features::IsFlossEnabled()) { |
| FlossMediaClient::Get()->SetPlayerDuration(duration); |
| } else { |
| CrasAudioClient::Get()->SetPlayerDuration(duration); |
| } |
| fetch_media_session_duration_ = false; |
| } |
| } |
| |
| int64_t current_position = position->GetPosition().InMicroseconds(); |
| if (current_position < 0 || (duration > 0 && current_position > duration)) { |
| return; |
| } |
| |
| // TODO(b/228608730): Remove this after Floss bypasses CRAS to receive media |
| // information directly from the provider. |
| if (floss::features::IsFlossEnabled()) { |
| FlossMediaClient::Get()->SetPlayerPosition(current_position); |
| } else { |
| CrasAudioClient::Get()->SetPlayerPosition(current_position); |
| } |
| } |
| |
| void CrasAudioHandler::OnMicrophoneMuteSwitchValueChanged(bool muted) { |
| input_muted_by_microphone_mute_switch_ = muted; |
| SetInputMute(muted, InputMuteChangeMethod::kPhysicalShutter); |
| |
| for (auto& observer : observers_) { |
| observer.OnInputMutedByMicrophoneMuteSwitchChanged(muted); |
| } |
| } |
| |
| void CrasAudioHandler::AddAudioObserver(AudioObserver* observer) { |
| observers_.AddObserver(observer); |
| } |
| |
| void CrasAudioHandler::RemoveAudioObserver(AudioObserver* observer) { |
| observers_.RemoveObserver(observer); |
| } |
| |
| bool CrasAudioHandler::HasKeyboardMic() { |
| return GetKeyboardMic() != nullptr; |
| } |
| |
| bool CrasAudioHandler::HasHotwordDevice() { |
| return GetHotwordDevice() != nullptr; |
| } |
| |
| bool CrasAudioHandler::IsOutputMuted() { |
| return output_mute_on_; |
| } |
| |
| bool CrasAudioHandler::IsOutputMutedForDevice(uint64_t device_id) { |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device) { |
| return false; |
| } |
| DCHECK(!device->is_input); |
| return audio_pref_handler_->GetMuteValue(*device); |
| } |
| |
| bool CrasAudioHandler::IsOutputMutedByPolicy() { |
| return output_mute_forced_by_policy_; |
| } |
| |
| bool CrasAudioHandler::IsOutputMutedBySecurityCurtain() { |
| return output_mute_forced_by_security_curtain_; |
| } |
| |
| bool CrasAudioHandler::IsOutputVolumeBelowDefaultMuteLevel() { |
| return output_volume_ <= kMuteThresholdPercent; |
| } |
| |
| bool CrasAudioHandler::IsInputMuted() { |
| return input_mute_on_; |
| } |
| |
| bool CrasAudioHandler::IsInputMutedBySecurityCurtain() { |
| return input_mute_forced_by_security_curtain_; |
| } |
| |
| bool CrasAudioHandler::IsInputMutedForDevice(uint64_t device_id) { |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device) { |
| return false; |
| } |
| DCHECK(device->is_input); |
| // We don't record input mute state for each device in the prefs, |
| // for any non-active input device, we assume mute is off. |
| if (device->id == active_input_node_id_) { |
| return input_mute_on_; |
| } |
| return false; |
| } |
| |
| int CrasAudioHandler::GetOutputDefaultVolumeMuteThreshold() const { |
| return kMuteThresholdPercent; |
| } |
| |
| int CrasAudioHandler::GetOutputVolumePercent() { |
| return output_volume_; |
| } |
| |
| int CrasAudioHandler::GetOutputVolumePercentForDevice(uint64_t device_id) { |
| if (device_id == active_output_node_id_) { |
| return output_volume_; |
| } |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| return static_cast<int>(audio_pref_handler_->GetOutputVolumeValue(device)); |
| } |
| |
| int CrasAudioHandler::GetInputGainPercent() { |
| return input_gain_; |
| } |
| |
| int CrasAudioHandler::GetInputGainPercentForDevice(uint64_t device_id) { |
| if (device_id == active_input_node_id_) { |
| return input_gain_; |
| } |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| return static_cast<int>(audio_pref_handler_->GetInputGainValue(device)); |
| } |
| |
| uint64_t CrasAudioHandler::GetPrimaryActiveOutputNode() const { |
| return active_output_node_id_; |
| } |
| |
| uint64_t CrasAudioHandler::GetPrimaryActiveInputNode() const { |
| return active_input_node_id_; |
| } |
| |
| void CrasAudioHandler::GetAudioDevices(AudioDeviceList* device_list) const { |
| device_list->clear(); |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| device_list->push_back(device); |
| } |
| } |
| |
| // static. |
| AudioDeviceList CrasAudioHandler::GetSimpleUsageAudioDevices( |
| const AudioDeviceMap& audio_devices, |
| bool is_input) { |
| AudioDeviceList device_list; |
| for (const auto& item : audio_devices) { |
| const AudioDevice& device = item.second; |
| // Do not count non simple usage devices. |
| if (!device.is_for_simple_usage()) { |
| continue; |
| } |
| if (device.is_input == is_input) { |
| device_list.push_back(device); |
| } |
| } |
| return device_list; |
| } |
| |
| const AudioDeviceMap& CrasAudioHandler::GetAudioDevicesMapForTesting( |
| bool is_current_device) const { |
| return is_current_device ? audio_devices_ : previous_audio_devices_; |
| } |
| |
| bool CrasAudioHandler::GetPrimaryActiveOutputDevice(AudioDevice* device) const { |
| const AudioDevice* active_device = GetDeviceFromId(active_output_node_id_); |
| if (!active_device || !device) { |
| return false; |
| } |
| *device = *active_device; |
| return true; |
| } |
| |
| bool CrasAudioHandler::GetPrimaryActiveInputDevice(AudioDevice* device) const { |
| const AudioDevice* active_device = GetDeviceFromId(active_input_node_id_); |
| if (!active_device || !device) { |
| return false; |
| } |
| *device = *active_device; |
| return true; |
| } |
| |
| const AudioDevice* CrasAudioHandler::GetDeviceByType(AudioDeviceType type) { |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.type == type) { |
| return &device; |
| } |
| } |
| return nullptr; |
| } |
| |
| base::flat_map<CrasAudioHandler::ClientType, uint32_t> |
| CrasAudioHandler::GetNumberOfInputStreamsWithPermission() const { |
| return number_of_input_streams_with_permission_; |
| } |
| |
| void CrasAudioHandler::GetDefaultOutputBufferSize(int32_t* buffer_size) const { |
| *buffer_size = default_output_buffer_size_; |
| } |
| |
| void CrasAudioHandler::RequestGetAudioEffectDlcs() { |
| CrasAudioClient::Get()->GetAudioEffectDlcs( |
| base::BindOnce(&CrasAudioHandler::HandleGetAudioEffectDlcs, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetAudioEffectDlcs( |
| std::optional<std::string> audio_effect_dlcs) { |
| if (!audio_effect_dlcs.has_value()) { |
| LOG(ERROR) << "cras_audio_handler: Failed to retrieve audio effect dlcs"; |
| } else { |
| audio_effect_dlcs_ = |
| base::SplitString(audio_effect_dlcs.value(), ",", base::TRIM_WHITESPACE, |
| base::SPLIT_WANT_NONEMPTY); |
| } |
| } |
| |
| std::optional<std::vector<std::string>> CrasAudioHandler::GetAudioEffectDlcs() |
| const { |
| return audio_effect_dlcs_; |
| } |
| |
| void CrasAudioHandler::RequestVoiceIsolationUIAppearance() { |
| CrasAudioClient::Get()->GetVoiceIsolationUIAppearance( |
| base::BindOnce(&CrasAudioHandler::HandleGetVoiceIsolationUIAppearance, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::ResetVoiceIsolationPreferredEffectIfNeeded() { |
| uint32_t effect_mode_options = |
| voice_isolation_ui_appearance_.effect_mode_options; |
| bool pref_is_zero = !audio_pref_handler_->GetVoiceIsolationPreferredEffect(); |
| if (effect_mode_options != 0 && pref_is_zero) { |
| // Default preferred effect is Style Transfer. |
| // Currently Style Transfer is always in effect_mode_options if it's not 0. |
| audio_pref_handler_->SetVoiceIsolationPreferredEffect( |
| cras::AudioEffectType::EFFECT_TYPE_STYLE_TRANSFER); |
| RefreshVoiceIsolationPreferredEffect(); |
| } |
| |
| // Reset to NONE if the preferred effect is not in the effect_mode_options. |
| if (!(effect_mode_options & |
| audio_pref_handler_->GetVoiceIsolationPreferredEffect())) { |
| audio_pref_handler_->SetVoiceIsolationPreferredEffect( |
| cras::AudioEffectType::EFFECT_TYPE_NONE); |
| RefreshVoiceIsolationPreferredEffect(); |
| } |
| } |
| |
| void CrasAudioHandler::HandleGetVoiceIsolationUIAppearance( |
| std::optional<VoiceIsolationUIAppearance> appearance) { |
| if (!appearance.has_value()) { |
| LOG(ERROR) << "cras_audio_handler: Failed to retrieve voice isolation UI " |
| "appearance."; |
| } else { |
| voice_isolation_ui_appearance_ = appearance.value(); |
| ResetVoiceIsolationPreferredEffectIfNeeded(); |
| } |
| |
| for (auto& observer : observers_) { |
| observer.OnVoiceIsolationUIAppearanceChanged( |
| voice_isolation_ui_appearance_); |
| } |
| } |
| |
| VoiceIsolationUIAppearance CrasAudioHandler::GetVoiceIsolationUIAppearance() { |
| return voice_isolation_ui_appearance_; |
| } |
| |
| bool CrasAudioHandler::GetVoiceIsolationState() const { |
| return audio_pref_handler_->GetVoiceIsolationState(); |
| } |
| |
| void CrasAudioHandler::RefreshVoiceIsolationState() { |
| // Refresh should only update the state in CRAS and leave the preference |
| // as-is. |
| CrasAudioClient::Get()->SetVoiceIsolationUIEnabled(GetVoiceIsolationState()); |
| } |
| |
| void CrasAudioHandler::RecordVoiceIsolationEnabledChangeSource( |
| AudioSettingsChangeSource source) { |
| base::UmaHistogramEnumeration(kVoiceIsolationEnabledChangeSourceHistogramName, |
| source); |
| } |
| |
| uint32_t CrasAudioHandler::GetVoiceIsolationPreferredEffect() const { |
| return audio_pref_handler_->GetVoiceIsolationPreferredEffect(); |
| } |
| |
| void CrasAudioHandler::RefreshVoiceIsolationPreferredEffect() { |
| CrasAudioClient::Get()->SetVoiceIsolationUIPreferredEffect( |
| GetVoiceIsolationPreferredEffect()); |
| } |
| |
| void CrasAudioHandler::RecordVoiceIsolationPreferredEffectChange( |
| audio_config::mojom::AudioEffectType preferred_effect) { |
| base::UmaHistogramEnumeration( |
| kVoiceIsolationPreferredEffectChangeHistogramName, preferred_effect); |
| } |
| |
| bool CrasAudioHandler::IsNoiseCancellationSupportedForDevice( |
| uint64_t device_id) { |
| if (!noise_cancellation_supported()) { |
| return false; |
| } |
| |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device) { |
| return false; |
| } |
| |
| if (!device->is_input) { |
| return false; |
| } |
| |
| return device->audio_effect & cras::EFFECT_TYPE_NOISE_CANCELLATION; |
| } |
| |
| bool CrasAudioHandler::GetNoiseCancellationState() const { |
| return audio_pref_handler_->GetNoiseCancellationState(); |
| } |
| |
| void CrasAudioHandler::SetNoiseCancellationState( |
| bool noise_cancellation_on, |
| AudioSettingsChangeSource source) { |
| CrasAudioClient::Get()->SetVoiceIsolationUIEnabled(noise_cancellation_on); |
| audio_pref_handler_->SetVoiceIsolationState(noise_cancellation_on); |
| |
| for (auto& observer : observers_) { |
| observer.OnNoiseCancellationStateChanged(); |
| } |
| base::UmaHistogramEnumeration(kNoiseCancellationEnabledSourceHistogramName, |
| source); |
| } |
| |
| void CrasAudioHandler::RequestNoiseCancellationSupported( |
| OnNoiseCancellationSupportedCallback callback) { |
| CrasAudioClient::Get()->GetNoiseCancellationSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetNoiseCancellationSupported, |
| weak_ptr_factory_.GetWeakPtr(), std::move(callback))); |
| } |
| |
| void CrasAudioHandler::HandleGetNoiseCancellationSupported( |
| OnNoiseCancellationSupportedCallback callback, |
| std::optional<bool> noise_cancellation_supported) { |
| if (!noise_cancellation_supported.has_value()) { |
| LOG(ERROR) |
| << "cras_audio_handler: Failed to retrieve noise cancellation support"; |
| } else { |
| noise_cancellation_supported_ = noise_cancellation_supported.value(); |
| } |
| |
| std::move(callback).Run(); |
| } |
| |
| void CrasAudioHandler::SetVoiceIsolationUIAppearanceForTesting( |
| cras::AudioEffectType toggle_type, |
| uint32_t effect_mode_options, |
| bool show_effect_fallback_message) { |
| voice_isolation_ui_appearance_ = VoiceIsolationUIAppearance( |
| toggle_type, effect_mode_options, show_effect_fallback_message); |
| } |
| |
| void CrasAudioHandler::SetNoiseCancellationSupportedForTesting(bool supported) { |
| noise_cancellation_supported_ = supported; |
| } |
| |
| bool CrasAudioHandler::IsStyleTransferSupportedForDevice(uint64_t device_id) { |
| if (!style_transfer_supported()) { |
| return false; |
| } |
| |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device) { |
| return false; |
| } |
| |
| return device->audio_effect & cras::EFFECT_TYPE_STYLE_TRANSFER; |
| } |
| |
| bool CrasAudioHandler::GetStyleTransferState() const { |
| return audio_pref_handler_->GetVoiceIsolationState(); |
| } |
| |
| void CrasAudioHandler::SetStyleTransferState(bool style_transfer_on) { |
| CrasAudioClient::Get()->SetVoiceIsolationUIEnabled(style_transfer_on); |
| audio_pref_handler_->SetVoiceIsolationState(style_transfer_on); |
| |
| for (auto& observer : observers_) { |
| observer.OnStyleTransferStateChanged(); |
| } |
| } |
| |
| void CrasAudioHandler::RequestStyleTransferSupported( |
| OnStyleTransferSupportedCallback callback) { |
| CrasAudioClient::Get()->GetStyleTransferSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetStyleTransferSupported, |
| weak_ptr_factory_.GetWeakPtr(), std::move(callback))); |
| } |
| |
| void CrasAudioHandler::HandleGetStyleTransferSupported( |
| OnStyleTransferSupportedCallback callback, |
| std::optional<bool> system_style_transfer_supported) { |
| if (!system_style_transfer_supported.has_value()) { |
| LOG(ERROR) |
| << "cras_audio_handler: Failed to retrieve style transfer support"; |
| } else { |
| style_transfer_supported_ = system_style_transfer_supported.value(); |
| } |
| |
| std::move(callback).Run(); |
| } |
| |
| void CrasAudioHandler::SetStyleTransferSupportedForTesting(bool supported) { |
| style_transfer_supported_ = supported; |
| } |
| |
| bool CrasAudioHandler::GetForceRespectUiGainsState() const { |
| return audio_pref_handler_->GetForceRespectUiGainsState(); |
| } |
| |
| void CrasAudioHandler::RefreshForceRespectUiGainsState() { |
| // Refresh should only update the state in CRAS and leave the preference |
| // as-is. |
| CrasAudioClient::Get()->SetForceRespectUiGains(GetForceRespectUiGainsState()); |
| } |
| |
| void CrasAudioHandler::SetForceRespectUiGainsState(bool state) { |
| base::UmaHistogramBoolean(CrasAudioHandler::kForceRespectUiGainsHistogramName, |
| state); |
| CrasAudioClient::Get()->SetForceRespectUiGains(state); |
| audio_pref_handler_->SetForceRespectUiGainsState(state); |
| |
| for (auto& observer : observers_) { |
| observer.OnForceRespectUiGainsStateChanged(); |
| } |
| } |
| |
| bool CrasAudioHandler::IsHfpMicSrSupportedForDevice(uint64_t device_id) { |
| if (!hfp_mic_sr_supported()) { |
| return false; |
| } |
| |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device || device->type != AudioDeviceType::kBluetoothNbMic) { |
| return false; |
| } |
| |
| return device->audio_effect & cras::EFFECT_TYPE_HFP_MIC_SR; |
| } |
| |
| void CrasAudioHandler::RequestHfpMicSrSupported( |
| OnHfpMicSrSupportedCallback callback) { |
| CrasAudioClient::Get()->GetHfpMicSrSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetHfpMicSrSupported, |
| weak_ptr_factory_.GetWeakPtr(), std::move(callback))); |
| } |
| |
| void CrasAudioHandler::SetHfpMicSrSupportedForTesting(bool supported) { |
| hfp_mic_sr_supported_ = supported; |
| } |
| |
| void CrasAudioHandler::HandleGetHfpMicSrSupported( |
| OnHfpMicSrSupportedCallback callback, |
| std::optional<bool> hfp_mic_sr_supported) { |
| if (!hfp_mic_sr_supported.has_value()) { |
| LOG(ERROR) << "cras_audio_handler: Failed to retrieve hfp_mic_sr support"; |
| } else { |
| hfp_mic_sr_supported_ = hfp_mic_sr_supported.value(); |
| } |
| |
| std::move(callback).Run(); |
| } |
| |
| bool CrasAudioHandler::GetHfpMicSrState() const { |
| return audio_pref_handler_->GetHfpMicSrState(); |
| } |
| |
| void CrasAudioHandler::RefreshHfpMicSrState() { |
| if (!hfp_mic_sr_supported()) { |
| return; |
| } |
| |
| const AudioDevice* device = GetDeviceByType(AudioDeviceType::kBluetoothNbMic); |
| if (!device) { |
| return; |
| } |
| |
| // Refresh should only update the state in CRAS and leave the preference |
| // as-is. |
| CrasAudioClient::Get()->SetHfpMicSrEnabled( |
| GetHfpMicSrState() && |
| (device->audio_effect & cras::EFFECT_TYPE_HFP_MIC_SR)); |
| } |
| |
| void CrasAudioHandler::SetHfpMicSrState(bool hfp_mic_sr_on, |
| AudioSettingsChangeSource source) { |
| CrasAudioClient::Get()->SetHfpMicSrEnabled(hfp_mic_sr_on); |
| audio_pref_handler_->SetHfpMicSrState(hfp_mic_sr_on); |
| |
| for (auto& observer : observers_) { |
| observer.OnHfpMicSrStateChanged(); |
| } |
| } |
| |
| bool CrasAudioHandler::IsSpatialAudioSupportedForDevice(uint64_t device_id) { |
| if (!spatial_audio_supported()) { |
| return false; |
| } |
| |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device || device->type != AudioDeviceType::kInternalSpeaker) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void CrasAudioHandler::RequestSpatialAudioSupported( |
| OnSpatialAudioSupportedCallback callback) { |
| CrasAudioClient::Get()->GetSpatialAudioSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetSpatialAudioSupported, |
| weak_ptr_factory_.GetWeakPtr(), std::move(callback))); |
| } |
| |
| void CrasAudioHandler::HandleGetSpatialAudioSupported( |
| OnSpatialAudioSupportedCallback callback, |
| std::optional<bool> spatial_audio_supported) { |
| if (!spatial_audio_supported.has_value()) { |
| LOG(ERROR) |
| << "cras_audio_handler: Failed to retrieve spatial audio support"; |
| } else { |
| spatial_audio_supported_ = spatial_audio_supported.value(); |
| } |
| |
| std::move(callback).Run(); |
| } |
| |
| bool CrasAudioHandler::GetSpatialAudioState() const { |
| return audio_pref_handler_->GetSpatialAudioState(); |
| } |
| |
| void CrasAudioHandler::RefreshSpatialAudioState() { |
| // Refresh should only update the state in CRAS and leave the preference |
| // as-is. |
| CrasAudioClient::Get()->SetSpatialAudio(GetSpatialAudioState()); |
| } |
| |
| void CrasAudioHandler::SetSpatialAudioState(bool state) { |
| base::UmaHistogramBoolean(CrasAudioHandler::kSpatialAudioHistogramName, |
| state); |
| CrasAudioClient::Get()->SetSpatialAudio(state); |
| audio_pref_handler_->SetSpatialAudioState(state); |
| |
| for (auto& observer : observers_) { |
| observer.OnSpatialAudioStateChanged(); |
| } |
| } |
| |
| void CrasAudioHandler::SetSpatialAudioSupportedForTesting(bool supported) { |
| spatial_audio_supported_ = supported; |
| } |
| |
| void CrasAudioHandler::SetKeyboardMicActive(bool active) { |
| const AudioDevice* keyboard_mic = GetKeyboardMic(); |
| if (!keyboard_mic) { |
| return; |
| } |
| // Keyboard mic is invisible to chromeos users. It is always added or removed |
| // as additional active node. |
| DCHECK(active_input_node_id_ && active_input_node_id_ != keyboard_mic->id); |
| if (active) { |
| AddActiveNode(keyboard_mic->id, true); |
| } else { |
| RemoveActiveNodeInternal(keyboard_mic->id, true); |
| } |
| } |
| |
| void CrasAudioHandler::SetSpeakOnMuteDetection(bool som_on) { |
| CrasAudioClient::Get()->SetSpeakOnMuteDetection(som_on); |
| speak_on_mute_detection_on_ = som_on; |
| } |
| |
| void CrasAudioHandler::SetEwmaPowerReportEnabled(bool enabled) { |
| CrasAudioClient::Get()->SetEwmaPowerReportEnabled(enabled); |
| ewma_power_report_enabled_ = enabled; |
| } |
| |
| double CrasAudioHandler::GetEwmaPower() { |
| return ewma_power_; |
| } |
| |
| void CrasAudioHandler::SetSidetoneEnabled(bool enabled) { |
| CrasAudioClient::Get()->SetSidetoneEnabled(enabled); |
| sidetone_enabled_ = enabled; |
| } |
| |
| bool CrasAudioHandler::GetSidetoneEnabled() const { |
| return sidetone_enabled_; |
| } |
| |
| bool CrasAudioHandler::IsSidetoneSupported() const { |
| return sidetone_supported_; |
| } |
| |
| void CrasAudioHandler::UpdateSidetoneSupportedState() { |
| CrasAudioClient::Get()->GetSidetoneSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetSidetoneSupported, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetSidetoneSupported( |
| std::optional<bool> supported) { |
| if (!supported.has_value()) { |
| LOG(ERROR) << "Failed to check whether sidetone is supported."; |
| return; |
| } |
| |
| sidetone_supported_ = *supported; |
| } |
| |
| void CrasAudioHandler::AddActiveNode(uint64_t node_id, bool notify) { |
| const AudioDevice* device = GetDeviceFromId(node_id); |
| if (!device) { |
| VLOG(1) << "AddActiveInputNode: Cannot find device id=" << "0x" << std::hex |
| << node_id; |
| return; |
| } |
| |
| // If there is no primary active device, set |node_id| to primary active node. |
| if ((device->is_input && !active_input_node_id_) || |
| (!device->is_input && !active_output_node_id_)) { |
| SwitchToDevice(*device, notify, DeviceActivateType::kActivateByUser); |
| return; |
| } |
| |
| AddAdditionalActiveNode(node_id, notify); |
| } |
| |
| void CrasAudioHandler::ChangeActiveNodes(const NodeIdList& new_active_ids) { |
| AudioDeviceList input_devices; |
| AudioDeviceList output_devices; |
| |
| for (uint64_t id : new_active_ids) { |
| const AudioDevice* device = GetDeviceFromId(id); |
| if (!device) { |
| continue; |
| } |
| if (device->is_input) { |
| input_devices.push_back(*device); |
| } else { |
| output_devices.push_back(*device); |
| } |
| } |
| if (!input_devices.empty()) { |
| SetActiveDevices(input_devices, true /* is_input */); |
| } |
| if (!output_devices.empty()) { |
| SetActiveDevices(output_devices, false /* is_input */); |
| } |
| } |
| |
| bool CrasAudioHandler::SetActiveInputNodes(const NodeIdList& node_ids) { |
| return SetActiveNodes(node_ids, true /* is_input */); |
| } |
| |
| bool CrasAudioHandler::SetActiveOutputNodes(const NodeIdList& node_ids) { |
| return SetActiveNodes(node_ids, false /* is_input */); |
| } |
| |
| bool CrasAudioHandler::SetActiveNodes(const NodeIdList& node_ids, |
| bool is_input) { |
| AudioDeviceList devices; |
| for (uint64_t id : node_ids) { |
| const AudioDevice* device = GetDeviceFromId(id); |
| if (!device || device->is_input != is_input) { |
| return false; |
| } |
| |
| devices.push_back(*device); |
| } |
| |
| SetActiveDevices(devices, is_input); |
| return true; |
| } |
| |
| void CrasAudioHandler::SetActiveDevices(const AudioDeviceList& devices, |
| bool is_input) { |
| std::set<uint64_t> new_active_ids; |
| for (const auto& active_device : devices) { |
| CHECK_EQ(is_input, active_device.is_input); |
| new_active_ids.insert(active_device.id); |
| } |
| |
| bool active_devices_changed = false; |
| |
| // If primary active node has to be switched, do that before adding or |
| // removing any other active devices. Switching to a device can change |
| // activity state of other devices - final device activity may end up being |
| // unintended if it is set before active device switches. |
| uint64_t primary_active = |
| is_input ? active_input_node_id_ : active_output_node_id_; |
| if (!new_active_ids.count(primary_active) && !devices.empty()) { |
| active_devices_changed = true; |
| SwitchToDevice(devices[0], false /* notify */, |
| DeviceActivateType::kActivateByUser); |
| } |
| |
| AudioDeviceList existing_devices; |
| GetAudioDevices(&existing_devices); |
| for (const auto& existing_device : existing_devices) { |
| if (existing_device.is_input != is_input) { |
| continue; |
| } |
| |
| bool should_be_active = new_active_ids.count(existing_device.id); |
| if (existing_device.active == should_be_active) { |
| continue; |
| } |
| active_devices_changed = true; |
| |
| if (should_be_active) { |
| AddActiveNode(existing_device.id, false /* notify */); |
| } else { |
| RemoveActiveNodeInternal(existing_device.id, false /* notify */); |
| } |
| } |
| |
| if (active_devices_changed) { |
| NotifyActiveNodeChanged(is_input); |
| } |
| } |
| |
| void CrasAudioHandler::SetHotwordModel(uint64_t node_id, |
| const std::string& hotword_model, |
| VoidCrasAudioHandlerCallback callback) { |
| CrasAudioClient::Get()->SetHotwordModel(node_id, hotword_model, |
| std::move(callback)); |
| } |
| |
| void CrasAudioHandler::SwapInternalSpeakerLeftRightChannel(bool swap) { |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (!device.is_input && device.type == AudioDeviceType::kInternalSpeaker) { |
| CrasAudioClient::Get()->SwapLeftRight(device.id, swap); |
| break; |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetDisplayRotation(cras::DisplayRotation rotation) { |
| display_rotation_ = rotation; |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.type == AudioDeviceType::kInternalSpeaker) { |
| CrasAudioClient::Get()->SetDisplayRotation(device.id, display_rotation_); |
| break; |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetOutputMonoEnabled(bool enabled) { |
| if (output_mono_enabled_ == enabled) { |
| return; |
| } |
| output_mono_enabled_ = enabled; |
| if (enabled) { |
| CrasAudioClient::Get()->SetGlobalOutputChannelRemix( |
| output_channels_, |
| std::vector<double>(kStereoToMono, std::end(kStereoToMono))); |
| } else { |
| CrasAudioClient::Get()->SetGlobalOutputChannelRemix( |
| output_channels_, |
| std::vector<double>(kStereoToStereo, std::end(kStereoToStereo))); |
| } |
| |
| for (auto& observer : observers_) { |
| observer.OnOutputChannelRemixingChanged(enabled); |
| } |
| } |
| |
| bool CrasAudioHandler::has_alternative_input() const { |
| return has_alternative_input_; |
| } |
| |
| bool CrasAudioHandler::has_alternative_output() const { |
| return has_alternative_output_; |
| } |
| |
| void CrasAudioHandler::SetOutputVolumePercent(int volume_percent) { |
| // Set all active devices to the same volume. |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (!device.is_input && device.active) { |
| SetOutputNodeVolumePercent(device.id, volume_percent); |
| } |
| } |
| } |
| |
| // TODO: Rename the 'Percent' to something more meaningful. |
| void CrasAudioHandler::SetInputGainPercent(int gain_percent) { |
| // TODO(jennyz): Should we set all input devices' gain to the same level? |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.is_input && device.active) { |
| SetInputNodeGainPercent(active_input_node_id_, gain_percent); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::AdjustOutputVolumeByPercent(int adjust_by_percent) { |
| SetOutputVolumePercent(output_volume_ + adjust_by_percent); |
| } |
| |
| void CrasAudioHandler::IncreaseOutputVolumeByOneStep(int one_step_percent) { |
| // Set all active devices to the same volume. |
| int new_output_volume = 0; |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (!device.is_input && device.active) { |
| // only USB device should depend on number_of_volume_steps |
| if (device.type == AudioDeviceType::kUsb) { |
| int32_t number_of_volume_steps = device.number_of_volume_steps; |
| if (number_of_volume_steps == 0) { |
| LOG(ERROR) |
| << device.ToString() |
| << ": No valid number_of_volume_steps. Falling back to default."; |
| number_of_volume_steps = NUMBER_OF_VOLUME_STEPS_DEFAULT; |
| } |
| int32_t volume_level = std::round( |
| (double)output_volume_ * (double)number_of_volume_steps * 0.01); |
| if (volume_level == 0 && output_volume_ > 0) { |
| volume_level = 1; |
| } |
| // increase one level and convert to volume |
| new_output_volume = std::min( |
| 100, static_cast<int>(std::floor(((double)(volume_level + 1)) / |
| number_of_volume_steps * 100))); |
| } else { |
| new_output_volume = std::min(100, output_volume_ + one_step_percent); |
| } |
| SetOutputNodeVolumePercent(device.id, new_output_volume); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::DecreaseOutputVolumeByOneStep(int one_step_percent) { |
| // Set all active devices to the same volume. |
| int new_output_volume = 0; |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (!device.is_input && device.active) { |
| if (device.type == AudioDeviceType::kUsb) { |
| int32_t number_of_volume_steps = device.number_of_volume_steps; |
| if (number_of_volume_steps == 0) { |
| LOG(ERROR) |
| << device.ToString() |
| << ": No valid number_of_volume_steps. Falling back to default."; |
| number_of_volume_steps = NUMBER_OF_VOLUME_STEPS_DEFAULT; |
| } |
| int32_t volume_level = std::round( |
| (double)output_volume_ * (double)number_of_volume_steps * 0.01); |
| |
| // decrease one level and convert to volume |
| new_output_volume = std::max( |
| 0, static_cast<int>(std::floor(((double)(volume_level - 1)) / |
| number_of_volume_steps * 100))); |
| } else { |
| new_output_volume = std::max(0, output_volume_ - one_step_percent); |
| } |
| SetOutputNodeVolumePercent(device.id, new_output_volume); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetOutputMute(bool mute_on) { |
| if (!SetOutputMuteInternal(mute_on)) { |
| return; |
| } |
| |
| // Save the mute state for all active output audio devices. |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (!device.is_input && device.active) { |
| audio_pref_handler_->SetMuteValue(device, output_mute_on_); |
| } |
| } |
| |
| for (auto& observer : observers_) { |
| observer.OnOutputMuteChanged(output_mute_on_); |
| } |
| } |
| |
| void CrasAudioHandler::SetOutputMute( |
| bool mute_on, |
| CrasAudioHandler::AudioSettingsChangeSource source) { |
| SetOutputMute(mute_on); |
| base::UmaHistogramEnumeration( |
| CrasAudioHandler::kOutputVolumeMuteSourceHistogramName, source); |
| } |
| |
| void CrasAudioHandler::SetOutputMuteLockedBySecurityCurtain(bool mute_on) { |
| if (output_mute_forced_by_security_curtain_ == mute_on) { |
| return; |
| } |
| |
| output_mute_forced_by_security_curtain_ = mute_on; |
| UpdateAudioOutputMute(); |
| } |
| |
| void CrasAudioHandler::AdjustOutputVolumeToAudibleLevel() { |
| if (output_volume_ <= kMuteThresholdPercent) { |
| for (const auto& item : audio_devices_) { |
| int unmute_volume = kDefaultUnmuteVolumePercent; |
| const AudioDevice& device = item.second; |
| if (!device.is_input && device.active) { |
| if (device.type == AudioDeviceType::kUsb) { |
| int32_t number_of_volume_steps = device.number_of_volume_steps; |
| DCHECK(number_of_volume_steps > 0); |
| unmute_volume = 100 / number_of_volume_steps; |
| } |
| SetOutputNodeVolumePercent(device.id, unmute_volume); |
| } |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetInputMute(bool mute_on, |
| InputMuteChangeMethod method) { |
| const bool old_mute_on = input_mute_on_; |
| SetInputMuteInternal(mute_on); |
| |
| if (old_mute_on != input_mute_on_) { |
| for (auto& observer : observers_) { |
| observer.OnInputMuteChanged(input_mute_on_, method); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetInputMute( |
| bool mute_on, |
| InputMuteChangeMethod method, |
| CrasAudioHandler::AudioSettingsChangeSource source) { |
| SetInputMute(mute_on, method); |
| base::UmaHistogramEnumeration( |
| CrasAudioHandler::kInputGainMuteSourceHistogramName, source); |
| } |
| |
| void CrasAudioHandler::SetInputMuteLockedBySecurityCurtain(bool mute_on) { |
| if (input_mute_forced_by_security_curtain_ == mute_on) { |
| return; |
| } |
| |
| input_mute_forced_by_security_curtain_ = mute_on; |
| SetInputMute(mute_on, InputMuteChangeMethod::kOther); |
| |
| for (auto& observer : observers_) { |
| observer.OnInputMutedBySecurityCurtainChanged(mute_on); |
| } |
| } |
| |
| void CrasAudioHandler::SetActiveDevice(const AudioDevice& active_device, |
| bool notify, |
| DeviceActivateType activate_by) { |
| if (activate_by == DeviceActivateType::kActivateByUser) { |
| audio_device_metrics_handler_.RecordUserSwitchAudioDevice( |
| active_device.is_input); |
| } else { |
| audio_device_metrics_handler_.MaybeRecordSystemSwitchDecisionAndContext( |
| active_device.is_input, |
| active_device.is_input ? has_alternative_input_ |
| : has_alternative_output_, |
| /*is_switched=*/true, audio_devices_, previous_audio_devices_); |
| } |
| |
| // Update *_selected_by_user_. |
| // Including to unset it when selected by priority or by camera. |
| if (active_device.is_input) { |
| audio_device_metrics_handler_.set_input_device_selected_by_user( |
| activate_by == DeviceActivateType::kActivateByUser); |
| } else { |
| audio_device_metrics_handler_.set_output_device_selected_by_user( |
| activate_by == DeviceActivateType::kActivateByUser); |
| } |
| |
| if (active_device.is_input) { |
| CrasAudioClient::Get()->SetActiveInputNode(active_device.id); |
| } else { |
| CrasAudioClient::Get()->SetActiveOutputNode(active_device.id); |
| } |
| |
| if (notify) { |
| NotifyActiveNodeChanged(active_device.is_input); |
| } |
| |
| // Active device has changed, update user preference and add the device to |
| // most recently activated device list. |
| if (features::IsAudioSelectionImprovementEnabled()) { |
| SyncDevicePrefSetMap(active_device.is_input); |
| audio_pref_handler_->UpdateMostRecentActivatedDeviceIdList(active_device); |
| |
| if (activate_by == DeviceActivateType::kActivateByUser) { |
| // Remove notification if the hotplugged device that triggered the |
| // notification has already been activated by user via settings or quick |
| // settings. |
| audio_selection_notification_handler_ |
| .RemoveNotificationIfHotpluggedDeviceActivated({active_device}); |
| } |
| } |
| |
| // Save active state for the nodes. |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.is_input != active_device.is_input) { |
| continue; |
| } |
| SaveDeviceState(device, device.active, activate_by); |
| } |
| } |
| |
| void CrasAudioHandler::SaveDeviceState(const AudioDevice& device, |
| bool active, |
| DeviceActivateType activate_by) { |
| // Don't save the active state for non-simple usage device, which is invisible |
| // to end users. |
| if (!device.is_for_simple_usage()) { |
| return; |
| } |
| |
| if (!active) { |
| audio_pref_handler_->SetDeviceActive(device, false, false); |
| } else { |
| switch (activate_by) { |
| case DeviceActivateType::kActivateByUser: |
| audio_pref_handler_->SetDeviceActive(device, true, true); |
| break; |
| case DeviceActivateType::kActivateByPriority: |
| audio_pref_handler_->SetDeviceActive(device, true, false); |
| break; |
| default: |
| // The device is made active due to its previous active state in prefs, |
| // don't change its active state settings in prefs. |
| break; |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetVolumeGainPercentForDevice(uint64_t device_id, |
| int value) { |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| if (!device) { |
| return; |
| } |
| |
| if (device->is_input) { |
| SetInputNodeGainPercent(device_id, value); |
| } else { |
| SetOutputNodeVolumePercent(device_id, value); |
| } |
| } |
| |
| void CrasAudioHandler::SetMuteForDevice(uint64_t device_id, bool mute_on) { |
| if (device_id == active_output_node_id_) { |
| SetOutputMute(mute_on); |
| return; |
| } |
| if (device_id == active_input_node_id_) { |
| VLOG(1) << "SetMuteForDevice sets active input device id=" << "0x" |
| << std::hex << device_id << " mute=" << mute_on; |
| SetInputMute(mute_on, InputMuteChangeMethod::kOther); |
| return; |
| } |
| |
| const AudioDevice* device = GetDeviceFromId(device_id); |
| // Input device's mute state is not recorded in the pref. crbug.com/365050. |
| if (device && !device->is_input) { |
| audio_pref_handler_->SetMuteValue(*device, mute_on); |
| } |
| } |
| |
| void CrasAudioHandler::SetMuteForDevice( |
| uint64_t device_id, |
| bool mute_on, |
| CrasAudioHandler::AudioSettingsChangeSource source) { |
| SetMuteForDevice(device_id, mute_on); |
| if (device_id == active_output_node_id_) { |
| base::UmaHistogramEnumeration( |
| CrasAudioHandler::kOutputVolumeMuteSourceHistogramName, source); |
| } else if (device_id == active_input_node_id_) { |
| base::UmaHistogramEnumeration( |
| CrasAudioHandler::kInputGainMuteSourceHistogramName, source); |
| } |
| } |
| |
| // If the HDMI device is the active output device, when the device enters/exits |
| // docking mode, or HDMI display changes resolution, or chromeos device |
| // suspends/resumes, cras will lose the HDMI output node for a short period of |
| // time, then rediscover it. This hotplug behavior will cause the audio output |
| // be leaked to the alternatvie active audio output during HDMI re-discovering |
| // period. See crbug.com/503667. |
| void CrasAudioHandler::SetActiveHDMIOutoutRediscoveringIfNecessary( |
| bool force_rediscovering) { |
| if (!GetDeviceFromId(active_output_node_id_)) { |
| return; |
| } |
| |
| // Marks the start of the HDMI re-discovering grace period, during which we |
| // will mute the audio output to prevent it to be be leaked to the |
| // alternative output device. |
| if ((hdmi_rediscovering_ && force_rediscovering) || |
| (!hdmi_rediscovering_ && IsHDMIPrimaryOutputDevice())) { |
| StartHDMIRediscoverGracePeriod(); |
| } |
| } |
| |
| CrasAudioHandler::CrasAudioHandler( |
| mojo::PendingRemote<media_session::mojom::MediaControllerManager> |
| media_controller_manager, |
| scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler, |
| std::unique_ptr<Delegate> delegate) |
| : media_controller_manager_(std::move(media_controller_manager)), |
| audio_pref_handler_(audio_pref_handler), |
| delegate_(std::move(delegate)) { |
| SetupCrasAudioHandler(audio_pref_handler); |
| } |
| |
| CrasAudioHandler::CrasAudioHandler( |
| mojo::PendingRemote<media_session::mojom::MediaControllerManager> |
| media_controller_manager, |
| scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) |
| : media_controller_manager_(std::move(media_controller_manager)), |
| audio_pref_handler_(audio_pref_handler) { |
| SetupCrasAudioHandler(audio_pref_handler); |
| } |
| |
| void CrasAudioHandler::SetupCrasAudioHandler( |
| scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) { |
| DCHECK(audio_pref_handler); |
| DCHECK(CrasAudioClient::Get()); |
| CrasAudioClient::Get()->AddObserver(this); |
| audio_pref_handler_->AddAudioPrefObserver(this); |
| ui::MicrophoneMuteSwitchMonitor::Get()->AddObserver(this); |
| |
| BindMediaControllerObserver(); |
| InitializeAudioState(); |
| // Unittest may not have the task runner for the current thread. |
| if (base::SingleThreadTaskRunner::HasCurrentDefault()) { |
| main_task_runner_ = base::SingleThreadTaskRunner::GetCurrentDefault(); |
| } |
| |
| DCHECK(!g_cras_audio_handler); |
| g_cras_audio_handler = this; |
| } |
| |
| CrasAudioHandler::~CrasAudioHandler() { |
| hdmi_rediscover_timer_.Stop(); |
| DCHECK(CrasAudioClient::Get()); |
| CrasAudioClient::Get()->RemoveObserver(this); |
| audio_pref_handler_->RemoveAudioPrefObserver(this); |
| ui::MicrophoneMuteSwitchMonitor::Get()->RemoveObserver(this); |
| |
| DCHECK(g_cras_audio_handler); |
| g_cras_audio_handler = nullptr; |
| } |
| |
| void CrasAudioHandler::BindMediaControllerObserver() { |
| if (!media_controller_manager_) { |
| return; |
| } |
| media_controller_manager_->CreateActiveMediaController( |
| media_session_controller_remote_.BindNewPipeAndPassReceiver()); |
| media_session_controller_remote_->AddObserver( |
| media_controller_observer_receiver_.BindNewPipeAndPassRemote()); |
| } |
| |
| void CrasAudioHandler::AudioClientRestarted() { |
| InitializeAudioState(); |
| } |
| |
| void CrasAudioHandler::NodesChanged() { |
| if (cras_service_available_) { |
| GetNodes(); |
| RequestVoiceIsolationUIAppearance(); |
| } |
| } |
| |
| void CrasAudioHandler::OutputNodeVolumeChanged(uint64_t node_id, int volume) { |
| const AudioDevice* device = this->GetDeviceFromId(node_id); |
| if (!device || device->is_input) { |
| LOG(ERROR) << "Unexpected OutputNodeVolumeChanged received on node: 0x" |
| << std::hex << node_id; |
| return; |
| } |
| if (volume < 0 || volume > 100) { |
| LOG(ERROR) << "Unexpected OutputNodeVolumeChanged received on volume: " |
| << volume; |
| return; |
| } |
| |
| // Sync internal volume state and notify UI for the change. We trust cras |
| // signal to report the volume state of the device, no matter which source |
| // set the volume, i.e., volume could be set from non-chrome source, like |
| // Bluetooth headset, etc. Assume all active output devices share a single |
| // volume. |
| if (device->active) { |
| output_volume_ = volume; |
| } |
| audio_pref_handler_->SetVolumeGainValue(*device, volume); |
| |
| if (initializing_audio_state_) { |
| // Do not notify the observers for volume changed event if CrasAudioHandler |
| // is initializing its state, i.e., the volume change event is in responding |
| // to SetOutputNodeVolume request from intializaing audio state, not |
| // from user action, no need to notify UI to pop uo the volume slider bar. |
| if (init_node_id_ == node_id && init_volume_ == volume) { |
| --init_volume_count_; |
| if (!init_volume_count_) { |
| initializing_audio_state_ = false; |
| } |
| return; |
| } else { |
| // Reset the initializing_audio_state_ in case SetOutputNodeVolume request |
| // is lost by cras due to cras is not ready when CrasAudioHandler is being |
| // initialized. |
| initializing_audio_state_ = false; |
| init_volume_count_ = 0; |
| } |
| } |
| |
| for (auto& observer : observers_) { |
| observer.OnOutputNodeVolumeChanged(node_id, volume); |
| } |
| } |
| |
| void CrasAudioHandler::InputNodeGainChanged(uint64_t node_id, int gain) { |
| const AudioDevice* device = this->GetDeviceFromId(node_id); |
| |
| if (!device || !device->is_input) { |
| LOG(ERROR) << "Unexpexted InputNodeGainChanged received on node: 0x" |
| << std::hex << node_id; |
| return; |
| } |
| |
| if (device->active) { |
| input_gain_ = gain; |
| } |
| |
| audio_pref_handler_->SetVolumeGainValue(*device, gain); |
| |
| for (auto& observer : observers_) { |
| observer.OnInputNodeGainChanged(node_id, gain); |
| } |
| } |
| |
| void CrasAudioHandler::ActiveOutputNodeChanged(uint64_t node_id) { |
| if (active_output_node_id_ == node_id) { |
| return; |
| } |
| |
| // Active audio output device should always be changed by chrome. |
| // During system boot, cras may change active input to unknown device 0x1, |
| // we don't need to log it, since it is not an valid device. |
| if (GetDeviceFromId(node_id)) { |
| LOG(WARNING) << "Active output node changed unexpectedly by system node_id=" |
| << "0x" << std::hex << node_id; |
| } |
| } |
| |
| void CrasAudioHandler::ActiveInputNodeChanged(uint64_t node_id) { |
| if (active_input_node_id_ == node_id) { |
| return; |
| } |
| |
| // Active audio input device should always be changed by chrome. |
| // During system boot, cras may change active input to unknown device 0x2, |
| // we don't need to log it, since it is not an valid device. |
| if (GetDeviceFromId(node_id)) { |
| LOG(WARNING) << "Active input node changed unexpectedly by system node_id=" |
| << "0x" << std::hex << node_id; |
| } |
| } |
| |
| void CrasAudioHandler::HotwordTriggered(uint64_t tv_sec, uint64_t tv_nsec) { |
| for (auto& observer : observers_) { |
| observer.OnHotwordTriggered(tv_sec, tv_nsec); |
| } |
| } |
| |
| void CrasAudioHandler::NumberOfActiveStreamsChanged() { |
| GetNumberOfOutputStreams(); |
| } |
| |
| void CrasAudioHandler::BluetoothBatteryChanged(const std::string& address, |
| uint32_t level) { |
| for (auto& observer : observers_) { |
| observer.OnBluetoothBatteryChanged(address, level); |
| } |
| } |
| |
| void CrasAudioHandler::NumberOfInputStreamsWithPermissionChanged( |
| const base::flat_map<std::string, uint32_t>& num_input_streams) { |
| HandleGetNumberOfInputStreamsWithPermission(num_input_streams); |
| for (auto& observer : observers_) { |
| observer.OnNumberOfInputStreamsWithPermissionChanged(); |
| } |
| } |
| |
| // static |
| std::unique_ptr<CrasAudioHandler::AudioSurvey> |
| CrasAudioHandler::AbstractAudioSurvey( |
| const base::flat_map<std::string, std::string>& survey_specific_data) { |
| auto survey = std::make_unique<CrasAudioHandler::AudioSurvey>(); |
| for (const auto& it : survey_specific_data) { |
| if (it.first == CrasAudioHandler::kSurveyNameKey) { |
| if (it.second == CrasAudioHandler::kSurveyNameGeneral) { |
| survey->set_type(SurveyType::kGeneral); |
| } else if (it.second == CrasAudioHandler::kSurveyNameBluetooth) { |
| survey->set_type(SurveyType::kBluetooth); |
| } else if (it.second == CrasAudioHandler::kSurveyNameOutputProc) { |
| survey->set_type(SurveyType::kOutputProc); |
| } |
| } else { |
| survey->AddData(it.first, it.second); |
| } |
| } |
| return survey; |
| } |
| |
| void CrasAudioHandler::SurveyTriggered( |
| const base::flat_map<std::string, std::string>& survey_specific_data) { |
| auto survey = CrasAudioHandler::AbstractAudioSurvey(survey_specific_data); |
| |
| for (auto& observer : observers_) { |
| observer.OnSurveyTriggered(*survey); |
| } |
| } |
| |
| void CrasAudioHandler::SpeakOnMuteDetected() { |
| for (auto& observer : observers_) { |
| observer.OnSpeakOnMuteDetected(); |
| } |
| } |
| |
| void CrasAudioHandler::EwmaPowerReported(double power) { |
| ewma_power_ = power; |
| } |
| |
| void CrasAudioHandler::NumStreamIgnoreUiGains(int32_t num) { |
| num_stream_ignore_ui_gains_ = num; |
| for (auto& observer : observers_) { |
| observer.OnNumStreamIgnoreUiGainsChanged(num); |
| } |
| } |
| |
| void CrasAudioHandler::SidetoneSupportedChanged(bool supported) { |
| sidetone_supported_ = supported; |
| } |
| |
| void CrasAudioHandler::AudioEffectUIAppearanceChanged( |
| VoiceIsolationUIAppearance appearance) { |
| HandleGetVoiceIsolationUIAppearance(appearance); |
| } |
| |
| void CrasAudioHandler::ResendBluetoothBattery() { |
| CrasAudioClient::Get()->ResendBluetoothBattery(); |
| } |
| |
| void CrasAudioHandler::SetPrefHandlerForTesting( |
| scoped_refptr<AudioDevicesPrefHandler> audio_pref_handler) { |
| audio_pref_handler_->RemoveAudioPrefObserver(this); |
| audio_pref_handler_ = audio_pref_handler; |
| audio_pref_handler_->AddAudioPrefObserver(this); |
| } |
| |
| void CrasAudioHandler::OnAudioPolicyPrefChanged() { |
| ApplyAudioPolicy(); |
| } |
| |
| void CrasAudioHandler::OnVoiceIsolationPrefChanged() { |
| RefreshVoiceIsolationState(); |
| RefreshVoiceIsolationPreferredEffect(); |
| } |
| |
| const AudioDevice* CrasAudioHandler::GetDeviceFromId(uint64_t device_id) const { |
| AudioDeviceMap::const_iterator it = audio_devices_.find(device_id); |
| if (it == audio_devices_.end()) { |
| return nullptr; |
| } |
| return &it->second; |
| } |
| |
| AudioDevice CrasAudioHandler::ConvertAudioNodeWithModifiedPriority( |
| const AudioNode& node) { |
| AudioDevice device(node); |
| device.user_priority = audio_pref_handler_->GetUserPriority(device); |
| return device; |
| } |
| |
| const AudioDevice* CrasAudioHandler::GetDeviceFromStableDeviceId( |
| bool is_input, |
| uint64_t stable_device_id) const { |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.is_input == is_input && |
| device.stable_device_id == stable_device_id) { |
| return &device; |
| } |
| } |
| return nullptr; |
| } |
| |
| const AudioDevice* CrasAudioHandler::GetKeyboardMic() const { |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.is_input && device.type == AudioDeviceType::kKeyboardMic) { |
| return &device; |
| } |
| } |
| return nullptr; |
| } |
| |
| const AudioDevice* CrasAudioHandler::GetHotwordDevice() const { |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.is_input && device.type == AudioDeviceType::kHotword) { |
| return &device; |
| } |
| } |
| return nullptr; |
| } |
| |
| void CrasAudioHandler::SetupAudioInputState() { |
| // Set the initial audio state to the ones read from audio prefs. |
| const AudioDevice* device = GetDeviceFromId(active_input_node_id_); |
| if (!device) { |
| LOG(ERROR) << "Can't set up audio state for unknown input device id =" |
| << "0x" << std::hex << active_input_node_id_; |
| return; |
| } |
| input_gain_ = audio_pref_handler_->GetInputGainValue(device); |
| VLOG(1) << "SetupAudioInputState for active device id=" << "0x" << std::hex |
| << device->id << " mute=" << input_mute_on_; |
| SetInputMuteInternal(input_mute_on_); |
| |
| SetInputNodeGain(active_input_node_id_, input_gain_); |
| } |
| |
| void CrasAudioHandler::SetupAudioOutputState() { |
| const AudioDevice* device = GetDeviceFromId(active_output_node_id_); |
| if (!device) { |
| LOG(ERROR) << "Can't set up audio state for unknown output device id =" |
| << "0x" << std::hex << active_output_node_id_; |
| return; |
| } |
| DCHECK(!device->is_input); |
| // Mute the output during HDMI re-discovering grace period. |
| if (hdmi_rediscovering_ && !IsHDMIPrimaryOutputDevice()) { |
| VLOG(1) << "Mute the output during HDMI re-discovering grace period"; |
| SetOutputMuteInternal(true); |
| } else { |
| SetOutputMuteInternal(audio_pref_handler_->GetMuteValue(*device)); |
| } |
| output_volume_ = audio_pref_handler_->GetOutputVolumeValue(device); |
| |
| if (initializing_audio_state_) { |
| // During power up, InitializeAudioState() could be called twice, first |
| // by CrasAudioHandler constructor, then by cras server restarting signal, |
| // both sending SetOutputNodeVolume requests, and could lead to two |
| // OutputNodeVolumeChanged signals. |
| ++init_volume_count_; |
| init_node_id_ = active_output_node_id_; |
| init_volume_ = output_volume_; |
| } |
| SetOutputNodeVolume(active_output_node_id_, output_volume_); |
| } |
| |
| // This sets up the state of an additional active node. |
| void CrasAudioHandler::SetupAdditionalActiveAudioNodeState(uint64_t node_id) { |
| const AudioDevice* device = GetDeviceFromId(node_id); |
| if (!device) { |
| VLOG(1) << "Can't set up audio state for unknown device id =" << "0x" |
| << std::hex << node_id; |
| return; |
| } |
| |
| DCHECK(node_id != active_output_node_id_ && node_id != active_input_node_id_); |
| |
| // Note: The mute state is a system wide state, we don't set mute per device, |
| // but just keep the mute state consistent for the active node in prefs. |
| // The output volume should be set to the same value for all active output |
| // devices. For input devices, we don't restore their gain value so far. |
| // TODO(jennyz): crbug.com/417418, track the status for the decison if |
| // we should persist input gain value in prefs. |
| if (!device->is_input) { |
| audio_pref_handler_->SetMuteValue(*device, IsOutputMuted()); |
| SetOutputNodeVolumePercent(node_id, GetOutputVolumePercent()); |
| } |
| } |
| |
| void CrasAudioHandler::InitializeAudioState() { |
| initializing_audio_state_ = true; |
| ApplyAudioPolicy(); |
| |
| // Defer querying cras for GetNodes until cras service becomes available. |
| cras_service_available_ = false; |
| CrasAudioClient::Get()->WaitForServiceToBeAvailable(base::BindOnce( |
| &CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::InitializeAudioAfterCrasServiceAvailable( |
| bool service_is_available) { |
| if (!service_is_available) { |
| LOG(ERROR) << "Cras service is not available"; |
| cras_service_available_ = false; |
| return; |
| } |
| |
| cras_service_available_ = true; |
| GetDefaultOutputBufferSizeInternal(); |
| GetSystemAecSupported(); |
| GetSystemAecGroupId(); |
| GetSystemNsSupported(); |
| GetSystemAgcSupported(); |
| RequestGetAudioEffectDlcs(); |
| RequestVoiceIsolationUIAppearance(); |
| RequestNoiseCancellationSupported(base::BindOnce( |
| &CrasAudioHandler::GetNodes, weak_ptr_factory_.GetWeakPtr())); |
| RequestStyleTransferSupported(base::BindOnce(&CrasAudioHandler::GetNodes, |
| weak_ptr_factory_.GetWeakPtr())); |
| RequestHfpMicSrSupported(base::BindOnce(&CrasAudioHandler::GetNodes, |
| weak_ptr_factory_.GetWeakPtr())); |
| RequestSpatialAudioSupported(base::BindOnce(&CrasAudioHandler::GetNodes, |
| weak_ptr_factory_.GetWeakPtr())); |
| GetNumberOfOutputStreams(); |
| GetNumberOfNonChromeOutputStreams(); |
| GetNumberOfInputStreamsWithPermissionInternal(); |
| GetNumStreamIgnoreUiGains(); |
| GetNumberOfArcStreams(); |
| CrasAudioClient::Get()->SetFixA2dpPacketSize( |
| base::FeatureList::IsEnabled(features::kBluetoothFixA2dpPacketSize)); |
| |
| // Sets Floss enabled based on feature flag. |
| CrasAudioClient::Get()->SetFlossEnabled(floss::features::IsFlossEnabled()); |
| |
| input_muted_by_microphone_mute_switch_ = IsMicrophoneMuteSwitchOn(); |
| if (input_muted_by_microphone_mute_switch_) { |
| SetInputMute(true, InputMuteChangeMethod::kPhysicalShutter); |
| } |
| |
| // Refreshes voice isolation state in CRAS, in case CRAS restarts. |
| RefreshVoiceIsolationState(); |
| |
| // Sets speak-on-mute detection enabled based on local variable, it re-applies |
| // the previous state if CRAS restarts. |
| CrasAudioClient::Get()->SetSpeakOnMuteDetection(speak_on_mute_detection_on_); |
| |
| // Sets force respect ui gains enabled based on audio pref, it re-applies the |
| // previous state if CRAS restarts. |
| CrasAudioClient::Get()->SetForceRespectUiGains(GetForceRespectUiGainsState()); |
| |
| UpdateSidetoneSupportedState(); |
| CrasAudioClient::Get()->SetSidetoneEnabled(sidetone_enabled_); |
| CrasAudioClient::Get()->SetEwmaPowerReportEnabled(ewma_power_report_enabled_); |
| } |
| |
| void CrasAudioHandler::ApplyAudioPolicy() { |
| bool mute_on = !audio_pref_handler_->GetAudioOutputAllowedValue(); |
| |
| if (output_mute_forced_by_policy_ == mute_on) { |
| return; |
| } |
| |
| output_mute_forced_by_policy_ = mute_on; |
| UpdateAudioOutputMute(); |
| // Policy for audio input is handled by kAudioCaptureAllowed in the Chrome |
| // media system. |
| } |
| |
| void CrasAudioHandler::UpdateAudioOutputMute() { |
| if (output_mute_forced_by_policy_ || |
| output_mute_forced_by_security_curtain_) { |
| // Mute the device, but do not update the preference. |
| SetOutputMuteInternal(true); |
| } else { |
| // Restore the mute state. |
| const AudioDevice* device = GetDeviceFromId(active_output_node_id_); |
| if (device) { |
| SetOutputMuteInternal(audio_pref_handler_->GetMuteValue(*device)); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::SetOutputNodeVolume(uint64_t node_id, int volume) { |
| CrasAudioClient::Get()->SetOutputNodeVolume(node_id, volume); |
| } |
| |
| void CrasAudioHandler::SetOutputNodeVolumePercent(uint64_t node_id, |
| int volume_percent) { |
| const AudioDevice* device = GetDeviceFromId(node_id); |
| if (!device || device->is_input) { |
| return; |
| } |
| |
| volume_percent = min(max(volume_percent, 0), 100); |
| if (volume_percent <= kMuteThresholdPercent) { |
| volume_percent = 0; |
| } |
| |
| // Save the volume setting in pref in case this is called on non-active |
| // node for configuration. |
| audio_pref_handler_->SetVolumeGainValue(*device, volume_percent); |
| |
| if (device->active) { |
| SetOutputNodeVolume(node_id, volume_percent); |
| } |
| } |
| |
| bool CrasAudioHandler::SetOutputMuteInternal(bool mute_on) { |
| bool is_output_mute_forced = (output_mute_forced_by_policy_ || |
| output_mute_forced_by_security_curtain_); |
| |
| if (is_output_mute_forced && !mute_on) { |
| // Do not allow unmuting if the policy forces the device to remain muted. |
| return false; |
| } |
| |
| output_mute_on_ = mute_on; |
| CrasAudioClient::Get()->SetOutputUserMute(mute_on); |
| return true; |
| } |
| |
| void CrasAudioHandler::SetInputNodeGain(uint64_t node_id, int gain) { |
| CrasAudioClient::Get()->SetInputNodeGain(node_id, gain); |
| } |
| |
| void CrasAudioHandler::SetInputNodeGainPercent(uint64_t node_id, |
| int gain_percent) { |
| const AudioDevice* device = GetDeviceFromId(node_id); |
| if (!device || !device->is_input) { |
| return; |
| } |
| |
| // NOTE: We do not sanitize input gain values since the range is completely |
| // dependent on the device. |
| |
| audio_pref_handler_->SetVolumeGainValue(*device, gain_percent); |
| |
| if (device->active) { |
| SetInputNodeGain(node_id, gain_percent); |
| } |
| } |
| |
| void CrasAudioHandler::SetInputMuteInternal(bool mute_on) { |
| // Do not allow unmuting the device if hardware microphone mute switch is on. |
| // The switch disables internal microphone, and cras audio handler is expected |
| // to keep system wide cras mute on while the switch is toggled (which should |
| // ensure non-internal audio input devices are kept muted). |
| // |
| // Also do not allow unmuting the device if the security curtain is showing, |
| // to prevent a remote admin from spying on the user |
| if (!mute_on && (input_muted_by_microphone_mute_switch_ || |
| input_mute_forced_by_security_curtain_)) { |
| return; |
| } |
| |
| input_mute_on_ = mute_on; |
| CrasAudioClient::Get()->SetInputMute(mute_on); |
| } |
| |
| void CrasAudioHandler::GetNodes() { |
| CrasAudioClient::Get()->GetNodes(base::BindOnce( |
| &CrasAudioHandler::HandleGetNodes, weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::GetNumberOfNonChromeOutputStreams() { |
| CrasAudioClient::Get()->GetNumberOfNonChromeOutputStreams( |
| base::BindOnce(&CrasAudioHandler::HandleGetNumberOfNonChromeOutputStreams, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::GetNumberOfOutputStreams() { |
| CrasAudioClient::Get()->GetNumberOfActiveOutputStreams( |
| base::BindOnce(&CrasAudioHandler::HandleGetNumActiveOutputStreams, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| bool CrasAudioHandler::ChangeActiveDevice( |
| const AudioDevice& new_active_device) { |
| uint64_t& current_active_node_id = new_active_device.is_input |
| ? active_input_node_id_ |
| : active_output_node_id_; |
| // If the device we want to switch to is already the current active device, |
| // do nothing. |
| if (new_active_device.active && |
| new_active_device.id == current_active_node_id) { |
| return false; |
| } |
| |
| bool found_new_active_device = false; |
| // Reset all other input or output devices' active status. The active audio |
| // device from the previous user session can be remembered by cras, but not |
| // in chrome. see crbug.com/273271. |
| for (auto& item : audio_devices_) { |
| AudioDevice& device = item.second; |
| if (device.is_input == new_active_device.is_input && |
| device.id != new_active_device.id) { |
| device.active = false; |
| } else if (device.is_input == new_active_device.is_input && |
| device.id == new_active_device.id) { |
| found_new_active_device = true; |
| } |
| } |
| |
| if (!found_new_active_device) { |
| LOG(ERROR) << "Invalid new active device: " << new_active_device.ToString(); |
| return false; |
| } |
| |
| // Update user priority whenever the audio device is activated. |
| const AudioDevice* current_active_device = |
| GetDeviceFromId(current_active_node_id); |
| audio_pref_handler_->SetUserPriorityHigherThan(new_active_device, |
| current_active_device); |
| |
| // Set the current active input/output device to the new_active_device. |
| current_active_node_id = new_active_device.id; |
| audio_devices_[current_active_node_id].active = true; |
| return true; |
| } |
| |
| void CrasAudioHandler::SwitchToDevice(const AudioDevice& device, |
| bool notify, |
| DeviceActivateType activate_by) { |
| if (!ChangeActiveDevice(device)) { |
| // Record the decision of system not switching active device. |
| if (activate_by != DeviceActivateType::kActivateByUser) { |
| audio_device_metrics_handler_.MaybeRecordSystemSwitchDecisionAndContext( |
| device.is_input, |
| device.is_input ? has_alternative_input_ : has_alternative_output_, |
| /*is_switched=*/false, audio_devices_, previous_audio_devices_); |
| } |
| return; |
| } |
| |
| if (device.is_input) { |
| SetupAudioInputState(); |
| } else { |
| SetupAudioOutputState(); |
| } |
| |
| SetActiveDevice(device, notify, activate_by); |
| |
| // content::MediaStreamManager listens to |
| // base::SystemMonitor::DevicesChangedObserver for audio devices, |
| // and updates EnumerateDevices when OnDevicesChanged is called. |
| base::SystemMonitor* monitor = base::SystemMonitor::Get(); |
| // In some unittest, |monitor| might be nullptr. |
| if (!monitor) { |
| return; |
| } |
| monitor->ProcessDevicesChanged( |
| base::SystemMonitor::DeviceType::DEVTYPE_AUDIO); |
| } |
| |
| bool CrasAudioHandler::HasDeviceChange(const AudioNodeList& new_nodes, |
| bool is_input, |
| AudioDeviceList* new_discovered, |
| AudioDeviceList* removed_devices, |
| bool* active_device_removed) { |
| removed_devices->clear(); |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (is_input != device.is_input) { |
| continue; |
| } |
| if (!IsDeviceInList(device, new_nodes)) { |
| removed_devices->push_back(device); |
| if ((is_input && device.id == active_input_node_id_) || |
| (!is_input && device.id == active_output_node_id_)) { |
| *active_device_removed = true; |
| } |
| } |
| } |
| |
| bool new_or_changed_device = false; |
| new_discovered->clear(); |
| |
| for (const AudioNode& node : new_nodes) { |
| if (is_input != node.is_input) { |
| continue; |
| } |
| // Check if the new device is not in the old device list. |
| AudioDevice device = ConvertAudioNodeWithModifiedPriority(node); |
| DeviceStatus status = CheckDeviceStatus(device); |
| if (status == NEW_DEVICE) { |
| // When audio selection improvement flag is off, always put the new device |
| // into the new discovered device list. |
| // When audio selection improvement flag is on, only put simple usage |
| // device into new discovered device list. |
| if (!features::IsAudioSelectionImprovementEnabled() || |
| device.is_for_simple_usage()) { |
| new_discovered->push_back(device); |
| } |
| } |
| if (status == NEW_DEVICE || status == CHANGED_DEVICE) { |
| new_or_changed_device = true; |
| } |
| } |
| return new_or_changed_device || !removed_devices->empty(); |
| } |
| |
| CrasAudioHandler::DeviceStatus CrasAudioHandler::CheckDeviceStatus( |
| const AudioDevice& device) { |
| const AudioDevice* device_found = |
| GetDeviceFromStableDeviceId(device.is_input, device.stable_device_id); |
| if (!device_found) { |
| return NEW_DEVICE; |
| } |
| |
| if (!IsSameAudioDevice(device, *device_found)) { |
| LOG(ERROR) << "Different Audio devices with same stable device id:" |
| << " new device: " << device.ToString() |
| << " old device: " << device_found->ToString(); |
| return CHANGED_DEVICE; |
| } |
| if (device.active != device_found->active) { |
| return CHANGED_DEVICE; |
| } |
| return OLD_DEVICE; |
| } |
| |
| void CrasAudioHandler::NotifyActiveNodeChanged(bool is_input) { |
| if (is_input) { |
| for (auto& observer : observers_) { |
| observer.OnActiveInputNodeChanged(); |
| } |
| } else { |
| for (auto& observer : observers_) { |
| observer.OnActiveOutputNodeChanged(); |
| } |
| } |
| } |
| |
| bool CrasAudioHandler::GetActiveDeviceFromUserPref(bool is_input, |
| AudioDevice* active_device) { |
| bool found_active_device = false; |
| bool last_active_device_activate_by_user = false; |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.is_input != is_input || !device.is_for_simple_usage()) { |
| continue; |
| } |
| |
| bool active = false; |
| bool activate_by_user = false; |
| // If the device entry is not found in prefs, it is likley a new audio |
| // device plugged in after the cros is powered down. We should ignore the |
| // previously saved active device, and select the active device by priority. |
| // crbug.com/622045. |
| if (!audio_pref_handler_->GetDeviceActive(device, &active, |
| &activate_by_user)) { |
| return false; |
| } |
| |
| if (!active) { |
| continue; |
| } |
| |
| if (!found_active_device) { |
| found_active_device = true; |
| *active_device = device; |
| last_active_device_activate_by_user = activate_by_user; |
| continue; |
| } |
| |
| // Choose the best one among multiple active devices from prefs. |
| if (activate_by_user) { |
| if (last_active_device_activate_by_user) { |
| // If there are more than one active devices activated by user in the |
| // prefs, most likely, after the device was shut down, and before it |
| // is rebooted, user has plugged in some previously unplugged audio |
| // devices. For such case, it does not make sense to honor the active |
| // states in the prefs. |
| VLOG(1) << "Found more than one user activated devices in the prefs."; |
| return false; |
| } |
| // Device activated by user has higher priority than the one |
| // is not activated by user. |
| *active_device = device; |
| last_active_device_activate_by_user = true; |
| } else if (!last_active_device_activate_by_user) { |
| // If there are more than one active devices activated by priority in the |
| // prefs, most likely, cras is still enumerating the audio devices |
| // progressively. For such case, it does not make sense to honor the |
| // active states in the prefs. |
| VLOG(1) << "Found more than one active devices by priority in the prefs."; |
| return false; |
| } |
| } |
| |
| if (found_active_device && !active_device->is_for_simple_usage()) { |
| // This is an odd case which is rare but possible to happen during cras |
| // initialization depeneding the audio device enumation process. The only |
| // audio node coming from cras is an internal audio device not visible |
| // to user, such as AudioDeviceType::kPostMixLoopback. |
| return false; |
| } |
| |
| return found_active_device; |
| } |
| |
| void CrasAudioHandler::PauseAllStreams() { |
| if (media_controller_manager_) { |
| media_controller_manager_->SuspendAllSessions(); |
| } |
| } |
| |
| void CrasAudioHandler::HandleNonHotplugNodesChange( |
| bool is_input, |
| const AudioDeviceList& devices, |
| const AudioDeviceList& hotplug_devices, |
| bool has_device_change, |
| bool has_device_removed, |
| bool active_device_removed) { |
| bool has_current_active_node = |
| is_input ? active_input_node_id_ : active_output_node_id_; |
| |
| // No device change, extra NodesChanged signal received. |
| if (!has_device_change && has_current_active_node) { |
| return; |
| } |
| |
| if (!hotplug_devices.empty()) { |
| // Looks like a new chrome session starts. |
| if (features::IsAudioSelectionImprovementEnabled()) { |
| HandleSystemBoots(is_input, devices); |
| } else { |
| SwitchToPreviousActiveDeviceIfAvailable(is_input, devices); |
| } |
| return; |
| } |
| |
| if (has_device_removed) { |
| if (!active_device_removed && has_current_active_node) { |
| // Removed a non-active device, keep the current active device. |
| // Record the decision of system not switching active device. |
| audio_device_metrics_handler_.MaybeRecordSystemSwitchDecisionAndContext( |
| is_input, is_input ? has_alternative_input_ : has_alternative_output_, |
| /*is_switched=*/false, audio_devices_, previous_audio_devices_); |
| |
| // When removing a non-active device, if the preferred device in the new |
| // device set is not the currently active device, do not switch but keep |
| // the current active device. Record metrics for Rule #2. |
| if (features::IsAudioSelectionImprovementEnabled()) { |
| const std::optional<AudioDevice> preferred_device = |
| GetPreferredDeviceIfDeviceSetSeenBefore( |
| is_input, GetSimpleUsageAudioDevices(audio_devices_, is_input)); |
| if (preferred_device.has_value()) { |
| const AudioDevice* current_active_device = GetDeviceFromId( |
| is_input ? active_input_node_id_ : active_output_node_id_); |
| if (current_active_device && |
| current_active_device->stable_device_id != |
| preferred_device->stable_device_id) { |
| audio_device_metrics_handler_.RecordExceptionRulesMet( |
| is_input |
| ? AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kInputRule2UnplugNonActiveDevice |
| : AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kOutputRule2UnplugNonActiveDevice); |
| } |
| } |
| } |
| |
| return; |
| } |
| |
| // Unplugged the current active device. |
| if (active_device_removed) { |
| // Pauses active streams when the active output device is |
| // removed. |
| if (!is_input) { |
| PauseAllStreams(); |
| } |
| |
| if (!features::IsAudioSelectionImprovementEnabled()) { |
| SwitchToTopPriorityDevice(devices); |
| return; |
| } |
| |
| CHECK(features::IsAudioSelectionImprovementEnabled()); |
| |
| // If there is only one device left, activate it. |
| if (devices.size() == 1) { |
| SwitchToDevice(devices.front(), /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| return; |
| } |
| |
| // Check if the remaining device set was seen before, activate the |
| // preferred one if so, otherwise, activate the most recently active |
| // device. |
| const std::optional<AudioDevice> preferred_device = |
| GetPreferredDeviceIfDeviceSetSeenBefore( |
| is_input, GetSimpleUsageAudioDevices(audio_devices_, is_input)); |
| if (preferred_device.has_value()) { |
| SwitchToDevice(preferred_device.value(), /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| } else { |
| // Record metrics for Exception Rule #4 that unplugging an active device |
| // and the remaining device set was not seen before. |
| audio_device_metrics_handler_.RecordExceptionRulesMet( |
| is_input ? AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kInputRule4UnplugDeviceCausesUnseenSet |
| : AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kOutputRule4UnplugDeviceCausesUnseenSet); |
| |
| if (!ActivateMostRecentActiveDevice(is_input)) { |
| // Fall back to previous approach if no device in the most recently |
| // active device list is currently connected. |
| SwitchToTopPriorityDevice(devices); |
| } |
| } |
| |
| return; |
| } |
| } |
| |
| // Some unexpected error happens on cras side. See crbug.com/586026. |
| // Either cras sent stale nodes to chrome again or cras triggered some |
| // error. Restore the previously selected active. |
| VLOG(1) << "Odd case from cras, the active node is lost unexpectedly."; |
| SwitchToPreviousActiveDeviceIfAvailable(is_input, devices); |
| } |
| |
| void CrasAudioHandler::HandleSystemBoots(bool is_input, |
| const AudioDeviceList& devices) { |
| // If there is only one device, activate it. |
| if (devices.size() == 1) { |
| SwitchToDevice(devices.front(), /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| return; |
| } |
| |
| // If the set of devices was seen before, activate the preferred one. |
| const std::optional<AudioDevice> preferred_device = |
| GetPreferredDeviceIfDeviceSetSeenBefore( |
| is_input, GetSimpleUsageAudioDevices(audio_devices_, is_input)); |
| if (preferred_device.has_value()) { |
| // Activate this device. |
| SwitchToDevice(preferred_device.value(), /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| return; |
| } |
| |
| // Otherwise when the device set was not seen before, if a 3.5mm headphone is |
| // connected, activate it. Do not show notification. |
| for (const AudioDevice& device : devices) { |
| if (device.type == AudioDeviceType::kHeadphone || |
| device.type == AudioDeviceType::kMic) { |
| SwitchToDevice(device, /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| return; |
| } |
| } |
| |
| // Otherwise, activate the most recent activated device and show |
| // notification. |
| if (ActivateMostRecentActiveDevice(is_input)) { |
| should_show_notification_ = true; |
| return; |
| } |
| |
| // Otherwise when no most recent activated device, if there is an internal |
| // device, activate it and show notification. |
| for (const AudioDevice& device : devices) { |
| if (device.type == AudioDeviceType::kInternalSpeaker || |
| device.type == AudioDeviceType::kInternalMic) { |
| SwitchToDevice(device, /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| should_show_notification_ = true; |
| return; |
| } |
| } |
| |
| // Otherwise when no most recent activated device and no internal device (a |
| // brand new chromebox), activate the highest priority and show |
| // notification. |
| // TODO(zhangwenyu): Add metrics for this case to understand how frequent it |
| // happens. |
| SwitchToTopPriorityDevice(devices); |
| should_show_notification_ = true; |
| } |
| |
| bool CrasAudioHandler::ActivateMostRecentActiveDevice(bool is_input) { |
| const base::Value::List& ids = |
| audio_pref_handler_->GetMostRecentActivatedDeviceIdList(is_input); |
| for (int i = ids.size() - 1; i >= 0; i--) { |
| std::optional<uint64_t> device_stable_id = |
| ParseDeviceId(ids[i].GetString()); |
| if (!device_stable_id.has_value()) { |
| continue; |
| } |
| const AudioDevice* device = |
| GetDeviceFromStableDeviceId(is_input, *device_stable_id); |
| if (!device) { |
| continue; |
| } |
| SwitchToDevice(*device, /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| return true; |
| } |
| return false; |
| } |
| |
| bool CrasAudioHandler::ShouldSwitchToHotPlugDevice( |
| const AudioDevice& hotplug_device) const { |
| // Whenever 35mm headphone or mic is hot plugged, always pick it as the active |
| // device. |
| if (hotplug_device.type == AudioDeviceType::kHeadphone || |
| hotplug_device.type == AudioDeviceType::kMic) { |
| return true; |
| } |
| |
| const uint64_t active_node_id = |
| hotplug_device.is_input ? active_input_node_id_ : active_output_node_id_; |
| const AudioDevice* current_active_device = GetDeviceFromId(active_node_id); |
| |
| if (!current_active_device) { |
| return true; |
| } |
| |
| // Use built-in priority if hotplug_device or current_active_device has |
| // kUserPriorityNone. Otherwise the newly plugged devices will never be |
| // selected due to having user_priority = 0. |
| // current_active_device can has kUserPriorityNone, if it is a new device |
| // and it is activated when there is no active device (ex: the first active |
| // device after boot). |
| if ((hotplug_device.user_priority == kUserPriorityNone || |
| current_active_device->user_priority == kUserPriorityNone)) { |
| return LessBuiltInPriority(*current_active_device, hotplug_device); |
| } |
| |
| return LessUserPriority(*current_active_device, hotplug_device); |
| } |
| |
| void CrasAudioHandler::HandleHotPlugDeviceByUserPriority( |
| const AudioDevice& hotplug_device) { |
| // This most likely may happen during the transition period of cras |
| // initialization phase, in which a non-simple-usage node may appear like |
| // a hotplug node. |
| if (!hotplug_device.is_for_simple_usage()) { |
| return; |
| } |
| |
| if (features::IsAudioSelectionImprovementEnabled()) { |
| HandleHotPlugDeviceWithNotification(hotplug_device); |
| return; |
| } |
| |
| if (ShouldSwitchToHotPlugDevice(hotplug_device)) { |
| SwitchToDevice(hotplug_device, true, |
| DeviceActivateType::kActivateByPriority); |
| return; |
| } else { |
| // Record the decision of system not switching active device. |
| audio_device_metrics_handler_.MaybeRecordSystemSwitchDecisionAndContext( |
| hotplug_device.is_input, |
| hotplug_device.is_input ? has_alternative_input_ |
| : has_alternative_output_, |
| /*is_switched=*/false, audio_devices_, previous_audio_devices_); |
| } |
| |
| // Do not active the hotplug device. The hotplug device is not the top |
| // priority device. |
| VLOG(1) << "Hotplug device remains inactive as its previous state:" |
| << hotplug_device.ToString(); |
| } |
| |
| void CrasAudioHandler::SwitchToTopPriorityDevice( |
| const AudioDeviceList& devices) { |
| if (devices.empty()) { |
| return; |
| } |
| |
| // When the audio selection improvement flag is on, no user priority will be |
| // maintained. Use built-in priority rather than user priority. |
| AudioDevice top_device = features::IsAudioSelectionImprovementEnabled() |
| ? std::ranges::max(devices, LessBuiltInPriority) |
| : std::ranges::max(devices, LessUserPriority); |
| if (!top_device.is_for_simple_usage()) { |
| return; |
| } |
| |
| // For the dual camera and dual microphone case, choose microphone |
| // that is consistent to the active camera. |
| if (IsFrontOrRearMic(top_device) && HasDualInternalMic() && IsCameraOn()) { |
| ActivateInternalMicForActiveCamera(); |
| return; |
| } |
| |
| SwitchToDevice(top_device, true, DeviceActivateType::kActivateByPriority); |
| } |
| |
| void CrasAudioHandler::SwitchToPreviousActiveDeviceIfAvailable( |
| bool is_input, |
| const AudioDeviceList& devices) { |
| // With new audio selection mechanism, activate the most recently active |
| // device first. |
| if (features::IsAudioSelectionImprovementEnabled() && |
| ActivateMostRecentActiveDevice(is_input)) { |
| return; |
| } |
| |
| AudioDevice previous_active_device; |
| if (GetActiveDeviceFromUserPref(is_input, &previous_active_device)) { |
| DCHECK(previous_active_device.is_for_simple_usage()); |
| // Switch to previous active device stored in user prefs. |
| SwitchToDevice(previous_active_device, true, |
| DeviceActivateType::kActivateByRestorePreviousState); |
| } else { |
| // No previous active device, switch to the top priority device. |
| SwitchToTopPriorityDevice(devices); |
| } |
| } |
| |
| void CrasAudioHandler::HandleRemoveNotification(bool is_input) { |
| audio_selection_notification_handler_ |
| .RemoveNotificationIfHotpluggedDeviceDisconnected( |
| is_input, GetSimpleUsageAudioDevices(audio_devices_, is_input)); |
| } |
| |
| void CrasAudioHandler::UpdateDevicesAndSwitchActive( |
| const AudioNodeList& nodes) { |
| AudioDeviceList output_devices; |
| AudioDeviceList input_devices; |
| AudioDeviceList hotplug_output_devices; |
| AudioDeviceList hotplug_input_devices; |
| AudioDeviceList removed_output_devices; |
| AudioDeviceList removed_input_devices; |
| bool active_output_removed = false; |
| bool active_input_removed = false; |
| bool output_devices_changed = |
| HasDeviceChange(nodes, false, &hotplug_output_devices, |
| &removed_output_devices, &active_output_removed); |
| bool input_devices_changed = |
| HasDeviceChange(nodes, true, &hotplug_input_devices, |
| &removed_input_devices, &active_input_removed); |
| |
| if (!removed_input_devices.empty()) { |
| // Add grace period in case the USB device is not firmly plugged, making |
| // it disconnected and reconnected in a short period of time. In this case, |
| // the notification should not be removed. |
| remove_notification_timer_for_input_.Start( |
| FROM_HERE, kRemoveNotificationDelay, |
| base::BindOnce(&CrasAudioHandler::HandleRemoveNotification, |
| weak_ptr_factory_.GetWeakPtr(), /*is_input=*/true)); |
| } |
| |
| if (!removed_output_devices.empty()) { |
| remove_notification_timer_for_output_.Start( |
| FROM_HERE, kRemoveNotificationDelay, |
| base::BindOnce(&CrasAudioHandler::HandleRemoveNotification, |
| weak_ptr_factory_.GetWeakPtr(), /*is_input=*/false)); |
| } |
| |
| // Record consecutive devices change metrics. |
| if (input_devices_changed) { |
| audio_device_metrics_handler_.RecordConsecutiveAudioDevicsChangeTimeElapsed( |
| /*is_input=*/true, /*is_device_added=*/!hotplug_input_devices.empty()); |
| } |
| if (output_devices_changed) { |
| audio_device_metrics_handler_.RecordConsecutiveAudioDevicsChangeTimeElapsed( |
| /*is_input=*/false, |
| /*is_device_added=*/!hotplug_output_devices.empty()); |
| } |
| |
| std::vector<AudioDevice> devices; |
| devices.reserve(nodes.size()); |
| for (AudioNode node : nodes) { |
| devices.push_back(ConvertAudioNodeWithModifiedPriority(node)); |
| } |
| |
| // Updates the display_rotation to the internal speaker when it's added. |
| for (AudioDevice device : devices) { |
| DeviceStatus status = CheckDeviceStatus(device); |
| if (status == NEW_DEVICE && |
| device.type == AudioDeviceType::kInternalSpeaker) { |
| CrasAudioClient::Get()->SetDisplayRotation(device.id, display_rotation_); |
| } |
| } |
| |
| // Remove the least recently seen devices if there are too many devices. |
| audio_pref_handler_->DropLeastRecentlySeenDevices(devices, |
| kMaxDeviceStoredInPref); |
| |
| // Before audio_devices_ is cleared, saves all audio device types to |
| // previous_audio_devices_. |
| previous_audio_devices_ = audio_devices_; |
| |
| audio_devices_.clear(); |
| has_alternative_input_ = false; |
| has_alternative_output_ = false; |
| |
| // Local variables to help determine if there are more than one audio devices |
| // currently connected. Note that kInternalMic, kFrontMic and kRearMic are |
| // considered one audio device since they are all displayed as internal mic in |
| // UI and user can not switch between them. |
| bool has_internal_input_device = false; |
| bool has_external_input_device = false; |
| bool has_internal_output_device = false; |
| bool has_external_output_device = false; |
| |
| for (AudioDevice device : devices) { |
| // When audio selection improvement flag is on, ignore non simple usage |
| // devices because users can't see/select them. |
| if (features::IsAudioSelectionImprovementEnabled() && |
| !device.is_for_simple_usage()) { |
| continue; |
| } |
| |
| audio_devices_[device.id] = device; |
| |
| if (device.is_input) { |
| input_devices.push_back(device); |
| |
| // If has_alternative_input_ has already been determined as true, no need |
| // to calculate it again. |
| if (has_alternative_input_) { |
| continue; |
| } |
| |
| bool has_two_external_input_devices = |
| has_external_input_device && device.IsExternalDevice(); |
| bool has_one_internal_and_one_external_input_device = |
| has_internal_input_device && device.IsExternalDevice(); |
| bool has_one_external_and_one_internal_input_device = |
| has_external_input_device && device.IsInternalMic(); |
| if (has_two_external_input_devices || |
| has_one_internal_and_one_external_input_device || |
| has_one_external_and_one_internal_input_device) { |
| has_alternative_input_ = true; |
| } |
| |
| if (device.IsInternalMic()) { |
| has_internal_input_device = true; |
| } else if (device.IsExternalDevice()) { |
| has_external_input_device = true; |
| } |
| |
| } else { |
| output_devices.push_back(device); |
| |
| // If has_alternative_output_ has already been determined as true, no need |
| // to calculate it again. |
| if (has_alternative_output_) { |
| continue; |
| } |
| |
| bool has_two_external_output_devices = |
| has_external_output_device && device.IsExternalDevice(); |
| bool has_one_internal_and_one_external_output_device = |
| has_internal_output_device && device.IsExternalDevice(); |
| bool has_one_external_and_one_internal_output_device = |
| has_external_output_device && device.IsInternalSpeaker(); |
| if (has_two_external_output_devices || |
| has_one_internal_and_one_external_output_device || |
| has_one_external_and_one_internal_output_device) { |
| has_alternative_output_ = true; |
| } |
| |
| if (device.IsInternalSpeaker()) { |
| has_internal_output_device = true; |
| } else if (device.IsExternalDevice()) { |
| has_external_output_device = true; |
| } |
| } |
| } |
| |
| // Handle output device changes. |
| HandleAudioDeviceChange( |
| false, output_devices, hotplug_output_devices, output_devices_changed, |
| !removed_output_devices.empty(), active_output_removed); |
| |
| // Handle input device changes. |
| HandleAudioDeviceChange(true, input_devices, hotplug_input_devices, |
| input_devices_changed, !removed_input_devices.empty(), |
| active_input_removed); |
| |
| // At this moment, system has already made the switching or not switching |
| // decision, set this flag to false. |
| audio_device_metrics_handler_.set_is_chrome_restarts(false); |
| |
| if (features::IsAudioSelectionImprovementEnabled() && |
| should_show_notification_) { |
| const AudioDevice* active_input_device = |
| GetDeviceFromId(active_input_node_id_); |
| const AudioDevice* active_output_device = |
| GetDeviceFromId(active_output_node_id_); |
| audio_selection_notification_handler_.ShowAudioSelectionNotification( |
| hotplug_input_devices, hotplug_output_devices, |
| active_input_device |
| ? std::make_optional(active_input_device->display_name) |
| : std::nullopt, |
| active_output_device |
| ? std::make_optional(active_output_device->display_name) |
| : std::nullopt, |
| base::BindRepeating(&CrasAudioHandler::SwitchToDevice, |
| weak_ptr_factory_.GetWeakPtr()), |
| base::BindRepeating(&CrasAudioHandler::OpenSettingsAudioPage, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| // Reset show notification flag. |
| should_show_notification_ = false; |
| } |
| |
| // content::MediaStreamManager listens to |
| // base::SystemMonitor::DevicesChangedObserver for audio devices, |
| // and updates EnumerateDevices when OnDevicesChanged is called. |
| base::SystemMonitor* monitor = base::SystemMonitor::Get(); |
| // In some unittest, |monitor| might be nullptr. |
| if (!monitor) { |
| return; |
| } |
| monitor->ProcessDevicesChanged( |
| base::SystemMonitor::DeviceType::DEVTYPE_AUDIO); |
| } |
| |
| void CrasAudioHandler::HandleAudioDeviceChange( |
| bool is_input, |
| const AudioDeviceList& devices, |
| const AudioDeviceList& hotplug_devices, |
| bool has_device_change, |
| bool has_device_removed, |
| bool active_device_removed) { |
| uint64_t& active_node_id = |
| is_input ? active_input_node_id_ : active_output_node_id_; |
| |
| if (has_device_change) { |
| // Mark device selected by the system, including when the algorithm |
| // does nothing ultimately. We still treat not switching the device |
| // as a decision of the algorithm. |
| if (is_input) { |
| audio_device_metrics_handler_.set_input_device_selected_by_user(false); |
| } else { |
| audio_device_metrics_handler_.set_output_device_selected_by_user(false); |
| } |
| } |
| |
| // No audio devices found. |
| if (devices.empty()) { |
| VLOG(1) << "No " << (is_input ? "input" : "output") << " devices found"; |
| active_node_id = 0; |
| NotifyActiveNodeChanged(is_input); |
| return; |
| } |
| |
| // If the previous active device is removed from the new node list, |
| // or changed to inactive by cras, reset active_node_id. |
| // See crbug.com/478968. |
| const AudioDevice* active_device = GetDeviceFromId(active_node_id); |
| if (!active_device || !active_device->active) { |
| active_node_id = 0; |
| } |
| |
| if (!active_node_id || hotplug_devices.empty() || |
| hotplug_devices.size() > 1) { |
| HandleNonHotplugNodesChange(is_input, devices, hotplug_devices, |
| has_device_change, has_device_removed, |
| active_device_removed); |
| if (features::IsAudioSelectionImprovementEnabled()) { |
| SyncDevicePrefSetMap(is_input); |
| } |
| } else { |
| // Typical user hotplug case. |
| HandleHotPlugDeviceByUserPriority(hotplug_devices.front()); |
| } |
| } |
| |
| void CrasAudioHandler::HandleGetNodes(std::optional<AudioNodeList> node_list) { |
| if (!node_list.has_value()) { |
| LOG(ERROR) << "Failed to retrieve audio nodes data"; |
| return; |
| } |
| |
| if (node_list->empty()) { |
| return; |
| } |
| |
| UpdateDevicesAndSwitchActive(node_list.value()); |
| |
| // Always set the hfp_mic_sr state on NodesChange event. |
| RefreshHfpMicSrState(); |
| |
| for (auto& observer : observers_) { |
| observer.OnAudioNodesChanged(); |
| } |
| } |
| |
| void CrasAudioHandler::HandleGetNumberOfNonChromeOutputStreams( |
| std::optional<int32_t> new_output_streams_count) { |
| if (!new_output_streams_count.has_value()) { |
| LOG(ERROR) << "Failed to retrieve number of active output streams."; |
| return; |
| } |
| DCHECK_GE(*new_output_streams_count, 0); |
| |
| if (*new_output_streams_count > 0 && |
| num_active_nonchrome_output_streams_ == 0) { |
| for (auto& observer : observers_) { |
| observer.OnNonChromeOutputStarted(); |
| } |
| } else if (*new_output_streams_count == 0 && |
| num_active_nonchrome_output_streams_ > 0) { |
| for (auto& observer : observers_) { |
| observer.OnNonChromeOutputStopped(); |
| } |
| } |
| num_active_nonchrome_output_streams_ = *new_output_streams_count; |
| } |
| |
| void CrasAudioHandler::HandleGetNumActiveOutputStreams( |
| std::optional<int> new_output_streams_count) { |
| if (!new_output_streams_count.has_value()) { |
| LOG(ERROR) << "Failed to retrieve number of active output streams"; |
| return; |
| } |
| |
| DCHECK_GE(*new_output_streams_count, 0); |
| if (*new_output_streams_count > 0 && num_active_output_streams_ == 0) { |
| for (auto& observer : observers_) { |
| observer.OnOutputStarted(); |
| } |
| } else if (*new_output_streams_count == 0 && num_active_output_streams_ > 0) { |
| for (auto& observer : observers_) { |
| observer.OnOutputStopped(); |
| } |
| } |
| num_active_output_streams_ = *new_output_streams_count; |
| } |
| |
| void CrasAudioHandler::AddAdditionalActiveNode(uint64_t node_id, bool notify) { |
| const AudioDevice* device = GetDeviceFromId(node_id); |
| if (!device) { |
| VLOG(1) << "AddActiveInputNode: Cannot find device id=" << "0x" << std::hex |
| << node_id; |
| return; |
| } |
| |
| audio_devices_[node_id].active = true; |
| SetupAdditionalActiveAudioNodeState(node_id); |
| |
| if (device->is_input) { |
| DCHECK(node_id != active_input_node_id_); |
| CrasAudioClient::Get()->AddActiveInputNode(node_id); |
| if (notify) { |
| NotifyActiveNodeChanged(true); |
| } |
| } else { |
| DCHECK(node_id != active_output_node_id_); |
| CrasAudioClient::Get()->AddActiveOutputNode(node_id); |
| if (notify) { |
| NotifyActiveNodeChanged(false); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::RemoveActiveNodeInternal(uint64_t node_id, bool notify) { |
| const AudioDevice* device = GetDeviceFromId(node_id); |
| if (!device) { |
| VLOG(1) << "RemoveActiveInputNode: Cannot find device id=" << "0x" |
| << std::hex << node_id; |
| return; |
| } |
| |
| audio_devices_[node_id].active = false; |
| if (device->is_input) { |
| if (node_id == active_input_node_id_) { |
| active_input_node_id_ = 0; |
| } |
| CrasAudioClient::Get()->RemoveActiveInputNode(node_id); |
| if (notify) { |
| NotifyActiveNodeChanged(true); |
| } |
| } else { |
| if (node_id == active_output_node_id_) { |
| active_output_node_id_ = 0; |
| } |
| CrasAudioClient::Get()->RemoveActiveOutputNode(node_id); |
| if (notify) { |
| NotifyActiveNodeChanged(false); |
| } |
| } |
| } |
| |
| void CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod() { |
| VLOG(1) << "HDMI output re-discover grace period ends."; |
| hdmi_rediscovering_ = false; |
| if (!IsOutputMutedForDevice(active_output_node_id_)) { |
| // Unmute the audio output after the HDMI transition period. |
| VLOG(1) << "Unmute output after HDMI rediscovering grace period."; |
| SetOutputMuteInternal(false); |
| } |
| } |
| |
| bool CrasAudioHandler::IsHDMIPrimaryOutputDevice() const { |
| const AudioDevice* device = GetDeviceFromId(active_output_node_id_); |
| return device && device->type == AudioDeviceType::kHdmi; |
| } |
| |
| void CrasAudioHandler::StartHDMIRediscoverGracePeriod() { |
| VLOG(1) << "Start HDMI rediscovering grace period."; |
| hdmi_rediscovering_ = true; |
| hdmi_rediscover_timer_.Stop(); |
| hdmi_rediscover_timer_.Start( |
| FROM_HERE, |
| base::Milliseconds(hdmi_rediscover_grace_period_duration_in_ms_), this, |
| &CrasAudioHandler::UpdateAudioAfterHDMIRediscoverGracePeriod); |
| } |
| |
| void CrasAudioHandler::SetHDMIRediscoverGracePeriodForTesting( |
| int duration_in_ms) { |
| hdmi_rediscover_grace_period_duration_in_ms_ = duration_in_ms; |
| } |
| |
| void CrasAudioHandler::ActivateMicForCamera( |
| media::VideoFacingMode camera_facing) { |
| const AudioDevice* mic = GetMicForCamera(camera_facing); |
| if (!mic || mic->active) { |
| return; |
| } |
| |
| SwitchToDevice(*mic, true, DeviceActivateType::kActivateByCamera); |
| } |
| |
| void CrasAudioHandler::ActivateInternalMicForActiveCamera() { |
| DCHECK(IsCameraOn()); |
| if (HasDualInternalMic()) { |
| media::VideoFacingMode facing = front_camera_on_ |
| ? media::MEDIA_VIDEO_FACING_USER |
| : media::MEDIA_VIDEO_FACING_ENVIRONMENT; |
| ActivateMicForCamera(facing); |
| } |
| } |
| |
| // For the dual microphone case, from user point of view, they only see internal |
| // microphone in UI. Chrome will make the best decision on which one to pick. |
| // If the camera is off, the front microphone should be picked as the default |
| // active microphone. Otherwise, it will switch to the microphone that |
| // matches the active camera, i.e. front microphone for front camera and |
| // rear microphone for rear camera. |
| void CrasAudioHandler::SwitchToFrontOrRearMic() { |
| DCHECK(HasDualInternalMic()); |
| if (IsCameraOn()) { |
| ActivateInternalMicForActiveCamera(); |
| } else { |
| SwitchToDevice(*GetDeviceByType(AudioDeviceType::kFrontMic), true, |
| DeviceActivateType::kActivateByUser); |
| } |
| } |
| |
| const AudioDevice* CrasAudioHandler::GetMicForCamera( |
| media::VideoFacingMode camera_facing) { |
| switch (camera_facing) { |
| case media::MEDIA_VIDEO_FACING_USER: |
| return GetDeviceByType(AudioDeviceType::kFrontMic); |
| case media::MEDIA_VIDEO_FACING_ENVIRONMENT: |
| return GetDeviceByType(AudioDeviceType::kRearMic); |
| default: |
| NOTREACHED(); |
| } |
| } |
| |
| bool CrasAudioHandler::HasDualInternalMic() const { |
| bool has_front_mic = false; |
| bool has_rear_mic = false; |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (device.type == AudioDeviceType::kFrontMic) { |
| has_front_mic = true; |
| } else if (device.type == AudioDeviceType::kRearMic) { |
| has_rear_mic = true; |
| } |
| if (has_front_mic && has_rear_mic) { |
| break; |
| } |
| } |
| return has_front_mic && has_rear_mic; |
| } |
| |
| bool CrasAudioHandler::HasActiveInputDeviceForSimpleUsage() const { |
| const AudioDevice* active_input_device = |
| GetDeviceFromId(active_input_node_id_); |
| if (active_input_device) { |
| return active_input_device->is_for_simple_usage(); |
| } |
| return false; |
| } |
| |
| bool CrasAudioHandler::IsFrontOrRearMic(const AudioDevice& device) const { |
| return device.is_input && (device.type == AudioDeviceType::kFrontMic || |
| device.type == AudioDeviceType::kRearMic); |
| } |
| |
| bool CrasAudioHandler::IsCameraOn() const { |
| return front_camera_on_ || rear_camera_on_; |
| } |
| |
| bool CrasAudioHandler::HasExternalDevice(bool is_input) const { |
| for (const auto& item : audio_devices_) { |
| const AudioDevice& device = item.second; |
| if (is_input == device.is_input && device.IsExternalDevice()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void CrasAudioHandler::GetNumberOfInputStreamsWithPermissionInternal() { |
| CrasAudioClient::Get()->GetNumberOfInputStreamsWithPermission(base::BindOnce( |
| &CrasAudioHandler::HandleGetNumberOfInputStreamsWithPermission, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| // static |
| CrasAudioHandler::ClientType CrasAudioHandler::ConvertClientTypeStringToEnum( |
| std::string client_type_str) { |
| if (client_type_str == "CRAS_CLIENT_TYPE_PLUGIN") { |
| return ClientType::VM_PLUGIN; |
| } else if (client_type_str == "CRAS_CLIENT_TYPE_CROSVM") { |
| return ClientType::VM_TERMINA; |
| } else if (client_type_str == "CRAS_CLIENT_TYPE_CHROME") { |
| return ClientType::CHROME; |
| } else if (client_type_str == "CRAS_CLIENT_TYPE_ARC" || |
| client_type_str == "CRAS_CLIENT_TYPE_ARCVM") { |
| return ClientType::ARC; |
| } else if (client_type_str == "CRAS_CLIENT_TYPE_BOREALIS") { |
| return ClientType::VM_BOREALIS; |
| } else { |
| return ClientType::UNKNOWN; |
| } |
| } |
| |
| void CrasAudioHandler::HandleGetNumberOfInputStreamsWithPermission( |
| std::optional<base::flat_map<std::string, uint32_t>> num_input_streams) { |
| if (!num_input_streams.has_value()) { |
| LOG(ERROR) << "Failed to retrieve number of input streams with permission"; |
| return; |
| } |
| number_of_input_streams_with_permission_.clear(); |
| for (const auto& it : *num_input_streams) { |
| CrasAudioHandler::ClientType type = ConvertClientTypeStringToEnum(it.first); |
| if (type != ClientType::UNKNOWN) { |
| number_of_input_streams_with_permission_[type] = it.second; |
| } |
| } |
| } |
| |
| void CrasAudioHandler::GetDefaultOutputBufferSizeInternal() { |
| CrasAudioClient::Get()->GetDefaultOutputBufferSize( |
| base::BindOnce(&CrasAudioHandler::HandleGetDefaultOutputBufferSize, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetDefaultOutputBufferSize( |
| std::optional<int> buffer_size) { |
| if (!buffer_size.has_value()) { |
| LOG(ERROR) << "Failed to retrieve output buffer size"; |
| return; |
| } |
| |
| default_output_buffer_size_ = buffer_size.value(); |
| } |
| |
| bool CrasAudioHandler::noise_cancellation_supported() const { |
| return noise_cancellation_supported_; |
| } |
| |
| bool CrasAudioHandler::style_transfer_supported() const { |
| return style_transfer_supported_; |
| } |
| |
| bool CrasAudioHandler::hfp_mic_sr_supported() const { |
| return hfp_mic_sr_supported_; |
| } |
| |
| bool CrasAudioHandler::system_aec_supported() const { |
| DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| return system_aec_supported_; |
| } |
| |
| bool CrasAudioHandler::spatial_audio_supported() const { |
| return spatial_audio_supported_; |
| } |
| |
| // GetSystemAecSupported() is only called in the same thread |
| // as the CrasAudioHandler constructor. We are safe here without |
| // thread check, because unittest may not have the task runner |
| // for the current thread. |
| void CrasAudioHandler::GetSystemAecSupported() { |
| CrasAudioClient::Get()->GetSystemAecSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetSystemAecSupported, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetSystemAecSupported( |
| std::optional<bool> system_aec_supported) { |
| if (!system_aec_supported.has_value()) { |
| LOG(ERROR) << "Failed to retrieve system aec supported"; |
| return; |
| } |
| system_aec_supported_ = system_aec_supported.value(); |
| } |
| |
| int32_t CrasAudioHandler::system_aec_group_id() const { |
| DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| return system_aec_group_id_; |
| } |
| |
| // GetSystemAecGroupId() is only called in the same thread |
| // as the CrasAudioHandler constructor. We are safe here without |
| // thread check, because unittest may not have the task runner |
| // for the current thread. |
| void CrasAudioHandler::GetSystemAecGroupId() { |
| CrasAudioClient::Get()->GetSystemAecGroupId( |
| base::BindOnce(&CrasAudioHandler::HandleGetSystemAecGroupId, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetSystemAecGroupId( |
| std::optional<int32_t> system_aec_group_id) { |
| if (!system_aec_group_id.has_value()) { |
| // If the group Id is not available, set the ID to reflect that. |
| system_aec_group_id_ = kSystemAecGroupIdNotAvailable; |
| return; |
| } |
| system_aec_group_id_ = system_aec_group_id.value(); |
| } |
| |
| bool CrasAudioHandler::system_ns_supported() const { |
| DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| return system_ns_supported_; |
| } |
| |
| // GetSystemNsSupported() is only called in the same thread |
| // as the CrasAudioHandler constructor. We are safe here without |
| // thread check, because unittest may not have the task runner |
| // for the current thread. |
| void CrasAudioHandler::GetSystemNsSupported() { |
| CrasAudioClient::Get()->GetSystemNsSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetSystemNsSupported, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetSystemNsSupported( |
| std::optional<bool> system_ns_supported) { |
| if (!system_ns_supported.has_value()) { |
| LOG(ERROR) << "Failed to retrieve system ns supported"; |
| return; |
| } |
| system_ns_supported_ = system_ns_supported.value(); |
| } |
| |
| bool CrasAudioHandler::system_agc_supported() const { |
| DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| return system_agc_supported_; |
| } |
| |
| int32_t CrasAudioHandler::num_stream_ignore_ui_gains() const { |
| return num_stream_ignore_ui_gains_; |
| } |
| |
| // GetSystemAgcSupported() is only called in the same thread |
| // as the CrasAudioHandler constructor. We are safe here without |
| // thread check, because unittest may not have the task runner |
| // for the current thread. |
| void CrasAudioHandler::GetSystemAgcSupported() { |
| CrasAudioClient::Get()->GetSystemAgcSupported( |
| base::BindOnce(&CrasAudioHandler::HandleGetSystemAgcSupported, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetSystemAgcSupported( |
| std::optional<bool> system_agc_supported) { |
| if (!system_agc_supported.has_value()) { |
| LOG(ERROR) << "Failed to retrieve system agc supported"; |
| return; |
| } |
| system_agc_supported_ = system_agc_supported.value(); |
| } |
| |
| void CrasAudioHandler::GetNumStreamIgnoreUiGains() { |
| CrasAudioClient::Get()->GetNumStreamIgnoreUiGains( |
| base::BindOnce(&CrasAudioHandler::HandleGetNumStreamIgnoreUiGains, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetNumStreamIgnoreUiGains( |
| std::optional<int32_t> new_stream_ignore_ui_gains_count) { |
| if (!new_stream_ignore_ui_gains_count.has_value()) { |
| LOG(ERROR) << "Failed to retrieve number of ignore ui gains streams."; |
| return; |
| } |
| DCHECK_GE(*new_stream_ignore_ui_gains_count, 0); |
| |
| if (*new_stream_ignore_ui_gains_count != num_stream_ignore_ui_gains_) { |
| for (auto& observer : observers_) { |
| observer.OnNumStreamIgnoreUiGainsChanged( |
| *new_stream_ignore_ui_gains_count); |
| } |
| } |
| |
| num_stream_ignore_ui_gains_ = *new_stream_ignore_ui_gains_count; |
| } |
| |
| void CrasAudioHandler::GetNumberOfArcStreams() { |
| CrasAudioClient::Get()->GetNumberOfArcStreams( |
| base::BindOnce(&CrasAudioHandler::HandleGetNumberOfArcStreams, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void CrasAudioHandler::HandleGetNumberOfArcStreams( |
| std::optional<int32_t> new_num_arc_streams) { |
| if (!new_num_arc_streams.has_value()) { |
| LOG(ERROR) << "Failed to retrieve number of active ARC streams."; |
| return; |
| } |
| DCHECK_GE(*new_num_arc_streams, 0); |
| |
| if (*new_num_arc_streams != num_arc_streams_) { |
| for (auto& observer : observers_) { |
| observer.OnNumberOfArcStreamsChanged(*new_num_arc_streams); |
| } |
| } |
| |
| num_arc_streams_ = *new_num_arc_streams; |
| } |
| |
| const std::optional<AudioDevice> |
| CrasAudioHandler::GetPreferredDeviceIfDeviceSetSeenBefore( |
| bool is_input, |
| const AudioDeviceList& devices) const { |
| std::optional<uint64_t> id = |
| audio_pref_handler_->GetPreferredDeviceFromPreferenceSet(is_input, |
| devices); |
| |
| if (!id.has_value()) { |
| return std::nullopt; |
| } |
| |
| const AudioDevice* device = GetDeviceFromStableDeviceId(is_input, id.value()); |
| if (!device) { |
| return std::nullopt; |
| } |
| |
| return *device; |
| } |
| |
| void CrasAudioHandler::SyncDevicePrefSetMap(bool is_input) { |
| const uint64_t& active_node_id = |
| is_input ? active_input_node_id_ : active_output_node_id_; |
| const AudioDevice* active_device = GetDeviceFromId(active_node_id); |
| if (!active_device) { |
| VLOG(1) << "SyncDevicePrefSetMap: No active device found."; |
| // Early return since no active_device is available to sync. |
| return; |
| } |
| |
| audio_pref_handler_->UpdateDevicePreferenceSet( |
| GetSimpleUsageAudioDevices(audio_devices_, is_input), *active_device); |
| } |
| |
| void CrasAudioHandler::HandleHotPlugDeviceWithNotification( |
| const AudioDevice& hotplug_device) { |
| // Whenever a device with privilege is hot plugged, always pick it as the |
| // active device. Make sure has_privilege is called only when the |
| // kAudioSelectionImprovement flag is on. |
| CHECK(features::IsAudioSelectionImprovementEnabled()); |
| if (hotplug_device.has_privilege()) { |
| SwitchToDevice(hotplug_device, /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| |
| // Record audio selection exception rule #1. |
| audio_device_metrics_handler_.RecordExceptionRulesMet( |
| hotplug_device.is_input |
| ? AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kInputRule1HotPlugPrivilegedDevice |
| : AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kOutputRule1HotPlugPrivilegedDevice); |
| return; |
| } |
| |
| // Check if current set of audio devices was seen before. |
| const std::optional<AudioDevice> preferred_device = |
| GetPreferredDeviceIfDeviceSetSeenBefore( |
| hotplug_device.is_input, |
| GetSimpleUsageAudioDevices(audio_devices_, |
| /*is_input=*/hotplug_device.is_input)); |
| // If the device set was seen and the preferred device is the hotplug device, |
| // activate it. This is the only case that the hot plug device will be |
| // activated. |
| if (preferred_device.has_value() && |
| preferred_device->stable_device_id == hotplug_device.stable_device_id) { |
| SwitchToDevice(hotplug_device, /*notify=*/true, |
| DeviceActivateType::kActivateByPriority); |
| return; |
| } |
| |
| // Otherwise sync the device preference set map. |
| SyncDevicePrefSetMap(hotplug_device.is_input); |
| |
| if (!preferred_device.has_value()) { |
| // The device set was not seen. Show notification to let user make decision. |
| // Early return here since below metrics are not supposed to be recorded. |
| should_show_notification_ = true; |
| return; |
| } |
| |
| // Only record system switch decision metrics when the set of devices is seen |
| // but the system decides to not switch to it. Do not record if this set of |
| // device is not seen and notification is shown. Because the system |
| // technically does not make any decisions but let users make the decision. |
| audio_device_metrics_handler_.MaybeRecordSystemSwitchDecisionAndContext( |
| /*is_input=*/hotplug_device.is_input, |
| /*has_alternative_device=*/hotplug_device.is_input |
| ? has_alternative_input_ |
| : has_alternative_output_, |
| /*is_switched=*/false, audio_devices_, previous_audio_devices_); |
| |
| // If the preferred device is not the hot plug device and also not the |
| // currently activated device, do not switch but keep the currently active |
| // device activated, according to audio selection exception rule #3, detailed |
| // in go/audio-io. |
| const AudioDevice* current_active_device = GetDeviceFromId( |
| hotplug_device.is_input ? active_input_node_id_ : active_output_node_id_); |
| if (current_active_device && current_active_device->stable_device_id != |
| preferred_device->stable_device_id) { |
| audio_device_metrics_handler_.RecordExceptionRulesMet( |
| hotplug_device.is_input |
| ? AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kInputRule3HotPlugUnpreferredDevice |
| : AudioDeviceMetricsHandler::AudioSelectionExceptionRules:: |
| kOutputRule3HotPlugUnpreferredDevice); |
| } |
| } |
| |
| void CrasAudioHandler::OpenSettingsAudioPage() { |
| if (delegate_) { |
| delegate_->OpenSettingsAudioPage(); |
| } |
| } |
| |
| ScopedCrasAudioHandlerForTesting::ScopedCrasAudioHandlerForTesting() { |
| CHECK(!CrasAudioClient::Get()) |
| << "ScopedCrasAudioHandlerForTesting expects that there is no " |
| "CrasAudioClient running at its constructor."; |
| |
| fake_cras_audio_client_ = std::make_unique<FakeCrasAudioClient>(); |
| |
| CrasAudioHandler::InitializeForTesting(); |
| } |
| |
| ScopedCrasAudioHandlerForTesting::~ScopedCrasAudioHandlerForTesting() { |
| CrasAudioHandler::Shutdown(); |
| } |
| |
| CrasAudioHandler& ScopedCrasAudioHandlerForTesting::Get() { |
| return *CrasAudioHandler::Get(); |
| } |
| |
| int32_t CrasAudioHandler::NumberOfNonChromeOutputStreams() const { |
| return num_active_nonchrome_output_streams_; |
| } |
| |
| int32_t CrasAudioHandler::NumberOfChromeOutputStreams() const { |
| return num_active_output_streams_; |
| } |
| |
| int32_t CrasAudioHandler::NumberOfArcStreams() const { |
| return num_arc_streams_; |
| } |
| |
| void CrasAudioHandler::SetNumberOfArcStreamsForTesting(int32_t num) { |
| num_arc_streams_ = num; |
| } |
| |
| } // namespace ash |
