IAudioPolicyService.cpp revision 64760240f931714858a59c1579f07264d7182ba2 
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,
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};
57
58class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
59{
60public:
61    BpAudioPolicyService(const sp<IBinder>& impl)
62        : BpInterface<IAudioPolicyService>(impl)
63    {
64    }
65
66    virtual status_t setDeviceConnectionState(
67                                    audio_devices_t device,
68                                    audio_policy_dev_state_t state,
69                                    const char *device_address)
70    {
71        Parcel data, reply;
72        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
73        data.writeInt32(static_cast <uint32_t>(device));
74        data.writeInt32(static_cast <uint32_t>(state));
75        data.writeCString(device_address);
76        remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply);
77        return static_cast <status_t> (reply.readInt32());
78    }
79
80    virtual audio_policy_dev_state_t getDeviceConnectionState(
81                                    audio_devices_t device,
82                                    const char *device_address)
83    {
84        Parcel data, reply;
85        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
86        data.writeInt32(static_cast <uint32_t>(device));
87        data.writeCString(device_address);
88        remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply);
89        return static_cast <audio_policy_dev_state_t>(reply.readInt32());
90    }
91
92    virtual status_t setPhoneState(int state)
93    {
94        Parcel data, reply;
95        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
96        data.writeInt32(state);
97        remote()->transact(SET_PHONE_STATE, data, &reply);
98        return static_cast <status_t> (reply.readInt32());
99    }
100
101    virtual status_t setRingerMode(uint32_t mode, uint32_t mask)
102    {
103        Parcel data, reply;
104        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
105        data.writeInt32(mode);
106        data.writeInt32(mask);
107        remote()->transact(SET_RINGER_MODE, data, &reply);
108        return static_cast <status_t> (reply.readInt32());
109    }
110
111    virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
112    {
113        Parcel data, reply;
114        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
115        data.writeInt32(static_cast <uint32_t>(usage));
116        data.writeInt32(static_cast <uint32_t>(config));
117        remote()->transact(SET_FORCE_USE, data, &reply);
118        return static_cast <status_t> (reply.readInt32());
119    }
120
121    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage)
122    {
123        Parcel data, reply;
124        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
125        data.writeInt32(static_cast <uint32_t>(usage));
126        remote()->transact(GET_FORCE_USE, data, &reply);
127        return static_cast <audio_policy_forced_cfg_t> (reply.readInt32());
128    }
129
130    virtual audio_io_handle_t getOutput(
131                                        audio_stream_type_t stream,
132                                        uint32_t samplingRate,
133                                        uint32_t format,
134                                        uint32_t channels,
135                                        audio_policy_output_flags_t flags)
136    {
137        Parcel data, reply;
138        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
139        data.writeInt32(static_cast <uint32_t>(stream));
140        data.writeInt32(samplingRate);
141        data.writeInt32(static_cast <uint32_t>(format));
142        data.writeInt32(channels);
143        data.writeInt32(static_cast <uint32_t>(flags));
144        remote()->transact(GET_OUTPUT, data, &reply);
145        return static_cast <audio_io_handle_t> (reply.readInt32());
146    }
147
148    virtual status_t startOutput(audio_io_handle_t output,
149                                 audio_stream_type_t stream,
150                                 int session)
151    {
152        Parcel data, reply;
153        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
154        data.writeInt32(output);
155        data.writeInt32(stream);
156        data.writeInt32(session);
157        remote()->transact(START_OUTPUT, data, &reply);
158        return static_cast <status_t> (reply.readInt32());
159    }
160
161    virtual status_t stopOutput(audio_io_handle_t output,
162                                audio_stream_type_t stream,
163                                int session)
164    {
165        Parcel data, reply;
166        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
167        data.writeInt32(output);
168        data.writeInt32(stream);
169        data.writeInt32(session);
170        remote()->transact(STOP_OUTPUT, data, &reply);
171        return static_cast <status_t> (reply.readInt32());
172    }
173
174    virtual void releaseOutput(audio_io_handle_t output)
175    {
176        Parcel data, reply;
177        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
178        data.writeInt32(output);
179        remote()->transact(RELEASE_OUTPUT, data, &reply);
180    }
181
182    virtual audio_io_handle_t getInput(
183                                    int inputSource,
184                                    uint32_t samplingRate,
185                                    uint32_t format,
186                                    uint32_t channels,
187                                    audio_in_acoustics_t acoustics)
188    {
189        Parcel data, reply;
190        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
191        data.writeInt32(inputSource);
192        data.writeInt32(samplingRate);
193        data.writeInt32(static_cast <uint32_t>(format));
194        data.writeInt32(channels);
195        data.writeInt32(static_cast <uint32_t>(acoustics));
196        remote()->transact(GET_INPUT, data, &reply);
197        return static_cast <audio_io_handle_t> (reply.readInt32());
198    }
199
200    virtual status_t startInput(audio_io_handle_t input)
201    {
202        Parcel data, reply;
203        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
204        data.writeInt32(input);
205        remote()->transact(START_INPUT, data, &reply);
206        return static_cast <status_t> (reply.readInt32());
207    }
208
209    virtual status_t stopInput(audio_io_handle_t input)
210    {
211        Parcel data, reply;
212        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
213        data.writeInt32(input);
214        remote()->transact(STOP_INPUT, data, &reply);
215        return static_cast <status_t> (reply.readInt32());
216    }
217
218    virtual void releaseInput(audio_io_handle_t input)
219    {
220        Parcel data, reply;
221        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
222        data.writeInt32(input);
223        remote()->transact(RELEASE_INPUT, data, &reply);
224    }
225
226    virtual status_t initStreamVolume(audio_stream_type_t stream,
227                                    int indexMin,
228                                    int indexMax)
229    {
230        Parcel data, reply;
231        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
232        data.writeInt32(static_cast <uint32_t>(stream));
233        data.writeInt32(indexMin);
234        data.writeInt32(indexMax);
235        remote()->transact(INIT_STREAM_VOLUME, data, &reply);
236        return static_cast <status_t> (reply.readInt32());
237    }
238
239    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index)
240    {
241        Parcel data, reply;
242        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
243        data.writeInt32(static_cast <uint32_t>(stream));
244        data.writeInt32(index);
245        remote()->transact(SET_STREAM_VOLUME, data, &reply);
246        return static_cast <status_t> (reply.readInt32());
247    }
248
249    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index)
250    {
251        Parcel data, reply;
252        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
253        data.writeInt32(static_cast <uint32_t>(stream));
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 uint32_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 (uint32_t) reply.readInt32();
276    }
277
278    virtual audio_io_handle_t getOutputForEffect(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(effect_descriptor_t *desc,
288                                        audio_io_handle_t output,
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(output);
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 bool isStreamActive(int stream, uint32_t inPastMs) const
314    {
315        Parcel data, reply;
316        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
317        data.writeInt32(stream);
318        data.writeInt32(inPastMs);
319        remote()->transact(IS_STREAM_ACTIVE, data, &reply);
320        return reply.readInt32();
321    }
322};
323
324IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
325
326// ----------------------------------------------------------------------
327
328
329status_t BnAudioPolicyService::onTransact(
330    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
331{
332    switch(code) {
333        case SET_DEVICE_CONNECTION_STATE: {
334            CHECK_INTERFACE(IAudioPolicyService, data, reply);
335            audio_devices_t device =
336                    static_cast <audio_devices_t>(data.readInt32());
337            audio_policy_dev_state_t state =
338                    static_cast <audio_policy_dev_state_t>(data.readInt32());
339            const char *device_address = data.readCString();
340            reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
341                                                                              state,
342                                                                              device_address)));
343            return NO_ERROR;
344        } break;
345
346        case GET_DEVICE_CONNECTION_STATE: {
347            CHECK_INTERFACE(IAudioPolicyService, data, reply);
348            audio_devices_t device =
349                    static_cast<audio_devices_t> (data.readInt32());
350            const char *device_address = data.readCString();
351            reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
352                                                                              device_address)));
353            return NO_ERROR;
354        } break;
355
356        case SET_PHONE_STATE: {
357            CHECK_INTERFACE(IAudioPolicyService, data, reply);
358            reply->writeInt32(static_cast <uint32_t>(setPhoneState(data.readInt32())));
359            return NO_ERROR;
360        } break;
361
362        case SET_RINGER_MODE: {
363            CHECK_INTERFACE(IAudioPolicyService, data, reply);
364            uint32_t mode = data.readInt32();
365            uint32_t mask = data.readInt32();
366            reply->writeInt32(static_cast <uint32_t>(setRingerMode(mode, mask)));
367            return NO_ERROR;
368        } break;
369
370        case SET_FORCE_USE: {
371            CHECK_INTERFACE(IAudioPolicyService, data, reply);
372            audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32());
373            audio_policy_forced_cfg_t config =
374                    static_cast <audio_policy_forced_cfg_t>(data.readInt32());
375            reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
376            return NO_ERROR;
377        } break;
378
379        case GET_FORCE_USE: {
380            CHECK_INTERFACE(IAudioPolicyService, data, reply);
381            audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32());
382            reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
383            return NO_ERROR;
384        } break;
385
386        case GET_OUTPUT: {
387            CHECK_INTERFACE(IAudioPolicyService, data, reply);
388            audio_stream_type_t stream =
389                    static_cast <audio_stream_type_t>(data.readInt32());
390            uint32_t samplingRate = data.readInt32();
391            uint32_t format = data.readInt32();
392            uint32_t channels = data.readInt32();
393            audio_policy_output_flags_t flags =
394                    static_cast <audio_policy_output_flags_t>(data.readInt32());
395
396            audio_io_handle_t output = getOutput(stream,
397                                                 samplingRate,
398                                                 format,
399                                                 channels,
400                                                 flags);
401            reply->writeInt32(static_cast <int>(output));
402            return NO_ERROR;
403        } break;
404
405        case START_OUTPUT: {
406            CHECK_INTERFACE(IAudioPolicyService, data, reply);
407            audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
408            uint32_t stream = data.readInt32();
409            int session = data.readInt32();
410            reply->writeInt32(static_cast <uint32_t>(startOutput(output,
411                                                                 (audio_stream_type_t)stream,
412                                                                 session)));
413            return NO_ERROR;
414        } break;
415
416        case STOP_OUTPUT: {
417            CHECK_INTERFACE(IAudioPolicyService, data, reply);
418            audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
419            uint32_t stream = data.readInt32();
420            int session = data.readInt32();
421            reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
422                                                                (audio_stream_type_t)stream,
423                                                                session)));
424            return NO_ERROR;
425        } break;
426
427        case RELEASE_OUTPUT: {
428            CHECK_INTERFACE(IAudioPolicyService, data, reply);
429            audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
430            releaseOutput(output);
431            return NO_ERROR;
432        } break;
433
434        case GET_INPUT: {
435            CHECK_INTERFACE(IAudioPolicyService, data, reply);
436            int inputSource = data.readInt32();
437            uint32_t samplingRate = data.readInt32();
438            uint32_t format = data.readInt32();
439            uint32_t channels = data.readInt32();
440            audio_in_acoustics_t acoustics =
441                    static_cast <audio_in_acoustics_t>(data.readInt32());
442            audio_io_handle_t input = getInput(inputSource,
443                                               samplingRate,
444                                               format,
445                                               channels,
446                                               acoustics);
447            reply->writeInt32(static_cast <int>(input));
448            return NO_ERROR;
449        } break;
450
451        case START_INPUT: {
452            CHECK_INTERFACE(IAudioPolicyService, data, reply);
453            audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
454            reply->writeInt32(static_cast <uint32_t>(startInput(input)));
455            return NO_ERROR;
456        } break;
457
458        case STOP_INPUT: {
459            CHECK_INTERFACE(IAudioPolicyService, data, reply);
460            audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
461            reply->writeInt32(static_cast <uint32_t>(stopInput(input)));
462            return NO_ERROR;
463        } break;
464
465        case RELEASE_INPUT: {
466            CHECK_INTERFACE(IAudioPolicyService, data, reply);
467            audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
468            releaseInput(input);
469            return NO_ERROR;
470        } break;
471
472        case INIT_STREAM_VOLUME: {
473            CHECK_INTERFACE(IAudioPolicyService, data, reply);
474            audio_stream_type_t stream =
475                    static_cast <audio_stream_type_t>(data.readInt32());
476            int indexMin = data.readInt32();
477            int indexMax = data.readInt32();
478            reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
479            return NO_ERROR;
480        } break;
481
482        case SET_STREAM_VOLUME: {
483            CHECK_INTERFACE(IAudioPolicyService, data, reply);
484            audio_stream_type_t stream =
485                    static_cast <audio_stream_type_t>(data.readInt32());
486            int index = data.readInt32();
487            reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, index)));
488            return NO_ERROR;
489        } break;
490
491        case GET_STREAM_VOLUME: {
492            CHECK_INTERFACE(IAudioPolicyService, data, reply);
493            audio_stream_type_t stream =
494                    static_cast <audio_stream_type_t>(data.readInt32());
495            int index;
496            status_t status = getStreamVolumeIndex(stream, &index);
497            reply->writeInt32(index);
498            reply->writeInt32(static_cast <uint32_t>(status));
499            return NO_ERROR;
500        } break;
501
502        case GET_STRATEGY_FOR_STREAM: {
503            CHECK_INTERFACE(IAudioPolicyService, data, reply);
504            audio_stream_type_t stream =
505                    static_cast <audio_stream_type_t>(data.readInt32());
506            reply->writeInt32(getStrategyForStream(stream));
507            return NO_ERROR;
508        } break;
509
510        case GET_DEVICES_FOR_STREAM: {
511            CHECK_INTERFACE(IAudioPolicyService, data, reply);
512            audio_stream_type_t stream =
513                    static_cast <audio_stream_type_t>(data.readInt32());
514            reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
515            return NO_ERROR;
516        } break;
517
518        case GET_OUTPUT_FOR_EFFECT: {
519            CHECK_INTERFACE(IAudioPolicyService, data, reply);
520            effect_descriptor_t desc;
521            data.read(&desc, sizeof(effect_descriptor_t));
522            audio_io_handle_t output = getOutputForEffect(&desc);
523            reply->writeInt32(static_cast <int>(output));
524            return NO_ERROR;
525        } break;
526
527        case REGISTER_EFFECT: {
528            CHECK_INTERFACE(IAudioPolicyService, data, reply);
529            effect_descriptor_t desc;
530            data.read(&desc, sizeof(effect_descriptor_t));
531            audio_io_handle_t output = data.readInt32();
532            uint32_t strategy = data.readInt32();
533            int session = data.readInt32();
534            int id = data.readInt32();
535            reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
536                                                                   output,
537                                                                   strategy,
538                                                                   session,
539                                                                   id)));
540            return NO_ERROR;
541        } break;
542
543        case UNREGISTER_EFFECT: {
544            CHECK_INTERFACE(IAudioPolicyService, data, reply);
545            int id = data.readInt32();
546            reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
547            return NO_ERROR;
548        } break;
549
550        case IS_STREAM_ACTIVE: {
551            CHECK_INTERFACE(IAudioPolicyService, data, reply);
552            int stream = data.readInt32();
553            uint32_t inPastMs = (uint32_t)data.readInt32();
554            reply->writeInt32( isStreamActive(stream, inPastMs) );
555            return NO_ERROR;
556        } break;
557
558        default:
559            return BBinder::onTransact(code, data, reply, flags);
560    }
561}
562
563// ----------------------------------------------------------------------------
564
565}; // namespace android
566