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 <system/audio.h>
29
30 namespace android {
31
32 enum {
33 SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION,
34 GET_DEVICE_CONNECTION_STATE,
35 SET_PHONE_STATE,
36 SET_RINGER_MODE, // reserved, no longer used
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 IS_SOURCE_ACTIVE,
56 GET_DEVICES_FOR_STREAM,
57 QUERY_DEFAULT_PRE_PROCESSING,
58 SET_EFFECT_ENABLED,
59 IS_STREAM_ACTIVE_REMOTELY,
60 IS_OFFLOAD_SUPPORTED
61 };
62
63 class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
64 {
65 public:
BpAudioPolicyService(const sp<IBinder> & impl)66 BpAudioPolicyService(const sp<IBinder>& impl)
67 : BpInterface<IAudioPolicyService>(impl)
68 {
69 }
70
setDeviceConnectionState(audio_devices_t device,audio_policy_dev_state_t state,const char * device_address)71 virtual status_t setDeviceConnectionState(
72 audio_devices_t device,
73 audio_policy_dev_state_t state,
74 const char *device_address)
75 {
76 Parcel data, reply;
77 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
78 data.writeInt32(static_cast <uint32_t>(device));
79 data.writeInt32(static_cast <uint32_t>(state));
80 data.writeCString(device_address);
81 remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply);
82 return static_cast <status_t> (reply.readInt32());
83 }
84
getDeviceConnectionState(audio_devices_t device,const char * device_address)85 virtual audio_policy_dev_state_t getDeviceConnectionState(
86 audio_devices_t device,
87 const char *device_address)
88 {
89 Parcel data, reply;
90 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
91 data.writeInt32(static_cast <uint32_t>(device));
92 data.writeCString(device_address);
93 remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply);
94 return static_cast <audio_policy_dev_state_t>(reply.readInt32());
95 }
96
setPhoneState(audio_mode_t state)97 virtual status_t setPhoneState(audio_mode_t state)
98 {
99 Parcel data, reply;
100 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
101 data.writeInt32(state);
102 remote()->transact(SET_PHONE_STATE, data, &reply);
103 return static_cast <status_t> (reply.readInt32());
104 }
105
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)106 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
107 {
108 Parcel data, reply;
109 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
110 data.writeInt32(static_cast <uint32_t>(usage));
111 data.writeInt32(static_cast <uint32_t>(config));
112 remote()->transact(SET_FORCE_USE, data, &reply);
113 return static_cast <status_t> (reply.readInt32());
114 }
115
getForceUse(audio_policy_force_use_t usage)116 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage)
117 {
118 Parcel data, reply;
119 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
120 data.writeInt32(static_cast <uint32_t>(usage));
121 remote()->transact(GET_FORCE_USE, data, &reply);
122 return static_cast <audio_policy_forced_cfg_t> (reply.readInt32());
123 }
124
getOutput(audio_stream_type_t stream,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,audio_output_flags_t flags,const audio_offload_info_t * offloadInfo)125 virtual audio_io_handle_t getOutput(
126 audio_stream_type_t stream,
127 uint32_t samplingRate,
128 audio_format_t format,
129 audio_channel_mask_t channelMask,
130 audio_output_flags_t flags,
131 const audio_offload_info_t *offloadInfo)
132 {
133 Parcel data, reply;
134 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
135 data.writeInt32(static_cast <uint32_t>(stream));
136 data.writeInt32(samplingRate);
137 data.writeInt32(static_cast <uint32_t>(format));
138 data.writeInt32(channelMask);
139 data.writeInt32(static_cast <uint32_t>(flags));
140 if (offloadInfo == NULL) {
141 data.writeInt32(0);
142 } else {
143 data.writeInt32(1);
144 data.write(offloadInfo, sizeof(audio_offload_info_t));
145 }
146 remote()->transact(GET_OUTPUT, data, &reply);
147 return static_cast <audio_io_handle_t> (reply.readInt32());
148 }
149
startOutput(audio_io_handle_t output,audio_stream_type_t stream,int session)150 virtual status_t startOutput(audio_io_handle_t output,
151 audio_stream_type_t stream,
152 int session)
153 {
154 Parcel data, reply;
155 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
156 data.writeInt32(output);
157 data.writeInt32((int32_t) stream);
158 data.writeInt32(session);
159 remote()->transact(START_OUTPUT, data, &reply);
160 return static_cast <status_t> (reply.readInt32());
161 }
162
stopOutput(audio_io_handle_t output,audio_stream_type_t stream,int session)163 virtual status_t stopOutput(audio_io_handle_t output,
164 audio_stream_type_t stream,
165 int session)
166 {
167 Parcel data, reply;
168 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
169 data.writeInt32(output);
170 data.writeInt32((int32_t) stream);
171 data.writeInt32(session);
172 remote()->transact(STOP_OUTPUT, data, &reply);
173 return static_cast <status_t> (reply.readInt32());
174 }
175
releaseOutput(audio_io_handle_t output)176 virtual void releaseOutput(audio_io_handle_t output)
177 {
178 Parcel data, reply;
179 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
180 data.writeInt32(output);
181 remote()->transact(RELEASE_OUTPUT, data, &reply);
182 }
183
getInput(audio_source_t inputSource,uint32_t samplingRate,audio_format_t format,audio_channel_mask_t channelMask,int audioSession)184 virtual audio_io_handle_t getInput(
185 audio_source_t inputSource,
186 uint32_t samplingRate,
187 audio_format_t format,
188 audio_channel_mask_t channelMask,
189 int audioSession)
190 {
191 Parcel data, reply;
192 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
193 data.writeInt32((int32_t) inputSource);
194 data.writeInt32(samplingRate);
195 data.writeInt32(static_cast <uint32_t>(format));
196 data.writeInt32(channelMask);
197 data.writeInt32(audioSession);
198 remote()->transact(GET_INPUT, data, &reply);
199 return static_cast <audio_io_handle_t> (reply.readInt32());
200 }
201
startInput(audio_io_handle_t input)202 virtual status_t startInput(audio_io_handle_t input)
203 {
204 Parcel data, reply;
205 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
206 data.writeInt32(input);
207 remote()->transact(START_INPUT, data, &reply);
208 return static_cast <status_t> (reply.readInt32());
209 }
210
stopInput(audio_io_handle_t input)211 virtual status_t stopInput(audio_io_handle_t input)
212 {
213 Parcel data, reply;
214 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
215 data.writeInt32(input);
216 remote()->transact(STOP_INPUT, data, &reply);
217 return static_cast <status_t> (reply.readInt32());
218 }
219
releaseInput(audio_io_handle_t input)220 virtual void releaseInput(audio_io_handle_t input)
221 {
222 Parcel data, reply;
223 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
224 data.writeInt32(input);
225 remote()->transact(RELEASE_INPUT, data, &reply);
226 }
227
initStreamVolume(audio_stream_type_t stream,int indexMin,int indexMax)228 virtual status_t initStreamVolume(audio_stream_type_t stream,
229 int indexMin,
230 int indexMax)
231 {
232 Parcel data, reply;
233 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
234 data.writeInt32(static_cast <uint32_t>(stream));
235 data.writeInt32(indexMin);
236 data.writeInt32(indexMax);
237 remote()->transact(INIT_STREAM_VOLUME, data, &reply);
238 return static_cast <status_t> (reply.readInt32());
239 }
240
setStreamVolumeIndex(audio_stream_type_t stream,int index,audio_devices_t device)241 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
242 int index,
243 audio_devices_t device)
244 {
245 Parcel data, reply;
246 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
247 data.writeInt32(static_cast <uint32_t>(stream));
248 data.writeInt32(index);
249 data.writeInt32(static_cast <uint32_t>(device));
250 remote()->transact(SET_STREAM_VOLUME, data, &reply);
251 return static_cast <status_t> (reply.readInt32());
252 }
253
getStreamVolumeIndex(audio_stream_type_t stream,int * index,audio_devices_t device)254 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
255 int *index,
256 audio_devices_t device)
257 {
258 Parcel data, reply;
259 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
260 data.writeInt32(static_cast <uint32_t>(stream));
261 data.writeInt32(static_cast <uint32_t>(device));
262
263 remote()->transact(GET_STREAM_VOLUME, data, &reply);
264 int lIndex = reply.readInt32();
265 if (index) *index = lIndex;
266 return static_cast <status_t> (reply.readInt32());
267 }
268
getStrategyForStream(audio_stream_type_t stream)269 virtual uint32_t getStrategyForStream(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_STRATEGY_FOR_STREAM, data, &reply);
275 return reply.readInt32();
276 }
277
getDevicesForStream(audio_stream_type_t stream)278 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream)
279 {
280 Parcel data, reply;
281 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
282 data.writeInt32(static_cast <uint32_t>(stream));
283 remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply);
284 return (audio_devices_t) reply.readInt32();
285 }
286
getOutputForEffect(const effect_descriptor_t * desc)287 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc)
288 {
289 Parcel data, reply;
290 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
291 data.write(desc, sizeof(effect_descriptor_t));
292 remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply);
293 return static_cast <audio_io_handle_t> (reply.readInt32());
294 }
295
registerEffect(const effect_descriptor_t * desc,audio_io_handle_t io,uint32_t strategy,int session,int id)296 virtual status_t registerEffect(const effect_descriptor_t *desc,
297 audio_io_handle_t io,
298 uint32_t strategy,
299 int session,
300 int id)
301 {
302 Parcel data, reply;
303 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
304 data.write(desc, sizeof(effect_descriptor_t));
305 data.writeInt32(io);
306 data.writeInt32(strategy);
307 data.writeInt32(session);
308 data.writeInt32(id);
309 remote()->transact(REGISTER_EFFECT, data, &reply);
310 return static_cast <status_t> (reply.readInt32());
311 }
312
unregisterEffect(int id)313 virtual status_t unregisterEffect(int id)
314 {
315 Parcel data, reply;
316 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
317 data.writeInt32(id);
318 remote()->transact(UNREGISTER_EFFECT, data, &reply);
319 return static_cast <status_t> (reply.readInt32());
320 }
321
setEffectEnabled(int id,bool enabled)322 virtual status_t setEffectEnabled(int id, bool enabled)
323 {
324 Parcel data, reply;
325 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
326 data.writeInt32(id);
327 data.writeInt32(enabled);
328 remote()->transact(SET_EFFECT_ENABLED, data, &reply);
329 return static_cast <status_t> (reply.readInt32());
330 }
331
isStreamActive(audio_stream_type_t stream,uint32_t inPastMs) const332 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
333 {
334 Parcel data, reply;
335 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
336 data.writeInt32((int32_t) stream);
337 data.writeInt32(inPastMs);
338 remote()->transact(IS_STREAM_ACTIVE, data, &reply);
339 return reply.readInt32();
340 }
341
isStreamActiveRemotely(audio_stream_type_t stream,uint32_t inPastMs) const342 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
343 {
344 Parcel data, reply;
345 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
346 data.writeInt32((int32_t) stream);
347 data.writeInt32(inPastMs);
348 remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply);
349 return reply.readInt32();
350 }
351
isSourceActive(audio_source_t source) const352 virtual bool isSourceActive(audio_source_t source) const
353 {
354 Parcel data, reply;
355 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
356 data.writeInt32((int32_t) source);
357 remote()->transact(IS_SOURCE_ACTIVE, data, &reply);
358 return reply.readInt32();
359 }
360
queryDefaultPreProcessing(int audioSession,effect_descriptor_t * descriptors,uint32_t * count)361 virtual status_t queryDefaultPreProcessing(int audioSession,
362 effect_descriptor_t *descriptors,
363 uint32_t *count)
364 {
365 if (descriptors == NULL || count == NULL) {
366 return BAD_VALUE;
367 }
368 Parcel data, reply;
369 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
370 data.writeInt32(audioSession);
371 data.writeInt32(*count);
372 status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply);
373 if (status != NO_ERROR) {
374 return status;
375 }
376 status = static_cast <status_t> (reply.readInt32());
377 uint32_t retCount = reply.readInt32();
378 if (retCount != 0) {
379 uint32_t numDesc = (retCount < *count) ? retCount : *count;
380 reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc);
381 }
382 *count = retCount;
383 return status;
384 }
385
isOffloadSupported(const audio_offload_info_t & info)386 virtual bool isOffloadSupported(const audio_offload_info_t& info)
387 {
388 Parcel data, reply;
389 data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
390 data.write(&info, sizeof(audio_offload_info_t));
391 remote()->transact(IS_OFFLOAD_SUPPORTED, data, &reply);
392 return reply.readInt32(); }
393 };
394
395 IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
396
397 // ----------------------------------------------------------------------
398
399
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)400 status_t BnAudioPolicyService::onTransact(
401 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
402 {
403 switch (code) {
404 case SET_DEVICE_CONNECTION_STATE: {
405 CHECK_INTERFACE(IAudioPolicyService, data, reply);
406 audio_devices_t device =
407 static_cast <audio_devices_t>(data.readInt32());
408 audio_policy_dev_state_t state =
409 static_cast <audio_policy_dev_state_t>(data.readInt32());
410 const char *device_address = data.readCString();
411 reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
412 state,
413 device_address)));
414 return NO_ERROR;
415 } break;
416
417 case GET_DEVICE_CONNECTION_STATE: {
418 CHECK_INTERFACE(IAudioPolicyService, data, reply);
419 audio_devices_t device =
420 static_cast<audio_devices_t> (data.readInt32());
421 const char *device_address = data.readCString();
422 reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
423 device_address)));
424 return NO_ERROR;
425 } break;
426
427 case SET_PHONE_STATE: {
428 CHECK_INTERFACE(IAudioPolicyService, data, reply);
429 reply->writeInt32(static_cast <uint32_t>(setPhoneState(
430 (audio_mode_t) data.readInt32())));
431 return NO_ERROR;
432 } break;
433
434 case SET_FORCE_USE: {
435 CHECK_INTERFACE(IAudioPolicyService, data, reply);
436 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
437 data.readInt32());
438 audio_policy_forced_cfg_t config =
439 static_cast <audio_policy_forced_cfg_t>(data.readInt32());
440 reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
441 return NO_ERROR;
442 } break;
443
444 case GET_FORCE_USE: {
445 CHECK_INTERFACE(IAudioPolicyService, data, reply);
446 audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
447 data.readInt32());
448 reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
449 return NO_ERROR;
450 } break;
451
452 case GET_OUTPUT: {
453 CHECK_INTERFACE(IAudioPolicyService, data, reply);
454 audio_stream_type_t stream =
455 static_cast <audio_stream_type_t>(data.readInt32());
456 uint32_t samplingRate = data.readInt32();
457 audio_format_t format = (audio_format_t) data.readInt32();
458 audio_channel_mask_t channelMask = data.readInt32();
459 audio_output_flags_t flags =
460 static_cast <audio_output_flags_t>(data.readInt32());
461 bool hasOffloadInfo = data.readInt32() != 0;
462 audio_offload_info_t offloadInfo;
463 if (hasOffloadInfo) {
464 data.read(&offloadInfo, sizeof(audio_offload_info_t));
465 }
466 audio_io_handle_t output = getOutput(stream,
467 samplingRate,
468 format,
469 channelMask,
470 flags,
471 hasOffloadInfo ? &offloadInfo : NULL);
472 reply->writeInt32(static_cast <int>(output));
473 return NO_ERROR;
474 } break;
475
476 case START_OUTPUT: {
477 CHECK_INTERFACE(IAudioPolicyService, data, reply);
478 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
479 uint32_t stream = data.readInt32();
480 int session = data.readInt32();
481 reply->writeInt32(static_cast <uint32_t>(startOutput(output,
482 (audio_stream_type_t)stream,
483 session)));
484 return NO_ERROR;
485 } break;
486
487 case STOP_OUTPUT: {
488 CHECK_INTERFACE(IAudioPolicyService, data, reply);
489 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
490 uint32_t stream = data.readInt32();
491 int session = data.readInt32();
492 reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
493 (audio_stream_type_t)stream,
494 session)));
495 return NO_ERROR;
496 } break;
497
498 case RELEASE_OUTPUT: {
499 CHECK_INTERFACE(IAudioPolicyService, data, reply);
500 audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
501 releaseOutput(output);
502 return NO_ERROR;
503 } break;
504
505 case GET_INPUT: {
506 CHECK_INTERFACE(IAudioPolicyService, data, reply);
507 audio_source_t inputSource = (audio_source_t) data.readInt32();
508 uint32_t samplingRate = data.readInt32();
509 audio_format_t format = (audio_format_t) data.readInt32();
510 audio_channel_mask_t channelMask = data.readInt32();
511 int audioSession = data.readInt32();
512 audio_io_handle_t input = getInput(inputSource,
513 samplingRate,
514 format,
515 channelMask,
516 audioSession);
517 reply->writeInt32(static_cast <int>(input));
518 return NO_ERROR;
519 } break;
520
521 case START_INPUT: {
522 CHECK_INTERFACE(IAudioPolicyService, data, reply);
523 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
524 reply->writeInt32(static_cast <uint32_t>(startInput(input)));
525 return NO_ERROR;
526 } break;
527
528 case STOP_INPUT: {
529 CHECK_INTERFACE(IAudioPolicyService, data, reply);
530 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
531 reply->writeInt32(static_cast <uint32_t>(stopInput(input)));
532 return NO_ERROR;
533 } break;
534
535 case RELEASE_INPUT: {
536 CHECK_INTERFACE(IAudioPolicyService, data, reply);
537 audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
538 releaseInput(input);
539 return NO_ERROR;
540 } break;
541
542 case INIT_STREAM_VOLUME: {
543 CHECK_INTERFACE(IAudioPolicyService, data, reply);
544 audio_stream_type_t stream =
545 static_cast <audio_stream_type_t>(data.readInt32());
546 int indexMin = data.readInt32();
547 int indexMax = data.readInt32();
548 reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
549 return NO_ERROR;
550 } break;
551
552 case SET_STREAM_VOLUME: {
553 CHECK_INTERFACE(IAudioPolicyService, data, reply);
554 audio_stream_type_t stream =
555 static_cast <audio_stream_type_t>(data.readInt32());
556 int index = data.readInt32();
557 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
558 reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
559 index,
560 device)));
561 return NO_ERROR;
562 } break;
563
564 case GET_STREAM_VOLUME: {
565 CHECK_INTERFACE(IAudioPolicyService, data, reply);
566 audio_stream_type_t stream =
567 static_cast <audio_stream_type_t>(data.readInt32());
568 audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
569 int index;
570 status_t status = getStreamVolumeIndex(stream, &index, device);
571 reply->writeInt32(index);
572 reply->writeInt32(static_cast <uint32_t>(status));
573 return NO_ERROR;
574 } break;
575
576 case GET_STRATEGY_FOR_STREAM: {
577 CHECK_INTERFACE(IAudioPolicyService, data, reply);
578 audio_stream_type_t stream =
579 static_cast <audio_stream_type_t>(data.readInt32());
580 reply->writeInt32(getStrategyForStream(stream));
581 return NO_ERROR;
582 } break;
583
584 case GET_DEVICES_FOR_STREAM: {
585 CHECK_INTERFACE(IAudioPolicyService, data, reply);
586 audio_stream_type_t stream =
587 static_cast <audio_stream_type_t>(data.readInt32());
588 reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
589 return NO_ERROR;
590 } break;
591
592 case GET_OUTPUT_FOR_EFFECT: {
593 CHECK_INTERFACE(IAudioPolicyService, data, reply);
594 effect_descriptor_t desc;
595 data.read(&desc, sizeof(effect_descriptor_t));
596 audio_io_handle_t output = getOutputForEffect(&desc);
597 reply->writeInt32(static_cast <int>(output));
598 return NO_ERROR;
599 } break;
600
601 case REGISTER_EFFECT: {
602 CHECK_INTERFACE(IAudioPolicyService, data, reply);
603 effect_descriptor_t desc;
604 data.read(&desc, sizeof(effect_descriptor_t));
605 audio_io_handle_t io = data.readInt32();
606 uint32_t strategy = data.readInt32();
607 int session = data.readInt32();
608 int id = data.readInt32();
609 reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
610 io,
611 strategy,
612 session,
613 id)));
614 return NO_ERROR;
615 } break;
616
617 case UNREGISTER_EFFECT: {
618 CHECK_INTERFACE(IAudioPolicyService, data, reply);
619 int id = data.readInt32();
620 reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
621 return NO_ERROR;
622 } break;
623
624 case SET_EFFECT_ENABLED: {
625 CHECK_INTERFACE(IAudioPolicyService, data, reply);
626 int id = data.readInt32();
627 bool enabled = static_cast <bool>(data.readInt32());
628 reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
629 return NO_ERROR;
630 } break;
631
632 case IS_STREAM_ACTIVE: {
633 CHECK_INTERFACE(IAudioPolicyService, data, reply);
634 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
635 uint32_t inPastMs = (uint32_t)data.readInt32();
636 reply->writeInt32( isStreamActive((audio_stream_type_t) stream, inPastMs) );
637 return NO_ERROR;
638 } break;
639
640 case IS_STREAM_ACTIVE_REMOTELY: {
641 CHECK_INTERFACE(IAudioPolicyService, data, reply);
642 audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
643 uint32_t inPastMs = (uint32_t)data.readInt32();
644 reply->writeInt32( isStreamActiveRemotely((audio_stream_type_t) stream, inPastMs) );
645 return NO_ERROR;
646 } break;
647
648 case IS_SOURCE_ACTIVE: {
649 CHECK_INTERFACE(IAudioPolicyService, data, reply);
650 audio_source_t source = (audio_source_t) data.readInt32();
651 reply->writeInt32( isSourceActive(source));
652 return NO_ERROR;
653 }
654
655 case QUERY_DEFAULT_PRE_PROCESSING: {
656 CHECK_INTERFACE(IAudioPolicyService, data, reply);
657 int audioSession = data.readInt32();
658 uint32_t count = data.readInt32();
659 uint32_t retCount = count;
660 effect_descriptor_t *descriptors =
661 (effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)];
662 status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
663 reply->writeInt32(status);
664 if (status != NO_ERROR && status != NO_MEMORY) {
665 retCount = 0;
666 }
667 reply->writeInt32(retCount);
668 if (retCount) {
669 if (retCount < count) {
670 count = retCount;
671 }
672 reply->write(descriptors, sizeof(effect_descriptor_t) * count);
673 }
674 delete[] descriptors;
675 return status;
676 }
677
678 case IS_OFFLOAD_SUPPORTED: {
679 CHECK_INTERFACE(IAudioPolicyService, data, reply);
680 audio_offload_info_t info;
681 data.read(&info, sizeof(audio_offload_info_t));
682 bool isSupported = isOffloadSupported(info);
683 reply->writeInt32(isSupported);
684 return NO_ERROR;
685 }
686
687 default:
688 return BBinder::onTransact(code, data, reply, flags);
689 }
690 }
691
692 // ----------------------------------------------------------------------------
693
694 }; // namespace android
695