Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 1 | /* |
| 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 19 | |
| 20 | #undef __STRICT_ANSI__ |
| 21 | #define __STDINT_LIMITS |
| 22 | #define __STDC_LIMIT_MACROS |
| 23 | #include <stdint.h> |
| 24 | |
| 25 | #include <sys/time.h> |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 26 | #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 Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 33 | #include <hardware_legacy/AudioPolicyManagerBase.h> |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 34 | #include <cutils/properties.h> |
| 35 | #include <dlfcn.h> |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 36 | #include <hardware_legacy/power.h> |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 37 | |
| 38 | // ---------------------------------------------------------------------------- |
| 39 | // the sim build doesn't have gettid |
| 40 | |
| 41 | #ifndef HAVE_GETTID |
| 42 | # define gettid getpid |
| 43 | #endif |
| 44 | |
| 45 | namespace android { |
| 46 | |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 47 | |
| 48 | static const char *kDeadlockedString = "AudioPolicyService may be deadlocked\n"; |
| 49 | static const char *kCmdDeadlockedString = "AudioPolicyService command thread may be deadlocked\n"; |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 50 | |
| 51 | static const int kDumpLockRetries = 50; |
| 52 | static const int kDumpLockSleep = 20000; |
| 53 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 54 | static 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 | |
| 66 | AudioPolicyService::AudioPolicyService() |
Eric Laurent | 4192cce | 2009-07-24 06:58:44 -0700 | [diff] [blame] | 67 | : BnAudioPolicyService() , mpPolicyManager(NULL) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 68 | { |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 69 | char value[PROPERTY_VALUE_MAX]; |
| 70 | |
Eric Laurent | 0163594 | 2011-01-18 18:39:02 -0800 | [diff] [blame] | 71 | Mutex::Autolock _l(mLock); |
| 72 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 73 | // start tone playback thread |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 74 | mTonePlaybackThread = new AudioCommandThread(String8("")); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 75 | // start audio commands thread |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 76 | mAudioCommandThread = new AudioCommandThread(String8("ApmCommandThread")); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 77 | |
Eric Laurent | 4192cce | 2009-07-24 06:58:44 -0700 | [diff] [blame] | 78 | #if (defined GENERIC_AUDIO) || (defined AUDIO_POLICY_TEST) |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 79 | mpPolicyManager = new AudioPolicyManagerBase(this); |
Eric Laurent | 4192cce | 2009-07-24 06:58:44 -0700 | [diff] [blame] | 80 | 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 Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 85 | mpPolicyManager = new AudioPolicyManagerBase(this); |
Eric Laurent | 4192cce | 2009-07-24 06:58:44 -0700 | [diff] [blame] | 86 | } |
| 87 | else { |
| 88 | LOGV("Using hardware specific audio policy"); |
| 89 | mpPolicyManager = createAudioPolicyManager(this); |
| 90 | } |
| 91 | #endif |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 92 | |
Eric Laurent | 0163594 | 2011-01-18 18:39:02 -0800 | [diff] [blame] | 93 | 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 Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | AudioPolicyService::~AudioPolicyService() |
| 108 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 109 | mTonePlaybackThread->exit(); |
| 110 | mTonePlaybackThread.clear(); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 111 | mAudioCommandThread->exit(); |
| 112 | mAudioCommandThread.clear(); |
| 113 | |
| 114 | if (mpPolicyManager) { |
Eric Laurent | 4192cce | 2009-07-24 06:58:44 -0700 | [diff] [blame] | 115 | delete mpPolicyManager; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 116 | } |
| 117 | } |
| 118 | |
| 119 | |
| 120 | status_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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 133 | if (state != AudioSystem::DEVICE_STATE_AVAILABLE && |
| 134 | state != AudioSystem::DEVICE_STATE_UNAVAILABLE) { |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 135 | 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 143 | AudioSystem::device_connection_state AudioPolicyService::getDeviceConnectionState( |
| 144 | AudioSystem::audio_devices device, |
| 145 | const char *device_address) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 146 | { |
| 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 | |
| 156 | status_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 | |
| 178 | status_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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 191 | status_t AudioPolicyService::setForceUse(AudioSystem::force_use usage, |
| 192 | AudioSystem::forced_config config) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 193 | { |
| 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 | |
| 212 | AudioSystem::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 | |
| 226 | audio_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 Laurent | ddb78e7 | 2009-07-28 08:44:33 -0700 | [diff] [blame] | 233 | return 0; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 234 | } |
| 235 | LOGV("getOutput() tid %d", gettid()); |
| 236 | Mutex::Autolock _l(mLock); |
| 237 | return mpPolicyManager->getOutput(stream, samplingRate, format, channels, flags); |
| 238 | } |
| 239 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 240 | status_t AudioPolicyService::startOutput(audio_io_handle_t output, |
| 241 | AudioSystem::stream_type stream, |
| 242 | int session) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 243 | { |
| 244 | if (mpPolicyManager == NULL) { |
| 245 | return NO_INIT; |
| 246 | } |
| 247 | LOGV("startOutput() tid %d", gettid()); |
| 248 | Mutex::Autolock _l(mLock); |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 249 | return mpPolicyManager->startOutput(output, stream, session); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 252 | status_t AudioPolicyService::stopOutput(audio_io_handle_t output, |
| 253 | AudioSystem::stream_type stream, |
| 254 | int session) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 255 | { |
| 256 | if (mpPolicyManager == NULL) { |
| 257 | return NO_INIT; |
| 258 | } |
| 259 | LOGV("stopOutput() tid %d", gettid()); |
| 260 | Mutex::Autolock _l(mLock); |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 261 | return mpPolicyManager->stopOutput(output, stream, session); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 262 | } |
| 263 | |
| 264 | void 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 | |
| 274 | audio_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 Laurent | ddb78e7 | 2009-07-28 08:44:33 -0700 | [diff] [blame] | 281 | return 0; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 282 | } |
| 283 | Mutex::Autolock _l(mLock); |
| 284 | return mpPolicyManager->getInput(inputSource, samplingRate, format, channels, acoustics); |
| 285 | } |
| 286 | |
| 287 | status_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 | |
| 296 | status_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 | |
| 305 | void 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 | |
| 314 | status_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 | |
| 331 | status_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 | |
| 346 | status_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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 360 | uint32_t AudioPolicyService::getStrategyForStream(AudioSystem::stream_type stream) |
| 361 | { |
| 362 | if (mpPolicyManager == NULL) { |
| 363 | return 0; |
| 364 | } |
| 365 | return mpPolicyManager->getStrategyForStream(stream); |
| 366 | } |
| 367 | |
| 368 | audio_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 | |
| 377 | status_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 | |
| 389 | status_t AudioPolicyService::unregisterEffect(int id) |
| 390 | { |
| 391 | if (mpPolicyManager == NULL) { |
| 392 | return NO_INIT; |
| 393 | } |
| 394 | return mpPolicyManager->unregisterEffect(id); |
| 395 | } |
| 396 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 397 | void AudioPolicyService::binderDied(const wp<IBinder>& who) { |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 398 | LOGW("binderDied() %p, tid %d, calling tid %d", who.unsafe_get(), gettid(), |
| 399 | IPCThreadState::self()->getCallingPid()); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 400 | } |
| 401 | |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 402 | static 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 | |
| 415 | status_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 Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 432 | status_t AudioPolicyService::dump(int fd, const Vector<String16>& args) |
| 433 | { |
| 434 | if (checkCallingPermission(String16("android.permission.DUMP")) == false) { |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 435 | dumpPermissionDenial(fd); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 436 | } else { |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 437 | bool locked = tryLock(mLock); |
| 438 | if (!locked) { |
| 439 | String8 result(kDeadlockedString); |
| 440 | write(fd, result.string(), result.size()); |
| 441 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 442 | |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 443 | 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 Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 456 | } |
| 457 | return NO_ERROR; |
| 458 | } |
| 459 | |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 460 | status_t AudioPolicyService::dumpPermissionDenial(int fd) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 461 | { |
| 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 | |
| 474 | status_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 Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 482 | // AudioPolicyClientInterface implementation |
| 483 | // ---------------------------------------------------------------------------- |
| 484 | |
| 485 | |
| 486 | audio_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 Laurent | ddb78e7 | 2009-07-28 08:44:33 -0700 | [diff] [blame] | 496 | return 0; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 497 | } |
| 498 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 499 | return af->openOutput(pDevices, |
| 500 | pSamplingRate, |
| 501 | (uint32_t *)pFormat, |
| 502 | pChannels, |
| 503 | pLatencyMs, |
| 504 | flags); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 505 | } |
| 506 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 507 | audio_io_handle_t AudioPolicyService::openDuplicateOutput(audio_io_handle_t output1, |
| 508 | audio_io_handle_t output2) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 509 | { |
| 510 | sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); |
| 511 | if (af == 0) { |
| 512 | LOGW("openDuplicateOutput() could not get AudioFlinger"); |
Eric Laurent | ddb78e7 | 2009-07-28 08:44:33 -0700 | [diff] [blame] | 513 | return 0; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 514 | } |
| 515 | return af->openDuplicateOutput(output1, output2); |
| 516 | } |
| 517 | |
| 518 | status_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 | |
| 527 | status_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 | |
| 538 | status_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 | |
| 549 | audio_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 Laurent | ddb78e7 | 2009-07-28 08:44:33 -0700 | [diff] [blame] | 558 | return 0; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 559 | } |
| 560 | |
| 561 | return af->openInput(pDevices, pSamplingRate, (uint32_t *)pFormat, pChannels, acoustics); |
| 562 | } |
| 563 | |
| 564 | status_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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 572 | status_t AudioPolicyService::setStreamVolume(AudioSystem::stream_type stream, |
| 573 | float volume, |
| 574 | audio_io_handle_t output, |
| 575 | int delayMs) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 576 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 577 | return mAudioCommandThread->volumeCommand((int)stream, volume, (int)output, delayMs); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 578 | } |
| 579 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 580 | status_t AudioPolicyService::setStreamOutput(AudioSystem::stream_type stream, |
| 581 | audio_io_handle_t output) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 582 | { |
| 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 589 | status_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 Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 594 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 595 | return af->moveEffects(session, (int)srcOutput, (int)dstOutput); |
| 596 | } |
| 597 | |
| 598 | void AudioPolicyService::setParameters(audio_io_handle_t ioHandle, |
| 599 | const String8& keyValuePairs, |
| 600 | int delayMs) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 601 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 602 | mAudioCommandThread->parametersCommand((int)ioHandle, keyValuePairs, delayMs); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 603 | } |
| 604 | |
| 605 | String8 AudioPolicyService::getParameters(audio_io_handle_t ioHandle, const String8& keys) |
| 606 | { |
| 607 | String8 result = AudioSystem::getParameters(ioHandle, keys); |
| 608 | return result; |
| 609 | } |
| 610 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 611 | status_t AudioPolicyService::startTone(ToneGenerator::tone_type tone, |
| 612 | AudioSystem::stream_type stream) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 613 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 614 | mTonePlaybackThread->startToneCommand(tone, stream); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 615 | return NO_ERROR; |
| 616 | } |
| 617 | |
| 618 | status_t AudioPolicyService::stopTone() |
| 619 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 620 | mTonePlaybackThread->stopToneCommand(); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 621 | return NO_ERROR; |
| 622 | } |
| 623 | |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 624 | status_t AudioPolicyService::setVoiceVolume(float volume, int delayMs) |
| 625 | { |
| 626 | return mAudioCommandThread->voiceVolumeCommand(volume, delayMs); |
| 627 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 628 | |
| 629 | // ----------- AudioPolicyService::AudioCommandThread implementation ---------- |
| 630 | |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 631 | AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name) |
| 632 | : Thread(false), mName(name) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 633 | { |
| 634 | mpToneGenerator = NULL; |
| 635 | } |
| 636 | |
| 637 | |
| 638 | AudioPolicyService::AudioCommandThread::~AudioCommandThread() |
| 639 | { |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 640 | if (mName != "" && !mAudioCommands.isEmpty()) { |
| 641 | release_wake_lock(mName.string()); |
| 642 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 643 | mAudioCommands.clear(); |
| 644 | if (mpToneGenerator != NULL) delete mpToneGenerator; |
| 645 | } |
| 646 | |
| 647 | void AudioPolicyService::AudioCommandThread::onFirstRef() |
| 648 | { |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 649 | if (mName != "") { |
| 650 | run(mName.string(), ANDROID_PRIORITY_AUDIO); |
| 651 | } else { |
| 652 | run("AudioCommandThread", ANDROID_PRIORITY_AUDIO); |
| 653 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 654 | } |
| 655 | |
| 656 | bool AudioPolicyService::AudioCommandThread::threadLoop() |
| 657 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 658 | nsecs_t waitTime = INT64_MAX; |
| 659 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 660 | mLock.lock(); |
| 661 | while (!exitPending()) |
| 662 | { |
| 663 | while(!mAudioCommands.isEmpty()) { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 664 | 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 Laurent | 3fdb126 | 2009-11-07 00:01:32 -0800 | [diff] [blame] | 669 | mLastCommand = *command; |
| 670 | |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 671 | 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 696 | 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 701 | 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 709 | LOGV("AudioCommandThread() processing set parameters string %s, io %d", |
| 710 | data->mKeyValuePairs.string(), data->mIO); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 711 | 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 Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 718 | case SET_VOICE_VOLUME: { |
| 719 | VoiceVolumeData *data = (VoiceVolumeData *)command->mParam; |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 720 | LOGV("AudioCommandThread() processing set voice volume volume %f", |
| 721 | data->mVolume); |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 722 | 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 729 | default: |
| 730 | LOGW("AudioCommandThread() unknown command %d", command->mCommand); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 731 | } |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 732 | delete command; |
| 733 | waitTime = INT64_MAX; |
| 734 | } else { |
| 735 | waitTime = mAudioCommands[0]->mTime - curTime; |
| 736 | break; |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 737 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 738 | } |
Eric Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 739 | // release delayed commands wake lock |
| 740 | if (mName != "" && mAudioCommands.isEmpty()) { |
| 741 | release_wake_lock(mName.string()); |
| 742 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 743 | LOGV("AudioCommandThread() going to sleep"); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 744 | mWaitWorkCV.waitRelative(mLock, waitTime); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 745 | LOGV("AudioCommandThread() waking up"); |
| 746 | } |
| 747 | mLock.unlock(); |
| 748 | return false; |
| 749 | } |
| 750 | |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 751 | status_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 Laurent | 3fdb126 | 2009-11-07 00:01:32 -0800 | [diff] [blame] | 769 | result.append(" Command Time Wait pParam\n"); |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 770 | for (int i = 0; i < (int)mAudioCommands.size(); i++) { |
| 771 | mAudioCommands[i]->dump(buffer, SIZE); |
| 772 | result.append(buffer); |
| 773 | } |
Eric Laurent | 3fdb126 | 2009-11-07 00:01:32 -0800 | [diff] [blame] | 774 | result.append(" Last Command\n"); |
| 775 | mLastCommand.dump(buffer, SIZE); |
| 776 | result.append(buffer); |
| 777 | |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 778 | write(fd, result.string(), result.size()); |
| 779 | |
| 780 | if (locked) mLock.unlock(); |
| 781 | |
| 782 | return NO_ERROR; |
| 783 | } |
| 784 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 785 | void AudioPolicyService::AudioCommandThread::startToneCommand(int type, int stream) |
| 786 | { |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 787 | 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 793 | command->mWaitStatus = false; |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 794 | Mutex::Autolock _l(mLock); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 795 | insertCommand_l(command); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 796 | LOGV("AudioCommandThread() adding tone start type %d, stream %d", type, stream); |
| 797 | mWaitWorkCV.signal(); |
| 798 | } |
| 799 | |
| 800 | void AudioPolicyService::AudioCommandThread::stopToneCommand() |
| 801 | { |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 802 | AudioCommand *command = new AudioCommand(); |
| 803 | command->mCommand = STOP_TONE; |
| 804 | command->mParam = NULL; |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 805 | command->mWaitStatus = false; |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 806 | Mutex::Autolock _l(mLock); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 807 | insertCommand_l(command); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 808 | LOGV("AudioCommandThread() adding tone stop"); |
| 809 | mWaitWorkCV.signal(); |
| 810 | } |
| 811 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 812 | status_t AudioPolicyService::AudioCommandThread::volumeCommand(int stream, |
| 813 | float volume, |
| 814 | int output, |
| 815 | int delayMs) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 816 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 817 | status_t status = NO_ERROR; |
| 818 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 819 | 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 826 | if (delayMs == 0) { |
| 827 | command->mWaitStatus = true; |
| 828 | } else { |
| 829 | command->mWaitStatus = false; |
| 830 | } |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 831 | Mutex::Autolock _l(mLock); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 832 | insertCommand_l(command, delayMs); |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 833 | LOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d", |
| 834 | stream, volume, output); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 835 | mWaitWorkCV.signal(); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 836 | if (command->mWaitStatus) { |
| 837 | command->mCond.wait(mLock); |
| 838 | status = command->mStatus; |
| 839 | mWaitWorkCV.signal(); |
| 840 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 841 | return status; |
| 842 | } |
| 843 | |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 844 | status_t AudioPolicyService::AudioCommandThread::parametersCommand(int ioHandle, |
| 845 | const String8& keyValuePairs, |
| 846 | int delayMs) |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 847 | { |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 848 | status_t status = NO_ERROR; |
| 849 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 850 | 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 856 | if (delayMs == 0) { |
| 857 | command->mWaitStatus = true; |
| 858 | } else { |
| 859 | command->mWaitStatus = false; |
| 860 | } |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 861 | Mutex::Autolock _l(mLock); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 862 | insertCommand_l(command, delayMs); |
Eric Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 863 | LOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d", |
| 864 | keyValuePairs.string(), ioHandle, delayMs); |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 865 | mWaitWorkCV.signal(); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 866 | if (command->mWaitStatus) { |
| 867 | command->mCond.wait(mLock); |
| 868 | status = command->mStatus; |
| 869 | mWaitWorkCV.signal(); |
| 870 | } |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 871 | return status; |
| 872 | } |
| 873 | |
Eric Laurent | 415f3e2 | 2009-10-21 08:14:22 -0700 | [diff] [blame] | 874 | status_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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 900 | // insertCommand_l() must be called with mLock held |
| 901 | void 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 Laurent | cef3cd7 | 2009-12-10 01:03:50 -0800 | [diff] [blame] | 908 | // 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 Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 913 | // 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 925 | LOGV("Comparing parameter command %s to new command %s", |
| 926 | data2->mKeyValuePairs.string(), data->mKeyValuePairs.string()); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 927 | 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 958 | LOGV("Filtering out volume command on output %d for stream %d", |
| 959 | data->mIO, data->mStream); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 960 | 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 Laurent | 8ed6ed0 | 2010-07-13 04:45:46 -0700 | [diff] [blame] | 983 | LOGV("inserting command: %d at index %d, num commands %d", |
| 984 | command->mCommand, (int)i+1, mAudioCommands.size()); |
Eric Laurent | 327c27b | 2009-08-27 00:48:47 -0700 | [diff] [blame] | 985 | mAudioCommands.insertAt(command, i + 1); |
| 986 | } |
| 987 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 988 | void AudioPolicyService::AudioCommandThread::exit() |
| 989 | { |
| 990 | LOGV("AudioCommandThread::exit"); |
| 991 | { |
| 992 | AutoMutex _l(mLock); |
| 993 | requestExit(); |
| 994 | mWaitWorkCV.signal(); |
| 995 | } |
| 996 | requestExitAndWait(); |
| 997 | } |
| 998 | |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 999 | void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size) |
| 1000 | { |
Eric Laurent | 3fdb126 | 2009-11-07 00:01:32 -0800 | [diff] [blame] | 1001 | snprintf(buffer, size, " %02d %06d.%03d %01u %p\n", |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 1002 | mCommand, |
| 1003 | (int)ns2s(mTime), |
| 1004 | (int)ns2ms(mTime)%1000, |
Eric Laurent | f4ee40e | 2009-11-02 10:29:02 -0800 | [diff] [blame] | 1005 | mWaitStatus, |
| 1006 | mParam); |
| 1007 | } |
| 1008 | |
Eric Laurent | a553c25 | 2009-07-17 12:17:14 -0700 | [diff] [blame] | 1009 | }; // namespace android |