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