AudioSystem: Add thread safety annotations
Use std::mutex and std::lock_guard
Update naming of mutex variables to use mutex vs lock.
Test: atest CtsMediaAudioTestCases
Bug: 326474970
Change-Id: Iffd72f06d51709cc28bc4adf5a71269c4b540b50
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index 6cc5d63..d723493 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -188,6 +188,7 @@
"-Wall",
"-Werror",
"-Wno-error=deprecated-declarations",
+ "-Wthread-safety",
],
sanitize: {
misc_undefined: [
diff --git a/media/libaudioclient/AudioSystem.cpp b/media/libaudioclient/AudioSystem.cpp
index 348e25f..1b13f3b 100644
--- a/media/libaudioclient/AudioSystem.cpp
+++ b/media/libaudioclient/AudioSystem.cpp
@@ -65,36 +65,37 @@
using media::audio::common::AudioUsage;
using media::audio::common::Int;
-// client singleton for AudioFlinger binder interface
-Mutex AudioSystem::gLock;
-Mutex AudioSystem::gLockErrorCallbacks;
-Mutex AudioSystem::gLockAPS;
+std::mutex AudioSystem::gMutex;
sp<IAudioFlinger> AudioSystem::gAudioFlinger;
+sp<IBinder> AudioSystem::gAudioFlingerBinder;
+sp<IAudioFlinger> AudioSystem::gLocalAudioFlinger;
sp<AudioSystem::AudioFlingerClient> AudioSystem::gAudioFlingerClient;
-std::set<audio_error_callback> AudioSystem::gAudioErrorCallbacks;
dynamic_policy_callback AudioSystem::gDynPolicyCallback = NULL;
record_config_callback AudioSystem::gRecordConfigCallback = NULL;
routing_callback AudioSystem::gRoutingCallback = NULL;
vol_range_init_req_callback AudioSystem::gVolRangeInitReqCallback = NULL;
-// Required to be held while calling into gSoundTriggerCaptureStateListener.
-class CaptureStateListenerImpl;
+std::mutex AudioSystem::gErrorCallbacksMutex;
+std::set<audio_error_callback> AudioSystem::gAudioErrorCallbacks;
-Mutex gSoundTriggerCaptureStateListenerLock;
-sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener = nullptr;
+std::mutex AudioSystem::gSoundTriggerMutex;
+sp<CaptureStateListenerImpl> AudioSystem::gSoundTriggerCaptureStateListener;
-// Binder for the AudioFlinger service that's passed to this client process from the system server.
+std::mutex AudioSystem::gAPSMutex;
+sp<IAudioPolicyService> AudioSystem::gAudioPolicyService;
+sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient;
+
+// Sets the Binder for the AudioFlinger service, passed to this client process
+// from the system server.
// This allows specific isolated processes to access the audio system. Currently used only for the
// HotwordDetectionService.
-static sp<IBinder> gAudioFlingerBinder = nullptr;
-
void AudioSystem::setAudioFlingerBinder(const sp<IBinder>& audioFlinger) {
if (audioFlinger->getInterfaceDescriptor() != media::IAudioFlingerService::descriptor) {
ALOGE("setAudioFlingerBinder: received a binder of type %s",
String8(audioFlinger->getInterfaceDescriptor()).c_str());
return;
}
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
if (gAudioFlinger != nullptr) {
ALOGW("setAudioFlingerBinder: ignoring; AudioFlinger connection already established.");
return;
@@ -102,10 +103,8 @@
gAudioFlingerBinder = audioFlinger;
}
-static sp<IAudioFlinger> gLocalAudioFlinger; // set if we are local.
-
status_t AudioSystem::setLocalAudioFlinger(const sp<IAudioFlinger>& af) {
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
if (gAudioFlinger != nullptr) return INVALID_OPERATION;
gLocalAudioFlinger = af;
return OK;
@@ -117,7 +116,7 @@
sp<AudioFlingerClient> afc;
bool reportNoError = false;
{
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
if (gAudioFlinger != nullptr) {
return gAudioFlinger;
}
@@ -172,7 +171,7 @@
// calling get_audio_flinger() will initialize gAudioFlingerClient if needed
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return 0;
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
return gAudioFlingerClient;
}
@@ -308,23 +307,23 @@
// convert volume steps to natural log scale
// change this value to change volume scaling
-static const float dBPerStep = 0.5f;
+constexpr float kdbPerStep = 0.5f;
// shouldn't need to touch these
-static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
-static const float dBConvertInverse = 1.0f / dBConvert;
+constexpr float kdBConvert = -kdbPerStep * 2.302585093f / 20.0f;
+constexpr float kdBConvertInverse = 1.0f / kdBConvert;
float AudioSystem::linearToLog(int volume) {
- // float v = volume ? exp(float(100 - volume) * dBConvert) : 0;
+ // float v = volume ? exp(float(100 - volume) * kdBConvert) : 0;
// ALOGD("linearToLog(%d)=%f", volume, v);
// return v;
- return volume ? exp(float(100 - volume) * dBConvert) : 0;
+ return volume ? exp(float(100 - volume) * kdBConvert) : 0;
}
int AudioSystem::logToLinear(float volume) {
- // int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
+ // int v = volume ? 100 - int(kdBConvertInverse * log(volume) + 0.5) : 0;
// ALOGD("logTolinear(%d)=%f", v, volume);
// return v;
- return volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
+ return volume ? 100 - int(kdBConvertInverse * log(volume) + 0.5) : 0;
}
/* static */ size_t AudioSystem::calculateMinFrameCount(
@@ -549,7 +548,7 @@
void AudioSystem::AudioFlingerClient::clearIoCache() {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
mIoDescriptors.clear();
mInBuffSize = 0;
mInSamplingRate = 0;
@@ -559,7 +558,7 @@
void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused) {
{
- Mutex::Autolock _l(AudioSystem::gLock);
+ std::lock_guard _l(AudioSystem::gMutex);
AudioSystem::gAudioFlinger.clear();
}
@@ -587,7 +586,7 @@
audio_port_handle_t deviceId = AUDIO_PORT_HANDLE_NONE;
std::vector<sp<AudioDeviceCallback>> callbacksToCall;
{
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
auto callbacks = std::map<audio_port_handle_t, wp<AudioDeviceCallback>>();
switch (event) {
@@ -692,8 +691,8 @@
}
}
- // Callbacks must be called without mLock held. May lead to dead lock if calling for
- // example getRoutedDevice that updates the device and tries to acquire mLock.
+ // Callbacks must be called without mMutex held. May lead to dead lock if calling for
+ // example getRoutedDevice that updates the device and tries to acquire mMutex.
for (auto cb : callbacksToCall) {
// If callbacksToCall is not empty, it implies ioDesc->getIoHandle() and deviceId are valid
cb->onAudioDeviceUpdate(ioDesc->getIoHandle(), deviceId);
@@ -712,7 +711,7 @@
std::vector<sp<SupportedLatencyModesCallback>> callbacks;
{
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (auto callback : mSupportedLatencyModesCallbacks) {
if (auto ref = callback.promote(); ref != nullptr) {
callbacks.push_back(ref);
@@ -733,7 +732,7 @@
if (af == 0) {
return PERMISSION_DENIED;
}
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
// Do we have a stale mInBuffSize or are we requesting the input buffer size for new values
if ((mInBuffSize == 0) || (sampleRate != mInSamplingRate) || (format != mInFormat)
|| (channelMask != mInChannelMask)) {
@@ -768,7 +767,7 @@
}
sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
return getIoDescriptor_l(ioHandle);
}
@@ -776,7 +775,7 @@
const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
audio_port_handle_t portId) {
ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
auto& callbacks = mAudioDeviceCallbacks.emplace(
audioIo,
std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
@@ -791,7 +790,7 @@
const wp<AudioDeviceCallback>& callback __unused, audio_io_handle_t audioIo,
audio_port_handle_t portId) {
ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
auto it = mAudioDeviceCallbacks.find(audioIo);
if (it == mAudioDeviceCallbacks.end()) {
return INVALID_OPERATION;
@@ -807,7 +806,7 @@
status_t AudioSystem::AudioFlingerClient::addSupportedLatencyModesCallback(
const sp<SupportedLatencyModesCallback>& callback) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
if (std::find(mSupportedLatencyModesCallbacks.begin(),
mSupportedLatencyModesCallbacks.end(),
callback) != mSupportedLatencyModesCallbacks.end()) {
@@ -819,7 +818,7 @@
status_t AudioSystem::AudioFlingerClient::removeSupportedLatencyModesCallback(
const sp<SupportedLatencyModesCallback>& callback) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
auto it = std::find(mSupportedLatencyModesCallbacks.begin(),
mSupportedLatencyModesCallbacks.end(),
callback);
@@ -831,55 +830,49 @@
}
/* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb) {
- Mutex::Autolock _l(gLockErrorCallbacks);
+ std::lock_guard _l(gErrorCallbacksMutex);
gAudioErrorCallbacks.insert(cb);
return reinterpret_cast<uintptr_t>(cb);
}
/* static */ void AudioSystem::removeErrorCallback(uintptr_t cb) {
- Mutex::Autolock _l(gLockErrorCallbacks);
+ std::lock_guard _l(gErrorCallbacksMutex);
gAudioErrorCallbacks.erase(reinterpret_cast<audio_error_callback>(cb));
}
/* static */ void AudioSystem::reportError(status_t err) {
- Mutex::Autolock _l(gLockErrorCallbacks);
+ std::lock_guard _l(gErrorCallbacksMutex);
for (auto callback : gAudioErrorCallbacks) {
callback(err);
}
}
/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb) {
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
gDynPolicyCallback = cb;
}
/*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb) {
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
gRecordConfigCallback = cb;
}
/*static*/ void AudioSystem::setRoutingCallback(routing_callback cb) {
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
gRoutingCallback = cb;
}
/*static*/ void AudioSystem::setVolInitReqCallback(vol_range_init_req_callback cb) {
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
gVolRangeInitReqCallback = cb;
}
-// client singleton for AudioPolicyService binder interface
-// protected by gLockAPS
-sp<IAudioPolicyService> AudioSystem::gAudioPolicyService;
-sp<AudioSystem::AudioPolicyServiceClient> AudioSystem::gAudioPolicyServiceClient;
-
-
// establish binder interface to AudioPolicy service
const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() {
sp<IAudioPolicyService> ap;
sp<AudioPolicyServiceClient> apc;
{
- Mutex::Autolock _l(gLockAPS);
+ std::lock_guard _l(gAPSMutex);
if (gAudioPolicyService == 0) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->waitForService(String16("media.audio_policy"));
@@ -910,7 +903,7 @@
}
void AudioSystem::clearAudioPolicyService() {
- Mutex::Autolock _l(gLockAPS);
+ std::lock_guard _l(gAPSMutex);
gAudioPolicyService.clear();
}
@@ -1513,7 +1506,7 @@
// called by restoreTrack_l(), which needs new IAudioFlinger and IAudioPolicyService instances
ALOGV("clearAudioConfigCache()");
{
- Mutex::Autolock _l(gLock);
+ std::lock_guard _l(gMutex);
if (gAudioFlingerClient != 0) {
gAudioFlingerClient->clearIoCache();
}
@@ -1682,7 +1675,7 @@
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- Mutex::Autolock _l(gLockAPS);
+ std::lock_guard _l(gAPSMutex);
if (gAudioPolicyServiceClient == 0) {
return NO_INIT;
}
@@ -1698,7 +1691,7 @@
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- Mutex::Autolock _l(gLockAPS);
+ std::lock_guard _l(gAPSMutex);
if (gAudioPolicyServiceClient == 0) {
return NO_INIT;
}
@@ -1713,7 +1706,7 @@
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- Mutex::Autolock _l(gLockAPS);
+ std::lock_guard _l(gAPSMutex);
if (gAudioPolicyServiceClient == 0) {
return NO_INIT;
}
@@ -1728,7 +1721,7 @@
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- Mutex::Autolock _l(gLockAPS);
+ std::lock_guard _l(gAPSMutex);
if (gAudioPolicyServiceClient == 0) {
return NO_INIT;
}
@@ -2605,15 +2598,15 @@
}
binder::Status setCaptureState(bool active) override {
- Mutex::Autolock _l(gSoundTriggerCaptureStateListenerLock);
+ std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
mListener->onStateChanged(active);
return binder::Status::ok();
}
void binderDied(const wp<IBinder>&) override {
- Mutex::Autolock _l(gSoundTriggerCaptureStateListenerLock);
+ std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
mListener->onServiceDied();
- gSoundTriggerCaptureStateListener = nullptr;
+ AudioSystem::gSoundTriggerCaptureStateListener = nullptr;
}
private:
@@ -2632,7 +2625,7 @@
return PERMISSION_DENIED;
}
- Mutex::Autolock _l(gSoundTriggerCaptureStateListenerLock);
+ std::lock_guard _l(AudioSystem::gSoundTriggerMutex);
gSoundTriggerCaptureStateListener = new CaptureStateListenerImpl(aps, listener);
gSoundTriggerCaptureStateListener->init();
@@ -2755,7 +2748,7 @@
int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(
const sp<AudioPortCallback>& callback) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
if (mAudioPortCallbacks[i] == callback) {
return -1;
@@ -2767,7 +2760,7 @@
int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(
const sp<AudioPortCallback>& callback) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
size_t i;
for (i = 0; i < mAudioPortCallbacks.size(); i++) {
if (mAudioPortCallbacks[i] == callback) {
@@ -2783,7 +2776,7 @@
Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
mAudioPortCallbacks[i]->onAudioPortListUpdate();
}
@@ -2791,7 +2784,7 @@
}
Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
mAudioPortCallbacks[i]->onAudioPatchListUpdate();
}
@@ -2801,7 +2794,7 @@
// ----------------------------------------------------------------------------
int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(
const sp<AudioVolumeGroupCallback>& callback) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
if (mAudioVolumeGroupCallback[i] == callback) {
return -1;
@@ -2813,7 +2806,7 @@
int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback(
const sp<AudioVolumeGroupCallback>& callback) {
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
size_t i;
for (i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
if (mAudioVolumeGroupCallback[i] == callback) {
@@ -2833,7 +2826,7 @@
aidl2legacy_int32_t_volume_group_t(group));
int flagsLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(flags));
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
mAudioVolumeGroupCallback[i]->onAudioVolumeGroupChanged(groupLegacy, flagsLegacy);
}
@@ -2849,7 +2842,7 @@
int stateLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(state));
dynamic_policy_callback cb = NULL;
{
- Mutex::Autolock _l(AudioSystem::gLock);
+ std::lock_guard _l(AudioSystem::gMutex);
cb = gDynPolicyCallback;
}
@@ -2870,7 +2863,7 @@
AudioSource source) {
record_config_callback cb = NULL;
{
- Mutex::Autolock _l(AudioSystem::gLock);
+ std::lock_guard _l(AudioSystem::gMutex);
cb = gRecordConfigCallback;
}
@@ -2903,7 +2896,7 @@
Status AudioSystem::AudioPolicyServiceClient::onRoutingUpdated() {
routing_callback cb = NULL;
{
- Mutex::Autolock _l(AudioSystem::gLock);
+ std::lock_guard _l(AudioSystem::gMutex);
cb = gRoutingCallback;
}
@@ -2916,7 +2909,7 @@
Status AudioSystem::AudioPolicyServiceClient::onVolumeRangeInitRequest() {
vol_range_init_req_callback cb = NULL;
{
- Mutex::Autolock _l(AudioSystem::gLock);
+ std::lock_guard _l(AudioSystem::gMutex);
cb = gVolRangeInitReqCallback;
}
@@ -2928,7 +2921,7 @@
void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused) {
{
- Mutex::Autolock _l(mLock);
+ std::lock_guard _l(mMutex);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
mAudioPortCallbacks[i]->onServiceDied();
}
diff --git a/media/libaudioclient/include/media/AudioSystem.h b/media/libaudioclient/include/media/AudioSystem.h
index acbcf3f..d00f771 100644
--- a/media/libaudioclient/include/media/AudioSystem.h
+++ b/media/libaudioclient/include/media/AudioSystem.h
@@ -19,6 +19,7 @@
#include <sys/types.h>
+#include <mutex>
#include <set>
#include <vector>
@@ -86,6 +87,7 @@
typedef void (*routing_callback)();
typedef void (*vol_range_init_req_callback)();
+class CaptureStateListenerImpl;
class IAudioFlinger;
class String8;
@@ -95,6 +97,9 @@
class AudioSystem
{
+ friend class AudioFlingerClient;
+ friend class AudioPolicyServiceClient;
+ friend class CaptureStateListenerImpl;
public:
// FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp
@@ -781,18 +786,15 @@
class AudioFlingerClient: public IBinder::DeathRecipient, public media::BnAudioFlingerClient
{
public:
- AudioFlingerClient() :
- mInBuffSize(0), mInSamplingRate(0),
- mInFormat(AUDIO_FORMAT_DEFAULT), mInChannelMask(AUDIO_CHANNEL_NONE) {
- }
+ AudioFlingerClient() = default;
- void clearIoCache();
+ void clearIoCache() EXCLUDES(mMutex);
status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format,
- audio_channel_mask_t channelMask, size_t* buffSize);
- sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle);
+ audio_channel_mask_t channelMask, size_t* buffSize) EXCLUDES(mMutex);
+ sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle) EXCLUDES(mMutex);
// DeathRecipient
- virtual void binderDied(const wp<IBinder>& who);
+ void binderDied(const wp<IBinder>& who) final;
// IAudioFlingerClient
@@ -800,61 +802,72 @@
// values for output/input parameters up-to-date in client process
binder::Status ioConfigChanged(
media::AudioIoConfigEvent event,
- const media::AudioIoDescriptor& ioDesc) override;
+ const media::AudioIoDescriptor& ioDesc) final EXCLUDES(mMutex);
binder::Status onSupportedLatencyModesChanged(
int output,
- const std::vector<media::audio::common::AudioLatencyMode>& latencyModes) override;
+ const std::vector<media::audio::common::AudioLatencyMode>& latencyModes)
+ final EXCLUDES(mMutex);
status_t addAudioDeviceCallback(const wp<AudioDeviceCallback>& callback,
- audio_io_handle_t audioIo,
- audio_port_handle_t portId);
+ audio_io_handle_t audioIo, audio_port_handle_t portId) EXCLUDES(mMutex);
status_t removeAudioDeviceCallback(const wp<AudioDeviceCallback>& callback,
- audio_io_handle_t audioIo,
- audio_port_handle_t portId);
+ audio_io_handle_t audioIo, audio_port_handle_t portId) EXCLUDES(mMutex);
status_t addSupportedLatencyModesCallback(
- const sp<SupportedLatencyModesCallback>& callback);
+ const sp<SupportedLatencyModesCallback>& callback) EXCLUDES(mMutex);
status_t removeSupportedLatencyModesCallback(
- const sp<SupportedLatencyModesCallback>& callback);
+ const sp<SupportedLatencyModesCallback>& callback) EXCLUDES(mMutex);
- audio_port_handle_t getDeviceIdForIo(audio_io_handle_t audioIo);
+ audio_port_handle_t getDeviceIdForIo(audio_io_handle_t audioIo) EXCLUDES(mMutex);
private:
- Mutex mLock;
- DefaultKeyedVector<audio_io_handle_t, sp<AudioIoDescriptor> > mIoDescriptors;
+ mutable std::mutex mMutex;
+ DefaultKeyedVector<audio_io_handle_t, sp<AudioIoDescriptor>>
+ mIoDescriptors GUARDED_BY(mMutex);
std::map<audio_io_handle_t, std::map<audio_port_handle_t, wp<AudioDeviceCallback>>>
- mAudioDeviceCallbacks;
+ mAudioDeviceCallbacks GUARDED_BY(mMutex);
std::vector<wp<SupportedLatencyModesCallback>>
- mSupportedLatencyModesCallbacks GUARDED_BY(mLock);
+ mSupportedLatencyModesCallbacks GUARDED_BY(mMutex);
// cached values for recording getInputBufferSize() queries
- size_t mInBuffSize; // zero indicates cache is invalid
- uint32_t mInSamplingRate;
- audio_format_t mInFormat;
- audio_channel_mask_t mInChannelMask;
- sp<AudioIoDescriptor> getIoDescriptor_l(audio_io_handle_t ioHandle);
+ size_t mInBuffSize GUARDED_BY(mMutex) = 0; // zero indicates cache is invalid
+ uint32_t mInSamplingRate GUARDED_BY(mMutex) = 0;
+ audio_format_t mInFormat GUARDED_BY(mMutex) = AUDIO_FORMAT_DEFAULT;
+ audio_channel_mask_t mInChannelMask GUARDED_BY(mMutex) = AUDIO_CHANNEL_NONE;
+
+ sp<AudioIoDescriptor> getIoDescriptor_l(audio_io_handle_t ioHandle) REQUIRES(mMutex);
};
class AudioPolicyServiceClient: public IBinder::DeathRecipient,
- public media::BnAudioPolicyServiceClient
- {
+ public media::BnAudioPolicyServiceClient {
public:
- AudioPolicyServiceClient() {
+ AudioPolicyServiceClient() = default;
+
+ int addAudioPortCallback(const sp<AudioPortCallback>& callback) EXCLUDES(mMutex);
+
+ int removeAudioPortCallback(const sp<AudioPortCallback>& callback) EXCLUDES(mMutex);
+
+ bool isAudioPortCbEnabled() const EXCLUDES(mMutex) {
+ std::lock_guard _l(mMutex);
+ return (mAudioPortCallbacks.size() != 0);
}
- int addAudioPortCallback(const sp<AudioPortCallback>& callback);
- int removeAudioPortCallback(const sp<AudioPortCallback>& callback);
- bool isAudioPortCbEnabled() const { return (mAudioPortCallbacks.size() != 0); }
+ int addAudioVolumeGroupCallback(
+ const sp<AudioVolumeGroupCallback>& callback) EXCLUDES(mMutex);
- int addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);
- int removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback);
- bool isAudioVolumeGroupCbEnabled() const { return (mAudioVolumeGroupCallback.size() != 0); }
+ int removeAudioVolumeGroupCallback(
+ const sp<AudioVolumeGroupCallback>& callback) EXCLUDES(mMutex);
+
+ bool isAudioVolumeGroupCbEnabled() const EXCLUDES(mMutex) {
+ std::lock_guard _l(mMutex);
+ return (mAudioVolumeGroupCallback.size() != 0);
+ }
// DeathRecipient
- virtual void binderDied(const wp<IBinder>& who);
+ void binderDied(const wp<IBinder>& who) final;
// IAudioPolicyServiceClient
binder::Status onAudioVolumeGroupChanged(int32_t group, int32_t flags) override;
@@ -875,9 +888,9 @@
binder::Status onVolumeRangeInitRequest();
private:
- Mutex mLock;
- Vector <sp <AudioPortCallback> > mAudioPortCallbacks;
- Vector <sp <AudioVolumeGroupCallback> > mAudioVolumeGroupCallback;
+ mutable std::mutex mMutex;
+ Vector<sp<AudioPortCallback>> mAudioPortCallbacks GUARDED_BY(mMutex);
+ Vector<sp<AudioVolumeGroupCallback>> mAudioVolumeGroupCallback GUARDED_BY(mMutex);
};
static audio_io_handle_t getOutput(audio_stream_type_t stream);
@@ -888,30 +901,31 @@
// Invokes all registered error callbacks with the given error code.
static void reportError(status_t err);
- static sp<AudioFlingerClient> gAudioFlingerClient;
- static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient;
- friend class AudioFlingerClient;
- friend class AudioPolicyServiceClient;
+ [[clang::no_destroy]] static std::mutex gMutex;
+ [[clang::no_destroy]] static sp<IAudioFlinger> gAudioFlinger GUARDED_BY(gMutex);
+ [[clang::no_destroy]] static sp<IBinder> gAudioFlingerBinder GUARDED_BY(gMutex);
+ [[clang::no_destroy]] static sp<IAudioFlinger> gLocalAudioFlinger GUARDED_BY(gMutex);
+ [[clang::no_destroy]] static sp<AudioFlingerClient> gAudioFlingerClient GUARDED_BY(gMutex);
+ static dynamic_policy_callback gDynPolicyCallback GUARDED_BY(gMutex);
+ static record_config_callback gRecordConfigCallback GUARDED_BY(gMutex);
+ static routing_callback gRoutingCallback GUARDED_BY(gMutex);
+ static vol_range_init_req_callback gVolRangeInitReqCallback GUARDED_BY(gMutex);
- static Mutex gLock; // protects gAudioFlinger
- static Mutex gLockErrorCallbacks; // protects gAudioErrorCallbacks
- static Mutex gLockAPS; // protects gAudioPolicyService and gAudioPolicyServiceClient
- static sp<IAudioFlinger> gAudioFlinger;
- static std::set<audio_error_callback> gAudioErrorCallbacks;
- static dynamic_policy_callback gDynPolicyCallback;
- static record_config_callback gRecordConfigCallback;
- static routing_callback gRoutingCallback;
- static vol_range_init_req_callback gVolRangeInitReqCallback;
+ [[clang::no_destroy]] static std::mutex gErrorCallbacksMutex;
+ [[clang::no_destroy]] static std::set<audio_error_callback> gAudioErrorCallbacks
+ GUARDED_BY(gErrorCallbacksMutex);
- static size_t gInBuffSize;
- // previous parameters for recording buffer size queries
- static uint32_t gPrevInSamplingRate;
- static audio_format_t gPrevInFormat;
- static audio_channel_mask_t gPrevInChannelMask;
+ [[clang::no_destroy]] static std::mutex gSoundTriggerMutex;
+ [[clang::no_destroy]] static sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener
+ GUARDED_BY(gSoundTriggerMutex);
- static sp<media::IAudioPolicyService> gAudioPolicyService;
+ [[clang::no_destroy]] static std::mutex gAPSMutex;
+ [[clang::no_destroy]] static sp<media::IAudioPolicyService> gAudioPolicyService
+ GUARDED_BY(gAPSMutex);
+ [[clang::no_destroy]] static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient
+ GUARDED_BY(gAPSMutex);
};
-}; // namespace android
+} // namespace android
#endif /*ANDROID_AUDIOSYSTEM_H_*/