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