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