AudioPolicyService.h revision 802da7bc462f6f9df6e681cc75c51dc0a056a4a1 
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 <media/IAudioPolicyService.h>
21#include <hardware_legacy/AudioPolicyInterface.h>
22#include <media/ToneGenerator.h>
23#include <utils/Vector.h>
24#include <binder/BinderService.h>
25
26namespace android {
27
28class String8;
29
30// ----------------------------------------------------------------------------
31
32class AudioPolicyService :
33    public BinderService<AudioPolicyService>,
34    public BnAudioPolicyService,
35    public AudioPolicyClientInterface,
36    public IBinder::DeathRecipient
37{
38    friend class BinderService<AudioPolicyService>;
39
40public:
41    // for BinderService
42    static const char *getServiceName() { return "media.audio_policy"; }
43
44    virtual status_t    dump(int fd, const Vector<String16>& args);
45
46    //
47    // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
48    //
49
50    virtual status_t setDeviceConnectionState(AudioSystem::audio_devices device,
51                                              AudioSystem::device_connection_state state,
52                                              const char *device_address);
53    virtual AudioSystem::device_connection_state getDeviceConnectionState(
54                                                                AudioSystem::audio_devices device,
55                                                                const char *device_address);
56    virtual status_t setPhoneState(int state);
57    virtual status_t setRingerMode(uint32_t mode, uint32_t mask);
58    virtual status_t setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config);
59    virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage);
60    virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream,
61                                        uint32_t samplingRate = 0,
62                                        uint32_t format = AudioSystem::FORMAT_DEFAULT,
63                                        uint32_t channels = 0,
64                                        AudioSystem::output_flags flags =
65                                                AudioSystem::OUTPUT_FLAG_INDIRECT);
66    virtual status_t startOutput(audio_io_handle_t output,
67                                 AudioSystem::stream_type stream,
68                                 int session = 0);
69    virtual status_t stopOutput(audio_io_handle_t output,
70                                AudioSystem::stream_type stream,
71                                int session = 0);
72    virtual void releaseOutput(audio_io_handle_t output);
73    virtual audio_io_handle_t getInput(int inputSource,
74                                    uint32_t samplingRate = 0,
75                                    uint32_t format = AudioSystem::FORMAT_DEFAULT,
76                                    uint32_t channels = 0,
77                                    AudioSystem::audio_in_acoustics acoustics =
78                                            (AudioSystem::audio_in_acoustics)0);
79    virtual status_t startInput(audio_io_handle_t input);
80    virtual status_t stopInput(audio_io_handle_t input);
81    virtual void releaseInput(audio_io_handle_t input);
82    virtual status_t initStreamVolume(AudioSystem::stream_type stream,
83                                      int indexMin,
84                                      int indexMax);
85    virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index);
86    virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int *index);
87
88    virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream);
89
90    virtual audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc);
91    virtual status_t registerEffect(effect_descriptor_t *desc,
92                                    audio_io_handle_t output,
93                                    uint32_t strategy,
94                                    int session,
95                                    int id);
96    virtual status_t unregisterEffect(int id);
97    virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const;
98
99    virtual     status_t    onTransact(
100                                uint32_t code,
101                                const Parcel& data,
102                                Parcel* reply,
103                                uint32_t flags);
104
105    // IBinder::DeathRecipient
106    virtual     void        binderDied(const wp<IBinder>& who);
107
108    //
109    // AudioPolicyClientInterface
110    //
111    virtual audio_io_handle_t openOutput(uint32_t *pDevices,
112                                    uint32_t *pSamplingRate,
113                                    uint32_t *pFormat,
114                                    uint32_t *pChannels,
115                                    uint32_t *pLatencyMs,
116                                    AudioSystem::output_flags flags);
117    virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
118                                                  audio_io_handle_t output2);
119    virtual status_t closeOutput(audio_io_handle_t output);
120    virtual status_t suspendOutput(audio_io_handle_t output);
121    virtual status_t restoreOutput(audio_io_handle_t output);
122    virtual audio_io_handle_t openInput(uint32_t *pDevices,
123                                    uint32_t *pSamplingRate,
124                                    uint32_t *pFormat,
125                                    uint32_t *pChannels,
126                                    uint32_t acoustics);
127    virtual status_t closeInput(audio_io_handle_t input);
128    virtual status_t setStreamVolume(AudioSystem::stream_type stream,
129                                     float volume,
130                                     audio_io_handle_t output,
131                                     int delayMs = 0);
132    virtual status_t setStreamOutput(AudioSystem::stream_type stream, audio_io_handle_t output);
133    virtual void setParameters(audio_io_handle_t ioHandle,
134                               const String8& keyValuePairs,
135                               int delayMs = 0);
136    virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys);
137    virtual status_t startTone(ToneGenerator::tone_type tone, AudioSystem::stream_type stream);
138    virtual status_t stopTone();
139    virtual status_t setVoiceVolume(float volume, int delayMs = 0);
140    virtual status_t moveEffects(int session,
141                                     audio_io_handle_t srcOutput,
142                                     audio_io_handle_t dstOutput);
143
144private:
145                        AudioPolicyService();
146    virtual             ~AudioPolicyService();
147
148            status_t dumpInternals(int fd);
149
150    // Thread used for tone playback and to send audio config commands to audio flinger
151    // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because startTone()
152    // and stopTone() are normally called with mLock locked and requesting a tone start or stop will cause
153    // calls to AudioPolicyService and an attempt to lock mLock.
154    // For audio config commands, it is necessary because audio flinger requires that the calling process (user)
155    // has permission to modify audio settings.
156    class AudioCommandThread : public Thread {
157        class AudioCommand;
158    public:
159
160        // commands for tone AudioCommand
161        enum {
162            START_TONE,
163            STOP_TONE,
164            SET_VOLUME,
165            SET_PARAMETERS,
166            SET_VOICE_VOLUME
167        };
168
169        AudioCommandThread (String8 name);
170        virtual             ~AudioCommandThread();
171
172                    status_t    dump(int fd);
173
174        // Thread virtuals
175        virtual     void        onFirstRef();
176        virtual     bool        threadLoop();
177
178                    void        exit();
179                    void        startToneCommand(int type = 0, int stream = 0);
180                    void        stopToneCommand();
181                    status_t    volumeCommand(int stream, float volume, int output, int delayMs = 0);
182                    status_t    parametersCommand(int ioHandle, const String8& keyValuePairs, int delayMs = 0);
183                    status_t    voiceVolumeCommand(float volume, int delayMs = 0);
184                    void        insertCommand_l(AudioCommand *command, int delayMs = 0);
185
186    private:
187        // descriptor for requested tone playback event
188        class AudioCommand {
189
190        public:
191            AudioCommand()
192            : mCommand(-1) {}
193
194            void dump(char* buffer, size_t size);
195
196            int mCommand;   // START_TONE, STOP_TONE ...
197            nsecs_t mTime;  // time stamp
198            Condition mCond; // condition for status return
199            status_t mStatus; // command status
200            bool mWaitStatus; // true if caller is waiting for status
201            void *mParam;     // command parameter (ToneData, VolumeData, ParametersData)
202        };
203
204        class ToneData {
205        public:
206            int mType;      // tone type (START_TONE only)
207            int mStream;    // stream type (START_TONE only)
208        };
209
210        class VolumeData {
211        public:
212            int mStream;
213            float mVolume;
214            int mIO;
215        };
216
217        class ParametersData {
218        public:
219            int mIO;
220            String8 mKeyValuePairs;
221        };
222
223        class VoiceVolumeData {
224        public:
225            float mVolume;
226        };
227
228        Mutex   mLock;
229        Condition mWaitWorkCV;
230        Vector <AudioCommand *> mAudioCommands; // list of pending commands
231        ToneGenerator *mpToneGenerator;     // the tone generator
232        AudioCommand mLastCommand;          // last processed command (used by dump)
233        String8 mName;                      // string used by wake lock fo delayed commands
234    };
235
236    // Internal dump utilities.
237    status_t dumpPermissionDenial(int fd);
238
239
240    mutable Mutex mLock;    // prevents concurrent access to AudioPolicy manager functions changing
241                            // device connection state  or routing
242    AudioPolicyInterface* mpPolicyManager;          // the platform specific policy manager
243    sp <AudioCommandThread> mAudioCommandThread;    // audio commands thread
244    sp <AudioCommandThread> mTonePlaybackThread;     // tone playback thread
245};
246
247}; // namespace android
248
249#endif // ANDROID_AUDIOPOLICYSERVICE_H
250