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