AudioPolicyService.h revision 6374252107fd6539397598195ea6defd5870fafb 
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 <utils/String8.h>
23#include <utils/Vector.h>
24#include <utils/SortedVector.h>
25#include <binder/BinderService.h>
26#include <system/audio.h>
27#include <system/audio_policy.h>
28#include <hardware/audio_policy.h>
29#include <media/IAudioPolicyService.h>
30#include <media/ToneGenerator.h>
31#include <media/AudioEffect.h>
32
33namespace android {
34
35// ----------------------------------------------------------------------------
36
37class AudioPolicyService :
38    public BinderService<AudioPolicyService>,
39    public BnAudioPolicyService,
40//    public AudioPolicyClientInterface,
41    public IBinder::DeathRecipient
42{
43    friend class BinderService<AudioPolicyService>;
44
45public:
46    // for BinderService
47    static const char *getServiceName() { return "media.audio_policy"; }
48
49    virtual status_t    dump(int fd, const Vector<String16>& args);
50
51    //
52    // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
53    //
54
55    virtual status_t setDeviceConnectionState(audio_devices_t device,
56                                              audio_policy_dev_state_t state,
57                                              const char *device_address);
58    virtual audio_policy_dev_state_t getDeviceConnectionState(
59                                                                audio_devices_t device,
60                                                                const char *device_address);
61    virtual status_t setPhoneState(audio_mode_t state);
62    virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
63    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
64    virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
65                                        uint32_t samplingRate = 0,
66                                        audio_format_t format = AUDIO_FORMAT_DEFAULT,
67                                        uint32_t channels = 0,
68                                        audio_policy_output_flags_t flags =
69                                                AUDIO_POLICY_OUTPUT_FLAG_NONE);
70    virtual status_t startOutput(audio_io_handle_t output,
71                                 audio_stream_type_t stream,
72                                 int session = 0);
73    virtual status_t stopOutput(audio_io_handle_t output,
74                                audio_stream_type_t stream,
75                                int session = 0);
76    virtual void releaseOutput(audio_io_handle_t output);
77    virtual audio_io_handle_t getInput(audio_source_t inputSource,
78                                    uint32_t samplingRate = 0,
79                                    audio_format_t format = AUDIO_FORMAT_DEFAULT,
80                                    uint32_t channels = 0,
81                                    audio_in_acoustics_t acoustics =
82                                            (audio_in_acoustics_t)0 /*AUDIO_IN_ACOUSTICS_NONE*/,
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(effect_descriptor_t *desc);
101    virtual status_t registerEffect(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
110    virtual status_t queryDefaultPreProcessing(int audioSession,
111                                              effect_descriptor_t *descriptors,
112                                              uint32_t *count);
113    virtual     status_t    onTransact(
114                                uint32_t code,
115                                const Parcel& data,
116                                Parcel* reply,
117                                uint32_t flags);
118
119    // IBinder::DeathRecipient
120    virtual     void        binderDied(const wp<IBinder>& who);
121
122    //
123    // Helpers for the struct audio_policy_service_ops implementation.
124    // This is used by the audio policy manager for certain operations that
125    // are implemented by the policy service.
126    //
127    virtual void setParameters(audio_io_handle_t ioHandle,
128                               const char *keyValuePairs,
129                               int delayMs);
130
131    virtual status_t setStreamVolume(audio_stream_type_t stream,
132                                     float volume,
133                                     audio_io_handle_t output,
134                                     int delayMs = 0);
135    virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream);
136    virtual status_t stopTone();
137    virtual status_t setVoiceVolume(float volume, int delayMs = 0);
138
139private:
140                        AudioPolicyService();
141    virtual             ~AudioPolicyService();
142
143            status_t dumpInternals(int fd);
144
145    // Thread used for tone playback and to send audio config commands to audio flinger
146    // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because startTone()
147    // and stopTone() are normally called with mLock locked and requesting a tone start or stop will cause
148    // calls to AudioPolicyService and an attempt to lock mLock.
149    // For audio config commands, it is necessary because audio flinger requires that the calling process (user)
150    // has permission to modify audio settings.
151    class AudioCommandThread : public Thread {
152        class AudioCommand;
153    public:
154
155        // commands for tone AudioCommand
156        enum {
157            START_TONE,
158            STOP_TONE,
159            SET_VOLUME,
160            SET_PARAMETERS,
161            SET_VOICE_VOLUME
162        };
163
164        AudioCommandThread (String8 name);
165        virtual             ~AudioCommandThread();
166
167                    status_t    dump(int fd);
168
169        // Thread virtuals
170        virtual     void        onFirstRef();
171        virtual     bool        threadLoop();
172
173                    void        exit();
174                    void        startToneCommand(ToneGenerator::tone_type type,
175                                                 audio_stream_type_t stream);
176                    void        stopToneCommand();
177                    status_t    volumeCommand(audio_stream_type_t stream, float volume,
178                                            audio_io_handle_t output, int delayMs = 0);
179                    status_t    parametersCommand(audio_io_handle_t ioHandle,
180                                            const char *keyValuePairs, int delayMs = 0);
181                    status_t    voiceVolumeCommand(float volume, int delayMs = 0);
182                    void        insertCommand_l(AudioCommand *command, int delayMs = 0);
183
184    private:
185        // descriptor for requested tone playback event
186        class AudioCommand {
187
188        public:
189            AudioCommand()
190            : mCommand(-1) {}
191
192            void dump(char* buffer, size_t size);
193
194            int mCommand;   // START_TONE, STOP_TONE ...
195            nsecs_t mTime;  // time stamp
196            Condition mCond; // condition for status return
197            status_t mStatus; // command status
198            bool mWaitStatus; // true if caller is waiting for status
199            void *mParam;     // command parameter (ToneData, VolumeData, ParametersData)
200        };
201
202        class ToneData {
203        public:
204            ToneGenerator::tone_type mType; // tone type (START_TONE only)
205            audio_stream_type_t mStream;    // stream type (START_TONE only)
206        };
207
208        class VolumeData {
209        public:
210            audio_stream_type_t mStream;
211            float mVolume;
212            audio_io_handle_t mIO;
213        };
214
215        class ParametersData {
216        public:
217            audio_io_handle_t mIO;
218            String8 mKeyValuePairs;
219        };
220
221        class VoiceVolumeData {
222        public:
223            float mVolume;
224        };
225
226        Mutex   mLock;
227        Condition mWaitWorkCV;
228        Vector <AudioCommand *> mAudioCommands; // list of pending commands
229        ToneGenerator *mpToneGenerator;     // the tone generator
230        AudioCommand mLastCommand;          // last processed command (used by dump)
231        String8 mName;                      // string used by wake lock fo delayed commands
232    };
233
234    class EffectDesc {
235    public:
236        EffectDesc(const char *name, const effect_uuid_t& uuid) :
237                        mName(strdup(name)),
238                        mUuid(uuid) { }
239        EffectDesc(const EffectDesc& orig) :
240                        mName(strdup(orig.mName)),
241                        mUuid(orig.mUuid) {
242                            // deep copy mParams
243                            for (size_t k = 0; k < orig.mParams.size(); k++) {
244                                effect_param_t *origParam = orig.mParams[k];
245                                // psize and vsize are rounded up to an int boundary for allocation
246                                size_t origSize = sizeof(effect_param_t) +
247                                                  ((origParam->psize + 3) & ~3) +
248                                                  ((origParam->vsize + 3) & ~3);
249                                effect_param_t *dupParam = (effect_param_t *) malloc(origSize);
250                                memcpy(dupParam, origParam, origSize);
251                                // This works because the param buffer allocation is also done by
252                                // multiples of 4 bytes originally. In theory we should memcpy only
253                                // the actual param size, that is without rounding vsize.
254                                mParams.add(dupParam);
255                            }
256                        }
257        /*virtual*/ ~EffectDesc() {
258            free(mName);
259            for (size_t k = 0; k < mParams.size(); k++) {
260                free(mParams[k]);
261            }
262        }
263        char *mName;
264        effect_uuid_t mUuid;
265        Vector <effect_param_t *> mParams;
266    };
267
268    class InputSourceDesc {
269    public:
270        InputSourceDesc() {}
271        /*virtual*/ ~InputSourceDesc() {
272            for (size_t j = 0; j < mEffects.size(); j++) {
273                delete mEffects[j];
274            }
275        }
276        Vector <EffectDesc *> mEffects;
277    };
278
279
280    class InputDesc {
281    public:
282        InputDesc() {}
283        virtual ~InputDesc() {}
284        int mSessionId;
285        Vector< sp<AudioEffect> >mEffects;
286    };
287
288    static const char * const kInputSourceNames[AUDIO_SOURCE_CNT -1];
289
290    void setPreProcessorEnabled(InputDesc *inputDesc, bool enabled);
291    status_t loadPreProcessorConfig(const char *path);
292    status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects);
293    EffectDesc *loadEffect(cnode *root);
294    status_t loadInputSources(cnode *root, const Vector <EffectDesc *>& effects);
295    audio_source_t inputSourceNameToEnum(const char *name);
296    InputSourceDesc *loadInputSource(cnode *root, const Vector <EffectDesc *>& effects);
297    void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params);
298    effect_param_t *loadEffectParameter(cnode *root);
299    size_t readParamValue(cnode *node,
300                          char *param,
301                          size_t *curSize,
302                          size_t *totSize);
303    size_t growParamSize(char *param,
304                         size_t size,
305                         size_t *curSize,
306                         size_t *totSize);
307
308    // Internal dump utilities.
309    status_t dumpPermissionDenial(int fd);
310
311
312    mutable Mutex mLock;    // prevents concurrent access to AudioPolicy manager functions changing
313                            // device connection state  or routing
314    sp <AudioCommandThread> mAudioCommandThread;    // audio commands thread
315    sp <AudioCommandThread> mTonePlaybackThread;     // tone playback thread
316    struct audio_policy_device *mpAudioPolicyDev;
317    struct audio_policy *mpAudioPolicy;
318    KeyedVector< audio_source_t, InputSourceDesc* > mInputSources;
319    KeyedVector< audio_io_handle_t, InputDesc* > mInputs;
320};
321
322}; // namespace android
323
324#endif // ANDROID_AUDIOPOLICYSERVICE_H
325