IAudioPolicyService.cpp revision fce7a473248381cc83a01855f92581077d3c9ee2
1/* 2** 3** Copyright 2009, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18#define LOG_TAG "IAudioPolicyService" 19#include <utils/Log.h> 20 21#include <stdint.h> 22#include <sys/types.h> 23 24#include <binder/Parcel.h> 25 26#include <media/IAudioPolicyService.h> 27 28#include <hardware/audio.h> 29 30namespace android { 31 32enum { 33 SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION, 34 GET_DEVICE_CONNECTION_STATE, 35 SET_PHONE_STATE, 36 SET_RINGER_MODE, 37 SET_FORCE_USE, 38 GET_FORCE_USE, 39 GET_OUTPUT, 40 START_OUTPUT, 41 STOP_OUTPUT, 42 RELEASE_OUTPUT, 43 GET_INPUT, 44 START_INPUT, 45 STOP_INPUT, 46 RELEASE_INPUT, 47 INIT_STREAM_VOLUME, 48 SET_STREAM_VOLUME, 49 GET_STREAM_VOLUME, 50 GET_STRATEGY_FOR_STREAM, 51 GET_OUTPUT_FOR_EFFECT, 52 REGISTER_EFFECT, 53 UNREGISTER_EFFECT, 54 IS_STREAM_ACTIVE, 55 GET_DEVICES_FOR_STREAM, 56}; 57 58class BpAudioPolicyService : public BpInterface<IAudioPolicyService> 59{ 60public: 61 BpAudioPolicyService(const sp<IBinder>& impl) 62 : BpInterface<IAudioPolicyService>(impl) 63 { 64 } 65 66 virtual status_t setDeviceConnectionState( 67 audio_devices_t device, 68 audio_policy_dev_state_t state, 69 const char *device_address) 70 { 71 Parcel data, reply; 72 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 73 data.writeInt32(static_cast <uint32_t>(device)); 74 data.writeInt32(static_cast <uint32_t>(state)); 75 data.writeCString(device_address); 76 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 77 return static_cast <status_t> (reply.readInt32()); 78 } 79 80 virtual audio_policy_dev_state_t getDeviceConnectionState( 81 audio_devices_t device, 82 const char *device_address) 83 { 84 Parcel data, reply; 85 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 86 data.writeInt32(static_cast <uint32_t>(device)); 87 data.writeCString(device_address); 88 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 89 return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 90 } 91 92 virtual status_t setPhoneState(int state) 93 { 94 Parcel data, reply; 95 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 96 data.writeInt32(state); 97 remote()->transact(SET_PHONE_STATE, data, &reply); 98 return static_cast <status_t> (reply.readInt32()); 99 } 100 101 virtual status_t setRingerMode(uint32_t mode, uint32_t mask) 102 { 103 Parcel data, reply; 104 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 105 data.writeInt32(mode); 106 data.writeInt32(mask); 107 remote()->transact(SET_RINGER_MODE, data, &reply); 108 return static_cast <status_t> (reply.readInt32()); 109 } 110 111 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 112 { 113 Parcel data, reply; 114 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 115 data.writeInt32(static_cast <uint32_t>(usage)); 116 data.writeInt32(static_cast <uint32_t>(config)); 117 remote()->transact(SET_FORCE_USE, data, &reply); 118 return static_cast <status_t> (reply.readInt32()); 119 } 120 121 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 122 { 123 Parcel data, reply; 124 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 125 data.writeInt32(static_cast <uint32_t>(usage)); 126 remote()->transact(GET_FORCE_USE, data, &reply); 127 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 128 } 129 130 virtual audio_io_handle_t getOutput( 131 audio_stream_type_t stream, 132 uint32_t samplingRate, 133 uint32_t format, 134 uint32_t channels, 135 audio_policy_output_flags_t flags) 136 { 137 Parcel data, reply; 138 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 139 data.writeInt32(static_cast <uint32_t>(stream)); 140 data.writeInt32(samplingRate); 141 data.writeInt32(static_cast <uint32_t>(format)); 142 data.writeInt32(channels); 143 data.writeInt32(static_cast <uint32_t>(flags)); 144 remote()->transact(GET_OUTPUT, data, &reply); 145 return static_cast <audio_io_handle_t> (reply.readInt32()); 146 } 147 148 virtual status_t startOutput(audio_io_handle_t output, 149 audio_stream_type_t stream, 150 int session) 151 { 152 Parcel data, reply; 153 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 154 data.writeInt32(output); 155 data.writeInt32(stream); 156 data.writeInt32(session); 157 remote()->transact(START_OUTPUT, data, &reply); 158 return static_cast <status_t> (reply.readInt32()); 159 } 160 161 virtual status_t stopOutput(audio_io_handle_t output, 162 audio_stream_type_t stream, 163 int session) 164 { 165 Parcel data, reply; 166 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 167 data.writeInt32(output); 168 data.writeInt32(stream); 169 data.writeInt32(session); 170 remote()->transact(STOP_OUTPUT, data, &reply); 171 return static_cast <status_t> (reply.readInt32()); 172 } 173 174 virtual void releaseOutput(audio_io_handle_t output) 175 { 176 Parcel data, reply; 177 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 178 data.writeInt32(output); 179 remote()->transact(RELEASE_OUTPUT, data, &reply); 180 } 181 182 virtual audio_io_handle_t getInput( 183 int inputSource, 184 uint32_t samplingRate, 185 uint32_t format, 186 uint32_t channels, 187 audio_in_acoustics_t acoustics) 188 { 189 Parcel data, reply; 190 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 191 data.writeInt32(inputSource); 192 data.writeInt32(samplingRate); 193 data.writeInt32(static_cast <uint32_t>(format)); 194 data.writeInt32(channels); 195 data.writeInt32(static_cast <uint32_t>(acoustics)); 196 remote()->transact(GET_INPUT, data, &reply); 197 return static_cast <audio_io_handle_t> (reply.readInt32()); 198 } 199 200 virtual status_t startInput(audio_io_handle_t input) 201 { 202 Parcel data, reply; 203 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 204 data.writeInt32(input); 205 remote()->transact(START_INPUT, data, &reply); 206 return static_cast <status_t> (reply.readInt32()); 207 } 208 209 virtual status_t stopInput(audio_io_handle_t input) 210 { 211 Parcel data, reply; 212 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 213 data.writeInt32(input); 214 remote()->transact(STOP_INPUT, data, &reply); 215 return static_cast <status_t> (reply.readInt32()); 216 } 217 218 virtual void releaseInput(audio_io_handle_t input) 219 { 220 Parcel data, reply; 221 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 222 data.writeInt32(input); 223 remote()->transact(RELEASE_INPUT, data, &reply); 224 } 225 226 virtual status_t initStreamVolume(audio_stream_type_t stream, 227 int indexMin, 228 int indexMax) 229 { 230 Parcel data, reply; 231 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 232 data.writeInt32(static_cast <uint32_t>(stream)); 233 data.writeInt32(indexMin); 234 data.writeInt32(indexMax); 235 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 236 return static_cast <status_t> (reply.readInt32()); 237 } 238 239 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index) 240 { 241 Parcel data, reply; 242 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 243 data.writeInt32(static_cast <uint32_t>(stream)); 244 data.writeInt32(index); 245 remote()->transact(SET_STREAM_VOLUME, data, &reply); 246 return static_cast <status_t> (reply.readInt32()); 247 } 248 249 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index) 250 { 251 Parcel data, reply; 252 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 253 data.writeInt32(static_cast <uint32_t>(stream)); 254 remote()->transact(GET_STREAM_VOLUME, data, &reply); 255 int lIndex = reply.readInt32(); 256 if (index) *index = lIndex; 257 return static_cast <status_t> (reply.readInt32()); 258 } 259 260 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 261 { 262 Parcel data, reply; 263 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 264 data.writeInt32(static_cast <uint32_t>(stream)); 265 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 266 return reply.readInt32(); 267 } 268 269 virtual uint32_t getDevicesForStream(audio_stream_type_t stream) 270 { 271 Parcel data, reply; 272 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 273 data.writeInt32(static_cast <uint32_t>(stream)); 274 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 275 return (uint32_t) reply.readInt32(); 276 } 277 278 virtual audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc) 279 { 280 Parcel data, reply; 281 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 282 data.write(desc, sizeof(effect_descriptor_t)); 283 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 284 return static_cast <audio_io_handle_t> (reply.readInt32()); 285 } 286 287 virtual status_t registerEffect(effect_descriptor_t *desc, 288 audio_io_handle_t output, 289 uint32_t strategy, 290 int session, 291 int id) 292 { 293 Parcel data, reply; 294 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 295 data.write(desc, sizeof(effect_descriptor_t)); 296 data.writeInt32(output); 297 data.writeInt32(strategy); 298 data.writeInt32(session); 299 data.writeInt32(id); 300 remote()->transact(REGISTER_EFFECT, data, &reply); 301 return static_cast <status_t> (reply.readInt32()); 302 } 303 304 virtual status_t unregisterEffect(int id) 305 { 306 Parcel data, reply; 307 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 308 data.writeInt32(id); 309 remote()->transact(UNREGISTER_EFFECT, data, &reply); 310 return static_cast <status_t> (reply.readInt32()); 311 } 312 313 virtual bool isStreamActive(int stream, uint32_t inPastMs) const 314 { 315 Parcel data, reply; 316 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 317 data.writeInt32(stream); 318 data.writeInt32(inPastMs); 319 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 320 return reply.readInt32(); 321 } 322}; 323 324IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 325 326// ---------------------------------------------------------------------- 327 328 329status_t BnAudioPolicyService::onTransact( 330 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 331{ 332 switch(code) { 333 case SET_DEVICE_CONNECTION_STATE: { 334 CHECK_INTERFACE(IAudioPolicyService, data, reply); 335 audio_devices_t device = 336 static_cast <audio_devices_t>(data.readInt32()); 337 audio_policy_dev_state_t state = 338 static_cast <audio_policy_dev_state_t>(data.readInt32()); 339 const char *device_address = data.readCString(); 340 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 341 state, 342 device_address))); 343 return NO_ERROR; 344 } break; 345 346 case GET_DEVICE_CONNECTION_STATE: { 347 CHECK_INTERFACE(IAudioPolicyService, data, reply); 348 audio_devices_t device = 349 static_cast<audio_devices_t> (data.readInt32()); 350 const char *device_address = data.readCString(); 351 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 352 device_address))); 353 return NO_ERROR; 354 } break; 355 356 case SET_PHONE_STATE: { 357 CHECK_INTERFACE(IAudioPolicyService, data, reply); 358 reply->writeInt32(static_cast <uint32_t>(setPhoneState(data.readInt32()))); 359 return NO_ERROR; 360 } break; 361 362 case SET_RINGER_MODE: { 363 CHECK_INTERFACE(IAudioPolicyService, data, reply); 364 uint32_t mode = data.readInt32(); 365 uint32_t mask = data.readInt32(); 366 reply->writeInt32(static_cast <uint32_t>(setRingerMode(mode, mask))); 367 return NO_ERROR; 368 } break; 369 370 case SET_FORCE_USE: { 371 CHECK_INTERFACE(IAudioPolicyService, data, reply); 372 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32()); 373 audio_policy_forced_cfg_t config = 374 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 375 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 376 return NO_ERROR; 377 } break; 378 379 case GET_FORCE_USE: { 380 CHECK_INTERFACE(IAudioPolicyService, data, reply); 381 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32()); 382 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 383 return NO_ERROR; 384 } break; 385 386 case GET_OUTPUT: { 387 CHECK_INTERFACE(IAudioPolicyService, data, reply); 388 audio_stream_type_t stream = 389 static_cast <audio_stream_type_t>(data.readInt32()); 390 uint32_t samplingRate = data.readInt32(); 391 uint32_t format = data.readInt32(); 392 uint32_t channels = data.readInt32(); 393 audio_policy_output_flags_t flags = 394 static_cast <audio_policy_output_flags_t>(data.readInt32()); 395 396 audio_io_handle_t output = getOutput(stream, 397 samplingRate, 398 format, 399 channels, 400 flags); 401 reply->writeInt32(static_cast <int>(output)); 402 return NO_ERROR; 403 } break; 404 405 case START_OUTPUT: { 406 CHECK_INTERFACE(IAudioPolicyService, data, reply); 407 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 408 uint32_t stream = data.readInt32(); 409 int session = data.readInt32(); 410 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 411 (audio_stream_type_t)stream, 412 session))); 413 return NO_ERROR; 414 } break; 415 416 case STOP_OUTPUT: { 417 CHECK_INTERFACE(IAudioPolicyService, data, reply); 418 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 419 uint32_t stream = data.readInt32(); 420 int session = data.readInt32(); 421 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 422 (audio_stream_type_t)stream, 423 session))); 424 return NO_ERROR; 425 } break; 426 427 case RELEASE_OUTPUT: { 428 CHECK_INTERFACE(IAudioPolicyService, data, reply); 429 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 430 releaseOutput(output); 431 return NO_ERROR; 432 } break; 433 434 case GET_INPUT: { 435 CHECK_INTERFACE(IAudioPolicyService, data, reply); 436 int inputSource = data.readInt32(); 437 uint32_t samplingRate = data.readInt32(); 438 uint32_t format = data.readInt32(); 439 uint32_t channels = data.readInt32(); 440 audio_in_acoustics_t acoustics = 441 static_cast <audio_in_acoustics_t>(data.readInt32()); 442 audio_io_handle_t input = getInput(inputSource, 443 samplingRate, 444 format, 445 channels, 446 acoustics); 447 reply->writeInt32(static_cast <int>(input)); 448 return NO_ERROR; 449 } break; 450 451 case START_INPUT: { 452 CHECK_INTERFACE(IAudioPolicyService, data, reply); 453 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 454 reply->writeInt32(static_cast <uint32_t>(startInput(input))); 455 return NO_ERROR; 456 } break; 457 458 case STOP_INPUT: { 459 CHECK_INTERFACE(IAudioPolicyService, data, reply); 460 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 461 reply->writeInt32(static_cast <uint32_t>(stopInput(input))); 462 return NO_ERROR; 463 } break; 464 465 case RELEASE_INPUT: { 466 CHECK_INTERFACE(IAudioPolicyService, data, reply); 467 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 468 releaseInput(input); 469 return NO_ERROR; 470 } break; 471 472 case INIT_STREAM_VOLUME: { 473 CHECK_INTERFACE(IAudioPolicyService, data, reply); 474 audio_stream_type_t stream = 475 static_cast <audio_stream_type_t>(data.readInt32()); 476 int indexMin = data.readInt32(); 477 int indexMax = data.readInt32(); 478 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 479 return NO_ERROR; 480 } break; 481 482 case SET_STREAM_VOLUME: { 483 CHECK_INTERFACE(IAudioPolicyService, data, reply); 484 audio_stream_type_t stream = 485 static_cast <audio_stream_type_t>(data.readInt32()); 486 int index = data.readInt32(); 487 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, index))); 488 return NO_ERROR; 489 } break; 490 491 case GET_STREAM_VOLUME: { 492 CHECK_INTERFACE(IAudioPolicyService, data, reply); 493 audio_stream_type_t stream = 494 static_cast <audio_stream_type_t>(data.readInt32()); 495 int index; 496 status_t status = getStreamVolumeIndex(stream, &index); 497 reply->writeInt32(index); 498 reply->writeInt32(static_cast <uint32_t>(status)); 499 return NO_ERROR; 500 } break; 501 502 case GET_STRATEGY_FOR_STREAM: { 503 CHECK_INTERFACE(IAudioPolicyService, data, reply); 504 audio_stream_type_t stream = 505 static_cast <audio_stream_type_t>(data.readInt32()); 506 reply->writeInt32(getStrategyForStream(stream)); 507 return NO_ERROR; 508 } break; 509 510 case GET_DEVICES_FOR_STREAM: { 511 CHECK_INTERFACE(IAudioPolicyService, data, reply); 512 audio_stream_type_t stream = 513 static_cast <audio_stream_type_t>(data.readInt32()); 514 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 515 return NO_ERROR; 516 } break; 517 518 case GET_OUTPUT_FOR_EFFECT: { 519 CHECK_INTERFACE(IAudioPolicyService, data, reply); 520 effect_descriptor_t desc; 521 data.read(&desc, sizeof(effect_descriptor_t)); 522 audio_io_handle_t output = getOutputForEffect(&desc); 523 reply->writeInt32(static_cast <int>(output)); 524 return NO_ERROR; 525 } break; 526 527 case REGISTER_EFFECT: { 528 CHECK_INTERFACE(IAudioPolicyService, data, reply); 529 effect_descriptor_t desc; 530 data.read(&desc, sizeof(effect_descriptor_t)); 531 audio_io_handle_t output = data.readInt32(); 532 uint32_t strategy = data.readInt32(); 533 int session = data.readInt32(); 534 int id = data.readInt32(); 535 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 536 output, 537 strategy, 538 session, 539 id))); 540 return NO_ERROR; 541 } break; 542 543 case UNREGISTER_EFFECT: { 544 CHECK_INTERFACE(IAudioPolicyService, data, reply); 545 int id = data.readInt32(); 546 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 547 return NO_ERROR; 548 } break; 549 550 case IS_STREAM_ACTIVE: { 551 CHECK_INTERFACE(IAudioPolicyService, data, reply); 552 int stream = data.readInt32(); 553 uint32_t inPastMs = (uint32_t)data.readInt32(); 554 reply->writeInt32( isStreamActive(stream, inPastMs) ); 555 return NO_ERROR; 556 } break; 557 558 default: 559 return BBinder::onTransact(code, data, reply, flags); 560 } 561} 562 563// ---------------------------------------------------------------------------- 564 565}; // namespace android 566