IAudioPolicyService.cpp revision 7c7f10bd4fda9a084e5e7f0eb3a040dfcbf01745 
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                                    int audioSession)
189    {
190        Parcel data, reply;
191        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
192        data.writeInt32(inputSource);
193        data.writeInt32(samplingRate);
194        data.writeInt32(static_cast <uint32_t>(format));
195        data.writeInt32(channels);
196        data.writeInt32(static_cast <uint32_t>(acoustics));
197        data.writeInt32(audioSession);
198        remote()->transact(GET_INPUT, data, &reply);
199        return static_cast <audio_io_handle_t> (reply.readInt32());
200    }
201
202    virtual status_t startInput(audio_io_handle_t input)
203    {
204        Parcel data, reply;
205        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
206        data.writeInt32(input);
207        remote()->transact(START_INPUT, data, &reply);
208        return static_cast <status_t> (reply.readInt32());
209    }
210
211    virtual status_t stopInput(audio_io_handle_t input)
212    {
213        Parcel data, reply;
214        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
215        data.writeInt32(input);
216        remote()->transact(STOP_INPUT, data, &reply);
217        return static_cast <status_t> (reply.readInt32());
218    }
219
220    virtual void releaseInput(audio_io_handle_t input)
221    {
222        Parcel data, reply;
223        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
224        data.writeInt32(input);
225        remote()->transact(RELEASE_INPUT, data, &reply);
226    }
227
228    virtual status_t initStreamVolume(audio_stream_type_t stream,
229                                    int indexMin,
230                                    int indexMax)
231    {
232        Parcel data, reply;
233        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
234        data.writeInt32(static_cast <uint32_t>(stream));
235        data.writeInt32(indexMin);
236        data.writeInt32(indexMax);
237        remote()->transact(INIT_STREAM_VOLUME, data, &reply);
238        return static_cast <status_t> (reply.readInt32());
239    }
240
241    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index)
242    {
243        Parcel data, reply;
244        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
245        data.writeInt32(static_cast <uint32_t>(stream));
246        data.writeInt32(index);
247        remote()->transact(SET_STREAM_VOLUME, data, &reply);
248        return static_cast <status_t> (reply.readInt32());
249    }
250
251    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index)
252    {
253        Parcel data, reply;
254        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
255        data.writeInt32(static_cast <uint32_t>(stream));
256        remote()->transact(GET_STREAM_VOLUME, data, &reply);
257        int lIndex = reply.readInt32();
258        if (index) *index = lIndex;
259        return static_cast <status_t> (reply.readInt32());
260    }
261
262    virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
263    {
264        Parcel data, reply;
265        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
266        data.writeInt32(static_cast <uint32_t>(stream));
267        remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply);
268        return reply.readInt32();
269    }
270
271    virtual uint32_t getDevicesForStream(audio_stream_type_t stream)
272    {
273        Parcel data, reply;
274        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
275        data.writeInt32(static_cast <uint32_t>(stream));
276        remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply);
277        return (uint32_t) reply.readInt32();
278    }
279
280    virtual audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc)
281    {
282        Parcel data, reply;
283        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
284        data.write(desc, sizeof(effect_descriptor_t));
285        remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply);
286        return static_cast <audio_io_handle_t> (reply.readInt32());
287    }
288
289    virtual status_t registerEffect(effect_descriptor_t *desc,
290                                        audio_io_handle_t io,
291                                        uint32_t strategy,
292                                        int session,
293                                        int id)
294    {
295        Parcel data, reply;
296        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
297        data.write(desc, sizeof(effect_descriptor_t));
298        data.writeInt32(io);
299        data.writeInt32(strategy);
300        data.writeInt32(session);
301        data.writeInt32(id);
302        remote()->transact(REGISTER_EFFECT, data, &reply);
303        return static_cast <status_t> (reply.readInt32());
304    }
305
306    virtual status_t unregisterEffect(int id)
307    {
308        Parcel data, reply;
309        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
310        data.writeInt32(id);
311        remote()->transact(UNREGISTER_EFFECT, data, &reply);
312        return static_cast <status_t> (reply.readInt32());
313    }
314
315    virtual bool isStreamActive(int stream, uint32_t inPastMs) const
316    {
317        Parcel data, reply;
318        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
319        data.writeInt32(stream);
320        data.writeInt32(inPastMs);
321        remote()->transact(IS_STREAM_ACTIVE, data, &reply);
322        return reply.readInt32();
323    }
324};
325
326IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
327
328// ----------------------------------------------------------------------
329
330
331status_t BnAudioPolicyService::onTransact(
332    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
333{
334    switch(code) {
335        case SET_DEVICE_CONNECTION_STATE: {
336            CHECK_INTERFACE(IAudioPolicyService, data, reply);
337            audio_devices_t device =
338                    static_cast <audio_devices_t>(data.readInt32());
339            audio_policy_dev_state_t state =
340                    static_cast <audio_policy_dev_state_t>(data.readInt32());
341            const char *device_address = data.readCString();
342            reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
343                                                                              state,
344                                                                              device_address)));
345            return NO_ERROR;
346        } break;
347
348        case GET_DEVICE_CONNECTION_STATE: {
349            CHECK_INTERFACE(IAudioPolicyService, data, reply);
350            audio_devices_t device =
351                    static_cast<audio_devices_t> (data.readInt32());
352            const char *device_address = data.readCString();
353            reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
354                                                                              device_address)));
355            return NO_ERROR;
356        } break;
357
358        case SET_PHONE_STATE: {
359            CHECK_INTERFACE(IAudioPolicyService, data, reply);
360            reply->writeInt32(static_cast <uint32_t>(setPhoneState(data.readInt32())));
361            return NO_ERROR;
362        } break;
363
364        case SET_RINGER_MODE: {
365            CHECK_INTERFACE(IAudioPolicyService, data, reply);
366            uint32_t mode = data.readInt32();
367            uint32_t mask = data.readInt32();
368            reply->writeInt32(static_cast <uint32_t>(setRingerMode(mode, mask)));
369            return NO_ERROR;
370        } break;
371
372        case SET_FORCE_USE: {
373            CHECK_INTERFACE(IAudioPolicyService, data, reply);
374            audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32());
375            audio_policy_forced_cfg_t config =
376                    static_cast <audio_policy_forced_cfg_t>(data.readInt32());
377            reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
378            return NO_ERROR;
379        } break;
380
381        case GET_FORCE_USE: {
382            CHECK_INTERFACE(IAudioPolicyService, data, reply);
383            audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32());
384            reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
385            return NO_ERROR;
386        } break;
387
388        case GET_OUTPUT: {
389            CHECK_INTERFACE(IAudioPolicyService, data, reply);
390            audio_stream_type_t stream =
391                    static_cast <audio_stream_type_t>(data.readInt32());
392            uint32_t samplingRate = data.readInt32();
393            uint32_t format = data.readInt32();
394            uint32_t channels = data.readInt32();
395            audio_policy_output_flags_t flags =
396                    static_cast <audio_policy_output_flags_t>(data.readInt32());
397
398            audio_io_handle_t output = getOutput(stream,
399                                                 samplingRate,
400                                                 format,
401                                                 channels,
402                                                 flags);
403            reply->writeInt32(static_cast <int>(output));
404            return NO_ERROR;
405        } break;
406
407        case START_OUTPUT: {
408            CHECK_INTERFACE(IAudioPolicyService, data, reply);
409            audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
410            uint32_t stream = data.readInt32();
411            int session = data.readInt32();
412            reply->writeInt32(static_cast <uint32_t>(startOutput(output,
413                                                                 (audio_stream_type_t)stream,
414                                                                 session)));
415            return NO_ERROR;
416        } break;
417
418        case STOP_OUTPUT: {
419            CHECK_INTERFACE(IAudioPolicyService, data, reply);
420            audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
421            uint32_t stream = data.readInt32();
422            int session = data.readInt32();
423            reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
424                                                                (audio_stream_type_t)stream,
425                                                                session)));
426            return NO_ERROR;
427        } break;
428
429        case RELEASE_OUTPUT: {
430            CHECK_INTERFACE(IAudioPolicyService, data, reply);
431            audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
432            releaseOutput(output);
433            return NO_ERROR;
434        } break;
435
436        case GET_INPUT: {
437            CHECK_INTERFACE(IAudioPolicyService, data, reply);
438            int inputSource = data.readInt32();
439            uint32_t samplingRate = data.readInt32();
440            uint32_t format = data.readInt32();
441            uint32_t channels = data.readInt32();
442            audio_in_acoustics_t acoustics =
443                    static_cast <audio_in_acoustics_t>(data.readInt32());
444            int audioSession = data.readInt32();
445            audio_io_handle_t input = getInput(inputSource,
446                                               samplingRate,
447                                               format,
448                                               channels,
449                                               acoustics,
450                                               audioSession);
451            reply->writeInt32(static_cast <int>(input));
452            return NO_ERROR;
453        } break;
454
455        case START_INPUT: {
456            CHECK_INTERFACE(IAudioPolicyService, data, reply);
457            audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
458            reply->writeInt32(static_cast <uint32_t>(startInput(input)));
459            return NO_ERROR;
460        } break;
461
462        case STOP_INPUT: {
463            CHECK_INTERFACE(IAudioPolicyService, data, reply);
464            audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
465            reply->writeInt32(static_cast <uint32_t>(stopInput(input)));
466            return NO_ERROR;
467        } break;
468
469        case RELEASE_INPUT: {
470            CHECK_INTERFACE(IAudioPolicyService, data, reply);
471            audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
472            releaseInput(input);
473            return NO_ERROR;
474        } break;
475
476        case INIT_STREAM_VOLUME: {
477            CHECK_INTERFACE(IAudioPolicyService, data, reply);
478            audio_stream_type_t stream =
479                    static_cast <audio_stream_type_t>(data.readInt32());
480            int indexMin = data.readInt32();
481            int indexMax = data.readInt32();
482            reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
483            return NO_ERROR;
484        } break;
485
486        case SET_STREAM_VOLUME: {
487            CHECK_INTERFACE(IAudioPolicyService, data, reply);
488            audio_stream_type_t stream =
489                    static_cast <audio_stream_type_t>(data.readInt32());
490            int index = data.readInt32();
491            reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, index)));
492            return NO_ERROR;
493        } break;
494
495        case GET_STREAM_VOLUME: {
496            CHECK_INTERFACE(IAudioPolicyService, data, reply);
497            audio_stream_type_t stream =
498                    static_cast <audio_stream_type_t>(data.readInt32());
499            int index;
500            status_t status = getStreamVolumeIndex(stream, &index);
501            reply->writeInt32(index);
502            reply->writeInt32(static_cast <uint32_t>(status));
503            return NO_ERROR;
504        } break;
505
506        case GET_STRATEGY_FOR_STREAM: {
507            CHECK_INTERFACE(IAudioPolicyService, data, reply);
508            audio_stream_type_t stream =
509                    static_cast <audio_stream_type_t>(data.readInt32());
510            reply->writeInt32(getStrategyForStream(stream));
511            return NO_ERROR;
512        } break;
513
514        case GET_DEVICES_FOR_STREAM: {
515            CHECK_INTERFACE(IAudioPolicyService, data, reply);
516            audio_stream_type_t stream =
517                    static_cast <audio_stream_type_t>(data.readInt32());
518            reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
519            return NO_ERROR;
520        } break;
521
522        case GET_OUTPUT_FOR_EFFECT: {
523            CHECK_INTERFACE(IAudioPolicyService, data, reply);
524            effect_descriptor_t desc;
525            data.read(&desc, sizeof(effect_descriptor_t));
526            audio_io_handle_t output = getOutputForEffect(&desc);
527            reply->writeInt32(static_cast <int>(output));
528            return NO_ERROR;
529        } break;
530
531        case REGISTER_EFFECT: {
532            CHECK_INTERFACE(IAudioPolicyService, data, reply);
533            effect_descriptor_t desc;
534            data.read(&desc, sizeof(effect_descriptor_t));
535            audio_io_handle_t io = data.readInt32();
536            uint32_t strategy = data.readInt32();
537            int session = data.readInt32();
538            int id = data.readInt32();
539            reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
540                                                                   io,
541                                                                   strategy,
542                                                                   session,
543                                                                   id)));
544            return NO_ERROR;
545        } break;
546
547        case UNREGISTER_EFFECT: {
548            CHECK_INTERFACE(IAudioPolicyService, data, reply);
549            int id = data.readInt32();
550            reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
551            return NO_ERROR;
552        } break;
553
554        case IS_STREAM_ACTIVE: {
555            CHECK_INTERFACE(IAudioPolicyService, data, reply);
556            int stream = data.readInt32();
557            uint32_t inPastMs = (uint32_t)data.readInt32();
558            reply->writeInt32( isStreamActive(stream, inPastMs) );
559            return NO_ERROR;
560        } break;
561
562        default:
563            return BBinder::onTransact(code, data, reply, flags);
564    }
565}
566
567// ----------------------------------------------------------------------------
568
569}; // namespace android
570