IAudioPolicyService.cpp revision 74adca9ad30b7f8a70d40c5237bade0d16c4ea58
11320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci/* 21320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** 31320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** Copyright 2009, The Android Open Source Project 41320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** 51320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** Licensed under the Apache License, Version 2.0 (the "License"); 61320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** you may not use this file except in compliance with the License. 71320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** You may obtain a copy of the License at 81320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** 91320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** http://www.apache.org/licenses/LICENSE-2.0 101320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** 111320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** Unless required by applicable law or agreed to in writing, software 121320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** distributed under the License is distributed on an "AS IS" BASIS, 131320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 141320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** See the License for the specific language governing permissions and 151320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci** limitations under the License. 161320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci*/ 171320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 181320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#define LOG_TAG "IAudioPolicyService" 191320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <utils/Log.h> 201320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 211320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <stdint.h> 221320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <sys/types.h> 231320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 241320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <binder/Parcel.h> 251320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 261320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <media/AudioEffect.h> 271320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <media/IAudioPolicyService.h> 281320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 291320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <system/audio.h> 301320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 311320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccinamespace android { 321320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 331320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccienum { 341320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION, 351320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_DEVICE_CONNECTION_STATE, 361320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_PHONE_STATE, 371320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_RINGER_MODE, // reserved, no longer used 381320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_FORCE_USE, 391320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_FORCE_USE, 401320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_OUTPUT, 411320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci START_OUTPUT, 421320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci STOP_OUTPUT, 431320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci RELEASE_OUTPUT, 441320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_INPUT, 451320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci START_INPUT, 461320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci STOP_INPUT, 471320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci RELEASE_INPUT, 481320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci INIT_STREAM_VOLUME, 491320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_STREAM_VOLUME, 501320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_STREAM_VOLUME, 511320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_STRATEGY_FOR_STREAM, 521320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_OUTPUT_FOR_EFFECT, 531320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci REGISTER_EFFECT, 541320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci UNREGISTER_EFFECT, 551320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci IS_STREAM_ACTIVE, 561320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci IS_SOURCE_ACTIVE, 571320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_DEVICES_FOR_STREAM, 581320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci QUERY_DEFAULT_PRE_PROCESSING, 591320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_EFFECT_ENABLED, 601320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci IS_STREAM_ACTIVE_REMOTELY, 611320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci IS_OFFLOAD_SUPPORTED, 621320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci LIST_AUDIO_PORTS, 631320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_AUDIO_PORT, 641320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci CREATE_AUDIO_PATCH, 651320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci RELEASE_AUDIO_PATCH, 661320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci LIST_AUDIO_PATCHES, 671320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SET_AUDIO_PORT_CONFIG, 681320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci REGISTER_CLIENT, 691320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_OUTPUT_FOR_ATTR, 701320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ACQUIRE_SOUNDTRIGGER_SESSION, 711320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci RELEASE_SOUNDTRIGGER_SESSION, 721320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci GET_PHONE_STATE 731320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci}; 741320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 751320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucciclass BpAudioPolicyService : public BpInterface<IAudioPolicyService> 761320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci{ 771320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccipublic: 781320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci BpAudioPolicyService(const sp<IBinder>& impl) 791320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci : BpInterface<IAudioPolicyService>(impl) 801320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci { 811320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 821320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 831320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci virtual status_t setDeviceConnectionState( 841320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci audio_devices_t device, 851320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci audio_policy_dev_state_t state, 861320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci const char *device_address) 871320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci { 881320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Parcel data, reply; 891320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 901320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInt32(static_cast <uint32_t>(device)); 911320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInt32(static_cast <uint32_t>(state)); 921320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeCString(device_address); 931320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply); 941320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return static_cast <status_t> (reply.readInt32()); 951320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 961320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 971320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci virtual audio_policy_dev_state_t getDeviceConnectionState( 981320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci audio_devices_t device, 991320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci const char *device_address) 1001320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci { 1011320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Parcel data, reply; 1021320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1031320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInt32(static_cast <uint32_t>(device)); 1041320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeCString(device_address); 1051320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); 1061320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return static_cast <audio_policy_dev_state_t>(reply.readInt32()); 1071320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 1081320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 1091320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci virtual status_t setPhoneState(audio_mode_t state) 1101320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci { 1111320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Parcel data, reply; 1121320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 1131320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data.writeInt32(state); 114 remote()->transact(SET_PHONE_STATE, data, &reply); 115 return static_cast <status_t> (reply.readInt32()); 116 } 117 118 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) 119 { 120 Parcel data, reply; 121 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 122 data.writeInt32(static_cast <uint32_t>(usage)); 123 data.writeInt32(static_cast <uint32_t>(config)); 124 remote()->transact(SET_FORCE_USE, data, &reply); 125 return static_cast <status_t> (reply.readInt32()); 126 } 127 128 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) 129 { 130 Parcel data, reply; 131 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 132 data.writeInt32(static_cast <uint32_t>(usage)); 133 remote()->transact(GET_FORCE_USE, data, &reply); 134 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); 135 } 136 137 virtual audio_io_handle_t getOutput( 138 audio_stream_type_t stream, 139 uint32_t samplingRate, 140 audio_format_t format, 141 audio_channel_mask_t channelMask, 142 audio_output_flags_t flags, 143 const audio_offload_info_t *offloadInfo) 144 { 145 Parcel data, reply; 146 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 147 data.writeInt32(static_cast <uint32_t>(stream)); 148 data.writeInt32(samplingRate); 149 data.writeInt32(static_cast <uint32_t>(format)); 150 data.writeInt32(channelMask); 151 data.writeInt32(static_cast <uint32_t>(flags)); 152 // hasOffloadInfo 153 if (offloadInfo == NULL) { 154 data.writeInt32(0); 155 } else { 156 data.writeInt32(1); 157 data.write(offloadInfo, sizeof(audio_offload_info_t)); 158 } 159 remote()->transact(GET_OUTPUT, data, &reply); 160 return static_cast <audio_io_handle_t> (reply.readInt32()); 161 } 162 163 virtual audio_io_handle_t getOutputForAttr( 164 const audio_attributes_t *attr, 165 uint32_t samplingRate, 166 audio_format_t format, 167 audio_channel_mask_t channelMask, 168 audio_output_flags_t flags, 169 const audio_offload_info_t *offloadInfo) 170 { 171 Parcel data, reply; 172 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 173 if (attr == NULL) { 174 ALOGE("Writing NULL audio attributes - shouldn't happen"); 175 return (audio_io_handle_t) 0; 176 } 177 data.write(attr, sizeof(audio_attributes_t)); 178 data.writeInt32(samplingRate); 179 data.writeInt32(static_cast <uint32_t>(format)); 180 data.writeInt32(channelMask); 181 data.writeInt32(static_cast <uint32_t>(flags)); 182 // hasOffloadInfo 183 if (offloadInfo == NULL) { 184 data.writeInt32(0); 185 } else { 186 data.writeInt32(1); 187 data.write(offloadInfo, sizeof(audio_offload_info_t)); 188 } 189 remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply); 190 return static_cast <audio_io_handle_t> (reply.readInt32()); 191 } 192 193 virtual status_t startOutput(audio_io_handle_t output, 194 audio_stream_type_t stream, 195 int session) 196 { 197 Parcel data, reply; 198 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 199 data.writeInt32(output); 200 data.writeInt32((int32_t) stream); 201 data.writeInt32(session); 202 remote()->transact(START_OUTPUT, data, &reply); 203 return static_cast <status_t> (reply.readInt32()); 204 } 205 206 virtual status_t stopOutput(audio_io_handle_t output, 207 audio_stream_type_t stream, 208 int session) 209 { 210 Parcel data, reply; 211 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 212 data.writeInt32(output); 213 data.writeInt32((int32_t) stream); 214 data.writeInt32(session); 215 remote()->transact(STOP_OUTPUT, data, &reply); 216 return static_cast <status_t> (reply.readInt32()); 217 } 218 219 virtual void releaseOutput(audio_io_handle_t output) 220 { 221 Parcel data, reply; 222 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 223 data.writeInt32(output); 224 remote()->transact(RELEASE_OUTPUT, data, &reply); 225 } 226 227 virtual audio_io_handle_t getInput( 228 audio_source_t inputSource, 229 uint32_t samplingRate, 230 audio_format_t format, 231 audio_channel_mask_t channelMask, 232 int audioSession, 233 audio_input_flags_t flags) 234 { 235 Parcel data, reply; 236 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 237 data.writeInt32((int32_t) inputSource); 238 data.writeInt32(samplingRate); 239 data.writeInt32(static_cast <uint32_t>(format)); 240 data.writeInt32(channelMask); 241 data.writeInt32(audioSession); 242 data.writeInt32(flags); 243 remote()->transact(GET_INPUT, data, &reply); 244 return static_cast <audio_io_handle_t> (reply.readInt32()); 245 } 246 247 virtual status_t startInput(audio_io_handle_t input, 248 audio_session_t session) 249 { 250 Parcel data, reply; 251 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 252 data.writeInt32(input); 253 data.writeInt32(session); 254 remote()->transact(START_INPUT, data, &reply); 255 return static_cast <status_t> (reply.readInt32()); 256 } 257 258 virtual status_t stopInput(audio_io_handle_t input, 259 audio_session_t session) 260 { 261 Parcel data, reply; 262 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 263 data.writeInt32(input); 264 data.writeInt32(session); 265 remote()->transact(STOP_INPUT, data, &reply); 266 return static_cast <status_t> (reply.readInt32()); 267 } 268 269 virtual void releaseInput(audio_io_handle_t input, 270 audio_session_t session) 271 { 272 Parcel data, reply; 273 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 274 data.writeInt32(input); 275 data.writeInt32(session); 276 remote()->transact(RELEASE_INPUT, data, &reply); 277 } 278 279 virtual status_t initStreamVolume(audio_stream_type_t stream, 280 int indexMin, 281 int indexMax) 282 { 283 Parcel data, reply; 284 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 285 data.writeInt32(static_cast <uint32_t>(stream)); 286 data.writeInt32(indexMin); 287 data.writeInt32(indexMax); 288 remote()->transact(INIT_STREAM_VOLUME, data, &reply); 289 return static_cast <status_t> (reply.readInt32()); 290 } 291 292 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 293 int index, 294 audio_devices_t device) 295 { 296 Parcel data, reply; 297 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 298 data.writeInt32(static_cast <uint32_t>(stream)); 299 data.writeInt32(index); 300 data.writeInt32(static_cast <uint32_t>(device)); 301 remote()->transact(SET_STREAM_VOLUME, data, &reply); 302 return static_cast <status_t> (reply.readInt32()); 303 } 304 305 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 306 int *index, 307 audio_devices_t device) 308 { 309 Parcel data, reply; 310 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 311 data.writeInt32(static_cast <uint32_t>(stream)); 312 data.writeInt32(static_cast <uint32_t>(device)); 313 314 remote()->transact(GET_STREAM_VOLUME, data, &reply); 315 int lIndex = reply.readInt32(); 316 if (index) *index = lIndex; 317 return static_cast <status_t> (reply.readInt32()); 318 } 319 320 virtual uint32_t getStrategyForStream(audio_stream_type_t stream) 321 { 322 Parcel data, reply; 323 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 324 data.writeInt32(static_cast <uint32_t>(stream)); 325 remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply); 326 return reply.readInt32(); 327 } 328 329 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) 330 { 331 Parcel data, reply; 332 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 333 data.writeInt32(static_cast <uint32_t>(stream)); 334 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply); 335 return (audio_devices_t) reply.readInt32(); 336 } 337 338 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) 339 { 340 Parcel data, reply; 341 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 342 data.write(desc, sizeof(effect_descriptor_t)); 343 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply); 344 return static_cast <audio_io_handle_t> (reply.readInt32()); 345 } 346 347 virtual status_t registerEffect(const effect_descriptor_t *desc, 348 audio_io_handle_t io, 349 uint32_t strategy, 350 int session, 351 int id) 352 { 353 Parcel data, reply; 354 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 355 data.write(desc, sizeof(effect_descriptor_t)); 356 data.writeInt32(io); 357 data.writeInt32(strategy); 358 data.writeInt32(session); 359 data.writeInt32(id); 360 remote()->transact(REGISTER_EFFECT, data, &reply); 361 return static_cast <status_t> (reply.readInt32()); 362 } 363 364 virtual status_t unregisterEffect(int id) 365 { 366 Parcel data, reply; 367 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 368 data.writeInt32(id); 369 remote()->transact(UNREGISTER_EFFECT, data, &reply); 370 return static_cast <status_t> (reply.readInt32()); 371 } 372 373 virtual status_t setEffectEnabled(int id, bool enabled) 374 { 375 Parcel data, reply; 376 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 377 data.writeInt32(id); 378 data.writeInt32(enabled); 379 remote()->transact(SET_EFFECT_ENABLED, data, &reply); 380 return static_cast <status_t> (reply.readInt32()); 381 } 382 383 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const 384 { 385 Parcel data, reply; 386 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 387 data.writeInt32((int32_t) stream); 388 data.writeInt32(inPastMs); 389 remote()->transact(IS_STREAM_ACTIVE, data, &reply); 390 return reply.readInt32(); 391 } 392 393 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const 394 { 395 Parcel data, reply; 396 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 397 data.writeInt32((int32_t) stream); 398 data.writeInt32(inPastMs); 399 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply); 400 return reply.readInt32(); 401 } 402 403 virtual bool isSourceActive(audio_source_t source) const 404 { 405 Parcel data, reply; 406 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 407 data.writeInt32((int32_t) source); 408 remote()->transact(IS_SOURCE_ACTIVE, data, &reply); 409 return reply.readInt32(); 410 } 411 412 virtual status_t queryDefaultPreProcessing(int audioSession, 413 effect_descriptor_t *descriptors, 414 uint32_t *count) 415 { 416 if (descriptors == NULL || count == NULL) { 417 return BAD_VALUE; 418 } 419 Parcel data, reply; 420 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 421 data.writeInt32(audioSession); 422 data.writeInt32(*count); 423 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply); 424 if (status != NO_ERROR) { 425 return status; 426 } 427 status = static_cast <status_t> (reply.readInt32()); 428 uint32_t retCount = reply.readInt32(); 429 if (retCount != 0) { 430 uint32_t numDesc = (retCount < *count) ? retCount : *count; 431 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc); 432 } 433 *count = retCount; 434 return status; 435 } 436 437 virtual bool isOffloadSupported(const audio_offload_info_t& info) 438 { 439 Parcel data, reply; 440 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 441 data.write(&info, sizeof(audio_offload_info_t)); 442 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply); 443 return reply.readInt32(); 444 } 445 446 virtual status_t listAudioPorts(audio_port_role_t role, 447 audio_port_type_t type, 448 unsigned int *num_ports, 449 struct audio_port *ports, 450 unsigned int *generation) 451 { 452 if (num_ports == NULL || (*num_ports != 0 && ports == NULL) || 453 generation == NULL) { 454 return BAD_VALUE; 455 } 456 Parcel data, reply; 457 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 458 unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports; 459 data.writeInt32(role); 460 data.writeInt32(type); 461 data.writeInt32(numPortsReq); 462 status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply); 463 if (status == NO_ERROR) { 464 status = (status_t)reply.readInt32(); 465 *num_ports = (unsigned int)reply.readInt32(); 466 } 467 if (status == NO_ERROR) { 468 if (numPortsReq > *num_ports) { 469 numPortsReq = *num_ports; 470 } 471 if (numPortsReq > 0) { 472 reply.read(ports, numPortsReq * sizeof(struct audio_port)); 473 } 474 *generation = reply.readInt32(); 475 } 476 return status; 477 } 478 479 virtual status_t getAudioPort(struct audio_port *port) 480 { 481 if (port == NULL) { 482 return BAD_VALUE; 483 } 484 Parcel data, reply; 485 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 486 data.write(port, sizeof(struct audio_port)); 487 status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply); 488 if (status != NO_ERROR || 489 (status = (status_t)reply.readInt32()) != NO_ERROR) { 490 return status; 491 } 492 reply.read(port, sizeof(struct audio_port)); 493 return status; 494 } 495 496 virtual status_t createAudioPatch(const struct audio_patch *patch, 497 audio_patch_handle_t *handle) 498 { 499 if (patch == NULL || handle == NULL) { 500 return BAD_VALUE; 501 } 502 Parcel data, reply; 503 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 504 data.write(patch, sizeof(struct audio_patch)); 505 data.write(handle, sizeof(audio_patch_handle_t)); 506 status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply); 507 if (status != NO_ERROR || 508 (status = (status_t)reply.readInt32()) != NO_ERROR) { 509 return status; 510 } 511 reply.read(handle, sizeof(audio_patch_handle_t)); 512 return status; 513 } 514 515 virtual status_t releaseAudioPatch(audio_patch_handle_t handle) 516 { 517 Parcel data, reply; 518 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 519 data.write(&handle, sizeof(audio_patch_handle_t)); 520 status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply); 521 if (status != NO_ERROR) { 522 status = (status_t)reply.readInt32(); 523 } 524 return status; 525 } 526 527 virtual status_t listAudioPatches(unsigned int *num_patches, 528 struct audio_patch *patches, 529 unsigned int *generation) 530 { 531 if (num_patches == NULL || (*num_patches != 0 && patches == NULL) || 532 generation == NULL) { 533 return BAD_VALUE; 534 } 535 Parcel data, reply; 536 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 537 unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches; 538 data.writeInt32(numPatchesReq); 539 status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply); 540 if (status == NO_ERROR) { 541 status = (status_t)reply.readInt32(); 542 *num_patches = (unsigned int)reply.readInt32(); 543 } 544 if (status == NO_ERROR) { 545 if (numPatchesReq > *num_patches) { 546 numPatchesReq = *num_patches; 547 } 548 if (numPatchesReq > 0) { 549 reply.read(patches, numPatchesReq * sizeof(struct audio_patch)); 550 } 551 *generation = reply.readInt32(); 552 } 553 return status; 554 } 555 556 virtual status_t setAudioPortConfig(const struct audio_port_config *config) 557 { 558 if (config == NULL) { 559 return BAD_VALUE; 560 } 561 Parcel data, reply; 562 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 563 data.write(config, sizeof(struct audio_port_config)); 564 status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply); 565 if (status != NO_ERROR) { 566 status = (status_t)reply.readInt32(); 567 } 568 return status; 569 } 570 571 virtual void registerClient(const sp<IAudioPolicyServiceClient>& client) 572 { 573 Parcel data, reply; 574 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 575 data.writeStrongBinder(client->asBinder()); 576 remote()->transact(REGISTER_CLIENT, data, &reply); 577 } 578 579 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 580 audio_io_handle_t *ioHandle, 581 audio_devices_t *device) 582 { 583 if (session == NULL || ioHandle == NULL || device == NULL) { 584 return BAD_VALUE; 585 } 586 Parcel data, reply; 587 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 588 status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply); 589 if (status != NO_ERROR) { 590 return status; 591 } 592 status = (status_t)reply.readInt32(); 593 if (status == NO_ERROR) { 594 *session = (audio_session_t)reply.readInt32(); 595 *ioHandle = (audio_io_handle_t)reply.readInt32(); 596 *device = (audio_devices_t)reply.readInt32(); 597 } 598 return status; 599 } 600 601 virtual status_t releaseSoundTriggerSession(audio_session_t session) 602 { 603 Parcel data, reply; 604 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 605 data.writeInt32(session); 606 status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply); 607 if (status != NO_ERROR) { 608 return status; 609 } 610 return (status_t)reply.readInt32(); 611 } 612 613 virtual audio_mode_t getPhoneState() 614 { 615 Parcel data, reply; 616 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); 617 status_t status = remote()->transact(GET_PHONE_STATE, data, &reply); 618 if (status != NO_ERROR) { 619 return AUDIO_MODE_INVALID; 620 } 621 return (audio_mode_t)reply.readInt32(); 622 } 623}; 624 625IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService"); 626 627// ---------------------------------------------------------------------- 628 629 630status_t BnAudioPolicyService::onTransact( 631 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 632{ 633 switch (code) { 634 case SET_DEVICE_CONNECTION_STATE: { 635 CHECK_INTERFACE(IAudioPolicyService, data, reply); 636 audio_devices_t device = 637 static_cast <audio_devices_t>(data.readInt32()); 638 audio_policy_dev_state_t state = 639 static_cast <audio_policy_dev_state_t>(data.readInt32()); 640 const char *device_address = data.readCString(); 641 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, 642 state, 643 device_address))); 644 return NO_ERROR; 645 } break; 646 647 case GET_DEVICE_CONNECTION_STATE: { 648 CHECK_INTERFACE(IAudioPolicyService, data, reply); 649 audio_devices_t device = 650 static_cast<audio_devices_t> (data.readInt32()); 651 const char *device_address = data.readCString(); 652 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, 653 device_address))); 654 return NO_ERROR; 655 } break; 656 657 case SET_PHONE_STATE: { 658 CHECK_INTERFACE(IAudioPolicyService, data, reply); 659 reply->writeInt32(static_cast <uint32_t>(setPhoneState( 660 (audio_mode_t) data.readInt32()))); 661 return NO_ERROR; 662 } break; 663 664 case SET_FORCE_USE: { 665 CHECK_INTERFACE(IAudioPolicyService, data, reply); 666 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 667 data.readInt32()); 668 audio_policy_forced_cfg_t config = 669 static_cast <audio_policy_forced_cfg_t>(data.readInt32()); 670 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); 671 return NO_ERROR; 672 } break; 673 674 case GET_FORCE_USE: { 675 CHECK_INTERFACE(IAudioPolicyService, data, reply); 676 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>( 677 data.readInt32()); 678 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); 679 return NO_ERROR; 680 } break; 681 682 case GET_OUTPUT: { 683 CHECK_INTERFACE(IAudioPolicyService, data, reply); 684 audio_stream_type_t stream = 685 static_cast <audio_stream_type_t>(data.readInt32()); 686 uint32_t samplingRate = data.readInt32(); 687 audio_format_t format = (audio_format_t) data.readInt32(); 688 audio_channel_mask_t channelMask = data.readInt32(); 689 audio_output_flags_t flags = 690 static_cast <audio_output_flags_t>(data.readInt32()); 691 bool hasOffloadInfo = data.readInt32() != 0; 692 audio_offload_info_t offloadInfo; 693 if (hasOffloadInfo) { 694 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 695 } 696 audio_io_handle_t output = getOutput(stream, 697 samplingRate, 698 format, 699 channelMask, 700 flags, 701 hasOffloadInfo ? &offloadInfo : NULL); 702 reply->writeInt32(static_cast <int>(output)); 703 return NO_ERROR; 704 } break; 705 706 case GET_OUTPUT_FOR_ATTR: { 707 CHECK_INTERFACE(IAudioPolicyService, data, reply); 708 audio_attributes_t *attr = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t)); 709 data.read(attr, sizeof(audio_attributes_t)); 710 uint32_t samplingRate = data.readInt32(); 711 audio_format_t format = (audio_format_t) data.readInt32(); 712 audio_channel_mask_t channelMask = data.readInt32(); 713 audio_output_flags_t flags = 714 static_cast <audio_output_flags_t>(data.readInt32()); 715 bool hasOffloadInfo = data.readInt32() != 0; 716 audio_offload_info_t offloadInfo; 717 if (hasOffloadInfo) { 718 data.read(&offloadInfo, sizeof(audio_offload_info_t)); 719 } 720 audio_io_handle_t output = getOutputForAttr(attr, 721 samplingRate, 722 format, 723 channelMask, 724 flags, 725 hasOffloadInfo ? &offloadInfo : NULL); 726 reply->writeInt32(static_cast <int>(output)); 727 return NO_ERROR; 728 } break; 729 730 case START_OUTPUT: { 731 CHECK_INTERFACE(IAudioPolicyService, data, reply); 732 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 733 audio_stream_type_t stream = 734 static_cast <audio_stream_type_t>(data.readInt32()); 735 int session = data.readInt32(); 736 reply->writeInt32(static_cast <uint32_t>(startOutput(output, 737 stream, 738 session))); 739 return NO_ERROR; 740 } break; 741 742 case STOP_OUTPUT: { 743 CHECK_INTERFACE(IAudioPolicyService, data, reply); 744 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 745 audio_stream_type_t stream = 746 static_cast <audio_stream_type_t>(data.readInt32()); 747 int session = data.readInt32(); 748 reply->writeInt32(static_cast <uint32_t>(stopOutput(output, 749 stream, 750 session))); 751 return NO_ERROR; 752 } break; 753 754 case RELEASE_OUTPUT: { 755 CHECK_INTERFACE(IAudioPolicyService, data, reply); 756 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32()); 757 releaseOutput(output); 758 return NO_ERROR; 759 } break; 760 761 case GET_INPUT: { 762 CHECK_INTERFACE(IAudioPolicyService, data, reply); 763 audio_source_t inputSource = (audio_source_t) data.readInt32(); 764 uint32_t samplingRate = data.readInt32(); 765 audio_format_t format = (audio_format_t) data.readInt32(); 766 audio_channel_mask_t channelMask = data.readInt32(); 767 int audioSession = data.readInt32(); 768 audio_input_flags_t flags = (audio_input_flags_t) data.readInt32(); 769 audio_io_handle_t input = getInput(inputSource, 770 samplingRate, 771 format, 772 channelMask, 773 audioSession, 774 flags); 775 reply->writeInt32(static_cast <int>(input)); 776 return NO_ERROR; 777 } break; 778 779 case START_INPUT: { 780 CHECK_INTERFACE(IAudioPolicyService, data, reply); 781 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 782 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 783 reply->writeInt32(static_cast <uint32_t>(startInput(input, session))); 784 return NO_ERROR; 785 } break; 786 787 case STOP_INPUT: { 788 CHECK_INTERFACE(IAudioPolicyService, data, reply); 789 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 790 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 791 reply->writeInt32(static_cast <uint32_t>(stopInput(input, session))); 792 return NO_ERROR; 793 } break; 794 795 case RELEASE_INPUT: { 796 CHECK_INTERFACE(IAudioPolicyService, data, reply); 797 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32()); 798 audio_session_t session = static_cast <audio_session_t>(data.readInt32()); 799 releaseInput(input, session); 800 return NO_ERROR; 801 } break; 802 803 case INIT_STREAM_VOLUME: { 804 CHECK_INTERFACE(IAudioPolicyService, data, reply); 805 audio_stream_type_t stream = 806 static_cast <audio_stream_type_t>(data.readInt32()); 807 int indexMin = data.readInt32(); 808 int indexMax = data.readInt32(); 809 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); 810 return NO_ERROR; 811 } break; 812 813 case SET_STREAM_VOLUME: { 814 CHECK_INTERFACE(IAudioPolicyService, data, reply); 815 audio_stream_type_t stream = 816 static_cast <audio_stream_type_t>(data.readInt32()); 817 int index = data.readInt32(); 818 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 819 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, 820 index, 821 device))); 822 return NO_ERROR; 823 } break; 824 825 case GET_STREAM_VOLUME: { 826 CHECK_INTERFACE(IAudioPolicyService, data, reply); 827 audio_stream_type_t stream = 828 static_cast <audio_stream_type_t>(data.readInt32()); 829 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32()); 830 int index; 831 status_t status = getStreamVolumeIndex(stream, &index, device); 832 reply->writeInt32(index); 833 reply->writeInt32(static_cast <uint32_t>(status)); 834 return NO_ERROR; 835 } break; 836 837 case GET_STRATEGY_FOR_STREAM: { 838 CHECK_INTERFACE(IAudioPolicyService, data, reply); 839 audio_stream_type_t stream = 840 static_cast <audio_stream_type_t>(data.readInt32()); 841 reply->writeInt32(getStrategyForStream(stream)); 842 return NO_ERROR; 843 } break; 844 845 case GET_DEVICES_FOR_STREAM: { 846 CHECK_INTERFACE(IAudioPolicyService, data, reply); 847 audio_stream_type_t stream = 848 static_cast <audio_stream_type_t>(data.readInt32()); 849 reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); 850 return NO_ERROR; 851 } break; 852 853 case GET_OUTPUT_FOR_EFFECT: { 854 CHECK_INTERFACE(IAudioPolicyService, data, reply); 855 effect_descriptor_t desc; 856 data.read(&desc, sizeof(effect_descriptor_t)); 857 audio_io_handle_t output = getOutputForEffect(&desc); 858 reply->writeInt32(static_cast <int>(output)); 859 return NO_ERROR; 860 } break; 861 862 case REGISTER_EFFECT: { 863 CHECK_INTERFACE(IAudioPolicyService, data, reply); 864 effect_descriptor_t desc; 865 data.read(&desc, sizeof(effect_descriptor_t)); 866 audio_io_handle_t io = data.readInt32(); 867 uint32_t strategy = data.readInt32(); 868 int session = data.readInt32(); 869 int id = data.readInt32(); 870 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc, 871 io, 872 strategy, 873 session, 874 id))); 875 return NO_ERROR; 876 } break; 877 878 case UNREGISTER_EFFECT: { 879 CHECK_INTERFACE(IAudioPolicyService, data, reply); 880 int id = data.readInt32(); 881 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id))); 882 return NO_ERROR; 883 } break; 884 885 case SET_EFFECT_ENABLED: { 886 CHECK_INTERFACE(IAudioPolicyService, data, reply); 887 int id = data.readInt32(); 888 bool enabled = static_cast <bool>(data.readInt32()); 889 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled))); 890 return NO_ERROR; 891 } break; 892 893 case IS_STREAM_ACTIVE: { 894 CHECK_INTERFACE(IAudioPolicyService, data, reply); 895 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 896 uint32_t inPastMs = (uint32_t)data.readInt32(); 897 reply->writeInt32( isStreamActive(stream, inPastMs) ); 898 return NO_ERROR; 899 } break; 900 901 case IS_STREAM_ACTIVE_REMOTELY: { 902 CHECK_INTERFACE(IAudioPolicyService, data, reply); 903 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32(); 904 uint32_t inPastMs = (uint32_t)data.readInt32(); 905 reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) ); 906 return NO_ERROR; 907 } break; 908 909 case IS_SOURCE_ACTIVE: { 910 CHECK_INTERFACE(IAudioPolicyService, data, reply); 911 audio_source_t source = (audio_source_t) data.readInt32(); 912 reply->writeInt32( isSourceActive(source)); 913 return NO_ERROR; 914 } 915 916 case QUERY_DEFAULT_PRE_PROCESSING: { 917 CHECK_INTERFACE(IAudioPolicyService, data, reply); 918 int audioSession = data.readInt32(); 919 uint32_t count = data.readInt32(); 920 if (count > AudioEffect::kMaxPreProcessing) { 921 count = AudioEffect::kMaxPreProcessing; 922 } 923 uint32_t retCount = count; 924 effect_descriptor_t *descriptors = new effect_descriptor_t[count]; 925 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount); 926 reply->writeInt32(status); 927 if (status != NO_ERROR && status != NO_MEMORY) { 928 retCount = 0; 929 } 930 reply->writeInt32(retCount); 931 if (retCount != 0) { 932 if (retCount < count) { 933 count = retCount; 934 } 935 reply->write(descriptors, sizeof(effect_descriptor_t) * count); 936 } 937 delete[] descriptors; 938 return status; 939 } 940 941 case IS_OFFLOAD_SUPPORTED: { 942 CHECK_INTERFACE(IAudioPolicyService, data, reply); 943 audio_offload_info_t info; 944 data.read(&info, sizeof(audio_offload_info_t)); 945 bool isSupported = isOffloadSupported(info); 946 reply->writeInt32(isSupported); 947 return NO_ERROR; 948 } 949 950 case LIST_AUDIO_PORTS: { 951 CHECK_INTERFACE(IAudioPolicyService, data, reply); 952 audio_port_role_t role = (audio_port_role_t)data.readInt32(); 953 audio_port_type_t type = (audio_port_type_t)data.readInt32(); 954 unsigned int numPortsReq = data.readInt32(); 955 unsigned int numPorts = numPortsReq; 956 unsigned int generation; 957 struct audio_port *ports = 958 (struct audio_port *)calloc(numPortsReq, sizeof(struct audio_port)); 959 status_t status = listAudioPorts(role, type, &numPorts, ports, &generation); 960 reply->writeInt32(status); 961 reply->writeInt32(numPorts); 962 963 if (status == NO_ERROR) { 964 if (numPortsReq > numPorts) { 965 numPortsReq = numPorts; 966 } 967 reply->write(ports, numPortsReq * sizeof(struct audio_port)); 968 reply->writeInt32(generation); 969 } 970 free(ports); 971 return NO_ERROR; 972 } 973 974 case GET_AUDIO_PORT: { 975 CHECK_INTERFACE(IAudioPolicyService, data, reply); 976 struct audio_port port; 977 data.read(&port, sizeof(struct audio_port)); 978 status_t status = getAudioPort(&port); 979 reply->writeInt32(status); 980 if (status == NO_ERROR) { 981 reply->write(&port, sizeof(struct audio_port)); 982 } 983 return NO_ERROR; 984 } 985 986 case CREATE_AUDIO_PATCH: { 987 CHECK_INTERFACE(IAudioPolicyService, data, reply); 988 struct audio_patch patch; 989 data.read(&patch, sizeof(struct audio_patch)); 990 audio_patch_handle_t handle; 991 data.read(&handle, sizeof(audio_patch_handle_t)); 992 status_t status = createAudioPatch(&patch, &handle); 993 reply->writeInt32(status); 994 if (status == NO_ERROR) { 995 reply->write(&handle, sizeof(audio_patch_handle_t)); 996 } 997 return NO_ERROR; 998 } 999 1000 case RELEASE_AUDIO_PATCH: { 1001 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1002 audio_patch_handle_t handle; 1003 data.read(&handle, sizeof(audio_patch_handle_t)); 1004 status_t status = releaseAudioPatch(handle); 1005 reply->writeInt32(status); 1006 return NO_ERROR; 1007 } 1008 1009 case LIST_AUDIO_PATCHES: { 1010 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1011 unsigned int numPatchesReq = data.readInt32(); 1012 unsigned int numPatches = numPatchesReq; 1013 unsigned int generation; 1014 struct audio_patch *patches = 1015 (struct audio_patch *)calloc(numPatchesReq, 1016 sizeof(struct audio_patch)); 1017 status_t status = listAudioPatches(&numPatches, patches, &generation); 1018 reply->writeInt32(status); 1019 reply->writeInt32(numPatches); 1020 if (status == NO_ERROR) { 1021 if (numPatchesReq > numPatches) { 1022 numPatchesReq = numPatches; 1023 } 1024 reply->write(patches, numPatchesReq * sizeof(struct audio_patch)); 1025 reply->writeInt32(generation); 1026 } 1027 free(patches); 1028 return NO_ERROR; 1029 } 1030 1031 case SET_AUDIO_PORT_CONFIG: { 1032 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1033 struct audio_port_config config; 1034 data.read(&config, sizeof(struct audio_port_config)); 1035 status_t status = setAudioPortConfig(&config); 1036 reply->writeInt32(status); 1037 return NO_ERROR; 1038 } 1039 1040 case REGISTER_CLIENT: { 1041 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1042 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1043 data.readStrongBinder()); 1044 registerClient(client); 1045 return NO_ERROR; 1046 } break; 1047 1048 case ACQUIRE_SOUNDTRIGGER_SESSION: { 1049 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1050 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1051 data.readStrongBinder()); 1052 audio_session_t session; 1053 audio_io_handle_t ioHandle; 1054 audio_devices_t device; 1055 status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device); 1056 reply->writeInt32(status); 1057 if (status == NO_ERROR) { 1058 reply->writeInt32(session); 1059 reply->writeInt32(ioHandle); 1060 reply->writeInt32(device); 1061 } 1062 return NO_ERROR; 1063 } break; 1064 1065 case RELEASE_SOUNDTRIGGER_SESSION: { 1066 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1067 sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>( 1068 data.readStrongBinder()); 1069 audio_session_t session = (audio_session_t)data.readInt32(); 1070 status_t status = releaseSoundTriggerSession(session); 1071 reply->writeInt32(status); 1072 return NO_ERROR; 1073 } break; 1074 1075 case GET_PHONE_STATE: { 1076 CHECK_INTERFACE(IAudioPolicyService, data, reply); 1077 reply->writeInt32((int32_t)getPhoneState()); 1078 return NO_ERROR; 1079 } break; 1080 1081 default: 1082 return BBinder::onTransact(code, data, reply, flags); 1083 } 1084} 1085 1086// ---------------------------------------------------------------------------- 1087 1088}; // namespace android 1089