blob: b2e30339861900e1146715359109ba319465aa6d [file] [log] [blame]
Eric Laurenta553c252009-07-17 12:17:14 -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
Eric Laurent327c27b2009-08-27 00:48:47 -070019
20#undef __STRICT_ANSI__
21#define __STDINT_LIMITS
22#define __STDC_LIMIT_MACROS
23#include <stdint.h>
24
25#include <sys/time.h>
Eric Laurenta553c252009-07-17 12:17:14 -070026#include <binder/IServiceManager.h>
27#include <utils/Log.h>
28#include <cutils/properties.h>
29#include <binder/IPCThreadState.h>
30#include <utils/String16.h>
31#include <utils/threads.h>
32#include "AudioPolicyService.h"
Eric Laurentcef3cd72009-12-10 01:03:50 -080033#include <hardware_legacy/AudioPolicyManagerBase.h>
Eric Laurenta553c252009-07-17 12:17:14 -070034#include <cutils/properties.h>
35#include <dlfcn.h>
Eric Laurentcef3cd72009-12-10 01:03:50 -080036#include <hardware_legacy/power.h>
Eric Laurenta553c252009-07-17 12:17:14 -070037
38// ----------------------------------------------------------------------------
39// the sim build doesn't have gettid
40
41#ifndef HAVE_GETTID
42# define gettid getpid
43#endif
44
45namespace android {
46
Eric Laurentcef3cd72009-12-10 01:03:50 -080047
48static const char *kDeadlockedString = "AudioPolicyService may be deadlocked\n";
49static const char *kCmdDeadlockedString = "AudioPolicyService command thread may be deadlocked\n";
Eric Laurentf4ee40e2009-11-02 10:29:02 -080050
51static const int kDumpLockRetries = 50;
52static const int kDumpLockSleep = 20000;
53
Eric Laurenta553c252009-07-17 12:17:14 -070054static bool checkPermission() {
55#ifndef HAVE_ANDROID_OS
56 return true;
57#endif
58 if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
59 bool ok = checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS"));
60 if (!ok) LOGE("Request requires android.permission.MODIFY_AUDIO_SETTINGS");
61 return ok;
62}
63
64// ----------------------------------------------------------------------------
65
66AudioPolicyService::AudioPolicyService()
Eric Laurent4192cce2009-07-24 06:58:44 -070067 : BnAudioPolicyService() , mpPolicyManager(NULL)
Eric Laurenta553c252009-07-17 12:17:14 -070068{
Eric Laurenta553c252009-07-17 12:17:14 -070069 char value[PROPERTY_VALUE_MAX];
70
Eric Laurent01635942011-01-18 18:39:02 -080071 Mutex::Autolock _l(mLock);
72
Eric Laurenta553c252009-07-17 12:17:14 -070073 // start tone playback thread
Eric Laurentcef3cd72009-12-10 01:03:50 -080074 mTonePlaybackThread = new AudioCommandThread(String8(""));
Eric Laurenta553c252009-07-17 12:17:14 -070075 // start audio commands thread
Eric Laurentcef3cd72009-12-10 01:03:50 -080076 mAudioCommandThread = new AudioCommandThread(String8("ApmCommandThread"));
Eric Laurenta553c252009-07-17 12:17:14 -070077
Eric Laurent4192cce2009-07-24 06:58:44 -070078#if (defined GENERIC_AUDIO) || (defined AUDIO_POLICY_TEST)
Eric Laurentcef3cd72009-12-10 01:03:50 -080079 mpPolicyManager = new AudioPolicyManagerBase(this);
Eric Laurent4192cce2009-07-24 06:58:44 -070080 LOGV("build for GENERIC_AUDIO - using generic audio policy");
81#else
82 // if running in emulation - use the emulator driver
83 if (property_get("ro.kernel.qemu", value, 0)) {
84 LOGV("Running in emulation - using generic audio policy");
Eric Laurentcef3cd72009-12-10 01:03:50 -080085 mpPolicyManager = new AudioPolicyManagerBase(this);
Eric Laurent4192cce2009-07-24 06:58:44 -070086 }
87 else {
88 LOGV("Using hardware specific audio policy");
89 mpPolicyManager = createAudioPolicyManager(this);
90 }
91#endif
Eric Laurenta553c252009-07-17 12:17:14 -070092
Eric Laurent01635942011-01-18 18:39:02 -080093 if ((mpPolicyManager != NULL) && (mpPolicyManager->initCheck() != NO_ERROR)) {
94 delete mpPolicyManager;
95 mpPolicyManager = NULL;
96 }
97
98 if (mpPolicyManager == NULL) {
99 LOGE("Could not create AudioPolicyManager");
100 } else {
101 // load properties
102 property_get("ro.camera.sound.forced", value, "0");
103 mpPolicyManager->setSystemProperty("ro.camera.sound.forced", value);
104 }
Eric Laurenta553c252009-07-17 12:17:14 -0700105}
106
107AudioPolicyService::~AudioPolicyService()
108{
Eric Laurent327c27b2009-08-27 00:48:47 -0700109 mTonePlaybackThread->exit();
110 mTonePlaybackThread.clear();
Eric Laurenta553c252009-07-17 12:17:14 -0700111 mAudioCommandThread->exit();
112 mAudioCommandThread.clear();
113
114 if (mpPolicyManager) {
Eric Laurent4192cce2009-07-24 06:58:44 -0700115 delete mpPolicyManager;
Eric Laurenta553c252009-07-17 12:17:14 -0700116 }
117}
118
119
120status_t AudioPolicyService::setDeviceConnectionState(AudioSystem::audio_devices device,
121 AudioSystem::device_connection_state state,
122 const char *device_address)
123{
124 if (mpPolicyManager == NULL) {
125 return NO_INIT;
126 }
127 if (!checkPermission()) {
128 return PERMISSION_DENIED;
129 }
130 if (!AudioSystem::isOutputDevice(device) && !AudioSystem::isInputDevice(device)) {
131 return BAD_VALUE;
132 }
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700133 if (state != AudioSystem::DEVICE_STATE_AVAILABLE &&
134 state != AudioSystem::DEVICE_STATE_UNAVAILABLE) {
Eric Laurenta553c252009-07-17 12:17:14 -0700135 return BAD_VALUE;
136 }
137
138 LOGV("setDeviceConnectionState() tid %d", gettid());
139 Mutex::Autolock _l(mLock);
140 return mpPolicyManager->setDeviceConnectionState(device, state, device_address);
141}
142
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700143AudioSystem::device_connection_state AudioPolicyService::getDeviceConnectionState(
144 AudioSystem::audio_devices device,
145 const char *device_address)
Eric Laurenta553c252009-07-17 12:17:14 -0700146{
147 if (mpPolicyManager == NULL) {
148 return AudioSystem::DEVICE_STATE_UNAVAILABLE;
149 }
150 if (!checkPermission()) {
151 return AudioSystem::DEVICE_STATE_UNAVAILABLE;
152 }
153 return mpPolicyManager->getDeviceConnectionState(device, device_address);
154}
155
156status_t AudioPolicyService::setPhoneState(int state)
157{
158 if (mpPolicyManager == NULL) {
159 return NO_INIT;
160 }
161 if (!checkPermission()) {
162 return PERMISSION_DENIED;
163 }
164 if (state < 0 || state >= AudioSystem::NUM_MODES) {
165 return BAD_VALUE;
166 }
167
168 LOGV("setPhoneState() tid %d", gettid());
169
170 // TODO: check if it is more appropriate to do it in platform specific policy manager
171 AudioSystem::setMode(state);
172
173 Mutex::Autolock _l(mLock);
174 mpPolicyManager->setPhoneState(state);
175 return NO_ERROR;
176}
177
178status_t AudioPolicyService::setRingerMode(uint32_t mode, uint32_t mask)
179{
180 if (mpPolicyManager == NULL) {
181 return NO_INIT;
182 }
183 if (!checkPermission()) {
184 return PERMISSION_DENIED;
185 }
186
187 mpPolicyManager->setRingerMode(mode, mask);
188 return NO_ERROR;
189}
190
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700191status_t AudioPolicyService::setForceUse(AudioSystem::force_use usage,
192 AudioSystem::forced_config config)
Eric Laurenta553c252009-07-17 12:17:14 -0700193{
194 if (mpPolicyManager == NULL) {
195 return NO_INIT;
196 }
197 if (!checkPermission()) {
198 return PERMISSION_DENIED;
199 }
200 if (usage < 0 || usage >= AudioSystem::NUM_FORCE_USE) {
201 return BAD_VALUE;
202 }
203 if (config < 0 || config >= AudioSystem::NUM_FORCE_CONFIG) {
204 return BAD_VALUE;
205 }
206 LOGV("setForceUse() tid %d", gettid());
207 Mutex::Autolock _l(mLock);
208 mpPolicyManager->setForceUse(usage, config);
209 return NO_ERROR;
210}
211
212AudioSystem::forced_config AudioPolicyService::getForceUse(AudioSystem::force_use usage)
213{
214 if (mpPolicyManager == NULL) {
215 return AudioSystem::FORCE_NONE;
216 }
217 if (!checkPermission()) {
218 return AudioSystem::FORCE_NONE;
219 }
220 if (usage < 0 || usage >= AudioSystem::NUM_FORCE_USE) {
221 return AudioSystem::FORCE_NONE;
222 }
223 return mpPolicyManager->getForceUse(usage);
224}
225
226audio_io_handle_t AudioPolicyService::getOutput(AudioSystem::stream_type stream,
227 uint32_t samplingRate,
228 uint32_t format,
229 uint32_t channels,
230 AudioSystem::output_flags flags)
231{
232 if (mpPolicyManager == NULL) {
Eric Laurentddb78e72009-07-28 08:44:33 -0700233 return 0;
Eric Laurenta553c252009-07-17 12:17:14 -0700234 }
235 LOGV("getOutput() tid %d", gettid());
236 Mutex::Autolock _l(mLock);
237 return mpPolicyManager->getOutput(stream, samplingRate, format, channels, flags);
238}
239
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700240status_t AudioPolicyService::startOutput(audio_io_handle_t output,
241 AudioSystem::stream_type stream,
242 int session)
Eric Laurenta553c252009-07-17 12:17:14 -0700243{
244 if (mpPolicyManager == NULL) {
245 return NO_INIT;
246 }
247 LOGV("startOutput() tid %d", gettid());
248 Mutex::Autolock _l(mLock);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700249 return mpPolicyManager->startOutput(output, stream, session);
Eric Laurenta553c252009-07-17 12:17:14 -0700250}
251
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700252status_t AudioPolicyService::stopOutput(audio_io_handle_t output,
253 AudioSystem::stream_type stream,
254 int session)
Eric Laurenta553c252009-07-17 12:17:14 -0700255{
256 if (mpPolicyManager == NULL) {
257 return NO_INIT;
258 }
259 LOGV("stopOutput() tid %d", gettid());
260 Mutex::Autolock _l(mLock);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700261 return mpPolicyManager->stopOutput(output, stream, session);
Eric Laurenta553c252009-07-17 12:17:14 -0700262}
263
264void AudioPolicyService::releaseOutput(audio_io_handle_t output)
265{
266 if (mpPolicyManager == NULL) {
267 return;
268 }
269 LOGV("releaseOutput() tid %d", gettid());
270 Mutex::Autolock _l(mLock);
271 mpPolicyManager->releaseOutput(output);
272}
273
274audio_io_handle_t AudioPolicyService::getInput(int inputSource,
275 uint32_t samplingRate,
276 uint32_t format,
277 uint32_t channels,
278 AudioSystem::audio_in_acoustics acoustics)
279{
280 if (mpPolicyManager == NULL) {
Eric Laurentddb78e72009-07-28 08:44:33 -0700281 return 0;
Eric Laurenta553c252009-07-17 12:17:14 -0700282 }
283 Mutex::Autolock _l(mLock);
284 return mpPolicyManager->getInput(inputSource, samplingRate, format, channels, acoustics);
285}
286
287status_t AudioPolicyService::startInput(audio_io_handle_t input)
288{
289 if (mpPolicyManager == NULL) {
290 return NO_INIT;
291 }
292 Mutex::Autolock _l(mLock);
293 return mpPolicyManager->startInput(input);
294}
295
296status_t AudioPolicyService::stopInput(audio_io_handle_t input)
297{
298 if (mpPolicyManager == NULL) {
299 return NO_INIT;
300 }
301 Mutex::Autolock _l(mLock);
302 return mpPolicyManager->stopInput(input);
303}
304
305void AudioPolicyService::releaseInput(audio_io_handle_t input)
306{
307 if (mpPolicyManager == NULL) {
308 return;
309 }
310 Mutex::Autolock _l(mLock);
311 mpPolicyManager->releaseInput(input);
312}
313
314status_t AudioPolicyService::initStreamVolume(AudioSystem::stream_type stream,
315 int indexMin,
316 int indexMax)
317{
318 if (mpPolicyManager == NULL) {
319 return NO_INIT;
320 }
321 if (!checkPermission()) {
322 return PERMISSION_DENIED;
323 }
324 if (stream < 0 || stream >= AudioSystem::NUM_STREAM_TYPES) {
325 return BAD_VALUE;
326 }
327 mpPolicyManager->initStreamVolume(stream, indexMin, indexMax);
328 return NO_ERROR;
329}
330
331status_t AudioPolicyService::setStreamVolumeIndex(AudioSystem::stream_type stream, int index)
332{
333 if (mpPolicyManager == NULL) {
334 return NO_INIT;
335 }
336 if (!checkPermission()) {
337 return PERMISSION_DENIED;
338 }
339 if (stream < 0 || stream >= AudioSystem::NUM_STREAM_TYPES) {
340 return BAD_VALUE;
341 }
342
343 return mpPolicyManager->setStreamVolumeIndex(stream, index);
344}
345
346status_t AudioPolicyService::getStreamVolumeIndex(AudioSystem::stream_type stream, int *index)
347{
348 if (mpPolicyManager == NULL) {
349 return NO_INIT;
350 }
351 if (!checkPermission()) {
352 return PERMISSION_DENIED;
353 }
354 if (stream < 0 || stream >= AudioSystem::NUM_STREAM_TYPES) {
355 return BAD_VALUE;
356 }
357 return mpPolicyManager->getStreamVolumeIndex(stream, index);
358}
359
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700360uint32_t AudioPolicyService::getStrategyForStream(AudioSystem::stream_type stream)
361{
362 if (mpPolicyManager == NULL) {
363 return 0;
364 }
365 return mpPolicyManager->getStrategyForStream(stream);
366}
367
368audio_io_handle_t AudioPolicyService::getOutputForEffect(effect_descriptor_t *desc)
369{
370 if (mpPolicyManager == NULL) {
371 return NO_INIT;
372 }
373 Mutex::Autolock _l(mLock);
374 return mpPolicyManager->getOutputForEffect(desc);
375}
376
377status_t AudioPolicyService::registerEffect(effect_descriptor_t *desc,
378 audio_io_handle_t output,
379 uint32_t strategy,
380 int session,
381 int id)
382{
383 if (mpPolicyManager == NULL) {
384 return NO_INIT;
385 }
386 return mpPolicyManager->registerEffect(desc, output, strategy, session, id);
387}
388
389status_t AudioPolicyService::unregisterEffect(int id)
390{
391 if (mpPolicyManager == NULL) {
392 return NO_INIT;
393 }
394 return mpPolicyManager->unregisterEffect(id);
395}
396
Eric Laurenta553c252009-07-17 12:17:14 -0700397void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700398 LOGW("binderDied() %p, tid %d, calling tid %d", who.unsafe_get(), gettid(),
399 IPCThreadState::self()->getCallingPid());
Eric Laurenta553c252009-07-17 12:17:14 -0700400}
401
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800402static bool tryLock(Mutex& mutex)
403{
404 bool locked = false;
405 for (int i = 0; i < kDumpLockRetries; ++i) {
406 if (mutex.tryLock() == NO_ERROR) {
407 locked = true;
408 break;
409 }
410 usleep(kDumpLockSleep);
411 }
412 return locked;
413}
414
415status_t AudioPolicyService::dumpInternals(int fd)
416{
417 const size_t SIZE = 256;
418 char buffer[SIZE];
419 String8 result;
420
421 snprintf(buffer, SIZE, "PolicyManager Interface: %p\n", mpPolicyManager);
422 result.append(buffer);
423 snprintf(buffer, SIZE, "Command Thread: %p\n", mAudioCommandThread.get());
424 result.append(buffer);
425 snprintf(buffer, SIZE, "Tones Thread: %p\n", mTonePlaybackThread.get());
426 result.append(buffer);
427
428 write(fd, result.string(), result.size());
429 return NO_ERROR;
430}
431
Eric Laurenta553c252009-07-17 12:17:14 -0700432status_t AudioPolicyService::dump(int fd, const Vector<String16>& args)
433{
434 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800435 dumpPermissionDenial(fd);
Eric Laurenta553c252009-07-17 12:17:14 -0700436 } else {
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800437 bool locked = tryLock(mLock);
438 if (!locked) {
439 String8 result(kDeadlockedString);
440 write(fd, result.string(), result.size());
441 }
Eric Laurenta553c252009-07-17 12:17:14 -0700442
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800443 dumpInternals(fd);
444 if (mAudioCommandThread != NULL) {
445 mAudioCommandThread->dump(fd);
446 }
447 if (mTonePlaybackThread != NULL) {
448 mTonePlaybackThread->dump(fd);
449 }
450
451 if (mpPolicyManager) {
452 mpPolicyManager->dump(fd);
453 }
454
455 if (locked) mLock.unlock();
Eric Laurenta553c252009-07-17 12:17:14 -0700456 }
457 return NO_ERROR;
458}
459
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800460status_t AudioPolicyService::dumpPermissionDenial(int fd)
Eric Laurenta553c252009-07-17 12:17:14 -0700461{
462 const size_t SIZE = 256;
463 char buffer[SIZE];
464 String8 result;
465 snprintf(buffer, SIZE, "Permission Denial: "
466 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
467 IPCThreadState::self()->getCallingPid(),
468 IPCThreadState::self()->getCallingUid());
469 result.append(buffer);
470 write(fd, result.string(), result.size());
471 return NO_ERROR;
472}
473
474status_t AudioPolicyService::onTransact(
475 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
476{
477 return BnAudioPolicyService::onTransact(code, data, reply, flags);
478}
479
480
481// ----------------------------------------------------------------------------
Eric Laurenta553c252009-07-17 12:17:14 -0700482// AudioPolicyClientInterface implementation
483// ----------------------------------------------------------------------------
484
485
486audio_io_handle_t AudioPolicyService::openOutput(uint32_t *pDevices,
487 uint32_t *pSamplingRate,
488 uint32_t *pFormat,
489 uint32_t *pChannels,
490 uint32_t *pLatencyMs,
491 AudioSystem::output_flags flags)
492{
493 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
494 if (af == 0) {
495 LOGW("openOutput() could not get AudioFlinger");
Eric Laurentddb78e72009-07-28 08:44:33 -0700496 return 0;
Eric Laurenta553c252009-07-17 12:17:14 -0700497 }
498
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700499 return af->openOutput(pDevices,
500 pSamplingRate,
501 (uint32_t *)pFormat,
502 pChannels,
503 pLatencyMs,
504 flags);
Eric Laurenta553c252009-07-17 12:17:14 -0700505}
506
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700507audio_io_handle_t AudioPolicyService::openDuplicateOutput(audio_io_handle_t output1,
508 audio_io_handle_t output2)
Eric Laurenta553c252009-07-17 12:17:14 -0700509{
510 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
511 if (af == 0) {
512 LOGW("openDuplicateOutput() could not get AudioFlinger");
Eric Laurentddb78e72009-07-28 08:44:33 -0700513 return 0;
Eric Laurenta553c252009-07-17 12:17:14 -0700514 }
515 return af->openDuplicateOutput(output1, output2);
516}
517
518status_t AudioPolicyService::closeOutput(audio_io_handle_t output)
519{
520 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
521 if (af == 0) return PERMISSION_DENIED;
522
523 return af->closeOutput(output);
524}
525
526
527status_t AudioPolicyService::suspendOutput(audio_io_handle_t output)
528{
529 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
530 if (af == 0) {
531 LOGW("suspendOutput() could not get AudioFlinger");
532 return PERMISSION_DENIED;
533 }
534
535 return af->suspendOutput(output);
536}
537
538status_t AudioPolicyService::restoreOutput(audio_io_handle_t output)
539{
540 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
541 if (af == 0) {
542 LOGW("restoreOutput() could not get AudioFlinger");
543 return PERMISSION_DENIED;
544 }
545
546 return af->restoreOutput(output);
547}
548
549audio_io_handle_t AudioPolicyService::openInput(uint32_t *pDevices,
550 uint32_t *pSamplingRate,
551 uint32_t *pFormat,
552 uint32_t *pChannels,
553 uint32_t acoustics)
554{
555 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
556 if (af == 0) {
557 LOGW("openInput() could not get AudioFlinger");
Eric Laurentddb78e72009-07-28 08:44:33 -0700558 return 0;
Eric Laurenta553c252009-07-17 12:17:14 -0700559 }
560
561 return af->openInput(pDevices, pSamplingRate, (uint32_t *)pFormat, pChannels, acoustics);
562}
563
564status_t AudioPolicyService::closeInput(audio_io_handle_t input)
565{
566 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
567 if (af == 0) return PERMISSION_DENIED;
568
569 return af->closeInput(input);
570}
571
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700572status_t AudioPolicyService::setStreamVolume(AudioSystem::stream_type stream,
573 float volume,
574 audio_io_handle_t output,
575 int delayMs)
Eric Laurenta553c252009-07-17 12:17:14 -0700576{
Eric Laurent327c27b2009-08-27 00:48:47 -0700577 return mAudioCommandThread->volumeCommand((int)stream, volume, (int)output, delayMs);
Eric Laurenta553c252009-07-17 12:17:14 -0700578}
579
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700580status_t AudioPolicyService::setStreamOutput(AudioSystem::stream_type stream,
581 audio_io_handle_t output)
Eric Laurenta553c252009-07-17 12:17:14 -0700582{
583 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
584 if (af == 0) return PERMISSION_DENIED;
585
586 return af->setStreamOutput(stream, output);
587}
588
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700589status_t AudioPolicyService::moveEffects(int session, audio_io_handle_t srcOutput,
590 audio_io_handle_t dstOutput)
591{
592 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
593 if (af == 0) return PERMISSION_DENIED;
Eric Laurenta553c252009-07-17 12:17:14 -0700594
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700595 return af->moveEffects(session, (int)srcOutput, (int)dstOutput);
596}
597
598void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
599 const String8& keyValuePairs,
600 int delayMs)
Eric Laurenta553c252009-07-17 12:17:14 -0700601{
Eric Laurent327c27b2009-08-27 00:48:47 -0700602 mAudioCommandThread->parametersCommand((int)ioHandle, keyValuePairs, delayMs);
Eric Laurenta553c252009-07-17 12:17:14 -0700603}
604
605String8 AudioPolicyService::getParameters(audio_io_handle_t ioHandle, const String8& keys)
606{
607 String8 result = AudioSystem::getParameters(ioHandle, keys);
608 return result;
609}
610
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700611status_t AudioPolicyService::startTone(ToneGenerator::tone_type tone,
612 AudioSystem::stream_type stream)
Eric Laurenta553c252009-07-17 12:17:14 -0700613{
Eric Laurent327c27b2009-08-27 00:48:47 -0700614 mTonePlaybackThread->startToneCommand(tone, stream);
Eric Laurenta553c252009-07-17 12:17:14 -0700615 return NO_ERROR;
616}
617
618status_t AudioPolicyService::stopTone()
619{
Eric Laurent327c27b2009-08-27 00:48:47 -0700620 mTonePlaybackThread->stopToneCommand();
Eric Laurenta553c252009-07-17 12:17:14 -0700621 return NO_ERROR;
622}
623
Eric Laurent415f3e22009-10-21 08:14:22 -0700624status_t AudioPolicyService::setVoiceVolume(float volume, int delayMs)
625{
626 return mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
627}
Eric Laurenta553c252009-07-17 12:17:14 -0700628
629// ----------- AudioPolicyService::AudioCommandThread implementation ----------
630
Eric Laurentcef3cd72009-12-10 01:03:50 -0800631AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name)
632 : Thread(false), mName(name)
Eric Laurenta553c252009-07-17 12:17:14 -0700633{
634 mpToneGenerator = NULL;
635}
636
637
638AudioPolicyService::AudioCommandThread::~AudioCommandThread()
639{
Eric Laurentcef3cd72009-12-10 01:03:50 -0800640 if (mName != "" && !mAudioCommands.isEmpty()) {
641 release_wake_lock(mName.string());
642 }
Eric Laurenta553c252009-07-17 12:17:14 -0700643 mAudioCommands.clear();
644 if (mpToneGenerator != NULL) delete mpToneGenerator;
645}
646
647void AudioPolicyService::AudioCommandThread::onFirstRef()
648{
Eric Laurentcef3cd72009-12-10 01:03:50 -0800649 if (mName != "") {
650 run(mName.string(), ANDROID_PRIORITY_AUDIO);
651 } else {
652 run("AudioCommandThread", ANDROID_PRIORITY_AUDIO);
653 }
Eric Laurenta553c252009-07-17 12:17:14 -0700654}
655
656bool AudioPolicyService::AudioCommandThread::threadLoop()
657{
Eric Laurent327c27b2009-08-27 00:48:47 -0700658 nsecs_t waitTime = INT64_MAX;
659
Eric Laurenta553c252009-07-17 12:17:14 -0700660 mLock.lock();
661 while (!exitPending())
662 {
663 while(!mAudioCommands.isEmpty()) {
Eric Laurent327c27b2009-08-27 00:48:47 -0700664 nsecs_t curTime = systemTime();
665 // commands are sorted by increasing time stamp: execute them from index 0 and up
666 if (mAudioCommands[0]->mTime <= curTime) {
667 AudioCommand *command = mAudioCommands[0];
668 mAudioCommands.removeAt(0);
Eric Laurent3fdb1262009-11-07 00:01:32 -0800669 mLastCommand = *command;
670
Eric Laurent327c27b2009-08-27 00:48:47 -0700671 switch (command->mCommand) {
672 case START_TONE: {
673 mLock.unlock();
674 ToneData *data = (ToneData *)command->mParam;
675 LOGV("AudioCommandThread() processing start tone %d on stream %d",
676 data->mType, data->mStream);
677 if (mpToneGenerator != NULL)
678 delete mpToneGenerator;
679 mpToneGenerator = new ToneGenerator(data->mStream, 1.0);
680 mpToneGenerator->startTone(data->mType);
681 delete data;
682 mLock.lock();
683 }break;
684 case STOP_TONE: {
685 mLock.unlock();
686 LOGV("AudioCommandThread() processing stop tone");
687 if (mpToneGenerator != NULL) {
688 mpToneGenerator->stopTone();
689 delete mpToneGenerator;
690 mpToneGenerator = NULL;
691 }
692 mLock.lock();
693 }break;
694 case SET_VOLUME: {
695 VolumeData *data = (VolumeData *)command->mParam;
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700696 LOGV("AudioCommandThread() processing set volume stream %d, \
697 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
698 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
699 data->mVolume,
700 data->mIO);
Eric Laurent327c27b2009-08-27 00:48:47 -0700701 if (command->mWaitStatus) {
702 command->mCond.signal();
703 mWaitWorkCV.wait(mLock);
704 }
705 delete data;
706 }break;
707 case SET_PARAMETERS: {
708 ParametersData *data = (ParametersData *)command->mParam;
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700709 LOGV("AudioCommandThread() processing set parameters string %s, io %d",
710 data->mKeyValuePairs.string(), data->mIO);
Eric Laurent327c27b2009-08-27 00:48:47 -0700711 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
712 if (command->mWaitStatus) {
713 command->mCond.signal();
714 mWaitWorkCV.wait(mLock);
715 }
716 delete data;
717 }break;
Eric Laurent415f3e22009-10-21 08:14:22 -0700718 case SET_VOICE_VOLUME: {
719 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam;
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700720 LOGV("AudioCommandThread() processing set voice volume volume %f",
721 data->mVolume);
Eric Laurent415f3e22009-10-21 08:14:22 -0700722 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
723 if (command->mWaitStatus) {
724 command->mCond.signal();
725 mWaitWorkCV.wait(mLock);
726 }
727 delete data;
728 }break;
Eric Laurent327c27b2009-08-27 00:48:47 -0700729 default:
730 LOGW("AudioCommandThread() unknown command %d", command->mCommand);
Eric Laurenta553c252009-07-17 12:17:14 -0700731 }
Eric Laurent327c27b2009-08-27 00:48:47 -0700732 delete command;
733 waitTime = INT64_MAX;
734 } else {
735 waitTime = mAudioCommands[0]->mTime - curTime;
736 break;
Eric Laurenta553c252009-07-17 12:17:14 -0700737 }
Eric Laurenta553c252009-07-17 12:17:14 -0700738 }
Eric Laurentcef3cd72009-12-10 01:03:50 -0800739 // release delayed commands wake lock
740 if (mName != "" && mAudioCommands.isEmpty()) {
741 release_wake_lock(mName.string());
742 }
Eric Laurenta553c252009-07-17 12:17:14 -0700743 LOGV("AudioCommandThread() going to sleep");
Eric Laurent327c27b2009-08-27 00:48:47 -0700744 mWaitWorkCV.waitRelative(mLock, waitTime);
Eric Laurenta553c252009-07-17 12:17:14 -0700745 LOGV("AudioCommandThread() waking up");
746 }
747 mLock.unlock();
748 return false;
749}
750
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800751status_t AudioPolicyService::AudioCommandThread::dump(int fd)
752{
753 const size_t SIZE = 256;
754 char buffer[SIZE];
755 String8 result;
756
757 snprintf(buffer, SIZE, "AudioCommandThread %p Dump\n", this);
758 result.append(buffer);
759 write(fd, result.string(), result.size());
760
761 bool locked = tryLock(mLock);
762 if (!locked) {
763 String8 result2(kCmdDeadlockedString);
764 write(fd, result2.string(), result2.size());
765 }
766
767 snprintf(buffer, SIZE, "- Commands:\n");
768 result = String8(buffer);
Eric Laurent3fdb1262009-11-07 00:01:32 -0800769 result.append(" Command Time Wait pParam\n");
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800770 for (int i = 0; i < (int)mAudioCommands.size(); i++) {
771 mAudioCommands[i]->dump(buffer, SIZE);
772 result.append(buffer);
773 }
Eric Laurent3fdb1262009-11-07 00:01:32 -0800774 result.append(" Last Command\n");
775 mLastCommand.dump(buffer, SIZE);
776 result.append(buffer);
777
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800778 write(fd, result.string(), result.size());
779
780 if (locked) mLock.unlock();
781
782 return NO_ERROR;
783}
784
Eric Laurenta553c252009-07-17 12:17:14 -0700785void AudioPolicyService::AudioCommandThread::startToneCommand(int type, int stream)
786{
Eric Laurenta553c252009-07-17 12:17:14 -0700787 AudioCommand *command = new AudioCommand();
788 command->mCommand = START_TONE;
789 ToneData *data = new ToneData();
790 data->mType = type;
791 data->mStream = stream;
792 command->mParam = (void *)data;
Eric Laurent327c27b2009-08-27 00:48:47 -0700793 command->mWaitStatus = false;
Eric Laurent415f3e22009-10-21 08:14:22 -0700794 Mutex::Autolock _l(mLock);
Eric Laurent327c27b2009-08-27 00:48:47 -0700795 insertCommand_l(command);
Eric Laurenta553c252009-07-17 12:17:14 -0700796 LOGV("AudioCommandThread() adding tone start type %d, stream %d", type, stream);
797 mWaitWorkCV.signal();
798}
799
800void AudioPolicyService::AudioCommandThread::stopToneCommand()
801{
Eric Laurenta553c252009-07-17 12:17:14 -0700802 AudioCommand *command = new AudioCommand();
803 command->mCommand = STOP_TONE;
804 command->mParam = NULL;
Eric Laurent327c27b2009-08-27 00:48:47 -0700805 command->mWaitStatus = false;
Eric Laurent415f3e22009-10-21 08:14:22 -0700806 Mutex::Autolock _l(mLock);
Eric Laurent327c27b2009-08-27 00:48:47 -0700807 insertCommand_l(command);
Eric Laurenta553c252009-07-17 12:17:14 -0700808 LOGV("AudioCommandThread() adding tone stop");
809 mWaitWorkCV.signal();
810}
811
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700812status_t AudioPolicyService::AudioCommandThread::volumeCommand(int stream,
813 float volume,
814 int output,
815 int delayMs)
Eric Laurenta553c252009-07-17 12:17:14 -0700816{
Eric Laurent327c27b2009-08-27 00:48:47 -0700817 status_t status = NO_ERROR;
818
Eric Laurenta553c252009-07-17 12:17:14 -0700819 AudioCommand *command = new AudioCommand();
820 command->mCommand = SET_VOLUME;
821 VolumeData *data = new VolumeData();
822 data->mStream = stream;
823 data->mVolume = volume;
824 data->mIO = output;
825 command->mParam = data;
Eric Laurent327c27b2009-08-27 00:48:47 -0700826 if (delayMs == 0) {
827 command->mWaitStatus = true;
828 } else {
829 command->mWaitStatus = false;
830 }
Eric Laurent415f3e22009-10-21 08:14:22 -0700831 Mutex::Autolock _l(mLock);
Eric Laurent327c27b2009-08-27 00:48:47 -0700832 insertCommand_l(command, delayMs);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700833 LOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
834 stream, volume, output);
Eric Laurenta553c252009-07-17 12:17:14 -0700835 mWaitWorkCV.signal();
Eric Laurent327c27b2009-08-27 00:48:47 -0700836 if (command->mWaitStatus) {
837 command->mCond.wait(mLock);
838 status = command->mStatus;
839 mWaitWorkCV.signal();
840 }
Eric Laurenta553c252009-07-17 12:17:14 -0700841 return status;
842}
843
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700844status_t AudioPolicyService::AudioCommandThread::parametersCommand(int ioHandle,
845 const String8& keyValuePairs,
846 int delayMs)
Eric Laurenta553c252009-07-17 12:17:14 -0700847{
Eric Laurent327c27b2009-08-27 00:48:47 -0700848 status_t status = NO_ERROR;
849
Eric Laurenta553c252009-07-17 12:17:14 -0700850 AudioCommand *command = new AudioCommand();
851 command->mCommand = SET_PARAMETERS;
852 ParametersData *data = new ParametersData();
853 data->mIO = ioHandle;
854 data->mKeyValuePairs = keyValuePairs;
855 command->mParam = data;
Eric Laurent327c27b2009-08-27 00:48:47 -0700856 if (delayMs == 0) {
857 command->mWaitStatus = true;
858 } else {
859 command->mWaitStatus = false;
860 }
Eric Laurent415f3e22009-10-21 08:14:22 -0700861 Mutex::Autolock _l(mLock);
Eric Laurent327c27b2009-08-27 00:48:47 -0700862 insertCommand_l(command, delayMs);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700863 LOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
864 keyValuePairs.string(), ioHandle, delayMs);
Eric Laurenta553c252009-07-17 12:17:14 -0700865 mWaitWorkCV.signal();
Eric Laurent327c27b2009-08-27 00:48:47 -0700866 if (command->mWaitStatus) {
867 command->mCond.wait(mLock);
868 status = command->mStatus;
869 mWaitWorkCV.signal();
870 }
Eric Laurenta553c252009-07-17 12:17:14 -0700871 return status;
872}
873
Eric Laurent415f3e22009-10-21 08:14:22 -0700874status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
875{
876 status_t status = NO_ERROR;
877
878 AudioCommand *command = new AudioCommand();
879 command->mCommand = SET_VOICE_VOLUME;
880 VoiceVolumeData *data = new VoiceVolumeData();
881 data->mVolume = volume;
882 command->mParam = data;
883 if (delayMs == 0) {
884 command->mWaitStatus = true;
885 } else {
886 command->mWaitStatus = false;
887 }
888 Mutex::Autolock _l(mLock);
889 insertCommand_l(command, delayMs);
890 LOGV("AudioCommandThread() adding set voice volume volume %f", volume);
891 mWaitWorkCV.signal();
892 if (command->mWaitStatus) {
893 command->mCond.wait(mLock);
894 status = command->mStatus;
895 mWaitWorkCV.signal();
896 }
897 return status;
898}
899
Eric Laurent327c27b2009-08-27 00:48:47 -0700900// insertCommand_l() must be called with mLock held
901void AudioPolicyService::AudioCommandThread::insertCommand_l(AudioCommand *command, int delayMs)
902{
903 ssize_t i;
904 Vector <AudioCommand *> removedCommands;
905
906 command->mTime = systemTime() + milliseconds(delayMs);
907
Eric Laurentcef3cd72009-12-10 01:03:50 -0800908 // acquire wake lock to make sure delayed commands are processed
909 if (mName != "" && mAudioCommands.isEmpty()) {
910 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
911 }
912
Eric Laurent327c27b2009-08-27 00:48:47 -0700913 // check same pending commands with later time stamps and eliminate them
914 for (i = mAudioCommands.size()-1; i >= 0; i--) {
915 AudioCommand *command2 = mAudioCommands[i];
916 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
917 if (command2->mTime <= command->mTime) break;
918 if (command2->mCommand != command->mCommand) continue;
919
920 switch (command->mCommand) {
921 case SET_PARAMETERS: {
922 ParametersData *data = (ParametersData *)command->mParam;
923 ParametersData *data2 = (ParametersData *)command2->mParam;
924 if (data->mIO != data2->mIO) break;
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700925 LOGV("Comparing parameter command %s to new command %s",
926 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Eric Laurent327c27b2009-08-27 00:48:47 -0700927 AudioParameter param = AudioParameter(data->mKeyValuePairs);
928 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
929 for (size_t j = 0; j < param.size(); j++) {
930 String8 key;
931 String8 value;
932 param.getAt(j, key, value);
933 for (size_t k = 0; k < param2.size(); k++) {
934 String8 key2;
935 String8 value2;
936 param2.getAt(k, key2, value2);
937 if (key2 == key) {
938 param2.remove(key2);
939 LOGV("Filtering out parameter %s", key2.string());
940 break;
941 }
942 }
943 }
944 // if all keys have been filtered out, remove the command.
945 // otherwise, update the key value pairs
946 if (param2.size() == 0) {
947 removedCommands.add(command2);
948 } else {
949 data2->mKeyValuePairs = param2.toString();
950 }
951 } break;
952
953 case SET_VOLUME: {
954 VolumeData *data = (VolumeData *)command->mParam;
955 VolumeData *data2 = (VolumeData *)command2->mParam;
956 if (data->mIO != data2->mIO) break;
957 if (data->mStream != data2->mStream) break;
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700958 LOGV("Filtering out volume command on output %d for stream %d",
959 data->mIO, data->mStream);
Eric Laurent327c27b2009-08-27 00:48:47 -0700960 removedCommands.add(command2);
961 } break;
962 case START_TONE:
963 case STOP_TONE:
964 default:
965 break;
966 }
967 }
968
969 // remove filtered commands
970 for (size_t j = 0; j < removedCommands.size(); j++) {
971 // removed commands always have time stamps greater than current command
972 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
973 if (mAudioCommands[k] == removedCommands[j]) {
974 LOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
975 mAudioCommands.removeAt(k);
976 break;
977 }
978 }
979 }
980 removedCommands.clear();
981
982 // insert command at the right place according to its time stamp
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700983 LOGV("inserting command: %d at index %d, num commands %d",
984 command->mCommand, (int)i+1, mAudioCommands.size());
Eric Laurent327c27b2009-08-27 00:48:47 -0700985 mAudioCommands.insertAt(command, i + 1);
986}
987
Eric Laurenta553c252009-07-17 12:17:14 -0700988void AudioPolicyService::AudioCommandThread::exit()
989{
990 LOGV("AudioCommandThread::exit");
991 {
992 AutoMutex _l(mLock);
993 requestExit();
994 mWaitWorkCV.signal();
995 }
996 requestExitAndWait();
997}
998
Eric Laurentf4ee40e2009-11-02 10:29:02 -0800999void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
1000{
Eric Laurent3fdb1262009-11-07 00:01:32 -08001001 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
Eric Laurentf4ee40e2009-11-02 10:29:02 -08001002 mCommand,
1003 (int)ns2s(mTime),
1004 (int)ns2ms(mTime)%1000,
Eric Laurentf4ee40e2009-11-02 10:29:02 -08001005 mWaitStatus,
1006 mParam);
1007}
1008
Eric Laurenta553c252009-07-17 12:17:14 -07001009}; // namespace android