blob: 6da1f9f3a5a723675b62ad979105259f19858dc8 [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "AudioPolicyService"
18//#define LOG_NDEBUG 0
19
Glenn Kasten153b9fe2013-07-15 11:23:36 -070020#include "Configuration.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070021#undef __STRICT_ANSI__
22#define __STDINT_LIMITS
23#define __STDC_LIMIT_MACROS
24#include <stdint.h>
25
26#include <sys/time.h>
27#include <binder/IServiceManager.h>
28#include <utils/Log.h>
29#include <cutils/properties.h>
30#include <binder/IPCThreadState.h>
Svet Ganovf4ddfef2018-01-16 07:37:58 -080031#include <binder/ActivityManager.h>
32#include <binder/PermissionController.h>
33#include <binder/IResultReceiver.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070034#include <utils/String16.h>
35#include <utils/threads.h>
36#include "AudioPolicyService.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070037#include <hardware_legacy/power.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070038#include <media/AudioEffect.h>
Chih-Hung Hsiehc84d9d22014-11-14 13:33:34 -080039#include <media/AudioParameter.h>
Andy Hungab7ef302018-05-15 19:35:29 -070040#include <mediautils/ServiceUtilities.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070041
Dima Zavin64760242011-05-11 14:15:23 -070042#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070043#include <system/audio_policy.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070044
Mathias Agopian65ab4712010-07-14 17:59:35 -070045namespace android {
46
Glenn Kasten8dad0e32012-01-09 08:41:22 -080047static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
48static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
Mathias Agopian65ab4712010-07-14 17:59:35 -070049
50static const int kDumpLockRetries = 50;
Glenn Kasten22ecc912012-01-09 08:33:38 -080051static const int kDumpLockSleepUs = 20000;
Mathias Agopian65ab4712010-07-14 17:59:35 -070052
Eric Laurent0ede8922014-05-09 18:04:42 -070053static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
Christer Fletcher5fa8c4b2013-01-18 15:27:03 +010054
Svet Ganovf4ddfef2018-01-16 07:37:58 -080055static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
Dima Zavinfce7a472011-04-19 22:30:36 -070056
Mathias Agopian65ab4712010-07-14 17:59:35 -070057// ----------------------------------------------------------------------------
58
59AudioPolicyService::AudioPolicyService()
Eric Laurentdce54a12014-03-10 12:19:46 -070060 : BnAudioPolicyService(), mpAudioPolicyDev(NULL), mpAudioPolicy(NULL),
Eric Laurentbb6c9a02014-09-25 14:11:47 -070061 mAudioPolicyManager(NULL), mAudioPolicyClient(NULL), mPhoneState(AUDIO_MODE_INVALID)
Mathias Agopian65ab4712010-07-14 17:59:35 -070062{
Eric Laurentf5ada6e2014-10-09 17:49:00 -070063}
64
65void AudioPolicyService::onFirstRef()
66{
Eric Laurent8b1e80b2014-10-07 09:08:47 -070067 {
68 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -080069
Eric Laurent8b1e80b2014-10-07 09:08:47 -070070 // start audio commands thread
71 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
72 // start output activity command thread
73 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -070074
Eric Laurent8b1e80b2014-10-07 09:08:47 -070075 mAudioPolicyClient = new AudioPolicyClient(this);
76 mAudioPolicyManager = createAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -070077 }
bryant_liuba2b4392014-06-11 16:49:30 +080078 // load audio processing modules
Eric Laurent8b1e80b2014-10-07 09:08:47 -070079 sp<AudioPolicyEffects>audioPolicyEffects = new AudioPolicyEffects();
80 {
81 Mutex::Autolock _l(mLock);
82 mAudioPolicyEffects = audioPolicyEffects;
83 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -080084
85 mUidPolicy = new UidPolicy(this);
86 mUidPolicy->registerSelf();
Mathias Agopian65ab4712010-07-14 17:59:35 -070087}
88
89AudioPolicyService::~AudioPolicyService()
90{
Mathias Agopian65ab4712010-07-14 17:59:35 -070091 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -070092 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -070093
Eric Laurentf269b8e2014-06-09 20:01:29 -070094 destroyAudioPolicyManager(mAudioPolicyManager);
Eric Laurentdce54a12014-03-10 12:19:46 -070095 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -070096
97 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +080098 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -080099
100 mUidPolicy->unregisterSelf();
101 mUidPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700102}
103
104// A notification client is always registered by AudioSystem when the client process
105// connects to AudioPolicyService.
106void AudioPolicyService::registerClient(const sp<IAudioPolicyServiceClient>& client)
107{
Eric Laurent12590252015-08-21 18:40:20 -0700108 if (client == 0) {
109 ALOGW("%s got NULL client", __FUNCTION__);
110 return;
111 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800112 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700113
114 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800115 pid_t pid = IPCThreadState::self()->getCallingPid();
116 int64_t token = ((int64_t)uid<<32) | pid;
117
118 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700119 sp<NotificationClient> notificationClient = new NotificationClient(this,
120 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800121 uid,
122 pid);
123 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700124
luochaojiang908c7d72018-06-21 14:58:04 +0800125 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700126
Marco Nelissenf8880202014-11-14 07:58:25 -0800127 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700128 binder->linkToDeath(notificationClient);
129 }
130}
131
Eric Laurente8726fe2015-06-26 09:39:24 -0700132void AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
133{
134 Mutex::Autolock _l(mNotificationClientsLock);
135
136 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800137 pid_t pid = IPCThreadState::self()->getCallingPid();
138 int64_t token = ((int64_t)uid<<32) | pid;
139
140 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurente8726fe2015-06-26 09:39:24 -0700141 return;
142 }
luochaojiang908c7d72018-06-21 14:58:04 +0800143 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Eric Laurente8726fe2015-06-26 09:39:24 -0700144}
145
Eric Laurentb52c1522014-05-20 11:27:36 -0700146// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800147void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700148{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800149 {
150 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800151 int64_t token = ((int64_t)uid<<32) | pid;
152 mNotificationClients.removeItem(token);
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800153 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800154 {
155 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800156 bool hasSameUid = false;
157 for (size_t i = 0; i < mNotificationClients.size(); i++) {
158 if (mNotificationClients.valueAt(i)->uid() == uid) {
159 hasSameUid = true;
160 break;
161 }
162 }
163 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700164 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700165 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700166 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800167 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700168}
169
170void AudioPolicyService::onAudioPortListUpdate()
171{
172 mOutputCommandThread->updateAudioPortListCommand();
173}
174
175void AudioPolicyService::doOnAudioPortListUpdate()
176{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800177 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700178 for (size_t i = 0; i < mNotificationClients.size(); i++) {
179 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
180 }
181}
182
183void AudioPolicyService::onAudioPatchListUpdate()
184{
185 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700186}
187
Eric Laurentb52c1522014-05-20 11:27:36 -0700188void AudioPolicyService::doOnAudioPatchListUpdate()
189{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800190 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700191 for (size_t i = 0; i < mNotificationClients.size(); i++) {
192 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
193 }
194}
195
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700196void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700197{
198 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
199 regId.string(), state);
200 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
201}
202
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700203void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700204{
205 Mutex::Autolock _l(mNotificationClientsLock);
206 for (size_t i = 0; i < mNotificationClients.size(); i++) {
207 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
208 }
209}
210
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800211void AudioPolicyService::onRecordingConfigurationUpdate(int event,
212 const record_client_info_t *clientInfo, const audio_config_base_t *clientConfig,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800213 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800214{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800215 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800216 clientConfig, deviceConfig, patchHandle);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800217}
218
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800219void AudioPolicyService::doOnRecordingConfigurationUpdate(int event,
220 const record_client_info_t *clientInfo, const audio_config_base_t *clientConfig,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800221 const audio_config_base_t *deviceConfig, audio_patch_handle_t patchHandle)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800222{
223 Mutex::Autolock _l(mNotificationClientsLock);
224 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800225 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800226 clientConfig, deviceConfig, patchHandle);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800227 }
228}
229
230status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
231 audio_patch_handle_t *handle,
232 int delayMs)
233{
234 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
235}
236
237status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
238 int delayMs)
239{
240 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
241}
242
Eric Laurente1715a42014-05-20 11:30:42 -0700243status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
244 int delayMs)
245{
246 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
247}
248
Eric Laurentb52c1522014-05-20 11:27:36 -0700249AudioPolicyService::NotificationClient::NotificationClient(const sp<AudioPolicyService>& service,
250 const sp<IAudioPolicyServiceClient>& client,
luochaojiang908c7d72018-06-21 14:58:04 +0800251 uid_t uid,
252 pid_t pid)
253 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
Eric Laurente8726fe2015-06-26 09:39:24 -0700254 mAudioPortCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700255{
256}
257
258AudioPolicyService::NotificationClient::~NotificationClient()
259{
260}
261
262void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
263{
264 sp<NotificationClient> keep(this);
265 sp<AudioPolicyService> service = mService.promote();
266 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800267 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700268 }
269}
270
271void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
272{
Eric Laurente8726fe2015-06-26 09:39:24 -0700273 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700274 mAudioPolicyServiceClient->onAudioPortListUpdate();
275 }
276}
277
278void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
279{
Eric Laurente8726fe2015-06-26 09:39:24 -0700280 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700281 mAudioPolicyServiceClient->onAudioPatchListUpdate();
282 }
283}
Eric Laurent57dae992011-07-24 13:36:09 -0700284
Jean-Michel Trivide801052015-04-14 19:10:14 -0700285void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700286 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700287{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700288 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800289 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(regId, state);
290 }
291}
292
293void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800294 int event, const record_client_info_t *clientInfo,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800295 const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
296 audio_patch_handle_t patchHandle)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800297{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700298 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800299 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(event, clientInfo,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800300 clientConfig, deviceConfig, patchHandle);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700301 }
302}
303
Eric Laurente8726fe2015-06-26 09:39:24 -0700304void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
305{
306 mAudioPortCallbacksEnabled = enabled;
307}
308
309
Mathias Agopian65ab4712010-07-14 17:59:35 -0700310void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700311 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700312 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700313}
314
315static bool tryLock(Mutex& mutex)
316{
317 bool locked = false;
318 for (int i = 0; i < kDumpLockRetries; ++i) {
319 if (mutex.tryLock() == NO_ERROR) {
320 locked = true;
321 break;
322 }
Glenn Kasten22ecc912012-01-09 08:33:38 -0800323 usleep(kDumpLockSleepUs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700324 }
325 return locked;
326}
327
328status_t AudioPolicyService::dumpInternals(int fd)
329{
330 const size_t SIZE = 256;
331 char buffer[SIZE];
332 String8 result;
333
Eric Laurentdce54a12014-03-10 12:19:46 -0700334 snprintf(buffer, SIZE, "AudioPolicyManager: %p\n", mAudioPolicyManager);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700335 result.append(buffer);
336 snprintf(buffer, SIZE, "Command Thread: %p\n", mAudioCommandThread.get());
337 result.append(buffer);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700338
339 write(fd, result.string(), result.size());
340 return NO_ERROR;
341}
342
Eric Laurentf32108e2018-10-04 17:22:04 -0700343void AudioPolicyService::setAppState(uid_t uid, app_state_t state)
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800344{
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700345 {
346 Mutex::Autolock _l(mLock);
347 if (mAudioPolicyManager) {
Eric Laurent10b71232018-04-13 18:14:44 -0700348 AutoCallerClear acc;
Eric Laurentf32108e2018-10-04 17:22:04 -0700349 mAudioPolicyManager->setAppState(uid, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700350 }
351 }
352 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
353 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -0700354 bool silenced = state == APP_STATE_IDLE;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700355 af->setRecordSilenced(uid, silenced);
356 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800357}
358
Glenn Kasten0f11b512014-01-31 16:18:54 -0800359status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700360{
Glenn Kasten44deb052012-02-05 18:09:08 -0800361 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700362 dumpPermissionDenial(fd);
363 } else {
364 bool locked = tryLock(mLock);
365 if (!locked) {
366 String8 result(kDeadlockedString);
367 write(fd, result.string(), result.size());
368 }
369
370 dumpInternals(fd);
Glenn Kasten9d1f02d2012-02-08 17:47:58 -0800371 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700372 mAudioCommandThread->dump(fd);
373 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700374
Eric Laurentdce54a12014-03-10 12:19:46 -0700375 if (mAudioPolicyManager) {
376 mAudioPolicyManager->dump(fd);
377 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700378
379 if (locked) mLock.unlock();
380 }
381 return NO_ERROR;
382}
383
384status_t AudioPolicyService::dumpPermissionDenial(int fd)
385{
386 const size_t SIZE = 256;
387 char buffer[SIZE];
388 String8 result;
389 snprintf(buffer, SIZE, "Permission Denial: "
390 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
391 IPCThreadState::self()->getCallingPid(),
392 IPCThreadState::self()->getCallingUid());
393 result.append(buffer);
394 write(fd, result.string(), result.size());
395 return NO_ERROR;
396}
397
398status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800399 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
400 switch (code) {
401 case SHELL_COMMAND_TRANSACTION: {
402 int in = data.readFileDescriptor();
403 int out = data.readFileDescriptor();
404 int err = data.readFileDescriptor();
405 int argc = data.readInt32();
406 Vector<String16> args;
407 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
408 args.add(data.readString16());
409 }
410 sp<IBinder> unusedCallback;
411 sp<IResultReceiver> resultReceiver;
412 status_t status;
413 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
414 return status;
415 }
416 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
417 return status;
418 }
419 status = shellCommand(in, out, err, args);
420 if (resultReceiver != nullptr) {
421 resultReceiver->send(status);
422 }
423 return NO_ERROR;
424 }
425 }
426
Mathias Agopian65ab4712010-07-14 17:59:35 -0700427 return BnAudioPolicyService::onTransact(code, data, reply, flags);
428}
429
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800430// ------------------- Shell command implementation -------------------
431
432// NOTE: This is a remote API - make sure all args are validated
433status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
434 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
435 return PERMISSION_DENIED;
436 }
437 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
438 return BAD_VALUE;
439 }
440 if (args.size() == 3 && args[0] == String16("set-uid-state")) {
441 return handleSetUidState(args, err);
442 } else if (args.size() == 2 && args[0] == String16("reset-uid-state")) {
443 return handleResetUidState(args, err);
444 } else if (args.size() == 2 && args[0] == String16("get-uid-state")) {
445 return handleGetUidState(args, out, err);
446 } else if (args.size() == 1 && args[0] == String16("help")) {
447 printHelp(out);
448 return NO_ERROR;
449 }
450 printHelp(err);
451 return BAD_VALUE;
452}
453
454status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
455 PermissionController pc;
456 int uid = pc.getPackageUid(args[1], 0);
457 if (uid <= 0) {
458 ALOGE("Unknown package: '%s'", String8(args[1]).string());
459 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
460 return BAD_VALUE;
461 }
462 bool active = false;
463 if (args[2] == String16("active")) {
464 active = true;
465 } else if ((args[2] != String16("idle"))) {
466 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
467 return BAD_VALUE;
468 }
469 mUidPolicy->addOverrideUid(uid, active);
470 return NO_ERROR;
471}
472
473status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
474 PermissionController pc;
475 int uid = pc.getPackageUid(args[1], 0);
476 if (uid < 0) {
477 ALOGE("Unknown package: '%s'", String8(args[1]).string());
478 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
479 return BAD_VALUE;
480 }
481 mUidPolicy->removeOverrideUid(uid);
482 return NO_ERROR;
483}
484
485status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
486 PermissionController pc;
487 int uid = pc.getPackageUid(args[1], 0);
488 if (uid < 0) {
489 ALOGE("Unknown package: '%s'", String8(args[1]).string());
490 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
491 return BAD_VALUE;
492 }
493 if (mUidPolicy->isUidActive(uid)) {
494 return dprintf(out, "active\n");
495 } else {
496 return dprintf(out, "idle\n");
497 }
498}
499
500status_t AudioPolicyService::printHelp(int out) {
501 return dprintf(out, "Audio policy service commands:\n"
502 " get-uid-state <PACKAGE> gets the uid state\n"
503 " set-uid-state <PACKAGE> <active|idle> overrides the uid state\n"
504 " reset-uid-state <PACKAGE> clears the uid state override\n"
505 " help print this message\n");
506}
507
508// ----------- AudioPolicyService::UidPolicy implementation ----------
509
510void AudioPolicyService::UidPolicy::registerSelf() {
511 ActivityManager am;
512 am.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
513 | ActivityManager::UID_OBSERVER_IDLE
514 | ActivityManager::UID_OBSERVER_ACTIVE,
515 ActivityManager::PROCESS_STATE_UNKNOWN,
516 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700517 status_t res = am.linkToDeath(this);
518 if (!res) {
519 Mutex::Autolock _l(mLock);
520 mObserverRegistered = true;
521 } else {
522 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
523 am.unregisterUidObserver(this);
524 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800525}
526
527void AudioPolicyService::UidPolicy::unregisterSelf() {
528 ActivityManager am;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700529 am.unlinkToDeath(this);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800530 am.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700531 Mutex::Autolock _l(mLock);
532 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800533}
534
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700535void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
536 Mutex::Autolock _l(mLock);
537 mCachedUids.clear();
538 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800539}
540
541bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700542 if (isServiceUid(uid)) return true;
543 bool needToReregister = false;
544 {
545 Mutex::Autolock _l(mLock);
546 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800547 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700548 if (needToReregister) {
549 // Looks like ActivityManager has died previously, attempt to re-register.
550 registerSelf();
551 }
552 {
553 Mutex::Autolock _l(mLock);
554 auto overrideIter = mOverrideUids.find(uid);
555 if (overrideIter != mOverrideUids.end()) {
556 return overrideIter->second;
557 }
558 // In an absense of the ActivityManager, assume everything to be active.
559 if (!mObserverRegistered) return true;
560 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -0700561 if (cacheIter != mCachedUids.end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700562 return cacheIter->second;
563 }
564 }
565 ActivityManager am;
566 bool active = am.isUidActive(uid, String16("audioserver"));
567 {
568 Mutex::Autolock _l(mLock);
569 mCachedUids.insert(std::pair<uid_t, bool>(uid, active));
570 }
571 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800572}
573
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700574void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
575 updateUidCache(uid, true, true);
576}
577
578void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
579 updateUidCache(uid, false, false);
580}
581
582void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
583 updateUidCache(uid, false, true);
584}
585
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700586void AudioPolicyService::UidPolicy::notifyService(uid_t uid, bool active) {
587 sp<AudioPolicyService> service = mService.promote();
588 if (service != nullptr) {
Eric Laurentf32108e2018-10-04 17:22:04 -0700589 service->setAppState(uid, active ?
590 APP_STATE_FOREGROUND :
591 APP_STATE_IDLE);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700592 }
593}
594
595void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
596 if (isServiceUid(uid)) return;
597 bool wasOverridden = false, wasActive = false;
598 {
599 Mutex::Autolock _l(mLock);
600 updateUidLocked(&mOverrideUids, uid, active, insert, &wasOverridden, &wasActive);
601 }
602 if (!wasOverridden && insert) {
603 notifyService(uid, active); // Started to override.
604 } else if (wasOverridden && !insert) {
605 notifyService(uid, isUidActive(uid)); // Override ceased, notify with ground truth.
606 } else if (wasActive != active) {
607 notifyService(uid, active); // Override updated.
608 }
609}
610
611void AudioPolicyService::UidPolicy::updateUidCache(uid_t uid, bool active, bool insert) {
612 if (isServiceUid(uid)) return;
613 bool wasActive = false;
614 {
615 Mutex::Autolock _l(mLock);
616 updateUidLocked(&mCachedUids, uid, active, insert, nullptr, &wasActive);
617 // Do not notify service if currently overridden.
618 if (mOverrideUids.find(uid) != mOverrideUids.end()) return;
619 }
620 bool nowActive = active && insert;
621 if (wasActive != nowActive) notifyService(uid, nowActive);
622}
623
624void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t, bool> *uids,
625 uid_t uid, bool active, bool insert, bool *wasThere, bool *wasActive) {
626 auto it = uids->find(uid);
627 if (it != uids->end()) {
628 if (wasThere != nullptr) *wasThere = true;
629 if (wasActive != nullptr) *wasActive = it->second;
630 if (insert) {
631 it->second = active;
632 } else {
633 uids->erase(it);
634 }
635 } else if (insert) {
636 uids->insert(std::pair<uid_t, bool>(uid, active));
637 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800638}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700639
Mathias Agopian65ab4712010-07-14 17:59:35 -0700640// ----------- AudioPolicyService::AudioCommandThread implementation ----------
641
Eric Laurentbfb1b832013-01-07 09:53:42 -0800642AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
643 const wp<AudioPolicyService>& service)
644 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700645{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700646}
647
648
649AudioPolicyService::AudioCommandThread::~AudioCommandThread()
650{
Eric Laurentbfb1b832013-01-07 09:53:42 -0800651 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700652 release_wake_lock(mName.string());
653 }
654 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700655}
656
657void AudioPolicyService::AudioCommandThread::onFirstRef()
658{
Eric Laurentbfb1b832013-01-07 09:53:42 -0800659 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700660}
661
662bool AudioPolicyService::AudioCommandThread::threadLoop()
663{
Eric Laurentd7eda8d2016-02-02 17:18:39 -0800664 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700665
666 mLock.lock();
667 while (!exitPending())
668 {
Eric Laurent59a89232014-06-08 14:14:17 -0700669 sp<AudioPolicyService> svc;
670 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700671 nsecs_t curTime = systemTime();
672 // commands are sorted by increasing time stamp: execute them from index 0 and up
673 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -0700674 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -0700675 mAudioCommands.removeAt(0);
Eric Laurent0ede8922014-05-09 18:04:42 -0700676 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700677
678 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700679 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -0700680 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +0100681 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -0700682 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -0700683 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -0700684 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
685 data->mVolume,
686 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -0700687 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700688 }break;
689 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -0700690 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700691 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
692 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -0700693 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700694 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -0700695 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -0700696 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700697 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -0700698 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +0100699 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -0700700 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -0700701 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700702 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -0700703 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700704 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800705 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -0700706 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700707 ALOGV("AudioCommandThread() processing stop output portId %d",
708 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -0700709 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800710 if (svc == 0) {
711 break;
712 }
713 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700714 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800715 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800716 }break;
717 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -0700718 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700719 ALOGV("AudioCommandThread() processing release output portId %d",
720 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -0700721 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800722 if (svc == 0) {
723 break;
724 }
725 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700726 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800727 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800728 }break;
Eric Laurent951f4552014-05-20 10:48:17 -0700729 case CREATE_AUDIO_PATCH: {
730 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
731 ALOGV("AudioCommandThread() processing create audio patch");
732 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
733 if (af == 0) {
734 command->mStatus = PERMISSION_DENIED;
735 } else {
Andy Hungfe726a62018-09-27 15:17:25 -0700736 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -0700737 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -0700738 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -0700739 }
740 } break;
741 case RELEASE_AUDIO_PATCH: {
742 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
743 ALOGV("AudioCommandThread() processing release audio patch");
744 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
745 if (af == 0) {
746 command->mStatus = PERMISSION_DENIED;
747 } else {
Andy Hungfe726a62018-09-27 15:17:25 -0700748 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -0700749 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -0700750 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -0700751 }
752 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -0700753 case UPDATE_AUDIOPORT_LIST: {
754 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -0700755 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -0700756 if (svc == 0) {
757 break;
758 }
759 mLock.unlock();
760 svc->doOnAudioPortListUpdate();
761 mLock.lock();
762 }break;
763 case UPDATE_AUDIOPATCH_LIST: {
764 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -0700765 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -0700766 if (svc == 0) {
767 break;
768 }
769 mLock.unlock();
770 svc->doOnAudioPatchListUpdate();
771 mLock.lock();
772 }break;
Eric Laurente1715a42014-05-20 11:30:42 -0700773 case SET_AUDIOPORT_CONFIG: {
774 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
775 ALOGV("AudioCommandThread() processing set port config");
776 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
777 if (af == 0) {
778 command->mStatus = PERMISSION_DENIED;
779 } else {
Andy Hungfe726a62018-09-27 15:17:25 -0700780 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -0700781 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -0700782 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -0700783 }
784 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -0700785 case DYN_POLICY_MIX_STATE_UPDATE: {
786 DynPolicyMixStateUpdateData *data =
787 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -0700788 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
789 data->mRegId.string(), data->mState);
790 svc = mService.promote();
791 if (svc == 0) {
792 break;
793 }
794 mLock.unlock();
795 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
796 mLock.lock();
797 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800798 case RECORDING_CONFIGURATION_UPDATE: {
799 RecordingConfigurationUpdateData *data =
800 (RecordingConfigurationUpdateData *)command->mParam.get();
801 ALOGV("AudioCommandThread() processing recording configuration update");
802 svc = mService.promote();
803 if (svc == 0) {
804 break;
805 }
806 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800807 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
808 &data->mClientConfig, &data->mDeviceConfig,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800809 data->mPatchHandle);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800810 mLock.lock();
811 } break;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700812 default:
Steve Block5ff1dd52012-01-05 23:22:43 +0000813 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700814 }
Eric Laurent0ede8922014-05-09 18:04:42 -0700815 {
816 Mutex::Autolock _l(command->mLock);
817 if (command->mWaitStatus) {
818 command->mWaitStatus = false;
819 command->mCond.signal();
820 }
821 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -0800822 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +0000823 // release mLock before releasing strong reference on the service as
824 // AudioPolicyService destructor calls AudioCommandThread::exit() which
825 // acquires mLock.
826 mLock.unlock();
827 svc.clear();
828 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700829 } else {
830 waitTime = mAudioCommands[0]->mTime - curTime;
831 break;
832 }
833 }
Zach Janga754b4f2015-10-27 01:29:34 +0000834
835 // release delayed commands wake lock if the queue is empty
836 if (mAudioCommands.isEmpty()) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -0700837 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +0000838 }
839
840 // At this stage we have either an empty command queue or the first command in the queue
841 // has a finite delay. So unless we are exiting it is safe to wait.
842 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -0700843 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -0800844 if (waitTime == -1) {
845 mWaitWorkCV.wait(mLock);
846 } else {
847 mWaitWorkCV.waitRelative(mLock, waitTime);
848 }
Eric Laurent59a89232014-06-08 14:14:17 -0700849 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700850 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -0700851 // release delayed commands wake lock before quitting
852 if (!mAudioCommands.isEmpty()) {
853 release_wake_lock(mName.string());
854 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700855 mLock.unlock();
856 return false;
857}
858
859status_t AudioPolicyService::AudioCommandThread::dump(int fd)
860{
861 const size_t SIZE = 256;
862 char buffer[SIZE];
863 String8 result;
864
865 snprintf(buffer, SIZE, "AudioCommandThread %p Dump\n", this);
866 result.append(buffer);
867 write(fd, result.string(), result.size());
868
869 bool locked = tryLock(mLock);
870 if (!locked) {
871 String8 result2(kCmdDeadlockedString);
872 write(fd, result2.string(), result2.size());
873 }
874
875 snprintf(buffer, SIZE, "- Commands:\n");
876 result = String8(buffer);
877 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -0800878 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700879 mAudioCommands[i]->dump(buffer, SIZE);
880 result.append(buffer);
881 }
882 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -0700883 if (mLastCommand != 0) {
884 mLastCommand->dump(buffer, SIZE);
885 result.append(buffer);
886 } else {
887 result.append(" none\n");
888 }
Mathias Agopian65ab4712010-07-14 17:59:35 -0700889
890 write(fd, result.string(), result.size());
891
892 if (locked) mLock.unlock();
893
894 return NO_ERROR;
895}
896
Glenn Kastenfff6d712012-01-12 16:38:12 -0800897status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -0700898 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800899 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -0700900 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700901{
Eric Laurent0ede8922014-05-09 18:04:42 -0700902 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700903 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -0700904 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700905 data->mStream = stream;
906 data->mVolume = volume;
907 data->mIO = output;
908 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -0700909 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +0100910 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -0700911 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -0700912 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700913}
914
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800915status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -0700916 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -0700917 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700918{
Eric Laurent0ede8922014-05-09 18:04:42 -0700919 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700920 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -0700921 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700922 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -0700923 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700924 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -0700925 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +0100926 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -0700927 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -0700928 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700929}
930
931status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
932{
Eric Laurent0ede8922014-05-09 18:04:42 -0700933 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700934 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -0700935 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700936 data->mVolume = volume;
937 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -0700938 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +0100939 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -0700940 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700941}
942
Eric Laurentd7fe0862018-07-14 16:48:01 -0700943void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -0800944{
Eric Laurent0ede8922014-05-09 18:04:42 -0700945 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800946 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -0700947 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700948 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100949 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700950 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -0700951 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -0800952}
953
Eric Laurentd7fe0862018-07-14 16:48:01 -0700954void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -0800955{
Eric Laurent0ede8922014-05-09 18:04:42 -0700956 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -0800957 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -0700958 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700959 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100960 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700961 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -0700962 sendCommand(command);
963}
964
Eric Laurent951f4552014-05-20 10:48:17 -0700965status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
966 const struct audio_patch *patch,
967 audio_patch_handle_t *handle,
968 int delayMs)
969{
970 status_t status = NO_ERROR;
971
972 sp<AudioCommand> command = new AudioCommand();
973 command->mCommand = CREATE_AUDIO_PATCH;
974 CreateAudioPatchData *data = new CreateAudioPatchData();
975 data->mPatch = *patch;
976 data->mHandle = *handle;
977 command->mParam = data;
978 command->mWaitStatus = true;
979 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
980 status = sendCommand(command, delayMs);
981 if (status == NO_ERROR) {
982 *handle = data->mHandle;
983 }
984 return status;
985}
986
987status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
988 int delayMs)
989{
990 sp<AudioCommand> command = new AudioCommand();
991 command->mCommand = RELEASE_AUDIO_PATCH;
992 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
993 data->mHandle = handle;
994 command->mParam = data;
995 command->mWaitStatus = true;
996 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
997 return sendCommand(command, delayMs);
998}
999
Eric Laurentb52c1522014-05-20 11:27:36 -07001000void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
1001{
1002 sp<AudioCommand> command = new AudioCommand();
1003 command->mCommand = UPDATE_AUDIOPORT_LIST;
1004 ALOGV("AudioCommandThread() adding update audio port list");
1005 sendCommand(command);
1006}
1007
1008void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
1009{
1010 sp<AudioCommand>command = new AudioCommand();
1011 command->mCommand = UPDATE_AUDIOPATCH_LIST;
1012 ALOGV("AudioCommandThread() adding update audio patch list");
1013 sendCommand(command);
1014}
1015
Eric Laurente1715a42014-05-20 11:30:42 -07001016status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
1017 const struct audio_port_config *config, int delayMs)
1018{
1019 sp<AudioCommand> command = new AudioCommand();
1020 command->mCommand = SET_AUDIOPORT_CONFIG;
1021 SetAudioPortConfigData *data = new SetAudioPortConfigData();
1022 data->mConfig = *config;
1023 command->mParam = data;
1024 command->mWaitStatus = true;
1025 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
1026 return sendCommand(command, delayMs);
1027}
1028
Jean-Michel Trivide801052015-04-14 19:10:14 -07001029void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07001030 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07001031{
1032 sp<AudioCommand> command = new AudioCommand();
1033 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
1034 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
1035 data->mRegId = regId;
1036 data->mState = state;
1037 command->mParam = data;
1038 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
1039 regId.string(), state);
1040 sendCommand(command);
1041}
1042
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001043void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08001044 int event, const record_client_info_t *clientInfo,
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08001045 const audio_config_base_t *clientConfig, const audio_config_base_t *deviceConfig,
1046 audio_patch_handle_t patchHandle)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001047{
1048 sp<AudioCommand>command = new AudioCommand();
1049 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
1050 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
1051 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08001052 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08001053 data->mClientConfig = *clientConfig;
1054 data->mDeviceConfig = *deviceConfig;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08001055 data->mPatchHandle = patchHandle;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001056 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08001057 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
1058 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001059 sendCommand(command);
1060}
1061
Eric Laurent0ede8922014-05-09 18:04:42 -07001062status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
1063{
1064 {
1065 Mutex::Autolock _l(mLock);
1066 insertCommand_l(command, delayMs);
1067 mWaitWorkCV.signal();
1068 }
1069 Mutex::Autolock _l(command->mLock);
1070 while (command->mWaitStatus) {
1071 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
1072 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
1073 command->mStatus = TIMED_OUT;
1074 command->mWaitStatus = false;
1075 }
1076 }
1077 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001078}
1079
Mathias Agopian65ab4712010-07-14 17:59:35 -07001080// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07001081void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001082{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08001083 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07001084 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001085 command->mTime = systemTime() + milliseconds(delayMs);
1086
1087 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08001088 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001089 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
1090 }
1091
1092 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07001093 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001094 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001095 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
1096 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07001097
1098 // create audio patch or release audio patch commands are equivalent
1099 // with regard to filtering
1100 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
1101 (command->mCommand == RELEASE_AUDIO_PATCH)) {
1102 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
1103 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
1104 continue;
1105 }
1106 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001107
1108 switch (command->mCommand) {
1109 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001110 ParametersData *data = (ParametersData *)command->mParam.get();
1111 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001112 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01001113 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07001114 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001115 AudioParameter param = AudioParameter(data->mKeyValuePairs);
1116 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
1117 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001118 String8 key;
1119 String8 value;
1120 param.getAt(j, key, value);
1121 for (size_t k = 0; k < param2.size(); k++) {
1122 String8 key2;
1123 String8 value2;
1124 param2.getAt(k, key2, value2);
1125 if (key2 == key) {
1126 param2.remove(key2);
1127 ALOGV("Filtering out parameter %s", key2.string());
1128 break;
1129 }
1130 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001131 }
1132 // if all keys have been filtered out, remove the command.
1133 // otherwise, update the key value pairs
1134 if (param2.size() == 0) {
1135 removedCommands.add(command2);
1136 } else {
1137 data2->mKeyValuePairs = param2.toString();
1138 }
Eric Laurent21e54562013-09-23 12:08:05 -07001139 command->mTime = command2->mTime;
1140 // force delayMs to non 0 so that code below does not request to wait for
1141 // command status as the command is now delayed
1142 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001143 } break;
1144
1145 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001146 VolumeData *data = (VolumeData *)command->mParam.get();
1147 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001148 if (data->mIO != data2->mIO) break;
1149 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01001150 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07001151 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001152 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07001153 command->mTime = command2->mTime;
1154 // force delayMs to non 0 so that code below does not request to wait for
1155 // command status as the command is now delayed
1156 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001157 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07001158
Eric Laurentbaf35fe2016-07-27 15:36:53 -07001159 case SET_VOICE_VOLUME: {
1160 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
1161 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
1162 ALOGV("Filtering out voice volume command value %f replaced by %f",
1163 data2->mVolume, data->mVolume);
1164 removedCommands.add(command2);
1165 command->mTime = command2->mTime;
1166 // force delayMs to non 0 so that code below does not request to wait for
1167 // command status as the command is now delayed
1168 delayMs = 1;
1169 } break;
1170
Eric Laurente45b48a2014-09-04 16:40:57 -07001171 case CREATE_AUDIO_PATCH:
1172 case RELEASE_AUDIO_PATCH: {
1173 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07001174 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07001175 if (command->mCommand == CREATE_AUDIO_PATCH) {
1176 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07001177 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07001178 } else {
1179 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07001180 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07001181 }
1182 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07001183 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07001184 if (command2->mCommand == CREATE_AUDIO_PATCH) {
1185 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07001186 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07001187 } else {
1188 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07001189 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07001190 }
1191 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07001192 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
1193 same output. */
1194 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
1195 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
1196 bool isOutputDiff = false;
1197 if (patch.num_sources == patch2.num_sources) {
1198 for (unsigned count = 0; count < patch.num_sources; count++) {
1199 if (patch.sources[count].id != patch2.sources[count].id) {
1200 isOutputDiff = true;
1201 break;
1202 }
1203 }
1204 if (isOutputDiff)
1205 break;
1206 }
1207 }
Eric Laurente45b48a2014-09-04 16:40:57 -07001208 ALOGV("Filtering out %s audio patch command for handle %d",
1209 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
1210 removedCommands.add(command2);
1211 command->mTime = command2->mTime;
1212 // force delayMs to non 0 so that code below does not request to wait for
1213 // command status as the command is now delayed
1214 delayMs = 1;
1215 } break;
1216
Jean-Michel Trivide801052015-04-14 19:10:14 -07001217 case DYN_POLICY_MIX_STATE_UPDATE: {
1218
1219 } break;
1220
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001221 case RECORDING_CONFIGURATION_UPDATE: {
1222
1223 } break;
1224
Mathias Agopian65ab4712010-07-14 17:59:35 -07001225 default:
1226 break;
1227 }
1228 }
1229
1230 // remove filtered commands
1231 for (size_t j = 0; j < removedCommands.size(); j++) {
1232 // removed commands always have time stamps greater than current command
1233 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001234 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01001235 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001236 mAudioCommands.removeAt(k);
1237 break;
1238 }
1239 }
1240 }
1241 removedCommands.clear();
1242
Eric Laurentaa79bef2015-01-15 14:33:51 -08001243 // Disable wait for status if delay is not 0.
1244 // Except for create audio patch command because the returned patch handle
1245 // is needed by audio policy manager
1246 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07001247 command->mWaitStatus = false;
1248 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07001249
Mathias Agopian65ab4712010-07-14 17:59:35 -07001250 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07001251 ALOGV("inserting command: %d at index %zd, num commands %zu",
1252 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001253 mAudioCommands.insertAt(command, i + 1);
1254}
1255
1256void AudioPolicyService::AudioCommandThread::exit()
1257{
Steve Block3856b092011-10-20 11:56:00 +01001258 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07001259 {
1260 AutoMutex _l(mLock);
1261 requestExit();
1262 mWaitWorkCV.signal();
1263 }
Zach Janga754b4f2015-10-27 01:29:34 +00001264 // Note that we can call it from the thread loop if all other references have been released
1265 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07001266 requestExitAndWait();
1267}
1268
1269void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
1270{
1271 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
1272 mCommand,
1273 (int)ns2s(mTime),
1274 (int)ns2ms(mTime)%1000,
1275 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07001276 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001277}
1278
Dima Zavinfce7a472011-04-19 22:30:36 -07001279/******* helpers for the service_ops callbacks defined below *********/
1280void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
1281 const char *keyValuePairs,
1282 int delayMs)
1283{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001284 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07001285 delayMs);
1286}
1287
1288int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
1289 float volume,
1290 audio_io_handle_t output,
1291 int delayMs)
1292{
Glenn Kastenfff6d712012-01-12 16:38:12 -08001293 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08001294 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07001295}
1296
Dima Zavinfce7a472011-04-19 22:30:36 -07001297int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
1298{
1299 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
1300}
1301
Dima Zavinfce7a472011-04-19 22:30:36 -07001302extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08001303audio_module_handle_t aps_load_hw_module(void *service __unused,
1304 const char *name);
1305audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07001306 audio_devices_t *pDevices,
1307 uint32_t *pSamplingRate,
1308 audio_format_t *pFormat,
1309 audio_channel_mask_t *pChannelMask,
1310 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001311 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07001312
Eric Laurent2d388ec2014-03-07 13:25:54 -08001313audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07001314 audio_module_handle_t module,
1315 audio_devices_t *pDevices,
1316 uint32_t *pSamplingRate,
1317 audio_format_t *pFormat,
1318 audio_channel_mask_t *pChannelMask,
1319 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001320 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001321 const audio_offload_info_t *offloadInfo);
1322audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07001323 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001324 audio_io_handle_t output2);
1325int aps_close_output(void *service __unused, audio_io_handle_t output);
1326int aps_suspend_output(void *service __unused, audio_io_handle_t output);
1327int aps_restore_output(void *service __unused, audio_io_handle_t output);
1328audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07001329 audio_devices_t *pDevices,
1330 uint32_t *pSamplingRate,
1331 audio_format_t *pFormat,
1332 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001333 audio_in_acoustics_t acoustics __unused);
1334audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07001335 audio_module_handle_t module,
1336 audio_devices_t *pDevices,
1337 uint32_t *pSamplingRate,
1338 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001339 audio_channel_mask_t *pChannelMask);
1340int aps_close_input(void *service __unused, audio_io_handle_t input);
1341int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08001342int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07001343 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001344 audio_io_handle_t dst_output);
1345char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
1346 const char *keys);
1347void aps_set_parameters(void *service, audio_io_handle_t io_handle,
1348 const char *kv_pairs, int delay_ms);
1349int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07001350 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08001351 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001352int aps_set_voice_volume(void *service, float volume, int delay_ms);
1353};
Dima Zavinfce7a472011-04-19 22:30:36 -07001354
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001355} // namespace android