gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

audo policy: more info in onRecordingConfigurationUpdate

Browse Source 
Report more information in onRecordingConfigurationUpdate() callback:
- For client:
  - Port ID
  - Enabled effects
  - Silenced by policy
- For stream:
  - Active effects
  - Active audio source

Bug: 111438757
Test: make
Change-Id: I34c3d0ee6251576de7d793bfaa2bc2c34efa2319
gugelfrei
Eric Laurent 6 years ago
parent c241b0dfc4
commit a9f86651ea
12 changed files with 242 additions and 84 deletions
Show Stats Download Patch File Download Diff File

14
media/libaudioclient/AudioSystem.cpp
Unescape View File

@ -1388,9 +1388,14 @@ void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(
}
void AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle) {
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) {
record_config_callback cb = NULL;
{
Mutex::Autolock _l(AudioSystem::gLock);
@ -1398,7 +1403,8 @@ void AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(
}
if (cb != NULL) {
cb(event, clientInfo, clientConfig, deviceConfig, patchHandle);
cb(event, clientInfo, clientConfig, clientEffects,
deviceConfig, effects, patchHandle, source);
}
}

52
media/libaudioclient/IAudioPolicyServiceClient.cpp
Unescape View File

@ -52,12 +52,37 @@ inline void readRecordClientInfoFromParcel(const Parcel& data, record_client_inf
clientInfo->uid = (uid_t) data.readUint32();
clientInfo->session = (audio_session_t) data.readInt32();
clientInfo->source = (audio_source_t) data.readInt32();
data.read(&clientInfo->port_id, sizeof(audio_port_handle_t));
clientInfo->silenced = data.readBool();
}
inline void writeRecordClientInfoFromParcel(Parcel& data, const record_client_info_t *clientInfo) {
inline void writeRecordClientInfoToParcel(Parcel& data, const record_client_info_t *clientInfo) {
data.writeUint32((uint32_t) clientInfo->uid);
data.writeInt32((int32_t) clientInfo->session);
data.writeInt32((int32_t) clientInfo->source);
data.write(&clientInfo->port_id, sizeof(audio_port_handle_t));
data.writeBool(clientInfo->silenced);
}
inline void readEffectVectorFromParcel(const Parcel& data,
std::vector<effect_descriptor_t> *effects) {
int32_t numEffects = data.readInt32();
for (int32_t i = 0; i < numEffects; i++) {
effect_descriptor_t effect;
if (data.read(&effect, sizeof(effect_descriptor_t)) != NO_ERROR) {
break;
}
(*effects).push_back(effect);
}
}
inline void writeEffectVectorToParcel(Parcel& data, std::vector<effect_descriptor_t> effects) {
data.writeUint32((uint32_t) effects.size());
for (const auto& effect : effects) {
if (data.write(&effect, sizeof(effect_descriptor_t)) != NO_ERROR) {
break;
}
}
}
// ----------------------------------------------------------------------
@ -92,16 +117,24 @@ public:
remote()->transact(MIX_STATE_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);
}
void onRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle) {
void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) {
Parcel data, reply;
data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());
data.writeInt32(event);
writeRecordClientInfoFromParcel(data, clientInfo);
writeRecordClientInfoToParcel(data, clientInfo);
writeAudioConfigBaseToParcel(data, clientConfig);
writeEffectVectorToParcel(data, clientEffects);
writeAudioConfigBaseToParcel(data, deviceConfig);
writeEffectVectorToParcel(data, effects);
data.writeInt32(patchHandle);
data.writeInt32((int32_t) source);
remote()->transact(RECORDING_CONFIGURATION_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);
}
};
@ -139,10 +172,15 @@ status_t BnAudioPolicyServiceClient::onTransact(
audio_config_base_t deviceConfig;
readRecordClientInfoFromParcel(data, &clientInfo);
readAudioConfigBaseFromParcel(data, &clientConfig);
std::vector<effect_descriptor_t> clientEffects;
readEffectVectorFromParcel(data, &clientEffects);
readAudioConfigBaseFromParcel(data, &deviceConfig);
std::vector<effect_descriptor_t> effects;
readEffectVectorFromParcel(data, &effects);
audio_patch_handle_t patchHandle = (audio_patch_handle_t) data.readInt32();
onRecordingConfigurationUpdate(event, &clientInfo, &clientConfig, &deviceConfig,
patchHandle);
audio_source_t source = (audio_source_t) data.readInt32();
onRecordingConfigurationUpdate(event, &clientInfo, &clientConfig, clientEffects,
&deviceConfig, effects, patchHandle, source);
return NO_ERROR;
} break;
default:

21
media/libaudioclient/include/media/AudioSystem.h
Unescape View File

@ -35,9 +35,14 @@ namespace android {
typedef void (*audio_error_callback)(status_t err);
typedef void (*dynamic_policy_callback)(int event, String8 regId, int val);
typedef void (*record_config_callback)(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle);
typedef void (*record_config_callback)(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
class IAudioFlinger;
class IAudioPolicyService;
@ -448,9 +453,13 @@ private:
virtual void onAudioPatchListUpdate();
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state);
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
private:
Mutex mLock;

9
media/libaudioclient/include/media/IAudioPolicyServiceClient.h
Unescape View File

@ -17,10 +17,12 @@
#ifndef ANDROID_IAUDIOPOLICYSERVICECLIENT_H
#define ANDROID_IAUDIOPOLICYSERVICECLIENT_H
#include <vector>
#include <utils/RefBase.h>
#include <binder/IInterface.h>
#include <system/audio.h>
#include <system/audio_effect.h>
namespace android {
@ -30,6 +32,8 @@ struct record_client_info {
uid_t uid;
audio_session_t session;
audio_source_t source;
audio_port_handle_t port_id;
bool silenced;
};
typedef struct record_client_info record_client_info_t;
@ -51,8 +55,11 @@ public:
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle) = 0;
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) = 0;
};

11
services/audiopolicy/AudioPolicyInterface.h
Unescape View File

@ -332,10 +332,13 @@ public:
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) = 0;
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const struct audio_config_base *clientConfig,
const struct audio_config_base *deviceConfig,
audio_patch_handle_t patchHandle) = 0;
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source) = 0;
};
extern "C" AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface);

2
services/audiopolicy/common/managerdefinitions/include/AudioInputDescriptor.h
Unescape View File

@ -88,6 +88,8 @@ public:
RecordClientVector clientsList(bool activeOnly = false,
audio_source_t source = AUDIO_SOURCE_DEFAULT, bool preferredDeviceOnly = false) const;
void setAppState(uid_t uid, app_state_t state);
// implementation of ClientMapHandler<RecordClientDescriptor>
void addClient(const sp<RecordClientDescriptor> &client) override;

53
services/audiopolicy/common/managerdefinitions/src/AudioInputDescriptor.cpp
Unescape View File

@ -322,11 +322,26 @@ void AudioInputDescriptor::updateClientRecordingConfiguration(
int event, const sp<RecordClientDescriptor>& client)
{
const audio_config_base_t sessionConfig = client->config();
const record_client_info_t recordClientInfo{client->uid(), client->session(), client->source()};
const record_client_info_t recordClientInfo{client->uid(), client->session(),
client->source(), client->portId(),
client->isSilenced()};
const audio_config_base_t config = getConfig();
mClientInterface->onRecordingConfigurationUpdate(event,
&recordClientInfo, &sessionConfig,
&config, mPatchHandle);
std::vector<effect_descriptor_t> clientEffects;
EffectDescriptorCollection effectsList = client->getEnabledEffects();
for (size_t i = 0; i < effectsList.size(); i++) {
clientEffects.push_back(effectsList.valueAt(i)->mDesc);
}
std::vector<effect_descriptor_t> effects;
effectsList = getEnabledEffects();
for (size_t i = 0; i < effectsList.size(); i++) {
effects.push_back(effectsList.valueAt(i)->mDesc);
}
mClientInterface->onRecordingConfigurationUpdate(event, &recordClientInfo, &sessionConfig,
clientEffects, &config, effects,
mPatchHandle, source());
}
RecordClientVector AudioInputDescriptor::getClientsForSession(
@ -358,16 +373,22 @@ RecordClientVector AudioInputDescriptor::clientsList(bool activeOnly, audio_sour
void AudioInputDescriptor::trackEffectEnabled(const sp<EffectDescriptor> &effect,
bool enabled)
{
RecordClientVector clients = getClientsForSession((audio_session_t)effect->mSession);
for (const auto& client : clients) {
client->trackEffectEnabled(effect, enabled);
}
if (enabled) {
mEnabledEffects.replaceValueFor(effect->mId, effect);
} else {
mEnabledEffects.removeItem(effect->mId);
}
RecordClientVector clients = getClientsForSession((audio_session_t)effect->mSession);
for (const auto& client : clients) {
sp<EffectDescriptor> clientEffect = client->getEnabledEffects().getEffect(effect->mId);
bool changed = (enabled && clientEffect == nullptr)
|| (!enabled && clientEffect != nullptr);
client->trackEffectEnabled(effect, enabled);
if (changed && client->active()) {
updateClientRecordingConfiguration(RECORD_CONFIG_EVENT_START, client);
}
}
}
EffectDescriptorCollection AudioInputDescriptor::getEnabledEffects() const
@ -382,6 +403,20 @@ EffectDescriptorCollection AudioInputDescriptor::getEnabledEffects() const
return enabledEffects;
}
void AudioInputDescriptor::setAppState(uid_t uid, app_state_t state) {
RecordClientVector clients = clientsList(false /*activeOnly*/);
for (const auto& client : clients) {
if (uid == client->uid()) {
bool wasSilenced = client->isSilenced();
client->setAppState(state);
if (client->active() && wasSilenced != client->isSilenced()) {
updateClientRecordingConfiguration(RECORD_CONFIG_EVENT_START, client);
}
}
}
}
void AudioInputDescriptor::dump(String8 *dst) const
{
dst->appendFormat(" ID: %d\n", getId());

8
services/audiopolicy/managerdefault/AudioPolicyManager.cpp
Unescape View File

@ -3733,13 +3733,11 @@ status_t AudioPolicyManager::setSurroundFormatEnabled(audio_format_t audioFormat
void AudioPolicyManager::setAppState(uid_t uid, app_state_t state)
{
Vector<sp<AudioInputDescriptor> > activeInputs = mInputs.getActiveInputs();
ALOGV("%s(uid:%d, state:%d)", __func__, uid, state);
for (size_t i = 0; i < activeInputs.size(); i++) {
sp<AudioInputDescriptor> activeDesc = activeInputs[i];
RecordClientVector clients = activeDesc->clientsList(true /*activeOnly*/);
for (size_t i = 0; i < mInputs.size(); i++) {
sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(i);
RecordClientVector clients = inputDesc->clientsList(false /*activeOnly*/);
for (const auto& client : clients) {
if (uid == client->uid()) {
client->setAppState(state);

13
services/audiopolicy/service/AudioPolicyClientImpl.cpp
Unescape View File

@ -209,12 +209,17 @@ void AudioPolicyService::AudioPolicyClient::onDynamicPolicyMixStateUpdate(
}
void AudioPolicyService::AudioPolicyClient::onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle)
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
mAudioPolicyService->onRecordingConfigurationUpdate(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
audio_unique_id_t AudioPolicyService::AudioPolicyClient::newAudioUniqueId(audio_unique_id_use_t use)

64
services/audiopolicy/service/AudioPolicyService.cpp
Unescape View File

@ -215,22 +215,34 @@ void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, i
}
}
void AudioPolicyService::onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo, const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle)
void AudioPolicyService::onRecordingConfigurationUpdate(
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
}
void AudioPolicyService::doOnRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo, const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle)
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
void AudioPolicyService::doOnRecordingConfigurationUpdate(
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
Mutex::Autolock _l(mNotificationClientsLock);
for (size_t i = 0; i < mNotificationClients.size(); i++) {
mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
}
@ -298,13 +310,18 @@ void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
}
void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle)
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
mAudioPolicyServiceClient->onRecordingConfigurationUpdate(event, clientInfo,
clientConfig, deviceConfig, patchHandle);
clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
}
}
@ -1071,8 +1088,9 @@ bool AudioPolicyService::AudioCommandThread::threadLoop()
}
mLock.unlock();
svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
&data->mClientConfig, &data->mDeviceConfig,
data->mPatchHandle);
&data->mClientConfig, data->mClientEffects,
&data->mDeviceConfig, data->mEffects,
data->mPatchHandle, data->mSource);
mLock.lock();
} break;
default:
@ -1307,9 +1325,14 @@ void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
}
void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle)
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source)
{
sp<AudioCommand>command = new AudioCommand();
command->mCommand = RECORDING_CONFIGURATION_UPDATE;
@ -1317,8 +1340,11 @@ void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand
data->mEvent = event;
data->mClientInfo = *clientInfo;
data->mClientConfig = *clientConfig;
data->mClientEffects = clientEffects;
data->mDeviceConfig = *deviceConfig;
data->mEffects = effects;
data->mPatchHandle = patchHandle;
data->mSource = source;
command->mParam = data;
ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
event, clientInfo->source, clientInfo->uid);

66
services/audiopolicy/service/AudioPolicyService.h
Unescape View File

@ -240,12 +240,22 @@ public:
void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
void onRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
void doOnRecordingConfigurationUpdate(int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
void doOnRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
private:
AudioPolicyService() ANDROID_API;
@ -409,13 +419,17 @@ private:
void updateAudioPatchListCommand();
status_t setAudioPortConfigCommand(const struct audio_port_config *config,
int delayMs);
void dynamicPolicyMixStateUpdateCommand(const String8& regId, int32_t state);
void dynamicPolicyMixStateUpdateCommand(const String8& regId,
int32_t state);
void recordingConfigurationUpdateCommand(
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle);
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
void insertCommand_l(AudioCommand *command, int delayMs = 0);
private:
class AudioCommandData;
@ -500,8 +514,11 @@ private:
int mEvent;
record_client_info_t mClientInfo;
struct audio_config_base mClientConfig;
std::vector<effect_descriptor_t> mClientEffects;
struct audio_config_base mDeviceConfig;
std::vector<effect_descriptor_t> mEffects;
audio_patch_handle_t mPatchHandle;
audio_source_t mSource;
};
Mutex mLock;
@ -605,9 +622,13 @@ private:
virtual void onAudioPatchListUpdate();
virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state);
virtual void onRecordingConfigurationUpdate(int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle);
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
@ -625,12 +646,17 @@ private:
void onAudioPortListUpdate();
void onAudioPatchListUpdate();
void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
void onDynamicPolicyMixStateUpdate(const String8& regId,
int32_t state);
void onRecordingConfigurationUpdate(
int event, const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
const audio_config_base_t *deviceConfig,
audio_patch_handle_t patchHandle);
int event,
const record_client_info_t *clientInfo,
const audio_config_base_t *clientConfig,
std::vector<effect_descriptor_t> clientEffects,
const audio_config_base_t *deviceConfig,
std::vector<effect_descriptor_t> effects,
audio_patch_handle_t patchHandle,
audio_source_t source);
void setAudioPortCallbacksEnabled(bool enabled);
uid_t uid() {

13
services/audiopolicy/tests/AudioPolicyTestClient.h
Unescape View File

@ -75,11 +75,14 @@ public:
void onAudioPatchListUpdate() override { }
audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t /*use*/) override { return 0; }
void onDynamicPolicyMixStateUpdate(String8 /*regId*/, int32_t /*state*/) override { }
void onRecordingConfigurationUpdate(int /*event*/,
const record_client_info_t* /*clientInfo*/,
const struct audio_config_base* /*clientConfig*/,
const struct audio_config_base* /*deviceConfig*/,
audio_patch_handle_t /*patchHandle*/) override { }
void onRecordingConfigurationUpdate(int event __unused,
const record_client_info_t *clientInfo __unused,
const audio_config_base_t *clientConfig __unused,
std::vector<effect_descriptor_t> clientEffects __unused,
const audio_config_base_t *deviceConfig __unused,
std::vector<effect_descriptor_t> effects __unused,
audio_patch_handle_t patchHandle __unused,
audio_source_t source __unused) override { }
};
} // namespace android

Write Preview
Loading…
Cancel
Save