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