diff options
Diffstat (limited to 'dom/system/gonk/AudioManager.cpp')
| -rw-r--r-- | dom/system/gonk/AudioManager.cpp | 1412 |
1 files changed, 1412 insertions, 0 deletions
diff --git a/dom/system/gonk/AudioManager.cpp b/dom/system/gonk/AudioManager.cpp new file mode 100644 index 000000000..88dff13f7 --- /dev/null +++ b/dom/system/gonk/AudioManager.cpp @@ -0,0 +1,1412 @@ +/* Copyright 2012 Mozilla Foundation and Mozilla contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <android/log.h> +#include <cutils/properties.h> +#include <binder/IServiceManager.h> + +#include "AudioChannelService.h" +#include "AudioManager.h" + +#include "nsIObserverService.h" +#include "nsISettingsService.h" +#include "nsPrintfCString.h" + +#include "mozilla/Hal.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/MozPromise.h" +#include "mozilla/dom/ScriptSettings.h" +#include "base/message_loop.h" + +#include "BluetoothCommon.h" +#include "BluetoothHfpManagerBase.h" + +#include "nsJSUtils.h" +#include "nsThreadUtils.h" +#include "nsServiceManagerUtils.h" +#include "nsComponentManagerUtils.h" +#include "nsContentUtils.h" +#include "nsXULAppAPI.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/SettingChangeNotificationBinding.h" + +using namespace mozilla::dom; +using namespace mozilla::dom::gonk; +using namespace android; +using namespace mozilla; +using namespace mozilla::dom::bluetooth; + +#undef LOG +#define LOG(args...) __android_log_print(ANDROID_LOG_INFO, "AudioManager" , ## args) + +#define HEADPHONES_STATUS_HEADSET u"headset" +#define HEADPHONES_STATUS_HEADPHONE u"headphone" +#define HEADPHONES_STATUS_OFF u"off" +#define HEADPHONES_STATUS_UNKNOWN u"unknown" +#define HEADPHONES_STATUS_CHANGED "headphones-status-changed" +#define MOZ_SETTINGS_CHANGE_ID "mozsettings-changed" +#define AUDIO_CHANNEL_PROCESS_CHANGED "audio-channel-process-changed" +#define AUDIO_POLICY_SERVICE_NAME "media.audio_policy" +#define SETTINGS_SERVICE "@mozilla.org/settingsService;1" + +// Refer AudioService.java from Android +static const uint32_t sMaxStreamVolumeTbl[AUDIO_STREAM_CNT] = { + 5, // voice call + 15, // system + 15, // ring + 15, // music + 15, // alarm + 15, // notification + 15, // BT SCO + 15, // enforced audible + 15, // DTMF + 15, // TTS +#if ANDROID_VERSION < 19 + 15, // FM +#endif +}; + +static const uint32_t sDefaultStreamVolumeTbl[AUDIO_STREAM_CNT] = { + 3, // voice call + 8, // system + 8, // ring + 8, // music + 8, // alarm + 8, // notification + 8, // BT SCO + 15, // enforced audible // XXX Handle as fixed maximum audio setting + 8, // DTMF + 8, // TTS +#if ANDROID_VERSION < 19 + 8, // FM +#endif +}; + +static const int32_t sStreamVolumeAliasTbl[AUDIO_STREAM_CNT] = { + AUDIO_STREAM_VOICE_CALL, // voice call + AUDIO_STREAM_NOTIFICATION, // system + AUDIO_STREAM_NOTIFICATION, // ring + AUDIO_STREAM_MUSIC, // music + AUDIO_STREAM_ALARM, // alarm + AUDIO_STREAM_NOTIFICATION, // notification + AUDIO_STREAM_BLUETOOTH_SCO, // BT SCO + AUDIO_STREAM_ENFORCED_AUDIBLE,// enforced audible + AUDIO_STREAM_DTMF, // DTMF + AUDIO_STREAM_TTS, // TTS +#if ANDROID_VERSION < 19 + AUDIO_STREAM_MUSIC, // FM +#endif +}; + +static const uint32_t sChannelStreamTbl[NUMBER_OF_AUDIO_CHANNELS] = { + AUDIO_STREAM_MUSIC, // AudioChannel::Normal + AUDIO_STREAM_MUSIC, // AudioChannel::Content + AUDIO_STREAM_NOTIFICATION, // AudioChannel::Notification + AUDIO_STREAM_ALARM, // AudioChannel::Alarm + AUDIO_STREAM_VOICE_CALL, // AudioChannel::Telephony + AUDIO_STREAM_RING, // AudioChannel::Ringer + AUDIO_STREAM_ENFORCED_AUDIBLE,// AudioChannel::Publicnotification + AUDIO_STREAM_SYSTEM, // AudioChannel::System +}; + + +struct AudioDeviceInfo { + /** The string the value maps to */ + const char* tag; + /** The enum value that maps to this string */ + uint32_t value; +}; + +// Mappings audio output devices to strings. +static const AudioDeviceInfo kAudioDeviceInfos[] = { + { "earpiece", AUDIO_DEVICE_OUT_EARPIECE }, + { "speaker", AUDIO_DEVICE_OUT_SPEAKER }, + { "wired_headset", AUDIO_DEVICE_OUT_WIRED_HEADSET }, + { "wired_headphone", AUDIO_DEVICE_OUT_WIRED_HEADPHONE }, + { "bt_scoheadset", AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET }, + { "bt_a2dp", AUDIO_DEVICE_OUT_BLUETOOTH_A2DP }, +}; + +static const int kBtSampleRate = 8000; + +typedef MozPromise<bool, const char*, true> VolumeInitPromise; + +namespace mozilla { +namespace dom { +namespace gonk { + +/** + * We have five sound volume settings from UX spec, + * You can see more informations in Bug1068219. + * (1) Media : music, video, FM ... + * (2) Notification : ringer, notification ... + * (3) Alarm : alarm + * (4) Telephony : GSM call, WebRTC call + * (5) Bluetooth SCO : SCO call + **/ +struct VolumeData { + const char* mChannelName; + int32_t mStreamType; +}; + +static const VolumeData gVolumeData[] = { + {"audio.volume.content", AUDIO_STREAM_MUSIC}, + {"audio.volume.notification", AUDIO_STREAM_NOTIFICATION}, + {"audio.volume.alarm", AUDIO_STREAM_ALARM}, + {"audio.volume.telephony", AUDIO_STREAM_VOICE_CALL}, + {"audio.volume.bt_sco", AUDIO_STREAM_BLUETOOTH_SCO} +}; + +class RunnableCallTask : public Runnable +{ +public: + explicit RunnableCallTask(nsIRunnable* aRunnable) + : mRunnable(aRunnable) {} + + NS_IMETHOD Run() override + { + return mRunnable->Run(); + } +protected: + nsCOMPtr<nsIRunnable> mRunnable; +}; + +nsCOMPtr<nsISettingsServiceLock> +GetSettingServiceLock() +{ + nsresult rv; + nsCOMPtr<nsISettingsService> service = do_GetService(SETTINGS_SERVICE, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + + nsCOMPtr<nsISettingsServiceLock> lock; + rv = service->CreateLock(nullptr, getter_AddRefs(lock)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return nullptr; + } + return lock.forget(); +} + +#if ANDROID_VERSION >= 21 +class GonkAudioPortCallback : public AudioSystem::AudioPortCallback +{ +public: + virtual void onAudioPortListUpdate() + { + nsCOMPtr<nsIRunnable> runnable = + NS_NewRunnableFunction([]() { + MOZ_ASSERT(NS_IsMainThread()); + RefPtr<AudioManager> audioManager = AudioManager::GetInstance(); + NS_ENSURE_TRUE(audioManager.get(), ); + audioManager->UpdateCachedActiveDevicesForStreams(); + audioManager->MaybeUpdateVolumeSettingToDatabase(); + }); + NS_DispatchToMainThread(runnable); + } + virtual void onAudioPatchListUpdate() { } + virtual void onServiceDied() { } +}; +#endif + +void +AudioManager::HandleAudioFlingerDied() +{ + //Disable volume change notification + mIsVolumeInited = false; + + uint32_t attempt; + for (attempt = 0; attempt < 50; attempt++) { + if (defaultServiceManager()->checkService(String16(AUDIO_POLICY_SERVICE_NAME)) != 0) { + break; + } + LOG("AudioPolicyService is dead! attempt=%d", attempt); + usleep(1000 * 200); + } + + MOZ_RELEASE_ASSERT(attempt < 50); + + // Indicate to audio HAL that we start the reconfiguration phase after a media + // server crash + AudioSystem::setParameters(0, String8("restarting=true")); + + // Restore device connection states + SetAllDeviceConnectionStates(); + + // Restore call state +#if ANDROID_VERSION < 17 + AudioSystem::setPhoneState(mPhoneState); +#else + AudioSystem::setPhoneState(static_cast<audio_mode_t>(mPhoneState)); +#endif + + // Restore master volume + AudioSystem::setMasterVolume(1.0); + + // Restore stream volumes + for (uint32_t streamType = 0; streamType < AUDIO_STREAM_CNT; ++streamType) { + mStreamStates[streamType]->InitStreamVolume(); + mStreamStates[streamType]->RestoreVolumeIndexToAllDevices(); + } + + // Indicate the end of reconfiguration phase to audio HAL + AudioSystem::setParameters(0, String8("restarting=true")); + + // Enable volume change notification + mIsVolumeInited = true; + mAudioOutDevicesUpdated = 0; + MaybeUpdateVolumeSettingToDatabase(true); +} + +class VolumeInitCallback final : public nsISettingsServiceCallback +{ +public: + NS_DECL_ISUPPORTS + + VolumeInitCallback() + : mInitCounter(0) + { + mPromise = mPromiseHolder.Ensure(__func__); + } + + RefPtr<VolumeInitPromise> GetPromise() const + { + return mPromise; + } + + NS_IMETHOD Handle(const nsAString& aName, JS::Handle<JS::Value> aResult) + { + RefPtr<AudioManager> audioManager = AudioManager::GetInstance(); + MOZ_ASSERT(audioManager); + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(gVolumeData); ++idx) { + NS_ConvertASCIItoUTF16 volumeType(gVolumeData[idx].mChannelName); + if (StringBeginsWith(aName, volumeType)) { + uint32_t device = GetDeviceFromSettingName(aName); + MOZ_ASSERT(device != AUDIO_DEVICE_NONE); + if (aResult.isInt32()) { + int32_t stream = gVolumeData[idx].mStreamType; + uint32_t volIndex = aResult.toInt32(); + nsresult rv = audioManager->ValidateVolumeIndex(stream, volIndex); + if (NS_WARN_IF(NS_FAILED(rv))) { + mPromiseHolder.Reject("Error : invalid volume index.", __func__); + return rv; + } + audioManager->SetStreamVolumeForDevice(stream, volIndex, device); + } + + if (++mInitCounter == MOZ_ARRAY_LENGTH(kAudioDeviceInfos) * MOZ_ARRAY_LENGTH(gVolumeData)) { + mPromiseHolder.Resolve(true, __func__); + } + return NS_OK; + } + } + mPromiseHolder.Reject("Error : unexpected audio init event.", __func__); + return NS_OK; + } + + NS_IMETHOD HandleError(const nsAString& aName) + { + mPromiseHolder.Reject(NS_ConvertUTF16toUTF8(aName).get(), __func__); + return NS_OK; + } + +protected: + ~VolumeInitCallback() {} + + uint32_t GetDeviceFromSettingName(const nsAString& aName) const + { + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(kAudioDeviceInfos); ++idx) { + NS_ConvertASCIItoUTF16 device(kAudioDeviceInfos[idx].tag); + if (StringEndsWith(aName, device)) { + return kAudioDeviceInfos[idx].value; + } + } + return AUDIO_DEVICE_NONE; + } + + RefPtr<VolumeInitPromise> mPromise; + MozPromiseHolder<VolumeInitPromise> mPromiseHolder; + uint32_t mInitCounter; +}; + +NS_IMPL_ISUPPORTS(VolumeInitCallback, nsISettingsServiceCallback) + +static void +BinderDeadCallback(status_t aErr) +{ + if (aErr != DEAD_OBJECT) { + return; + } + + nsCOMPtr<nsIRunnable> runnable = + NS_NewRunnableFunction([]() { + MOZ_ASSERT(NS_IsMainThread()); + RefPtr<AudioManager> audioManager = AudioManager::GetInstance(); + NS_ENSURE_TRUE(audioManager.get(), ); + audioManager->HandleAudioFlingerDied(); + }); + + NS_DispatchToMainThread(runnable); +} + +bool +AudioManager::IsFmOutConnected() +{ + return mConnectedDevices.Get(AUDIO_DEVICE_OUT_FM, nullptr); +} + +NS_IMPL_ISUPPORTS(AudioManager, nsIAudioManager, nsIObserver) + +void +AudioManager::AudioOutDeviceUpdated(uint32_t aDevice) +{ + MOZ_ASSERT(audio_is_output_device(aDevice)); + mAudioOutDevicesUpdated |= aDevice; +} + +void +AudioManager::UpdateHeadsetConnectionState(hal::SwitchState aState) +{ + bool headphoneConnected = mConnectedDevices.Get(AUDIO_DEVICE_OUT_WIRED_HEADPHONE, + nullptr); + bool headsetConnected = mConnectedDevices.Get(AUDIO_DEVICE_OUT_WIRED_HEADSET, + nullptr); + if (aState == hal::SWITCH_STATE_HEADSET) { + UpdateDeviceConnectionState(true, + AUDIO_DEVICE_OUT_WIRED_HEADSET, + NS_LITERAL_CSTRING("")); + } else if (aState == hal::SWITCH_STATE_HEADPHONE) { + UpdateDeviceConnectionState(true, + AUDIO_DEVICE_OUT_WIRED_HEADPHONE, + NS_LITERAL_CSTRING("")); + } else if (aState == hal::SWITCH_STATE_OFF) { + if (headsetConnected) { + UpdateDeviceConnectionState(false, + AUDIO_DEVICE_OUT_WIRED_HEADSET, + NS_LITERAL_CSTRING("")); + } + if (headphoneConnected) { + UpdateDeviceConnectionState(false, + AUDIO_DEVICE_OUT_WIRED_HEADPHONE, + NS_LITERAL_CSTRING("")); + } + } +} + +void +AudioManager::UpdateDeviceConnectionState(bool aIsConnected, uint32_t aDevice, const nsCString& aDeviceName) +{ +#if ANDROID_VERSION >= 15 + bool isConnected = mConnectedDevices.Get(aDevice, nullptr); + if (isConnected && !aIsConnected) { + AudioSystem::setDeviceConnectionState(static_cast<audio_devices_t>(aDevice), + AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, + aDeviceName.get()); + mConnectedDevices.Remove(aDevice); + } else if(!isConnected && aIsConnected) { + AudioSystem::setDeviceConnectionState(static_cast<audio_devices_t>(aDevice), + AUDIO_POLICY_DEVICE_STATE_AVAILABLE, + aDeviceName.get()); + mConnectedDevices.Put(aDevice, aDeviceName); + } +#if ANDROID_VERSION < 21 + // Manually call it, since AudioPortCallback is not supported. + // Current volumes might be changed by updating active devices in android + // AudioPolicyManager. + MaybeUpdateVolumeSettingToDatabase(); +#endif +#else + NS_NOTREACHED("Doesn't support audio routing on GB version"); +#endif +} + +void +AudioManager::SetAllDeviceConnectionStates() +{ + for (auto iter = mConnectedDevices.Iter(); !iter.Done(); iter.Next()) { + const uint32_t& device = iter.Key(); + nsCString& deviceAddress = iter.Data(); + AudioSystem::setDeviceConnectionState(static_cast<audio_devices_t>(device), + AUDIO_POLICY_DEVICE_STATE_AVAILABLE, + deviceAddress.get()); + } +#if ANDROID_VERSION < 21 + // Manually call it, since AudioPortCallback is not supported. + // Current volumes might be changed by updating active devices in android + // AudioPolicyManager. + MaybeUpdateVolumeSettingToDatabase(true); +#endif +} + +void +AudioManager::HandleBluetoothStatusChanged(nsISupports* aSubject, + const char* aTopic, + const nsCString aAddress) +{ +#ifdef MOZ_B2G_BT + bool isConnected = false; + if (!strcmp(aTopic, BLUETOOTH_SCO_STATUS_CHANGED_ID)) { + BluetoothHfpManagerBase* hfp = + static_cast<BluetoothHfpManagerBase*>(aSubject); + isConnected = hfp->IsScoConnected(); + } else { + BluetoothProfileManagerBase* profile = + static_cast<BluetoothProfileManagerBase*>(aSubject); + isConnected = profile->IsConnected(); + } + + if (!strcmp(aTopic, BLUETOOTH_SCO_STATUS_CHANGED_ID)) { + if (isConnected) { + String8 cmd; + cmd.appendFormat("bt_samplerate=%d", kBtSampleRate); + AudioSystem::setParameters(0, cmd); + SetForceForUse(nsIAudioManager::USE_COMMUNICATION, nsIAudioManager::FORCE_BT_SCO); + } else { + int32_t force; + GetForceForUse(nsIAudioManager::USE_COMMUNICATION, &force); + if (force == nsIAudioManager::FORCE_BT_SCO) { + SetForceForUse(nsIAudioManager::USE_COMMUNICATION, nsIAudioManager::FORCE_NONE); + } + } + } else if (!strcmp(aTopic, BLUETOOTH_A2DP_STATUS_CHANGED_ID)) { + if (!isConnected && mA2dpSwitchDone) { + RefPtr<AudioManager> self = this; + nsCOMPtr<nsIRunnable> runnable = + NS_NewRunnableFunction([self, isConnected, aAddress]() { + if (self->mA2dpSwitchDone) { + return; + } + self->UpdateDeviceConnectionState(isConnected, + AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, + aAddress); + + String8 cmd("bluetooth_enabled=false"); + AudioSystem::setParameters(0, cmd); + cmd.setTo("A2dpSuspended=true"); + AudioSystem::setParameters(0, cmd); + self->mA2dpSwitchDone = true; + }); + MessageLoop::current()->PostDelayedTask( + MakeAndAddRef<RunnableCallTask>(runnable), 1000); + + mA2dpSwitchDone = false; + } else { + UpdateDeviceConnectionState(isConnected, + AUDIO_DEVICE_OUT_BLUETOOTH_A2DP, + aAddress); + String8 cmd("bluetooth_enabled=true"); + AudioSystem::setParameters(0, cmd); + cmd.setTo("A2dpSuspended=false"); + AudioSystem::setParameters(0, cmd); + mA2dpSwitchDone = true; +#if ANDROID_VERSION >= 17 + if (AudioSystem::getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA) == AUDIO_POLICY_FORCE_NO_BT_A2DP) { + SetForceForUse(AUDIO_POLICY_FORCE_FOR_MEDIA, AUDIO_POLICY_FORCE_NONE); + } +#endif + } + mBluetoothA2dpEnabled = isConnected; + } else if (!strcmp(aTopic, BLUETOOTH_HFP_STATUS_CHANGED_ID)) { + UpdateDeviceConnectionState(isConnected, + AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET, + aAddress); + UpdateDeviceConnectionState(isConnected, + AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, + aAddress); + } else if (!strcmp(aTopic, BLUETOOTH_HFP_NREC_STATUS_CHANGED_ID)) { + String8 cmd; + BluetoothHfpManagerBase* hfp = + static_cast<BluetoothHfpManagerBase*>(aSubject); + if (hfp->IsNrecEnabled()) { + cmd.setTo("bt_headset_name=<unknown>;bt_headset_nrec=on"); + AudioSystem::setParameters(0, cmd); + } else { + cmd.setTo("bt_headset_name=<unknown>;bt_headset_nrec=off"); + AudioSystem::setParameters(0, cmd); + } + } +#endif +} + +void +AudioManager::HandleAudioChannelProcessChanged() +{ + // Note: If the user answers a VoIP call (e.g. WebRTC calls) during the + // telephony call (GSM/CDMA calls) the audio manager won't set the + // PHONE_STATE_IN_COMMUNICATION audio state. Once the telephony call finishes + // the RIL plumbing sets the PHONE_STATE_NORMAL audio state. This seems to be + // an issue for the VoIP call but it is not. Once the RIL plumbing sets the + // the PHONE_STATE_NORMAL audio state the AudioManager::mPhoneAudioAgent + // member will call the NotifyStoppedPlaying() method causing that this function will + // be called again and therefore the audio manager sets the + // PHONE_STATE_IN_COMMUNICATION audio state. + + if ((mPhoneState == PHONE_STATE_IN_CALL) || + (mPhoneState == PHONE_STATE_RINGTONE)) { + return; + } + + RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate(); + bool telephonyChannelIsActive = service && service->TelephonyChannelIsActive(); + telephonyChannelIsActive ? SetPhoneState(PHONE_STATE_IN_COMMUNICATION) : + SetPhoneState(PHONE_STATE_NORMAL); +} + +nsresult +AudioManager::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) +{ + if ((strcmp(aTopic, BLUETOOTH_SCO_STATUS_CHANGED_ID) == 0) || + (strcmp(aTopic, BLUETOOTH_HFP_STATUS_CHANGED_ID) == 0) || + (strcmp(aTopic, BLUETOOTH_HFP_NREC_STATUS_CHANGED_ID) == 0) || + (strcmp(aTopic, BLUETOOTH_A2DP_STATUS_CHANGED_ID) == 0)) { + nsCString address = NS_ConvertUTF16toUTF8(nsDependentString(aData)); + if (address.IsEmpty()) { + NS_WARNING(nsPrintfCString("Invalid address of %s", aTopic).get()); + return NS_ERROR_FAILURE; + } + + HandleBluetoothStatusChanged(aSubject, aTopic, address); + return NS_OK; + } + + else if (!strcmp(aTopic, AUDIO_CHANNEL_PROCESS_CHANGED)) { + HandleAudioChannelProcessChanged(); + return NS_OK; + } + + // To process the volume control on each volume categories according to + // change of settings + else if (!strcmp(aTopic, MOZ_SETTINGS_CHANGE_ID)) { + RootedDictionary<dom::SettingChangeNotification> setting(RootingCx()); + if (!WrappedJSToDictionary(aSubject, setting)) { + return NS_OK; + } + if (!StringBeginsWith(setting.mKey, NS_LITERAL_STRING("audio.volume."))) { + return NS_OK; + } + if (!setting.mValue.isNumber()) { + return NS_OK; + } + + uint32_t volIndex = setting.mValue.toNumber(); + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(gVolumeData); ++idx) { + if (setting.mKey.EqualsASCII(gVolumeData[idx].mChannelName)) { + SetStreamVolumeIndex(gVolumeData[idx].mStreamType, volIndex); + return NS_OK; + } + } + } + + NS_WARNING("Unexpected topic in AudioManager"); + return NS_ERROR_FAILURE; +} + +static void +NotifyHeadphonesStatus(hal::SwitchState aState) +{ + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + if (aState == hal::SWITCH_STATE_HEADSET) { + obs->NotifyObservers(nullptr, HEADPHONES_STATUS_CHANGED, HEADPHONES_STATUS_HEADSET); + } else if (aState == hal::SWITCH_STATE_HEADPHONE) { + obs->NotifyObservers(nullptr, HEADPHONES_STATUS_CHANGED, HEADPHONES_STATUS_HEADPHONE); + } else if (aState == hal::SWITCH_STATE_OFF) { + obs->NotifyObservers(nullptr, HEADPHONES_STATUS_CHANGED, HEADPHONES_STATUS_OFF); + } else { + obs->NotifyObservers(nullptr, HEADPHONES_STATUS_CHANGED, HEADPHONES_STATUS_UNKNOWN); + } + } +} + +class HeadphoneSwitchObserver : public hal::SwitchObserver +{ +public: + void Notify(const hal::SwitchEvent& aEvent) { + RefPtr<AudioManager> audioManager = AudioManager::GetInstance(); + MOZ_ASSERT(audioManager); + audioManager->HandleHeadphoneSwitchEvent(aEvent); + } +}; + +void +AudioManager::HandleHeadphoneSwitchEvent(const hal::SwitchEvent& aEvent) +{ + NotifyHeadphonesStatus(aEvent.status()); + // When user pulled out the headset, a delay of routing here can avoid the leakage of audio from speaker. + if (aEvent.status() == hal::SWITCH_STATE_OFF && mSwitchDone) { + + RefPtr<AudioManager> self = this; + nsCOMPtr<nsIRunnable> runnable = + NS_NewRunnableFunction([self]() { + if (self->mSwitchDone) { + return; + } + self->UpdateHeadsetConnectionState(hal::SWITCH_STATE_OFF); + self->mSwitchDone = true; + }); + MessageLoop::current()->PostDelayedTask( + MakeAndAddRef<RunnableCallTask>(runnable), 1000); + mSwitchDone = false; + } else if (aEvent.status() != hal::SWITCH_STATE_OFF) { + UpdateHeadsetConnectionState(aEvent.status()); + mSwitchDone = true; + } + // Handle the coexistence of a2dp / headset device, latest one wins. +#if ANDROID_VERSION >= 17 + int32_t forceUse = 0; + GetForceForUse(AUDIO_POLICY_FORCE_FOR_MEDIA, &forceUse); + if (aEvent.status() != hal::SWITCH_STATE_OFF && mBluetoothA2dpEnabled) { + SetForceForUse(AUDIO_POLICY_FORCE_FOR_MEDIA, AUDIO_POLICY_FORCE_NO_BT_A2DP); + } else if (forceUse == AUDIO_POLICY_FORCE_NO_BT_A2DP) { + SetForceForUse(AUDIO_POLICY_FORCE_FOR_MEDIA, AUDIO_POLICY_FORCE_NONE); + } +#endif +} + +AudioManager::AudioManager() + : mPhoneState(PHONE_STATE_CURRENT) + , mIsVolumeInited(false) + , mAudioOutDevicesUpdated(0) + , mSwitchDone(true) +#if defined(MOZ_B2G_BT) || ANDROID_VERSION >= 17 + , mBluetoothA2dpEnabled(false) +#endif +#ifdef MOZ_B2G_BT + , mA2dpSwitchDone(true) +#endif + , mObserver(new HeadphoneSwitchObserver()) +{ + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(kAudioDeviceInfos); ++idx) { + mAudioDeviceTableIdMaps.Put(kAudioDeviceInfos[idx].value, idx); + } + + AudioSystem::setErrorCallback(BinderDeadCallback); +#if ANDROID_VERSION >= 21 + android::sp<GonkAudioPortCallback> callback = new GonkAudioPortCallback(); + AudioSystem::setAudioPortCallback(callback); +#endif + + // Create VolumeStreamStates + for (uint32_t loop = 0; loop < AUDIO_STREAM_CNT; ++loop) { + VolumeStreamState* streamState = + new VolumeStreamState(*this, static_cast<audio_stream_type_t>(loop)); + mStreamStates.AppendElement(streamState); + } + // Initialize stream volumes with default values + for (int32_t streamType = 0; streamType < AUDIO_STREAM_MAX; streamType++) { + uint32_t volIndex = sDefaultStreamVolumeTbl[streamType]; + SetStreamVolumeForDevice(streamType, volIndex, AUDIO_DEVICE_OUT_DEFAULT); + } + UpdateCachedActiveDevicesForStreams(); + + RegisterSwitchObserver(hal::SWITCH_HEADPHONES, mObserver); + // Initialize headhone/heaset status + UpdateHeadsetConnectionState(hal::GetCurrentSwitchState(hal::SWITCH_HEADPHONES)); + NotifyHeadphonesStatus(hal::GetCurrentSwitchState(hal::SWITCH_HEADPHONES)); + + // Get the initial volume index from settings DB during boot up. + InitVolumeFromDatabase(); + + // Gecko only control stream volume not master so set to default value + // directly. + AudioSystem::setMasterVolume(1.0); + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + NS_ENSURE_TRUE_VOID(obs); + if (NS_FAILED(obs->AddObserver(this, BLUETOOTH_SCO_STATUS_CHANGED_ID, false))) { + NS_WARNING("Failed to add bluetooth sco status changed observer!"); + } + if (NS_FAILED(obs->AddObserver(this, BLUETOOTH_A2DP_STATUS_CHANGED_ID, false))) { + NS_WARNING("Failed to add bluetooth a2dp status changed observer!"); + } + if (NS_FAILED(obs->AddObserver(this, BLUETOOTH_HFP_STATUS_CHANGED_ID, false))) { + NS_WARNING("Failed to add bluetooth hfp status changed observer!"); + } + if (NS_FAILED(obs->AddObserver(this, BLUETOOTH_HFP_NREC_STATUS_CHANGED_ID, false))) { + NS_WARNING("Failed to add bluetooth hfp NREC status changed observer!"); + } + if (NS_FAILED(obs->AddObserver(this, MOZ_SETTINGS_CHANGE_ID, false))) { + NS_WARNING("Failed to add mozsettings-changed observer!"); + } + if (NS_FAILED(obs->AddObserver(this, AUDIO_CHANNEL_PROCESS_CHANGED, false))) { + NS_WARNING("Failed to add audio-channel-process-changed observer!"); + } + +} + +AudioManager::~AudioManager() { + AudioSystem::setErrorCallback(nullptr); +#if ANDROID_VERSION >= 21 + AudioSystem::setAudioPortCallback(nullptr); +#endif + hal::UnregisterSwitchObserver(hal::SWITCH_HEADPHONES, mObserver); + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + NS_ENSURE_TRUE_VOID(obs); + if (NS_FAILED(obs->RemoveObserver(this, BLUETOOTH_SCO_STATUS_CHANGED_ID))) { + NS_WARNING("Failed to remove bluetooth sco status changed observer!"); + } + if (NS_FAILED(obs->RemoveObserver(this, BLUETOOTH_A2DP_STATUS_CHANGED_ID))) { + NS_WARNING("Failed to remove bluetooth a2dp status changed observer!"); + } + if (NS_FAILED(obs->RemoveObserver(this, BLUETOOTH_HFP_STATUS_CHANGED_ID))) { + NS_WARNING("Failed to remove bluetooth hfp status changed observer!"); + } + if (NS_FAILED(obs->RemoveObserver(this, BLUETOOTH_HFP_NREC_STATUS_CHANGED_ID))) { + NS_WARNING("Failed to remove bluetooth hfp NREC status changed observer!"); + } + if (NS_FAILED(obs->RemoveObserver(this, MOZ_SETTINGS_CHANGE_ID))) { + NS_WARNING("Failed to remove mozsettings-changed observer!"); + } + if (NS_FAILED(obs->RemoveObserver(this, AUDIO_CHANNEL_PROCESS_CHANGED))) { + NS_WARNING("Failed to remove audio-channel-process-changed!"); + } +} + +static StaticRefPtr<AudioManager> sAudioManager; + +already_AddRefed<AudioManager> +AudioManager::GetInstance() +{ + // Avoid createing AudioManager from content process. + if (!XRE_IsParentProcess()) { + MOZ_CRASH("Non-chrome processes should not get here."); + } + + // Avoid createing multiple AudioManager instance inside main process. + if (!sAudioManager) { + sAudioManager = new AudioManager(); + ClearOnShutdown(&sAudioManager); + } + + RefPtr<AudioManager> audioMgr = sAudioManager.get(); + return audioMgr.forget(); +} + +NS_IMETHODIMP +AudioManager::GetMicrophoneMuted(bool* aMicrophoneMuted) +{ + + if (AudioSystem::isMicrophoneMuted(aMicrophoneMuted)) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +NS_IMETHODIMP +AudioManager::SetMicrophoneMuted(bool aMicrophoneMuted) +{ + if (!AudioSystem::muteMicrophone(aMicrophoneMuted)) { + return NS_OK; + } + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +AudioManager::GetPhoneState(int32_t* aState) +{ + *aState = mPhoneState; + return NS_OK; +} + +NS_IMETHODIMP +AudioManager::SetPhoneState(int32_t aState) +{ + if (mPhoneState == aState) { + return NS_OK; + } + + nsCOMPtr<nsIObserverService> obs = services::GetObserverService(); + if (obs) { + nsString state; + state.AppendInt(aState); + obs->NotifyObservers(nullptr, "phone-state-changed", state.get()); + } + +#if ANDROID_VERSION < 17 + if (AudioSystem::setPhoneState(aState)) { +#else + if (AudioSystem::setPhoneState(static_cast<audio_mode_t>(aState))) { +#endif + return NS_ERROR_FAILURE; + } + +#if ANDROID_VERSION < 21 + // Manually call it, since AudioPortCallback is not supported. + // Current volumes might be changed by updating active devices in android + // AudioPolicyManager. + MaybeUpdateVolumeSettingToDatabase(); +#endif + mPhoneState = aState; + return NS_OK; +} + +NS_IMETHODIMP +AudioManager::SetForceForUse(int32_t aUsage, int32_t aForce) +{ +#if ANDROID_VERSION >= 15 + status_t status = AudioSystem::setForceUse( + (audio_policy_force_use_t)aUsage, + (audio_policy_forced_cfg_t)aForce); +#if ANDROID_VERSION < 21 + // Manually call it, since AudioPortCallback is not supported. + // Current volumes might be changed by updating active devices in android + // AudioPolicyManager. + MaybeUpdateVolumeSettingToDatabase(); +#endif + return status ? NS_ERROR_FAILURE : NS_OK; +#else + NS_NOTREACHED("Doesn't support force routing on GB version"); + return NS_ERROR_UNEXPECTED; +#endif +} + +NS_IMETHODIMP +AudioManager::GetForceForUse(int32_t aUsage, int32_t* aForce) { +#if ANDROID_VERSION >= 15 + *aForce = AudioSystem::getForceUse((audio_policy_force_use_t)aUsage); + return NS_OK; +#else + NS_NOTREACHED("Doesn't support force routing on GB version"); + return NS_ERROR_UNEXPECTED; +#endif +} + +NS_IMETHODIMP +AudioManager::SetAudioChannelVolume(uint32_t aChannel, uint32_t aIndex) +{ + if (aChannel >= NUMBER_OF_AUDIO_CHANNELS) { + return NS_ERROR_INVALID_ARG; + } + + return SetStreamVolumeIndex(sChannelStreamTbl[aChannel], aIndex); +} + +NS_IMETHODIMP +AudioManager::GetAudioChannelVolume(uint32_t aChannel, uint32_t* aIndex) +{ + if (aChannel >= NUMBER_OF_AUDIO_CHANNELS) { + return NS_ERROR_INVALID_ARG; + } + + if (!aIndex) { + return NS_ERROR_NULL_POINTER; + } + + return GetStreamVolumeIndex(sChannelStreamTbl[aChannel], aIndex); +} + +NS_IMETHODIMP +AudioManager::GetMaxAudioChannelVolume(uint32_t aChannel, uint32_t* aMaxIndex) +{ + if (aChannel >= NUMBER_OF_AUDIO_CHANNELS) { + return NS_ERROR_INVALID_ARG; + } + + if (!aMaxIndex) { + return NS_ERROR_NULL_POINTER; + } + + *aMaxIndex = mStreamStates[sChannelStreamTbl[aChannel]]->GetMaxIndex(); + return NS_OK; +} + +nsresult +AudioManager::ValidateVolumeIndex(int32_t aStream, uint32_t aIndex) const +{ + if (aStream <= AUDIO_STREAM_DEFAULT || aStream >= AUDIO_STREAM_MAX) { + return NS_ERROR_INVALID_ARG; + } + + uint32_t maxIndex = mStreamStates[aStream]->GetMaxIndex(); + if (aIndex > maxIndex) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +nsresult +AudioManager::SetStreamVolumeForDevice(int32_t aStream, + uint32_t aIndex, + uint32_t aDevice) +{ + if (aStream <= AUDIO_STREAM_DEFAULT || aStream >= AUDIO_STREAM_MAX) { + return NS_ERROR_INVALID_ARG; + } + + int32_t streamAlias = sStreamVolumeAliasTbl[aStream]; + VolumeStreamState* streamState = mStreamStates[streamAlias].get(); + return streamState->SetVolumeIndexToAliasStreams(aIndex, aDevice); +} + +nsresult +AudioManager::SetStreamVolumeIndex(int32_t aStream, uint32_t aIndex) +{ + if (aStream <= AUDIO_STREAM_DEFAULT || aStream >= AUDIO_STREAM_MAX) { + return NS_ERROR_INVALID_ARG; + } + + int32_t streamAlias = sStreamVolumeAliasTbl[aStream]; + + nsresult rv; + for (int32_t streamType = 0; streamType < AUDIO_STREAM_MAX; streamType++) { + if (streamAlias == sStreamVolumeAliasTbl[streamType]) { + rv = mStreamStates[streamType]->SetVolumeIndexToActiveDevices(aIndex); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + } + + // AUDIO_STREAM_FM is not used on recent gonk. + // AUDIO_STREAM_MUSIC is used for FM radio volume control. +#if ANDROID_VERSION < 19 + if (streamAlias == AUDIO_STREAM_MUSIC && IsFmOutConnected()) { + rv = mStreamStates[AUDIO_STREAM_FM]-> + SetVolumeIndex(aIndex, AUDIO_DEVICE_OUT_FM); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } +#endif + + MaybeUpdateVolumeSettingToDatabase(); + return NS_OK; +} + +nsresult +AudioManager::GetStreamVolumeIndex(int32_t aStream, uint32_t *aIndex) +{ + if (!aIndex) { + return NS_ERROR_INVALID_ARG; + } + + if (aStream <= AUDIO_STREAM_DEFAULT || aStream >= AUDIO_STREAM_MAX) { + return NS_ERROR_INVALID_ARG; + } + + *aIndex = mStreamStates[aStream]->GetVolumeIndex(); + return NS_OK; +} + +nsAutoCString +AudioManager::AppendDeviceToVolumeSetting(const char* aName, uint32_t aDevice) +{ + nsAutoCString topic; + topic.Assign(aName); + topic.Append("."); + uint32_t index = 0; + DebugOnly<bool> exist = mAudioDeviceTableIdMaps.Get(aDevice, &index); + MOZ_ASSERT(exist); + topic.Append(kAudioDeviceInfos[index].tag); + return topic; +} + +void +AudioManager::InitVolumeFromDatabase() +{ + nsresult rv; + nsCOMPtr<nsISettingsService> service = do_GetService(SETTINGS_SERVICE, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + nsCOMPtr<nsISettingsServiceLock> lock; + rv = service->CreateLock(nullptr, getter_AddRefs(lock)); + if (NS_WARN_IF(NS_FAILED(rv))) { + return; + } + + RefPtr<VolumeInitCallback> callback = new VolumeInitCallback(); + MOZ_ASSERT(callback); + callback->GetPromise()->Then(AbstractThread::MainThread(), __func__, this, + &AudioManager::InitDeviceVolumeSucceeded, + &AudioManager::InitDeviceVolumeFailed); + + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(gVolumeData); ++idx) { + for (uint32_t idx2 = 0; idx2 < MOZ_ARRAY_LENGTH(kAudioDeviceInfos); ++idx2) { + lock->Get(AppendDeviceToVolumeSetting(gVolumeData[idx].mChannelName, + kAudioDeviceInfos[idx2].value).get(), + callback); + } + } +} + +void +AudioManager::InitDeviceVolumeSucceeded() +{ + mIsVolumeInited = true; + MaybeUpdateVolumeSettingToDatabase(true); +} + +void +AudioManager::InitDeviceVolumeFailed(const char* aError) +{ + // Default volume of AUDIO_DEVICE_OUT_DEFAULT is already set. + mIsVolumeInited = true; + MaybeUpdateVolumeSettingToDatabase(true); + NS_WARNING(aError); +} + +void +AudioManager::MaybeUpdateVolumeSettingToDatabase(bool aForce) +{ + if (!mIsVolumeInited) { + return; + } + + nsCOMPtr<nsISettingsServiceLock> lock = GetSettingServiceLock(); + if (NS_WARN_IF(!lock)) { + return; + } + + // Send events to update the Gaia volumes + JS::Rooted<JS::Value> value(RootingCx()); + uint32_t volume = 0; + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(gVolumeData); ++idx) { + int32_t streamType = gVolumeData[idx].mStreamType; + VolumeStreamState* streamState = mStreamStates[streamType].get(); + if(!aForce && !streamState->IsDevicesChanged()) { + continue; + } + // Get volume index of active device. + volume = streamState->GetVolumeIndex(); + value.setInt32(volume); + lock->Set(gVolumeData[idx].mChannelName, value, nullptr, nullptr); + } + + // For reducing the code dependency, Gaia doesn't need to know the + // device volume, it only need to care about different volume categories. + // However, we need to send the setting volume to the permanent database, + // so that we can store the volume setting even if the phone reboots. + + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(gVolumeData); ++idx) { + int32_t streamType = gVolumeData[idx].mStreamType; + VolumeStreamState* streamState = mStreamStates[streamType].get(); + + if(!streamState->IsVolumeIndexesChanged()) { + continue; + } + + uint32_t remainingDevices = mAudioOutDevicesUpdated; + for (uint32_t i = 0; remainingDevices != 0; i++) { + uint32_t device = (1 << i); + if ((device & remainingDevices) == 0) { + continue; + } + remainingDevices &= ~device; + if (!mAudioDeviceTableIdMaps.Get(device, nullptr)) { + continue; + } + volume = streamState->GetVolumeIndex(device); + value.setInt32(volume); + lock->Set(AppendDeviceToVolumeSetting(gVolumeData[idx].mChannelName, + device).get(), + value, nullptr, nullptr); + } + } + + // Clear changed flags + for (uint32_t idx = 0; idx < MOZ_ARRAY_LENGTH(gVolumeData); ++idx) { + int32_t streamType = gVolumeData[idx].mStreamType; + mStreamStates[streamType]->ClearDevicesChanged(); + mStreamStates[streamType]->ClearVolumeIndexesChanged(); + } + // Clear mAudioOutDevicesUpdated + mAudioOutDevicesUpdated = 0; +} + +void +AudioManager::UpdateCachedActiveDevicesForStreams() +{ + // This function updates cached active devices for streams. + // It is used for optimization of GetDevicesForStream() since L. + // AudioManager could know when active devices + // are changed in AudioPolicyManager by onAudioPortListUpdate(). + // Except it, AudioManager normally do not need to ask AuidoPolicyManager + // about current active devices of streams and could use cached values. + // Before L, onAudioPortListUpdate() does not exist and GetDevicesForStream() + // does not use the cache. Therefore this function do nothing. +#if ANDROID_VERSION >= 21 + for (int32_t streamType = 0; streamType < AUDIO_STREAM_MAX; streamType++) { + // Update cached active devices of stream + mStreamStates[streamType]->IsDevicesChanged(false /* aFromCache */); + } +#endif +} + +uint32_t +AudioManager::GetDevicesForStream(int32_t aStream, bool aFromCache) +{ +#if ANDROID_VERSION >= 21 + // Since Lollipop, devices update could be notified by AudioPortCallback. + // Cached values can be used if there is no update. + if (aFromCache) { + return mStreamStates[aStream]->GetLastDevices(); + } +#endif + +#if ANDROID_VERSION >= 17 + audio_devices_t devices = + AudioSystem::getDevicesForStream(static_cast<audio_stream_type_t>(aStream)); + + return static_cast<uint32_t>(devices); +#else + // Per audio out device volume is not supported. + // Use AUDIO_DEVICE_OUT_SPEAKER just to store audio volume to DB. + return AUDIO_DEVICE_OUT_SPEAKER; +#endif +} + +uint32_t +AudioManager::GetDeviceForStream(int32_t aStream) +{ + uint32_t devices = + GetDevicesForStream(static_cast<audio_stream_type_t>(aStream)); + uint32_t device = SelectDeviceFromDevices(devices); + return device; +} + +/* static */ uint32_t +AudioManager::SelectDeviceFromDevices(uint32_t aOutDevices) +{ + uint32_t device = aOutDevices; + + // See android AudioService.getDeviceForStream(). + // AudioPolicyManager expects it. + // See also android AudioPolicyManager::getDeviceForVolume(). + if ((device & (device - 1)) != 0) { + // Multiple device selection. + if ((device & AUDIO_DEVICE_OUT_SPEAKER) != 0) { + device = AUDIO_DEVICE_OUT_SPEAKER; +#if ANDROID_VERSION >= 21 + } else if ((device & AUDIO_DEVICE_OUT_HDMI_ARC) != 0) { + device = AUDIO_DEVICE_OUT_HDMI_ARC; + } else if ((device & AUDIO_DEVICE_OUT_SPDIF) != 0) { + device = AUDIO_DEVICE_OUT_SPDIF; + } else if ((device & AUDIO_DEVICE_OUT_AUX_LINE) != 0) { + device = AUDIO_DEVICE_OUT_AUX_LINE; +#endif + } else { + device &= AUDIO_DEVICE_OUT_ALL_A2DP; + } + } + MOZ_ASSERT(audio_is_output_device(device)); + return device; +} +AudioManager::VolumeStreamState::VolumeStreamState(AudioManager& aManager, + int32_t aStreamType) + : mManager(aManager) + , mStreamType(aStreamType) + , mLastDevices(0) + , mIsDevicesChanged(true) + , mIsVolumeIndexesChanged(true) +{ + InitStreamVolume(); +} + +bool +AudioManager::VolumeStreamState::IsDevicesChanged(bool aFromCache) +{ + uint32_t devices = mManager.GetDevicesForStream(mStreamType, aFromCache); + if (devices != mLastDevices) { + mLastDevices = devices; + mIsDevicesChanged = true; + } + return mIsDevicesChanged; +} + +void +AudioManager::VolumeStreamState::ClearDevicesChanged() +{ + mIsDevicesChanged = false; +} + +bool +AudioManager::VolumeStreamState::IsVolumeIndexesChanged() +{ + return mIsVolumeIndexesChanged; +} + +void +AudioManager::VolumeStreamState::ClearVolumeIndexesChanged() +{ + mIsVolumeIndexesChanged = false; +} + +void +AudioManager::VolumeStreamState::InitStreamVolume() +{ + AudioSystem::initStreamVolume(static_cast<audio_stream_type_t>(mStreamType), + 0, + GetMaxIndex()); +} + +uint32_t +AudioManager::VolumeStreamState::GetMaxIndex() +{ + return sMaxStreamVolumeTbl[mStreamType]; +} + +uint32_t +AudioManager::VolumeStreamState::GetDefaultIndex() +{ + return sDefaultStreamVolumeTbl[mStreamType]; +} + +uint32_t +AudioManager::VolumeStreamState::GetVolumeIndex() +{ + uint32_t device = mManager.GetDeviceForStream(mStreamType); + return GetVolumeIndex(device); +} + +uint32_t +AudioManager::VolumeStreamState::GetVolumeIndex(uint32_t aDevice) +{ + uint32_t index = 0; + bool ret = mVolumeIndexes.Get(aDevice, &index); + if (!ret) { + index = mVolumeIndexes.Get(AUDIO_DEVICE_OUT_DEFAULT); + } + return index; +} + +nsresult +AudioManager::VolumeStreamState::SetVolumeIndexToActiveDevices(uint32_t aIndex) +{ + uint32_t device = mManager.GetDeviceForStream(mStreamType); + + // Update volume index for device + uint32_t oldVolumeIndex = 0; + bool exist = mVolumeIndexes.Get(device, &oldVolumeIndex); + if (exist && aIndex == oldVolumeIndex) { + // No update + return NS_OK; + } + + // AudioPolicyManager::setStreamVolumeIndex() set volumes of all active + // devices for stream. + nsresult rv; + rv = SetVolumeIndexToConsistentDeviceIfNeeded(aIndex, device); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + return NS_OK; +} + +nsresult +AudioManager::VolumeStreamState::SetVolumeIndexToAliasStreams(uint32_t aIndex, + uint32_t aDevice) +{ + uint32_t oldVolumeIndex = 0; + bool exist = mVolumeIndexes.Get(aDevice, &oldVolumeIndex); + if (exist && aIndex == oldVolumeIndex) { + // No update + return NS_OK; + } + + nsresult rv = SetVolumeIndexToConsistentDeviceIfNeeded(aIndex, aDevice); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + for (int32_t streamType = 0; streamType < AUDIO_STREAM_MAX; streamType++) { + if ((streamType != mStreamType) && + sStreamVolumeAliasTbl[streamType] == mStreamType) { + // Rescaling of index is not necessary. + rv = mManager.mStreamStates[streamType]-> + SetVolumeIndexToAliasStreams(aIndex, aDevice); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + } + + return NS_OK; +} + +nsresult +AudioManager::VolumeStreamState::SetVolumeIndexToConsistentDeviceIfNeeded(uint32_t aIndex, uint32_t aDevice) +{ + nsresult rv; + if (aDevice == AUDIO_DEVICE_OUT_SPEAKER || aDevice == AUDIO_DEVICE_OUT_EARPIECE) { + // Set AUDIO_DEVICE_OUT_SPEAKER and AUDIO_DEVICE_OUT_EARPIECE to same volume. + rv = SetVolumeIndex(aIndex, AUDIO_DEVICE_OUT_SPEAKER); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + rv = SetVolumeIndex(aIndex, AUDIO_DEVICE_OUT_EARPIECE); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } else { + // No alias device + rv = SetVolumeIndex(aIndex, aDevice); + } + return rv; +} + +nsresult +AudioManager::VolumeStreamState::SetVolumeIndex(uint32_t aIndex, + uint32_t aDevice, + bool aUpdateCache) +{ + status_t rv; +#if ANDROID_VERSION >= 17 + if (aUpdateCache) { + mVolumeIndexes.Put(aDevice, aIndex); + mIsVolumeIndexesChanged = true; + mManager.AudioOutDeviceUpdated(aDevice); + } + + rv = AudioSystem::setStreamVolumeIndex( + static_cast<audio_stream_type_t>(mStreamType), + aIndex, + aDevice); + return rv ? NS_ERROR_FAILURE : NS_OK; +#else + if (aUpdateCache) { + // Per audio out device volume is not supported. + // Use AUDIO_DEVICE_OUT_SPEAKER just to store audio volume to DB. + mVolumeIndexes.Put(AUDIO_DEVICE_OUT_SPEAKER, aIndex); + mIsVolumeIndexesChanged = true; + mManager.AudioOutDeviceUpdated(AUDIO_DEVICE_OUT_SPEAKER); + } + rv = AudioSystem::setStreamVolumeIndex( + static_cast<audio_stream_type_t>(mStreamType), + aIndex); + return rv ? NS_ERROR_FAILURE : NS_OK; +#endif +} + +void +AudioManager::VolumeStreamState::RestoreVolumeIndexToAllDevices() +{ + for (auto iter = mVolumeIndexes.Iter(); !iter.Done(); iter.Next()) { + const uint32_t& key = iter.Key(); + uint32_t& index = iter.Data(); + SetVolumeIndex(key, index, /* aUpdateCache */ false); + } +} + +} /* namespace gonk */ +} /* namespace dom */ +} /* namespace mozilla */ |