IAudioPolicyService.cpp revision e53b9ead781c36e96d6b6f012ddffc93a3d80f0d 
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    GET_DEVICES_FOR_STREAM,
56    QUERY_DEFAULT_PRE_PROCESSING,
57    SET_EFFECT_ENABLED
58};
59
60class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
61{
62public:
63    BpAudioPolicyService(const sp<IBinder>& impl)
64        : BpInterface<IAudioPolicyService>(impl)
65    {
66    }
67
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
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
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
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
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
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_policy_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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
324    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
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
360IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
361
362// ----------------------------------------------------------------------
363
364
365status_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_policy_output_flags_t flags =
422                    static_cast <audio_policy_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