AudioPolicyService.h revision c7e5040aa8b8e4da86814bf560346c7571e48087 
1/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_AUDIOPOLICYSERVICE_H
18#define ANDROID_AUDIOPOLICYSERVICE_H
19
20#include <cutils/misc.h>
21#include <cutils/config_utils.h>
22#include <cutils/compiler.h>
23#include <utils/String8.h>
24#include <utils/Vector.h>
25#include <utils/SortedVector.h>
26#include <binder/BinderService.h>
27#include <system/audio.h>
28#include <system/audio_policy.h>
29#include <hardware/audio_policy.h>
30#include <media/IAudioPolicyService.h>
31#include <media/ToneGenerator.h>
32#include <media/AudioEffect.h>
33
34namespace android {
35
36// ----------------------------------------------------------------------------
37
38class AudioPolicyService :
39    public BinderService<AudioPolicyService>,
40    public BnAudioPolicyService,
41//    public AudioPolicyClientInterface,
42    public IBinder::DeathRecipient
43{
44    friend class BinderService<AudioPolicyService>;
45
46public:
47    // for BinderService
48    static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
49
50    virtual status_t    dump(int fd, const Vector<String16>& args);
51
52    //
53    // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
54    //
55
56    virtual status_t setDeviceConnectionState(audio_devices_t device,
57                                              audio_policy_dev_state_t state,
58                                              const char *device_address);
59    virtual audio_policy_dev_state_t getDeviceConnectionState(
60                                                                audio_devices_t device,
61                                                                const char *device_address);
62    virtual status_t setPhoneState(audio_mode_t state);
63    virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
64    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
65    virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
66                                        uint32_t samplingRate = 0,
67                                        audio_format_t format = AUDIO_FORMAT_DEFAULT,
68                                        audio_channel_mask_t channelMask = 0,
69                                        audio_output_flags_t flags =
70                                                AUDIO_OUTPUT_FLAG_NONE,
71                                        const audio_offload_info_t *offloadInfo = NULL);
72    virtual status_t startOutput(audio_io_handle_t output,
73                                 audio_stream_type_t stream,
74                                 int session = 0);
75    virtual status_t stopOutput(audio_io_handle_t output,
76                                audio_stream_type_t stream,
77                                int session = 0);
78    virtual void releaseOutput(audio_io_handle_t output);
79    virtual audio_io_handle_t getInput(audio_source_t inputSource,
80                                    uint32_t samplingRate = 0,
81                                    audio_format_t format = AUDIO_FORMAT_DEFAULT,
82                                    audio_channel_mask_t channelMask = 0,
83                                    int audioSession = 0);
84    virtual status_t startInput(audio_io_handle_t input);
85    virtual status_t stopInput(audio_io_handle_t input);
86    virtual void releaseInput(audio_io_handle_t input);
87    virtual status_t initStreamVolume(audio_stream_type_t stream,
88                                      int indexMin,
89                                      int indexMax);
90    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
91                                          int index,
92                                          audio_devices_t device);
93    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
94                                          int *index,
95                                          audio_devices_t device);
96
97    virtual uint32_t getStrategyForStream(audio_stream_type_t stream);
98    virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);
99
100    virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc);
101    virtual status_t registerEffect(const effect_descriptor_t *desc,
102                                    audio_io_handle_t io,
103                                    uint32_t strategy,
104                                    int session,
105                                    int id);
106    virtual status_t unregisterEffect(int id);
107    virtual status_t setEffectEnabled(int id, bool enabled);
108    virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
109    virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
110    virtual bool isSourceActive(audio_source_t source) const;
111
112    virtual status_t queryDefaultPreProcessing(int audioSession,
113                                              effect_descriptor_t *descriptors,
114                                              uint32_t *count);
115    virtual     status_t    onTransact(
116                                uint32_t code,
117                                const Parcel& data,
118                                Parcel* reply,
119                                uint32_t flags);
120
121    // IBinder::DeathRecipient
122    virtual     void        binderDied(const wp<IBinder>& who);
123
124    //
125    // Helpers for the struct audio_policy_service_ops implementation.
126    // This is used by the audio policy manager for certain operations that
127    // are implemented by the policy service.
128    //
129    virtual void setParameters(audio_io_handle_t ioHandle,
130                               const char *keyValuePairs,
131                               int delayMs);
132
133    virtual status_t setStreamVolume(audio_stream_type_t stream,
134                                     float volume,
135                                     audio_io_handle_t output,
136                                     int delayMs = 0);
137    virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream);
138    virtual status_t stopTone();
139    virtual status_t setVoiceVolume(float volume, int delayMs = 0);
140    virtual bool isOffloadSupported(const audio_offload_info_t &config);
141
142            status_t doStopOutput(audio_io_handle_t output,
143                                  audio_stream_type_t stream,
144                                  int session = 0);
145            void doReleaseOutput(audio_io_handle_t output);
146
147private:
148                        AudioPolicyService() ANDROID_API;
149    virtual             ~AudioPolicyService();
150
151            status_t dumpInternals(int fd);
152
153    // Thread used for tone playback and to send audio config commands to audio flinger
154    // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because
155    // startTone() and stopTone() are normally called with mLock locked and requesting a tone start
156    // or stop will cause calls to AudioPolicyService and an attempt to lock mLock.
157    // For audio config commands, it is necessary because audio flinger requires that the calling
158    // process (user) has permission to modify audio settings.
159    class AudioCommandThread : public Thread {
160        class AudioCommand;
161    public:
162
163        // commands for tone AudioCommand
164        enum {
165            START_TONE,
166            STOP_TONE,
167            SET_VOLUME,
168            SET_PARAMETERS,
169            SET_VOICE_VOLUME,
170            STOP_OUTPUT,
171            RELEASE_OUTPUT
172        };
173
174        AudioCommandThread (String8 name, const wp<AudioPolicyService>& service);
175        virtual             ~AudioCommandThread();
176
177                    status_t    dump(int fd);
178
179        // Thread virtuals
180        virtual     void        onFirstRef();
181        virtual     bool        threadLoop();
182
183                    void        exit();
184                    void        startToneCommand(ToneGenerator::tone_type type,
185                                                 audio_stream_type_t stream);
186                    void        stopToneCommand();
187                    status_t    volumeCommand(audio_stream_type_t stream, float volume,
188                                            audio_io_handle_t output, int delayMs = 0);
189                    status_t    parametersCommand(audio_io_handle_t ioHandle,
190                                            const char *keyValuePairs, int delayMs = 0);
191                    status_t    voiceVolumeCommand(float volume, int delayMs = 0);
192                    void        stopOutputCommand(audio_io_handle_t output,
193                                                  audio_stream_type_t stream,
194                                                  int session);
195                    void        releaseOutputCommand(audio_io_handle_t output);
196
197                    void        insertCommand_l(AudioCommand *command, int delayMs = 0);
198
199    private:
200        // descriptor for requested tone playback event
201        class AudioCommand {
202
203        public:
204            AudioCommand()
205            : mCommand(-1) {}
206
207            void dump(char* buffer, size_t size);
208
209            int mCommand;   // START_TONE, STOP_TONE ...
210            nsecs_t mTime;  // time stamp
211            Condition mCond; // condition for status return
212            status_t mStatus; // command status
213            bool mWaitStatus; // true if caller is waiting for status
214            void *mParam;     // command parameter (ToneData, VolumeData, ParametersData)
215        };
216
217        class ToneData {
218        public:
219            ToneGenerator::tone_type mType; // tone type (START_TONE only)
220            audio_stream_type_t mStream;    // stream type (START_TONE only)
221        };
222
223        class VolumeData {
224        public:
225            audio_stream_type_t mStream;
226            float mVolume;
227            audio_io_handle_t mIO;
228        };
229
230        class ParametersData {
231        public:
232            audio_io_handle_t mIO;
233            String8 mKeyValuePairs;
234        };
235
236        class VoiceVolumeData {
237        public:
238            float mVolume;
239        };
240
241        class StopOutputData {
242        public:
243            audio_io_handle_t mIO;
244            audio_stream_type_t mStream;
245            int mSession;
246        };
247
248        class ReleaseOutputData {
249        public:
250            audio_io_handle_t mIO;
251        };
252
253        Mutex   mLock;
254        Condition mWaitWorkCV;
255        Vector <AudioCommand *> mAudioCommands; // list of pending commands
256        ToneGenerator *mpToneGenerator;     // the tone generator
257        AudioCommand mLastCommand;          // last processed command (used by dump)
258        String8 mName;                      // string used by wake lock fo delayed commands
259        wp<AudioPolicyService> mService;
260    };
261
262    class EffectDesc {
263    public:
264        EffectDesc(const char *name, const effect_uuid_t& uuid) :
265                        mName(strdup(name)),
266                        mUuid(uuid) { }
267        EffectDesc(const EffectDesc& orig) :
268                        mName(strdup(orig.mName)),
269                        mUuid(orig.mUuid) {
270                            // deep copy mParams
271                            for (size_t k = 0; k < orig.mParams.size(); k++) {
272                                effect_param_t *origParam = orig.mParams[k];
273                                // psize and vsize are rounded up to an int boundary for allocation
274                                size_t origSize = sizeof(effect_param_t) +
275                                                  ((origParam->psize + 3) & ~3) +
276                                                  ((origParam->vsize + 3) & ~3);
277                                effect_param_t *dupParam = (effect_param_t *) malloc(origSize);
278                                memcpy(dupParam, origParam, origSize);
279                                // This works because the param buffer allocation is also done by
280                                // multiples of 4 bytes originally. In theory we should memcpy only
281                                // the actual param size, that is without rounding vsize.
282                                mParams.add(dupParam);
283                            }
284                        }
285        /*virtual*/ ~EffectDesc() {
286            free(mName);
287            for (size_t k = 0; k < mParams.size(); k++) {
288                free(mParams[k]);
289            }
290        }
291        char *mName;
292        effect_uuid_t mUuid;
293        Vector <effect_param_t *> mParams;
294    };
295
296    class InputSourceDesc {
297    public:
298        InputSourceDesc() {}
299        /*virtual*/ ~InputSourceDesc() {
300            for (size_t j = 0; j < mEffects.size(); j++) {
301                delete mEffects[j];
302            }
303        }
304        Vector <EffectDesc *> mEffects;
305    };
306
307
308    class InputDesc {
309    public:
310        InputDesc(int session) : mSessionId(session) {}
311        /*virtual*/ ~InputDesc() {}
312        const int mSessionId;
313        Vector< sp<AudioEffect> >mEffects;
314    };
315
316    static const char * const kInputSourceNames[AUDIO_SOURCE_CNT -1];
317
318    void setPreProcessorEnabled(const InputDesc *inputDesc, bool enabled);
319    status_t loadPreProcessorConfig(const char *path);
320    status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects);
321    EffectDesc *loadEffect(cnode *root);
322    status_t loadInputSources(cnode *root, const Vector <EffectDesc *>& effects);
323    audio_source_t inputSourceNameToEnum(const char *name);
324    InputSourceDesc *loadInputSource(cnode *root, const Vector <EffectDesc *>& effects);
325    void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params);
326    effect_param_t *loadEffectParameter(cnode *root);
327    size_t readParamValue(cnode *node,
328                          char *param,
329                          size_t *curSize,
330                          size_t *totSize);
331    size_t growParamSize(char *param,
332                         size_t size,
333                         size_t *curSize,
334                         size_t *totSize);
335
336    // Internal dump utilities.
337    status_t dumpPermissionDenial(int fd);
338
339
340    mutable Mutex mLock;    // prevents concurrent access to AudioPolicy manager functions changing
341                            // device connection state  or routing
342    sp<AudioCommandThread> mAudioCommandThread;     // audio commands thread
343    sp<AudioCommandThread> mTonePlaybackThread;     // tone playback thread
344    sp<AudioCommandThread> mOutputCommandThread;    // process stop and release output
345    struct audio_policy_device *mpAudioPolicyDev;
346    struct audio_policy *mpAudioPolicy;
347    KeyedVector< audio_source_t, InputSourceDesc* > mInputSources;
348    KeyedVector< audio_io_handle_t, InputDesc* > mInputs;
349};
350
351}; // namespace android
352
353#endif // ANDROID_AUDIOPOLICYSERVICE_H
354