AudioPolicyService.h revision 56ec4ffcbae8aeac6c5245fc7b825d02e2e6cefd 
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#include <media/AudioPolicy.h>
34#ifdef USE_LEGACY_AUDIO_POLICY
35#include <hardware_legacy/AudioPolicyInterface.h>
36#endif
37#include "AudioPolicyEffects.h"
38#include "managerdefault/AudioPolicyManager.h"
39
40
41namespace android {
42
43// ----------------------------------------------------------------------------
44
45class AudioPolicyService :
46    public BinderService<AudioPolicyService>,
47    public BnAudioPolicyService,
48    public IBinder::DeathRecipient
49{
50    friend class BinderService<AudioPolicyService>;
51
52public:
53    // for BinderService
54    static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
55
56    virtual status_t    dump(int fd, const Vector<String16>& args);
57
58    //
59    // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
60    //
61
62    virtual status_t setDeviceConnectionState(audio_devices_t device,
63                                              audio_policy_dev_state_t state,
64                                              const char *device_address,
65                                              const char *device_name);
66    virtual audio_policy_dev_state_t getDeviceConnectionState(
67                                                                audio_devices_t device,
68                                                                const char *device_address);
69    virtual status_t setPhoneState(audio_mode_t state);
70    virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
71    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
72    virtual audio_io_handle_t getOutput(audio_stream_type_t stream,
73                                        uint32_t samplingRate = 0,
74                                        audio_format_t format = AUDIO_FORMAT_DEFAULT,
75                                        audio_channel_mask_t channelMask = 0,
76                                        audio_output_flags_t flags =
77                                                AUDIO_OUTPUT_FLAG_NONE,
78                                        const audio_offload_info_t *offloadInfo = NULL);
79    virtual status_t getOutputForAttr(const audio_attributes_t *attr,
80                                      audio_io_handle_t *output,
81                                      audio_session_t session,
82                                      audio_stream_type_t *stream,
83                                      uint32_t samplingRate = 0,
84                                      audio_format_t format = AUDIO_FORMAT_DEFAULT,
85                                      audio_channel_mask_t channelMask = 0,
86                                      audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
87                                      const audio_offload_info_t *offloadInfo = NULL);
88    virtual status_t startOutput(audio_io_handle_t output,
89                                 audio_stream_type_t stream,
90                                 audio_session_t session);
91    virtual status_t stopOutput(audio_io_handle_t output,
92                                audio_stream_type_t stream,
93                                audio_session_t session);
94    virtual void releaseOutput(audio_io_handle_t output,
95                               audio_stream_type_t stream,
96                               audio_session_t session);
97    virtual status_t getInputForAttr(const audio_attributes_t *attr,
98                                     audio_io_handle_t *input,
99                                     audio_session_t session,
100                                     uint32_t samplingRate,
101                                     audio_format_t format,
102                                     audio_channel_mask_t channelMask,
103                                     audio_input_flags_t flags);
104    virtual status_t startInput(audio_io_handle_t input,
105                                audio_session_t session);
106    virtual status_t stopInput(audio_io_handle_t input,
107                               audio_session_t session);
108    virtual void releaseInput(audio_io_handle_t input,
109                              audio_session_t session);
110    virtual status_t initStreamVolume(audio_stream_type_t stream,
111                                      int indexMin,
112                                      int indexMax);
113    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
114                                          int index,
115                                          audio_devices_t device);
116    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
117                                          int *index,
118                                          audio_devices_t device);
119
120    virtual uint32_t getStrategyForStream(audio_stream_type_t stream);
121    virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);
122
123    virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc);
124    virtual status_t registerEffect(const effect_descriptor_t *desc,
125                                    audio_io_handle_t io,
126                                    uint32_t strategy,
127                                    int session,
128                                    int id);
129    virtual status_t unregisterEffect(int id);
130    virtual status_t setEffectEnabled(int id, bool enabled);
131    virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
132    virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
133    virtual bool isSourceActive(audio_source_t source) const;
134
135    virtual status_t queryDefaultPreProcessing(int audioSession,
136                                              effect_descriptor_t *descriptors,
137                                              uint32_t *count);
138    virtual     status_t    onTransact(
139                                uint32_t code,
140                                const Parcel& data,
141                                Parcel* reply,
142                                uint32_t flags);
143
144    // IBinder::DeathRecipient
145    virtual     void        binderDied(const wp<IBinder>& who);
146
147    // RefBase
148    virtual     void        onFirstRef();
149
150    //
151    // Helpers for the struct audio_policy_service_ops implementation.
152    // This is used by the audio policy manager for certain operations that
153    // are implemented by the policy service.
154    //
155    virtual void setParameters(audio_io_handle_t ioHandle,
156                               const char *keyValuePairs,
157                               int delayMs);
158
159    virtual status_t setStreamVolume(audio_stream_type_t stream,
160                                     float volume,
161                                     audio_io_handle_t output,
162                                     int delayMs = 0);
163    virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream);
164    virtual status_t stopTone();
165    virtual status_t setVoiceVolume(float volume, int delayMs = 0);
166    virtual bool isOffloadSupported(const audio_offload_info_t &config);
167
168    virtual status_t listAudioPorts(audio_port_role_t role,
169                                    audio_port_type_t type,
170                                    unsigned int *num_ports,
171                                    struct audio_port *ports,
172                                    unsigned int *generation);
173    virtual status_t getAudioPort(struct audio_port *port);
174    virtual status_t createAudioPatch(const struct audio_patch *patch,
175                                       audio_patch_handle_t *handle);
176    virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
177    virtual status_t listAudioPatches(unsigned int *num_patches,
178                                      struct audio_patch *patches,
179                                      unsigned int *generation);
180    virtual status_t setAudioPortConfig(const struct audio_port_config *config);
181
182    virtual void registerClient(const sp<IAudioPolicyServiceClient>& client);
183
184    virtual status_t acquireSoundTriggerSession(audio_session_t *session,
185                                           audio_io_handle_t *ioHandle,
186                                           audio_devices_t *device);
187
188    virtual status_t releaseSoundTriggerSession(audio_session_t session);
189
190    virtual audio_mode_t getPhoneState();
191
192    virtual status_t registerPolicyMixes(Vector<AudioMix> mixes, bool registration);
193
194            status_t doStopOutput(audio_io_handle_t output,
195                                  audio_stream_type_t stream,
196                                  audio_session_t session);
197            void doReleaseOutput(audio_io_handle_t output,
198                                 audio_stream_type_t stream,
199                                 audio_session_t session);
200
201            status_t clientCreateAudioPatch(const struct audio_patch *patch,
202                                      audio_patch_handle_t *handle,
203                                      int delayMs);
204            status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
205                                             int delayMs);
206            virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
207                                                      int delayMs);
208
209            void removeNotificationClient(uid_t uid);
210            void onAudioPortListUpdate();
211            void doOnAudioPortListUpdate();
212            void onAudioPatchListUpdate();
213            void doOnAudioPatchListUpdate();
214
215private:
216                        AudioPolicyService() ANDROID_API;
217    virtual             ~AudioPolicyService();
218
219            status_t dumpInternals(int fd);
220
221    // Thread used for tone playback and to send audio config commands to audio flinger
222    // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because
223    // startTone() and stopTone() are normally called with mLock locked and requesting a tone start
224    // or stop will cause calls to AudioPolicyService and an attempt to lock mLock.
225    // For audio config commands, it is necessary because audio flinger requires that the calling
226    // process (user) has permission to modify audio settings.
227    class AudioCommandThread : public Thread {
228        class AudioCommand;
229    public:
230
231        // commands for tone AudioCommand
232        enum {
233            START_TONE,
234            STOP_TONE,
235            SET_VOLUME,
236            SET_PARAMETERS,
237            SET_VOICE_VOLUME,
238            STOP_OUTPUT,
239            RELEASE_OUTPUT,
240            CREATE_AUDIO_PATCH,
241            RELEASE_AUDIO_PATCH,
242            UPDATE_AUDIOPORT_LIST,
243            UPDATE_AUDIOPATCH_LIST,
244            SET_AUDIOPORT_CONFIG,
245        };
246
247        AudioCommandThread (String8 name, const wp<AudioPolicyService>& service);
248        virtual             ~AudioCommandThread();
249
250                    status_t    dump(int fd);
251
252        // Thread virtuals
253        virtual     void        onFirstRef();
254        virtual     bool        threadLoop();
255
256                    void        exit();
257                    void        startToneCommand(ToneGenerator::tone_type type,
258                                                 audio_stream_type_t stream);
259                    void        stopToneCommand();
260                    status_t    volumeCommand(audio_stream_type_t stream, float volume,
261                                            audio_io_handle_t output, int delayMs = 0);
262                    status_t    parametersCommand(audio_io_handle_t ioHandle,
263                                            const char *keyValuePairs, int delayMs = 0);
264                    status_t    voiceVolumeCommand(float volume, int delayMs = 0);
265                    void        stopOutputCommand(audio_io_handle_t output,
266                                                  audio_stream_type_t stream,
267                                                  audio_session_t session);
268                    void        releaseOutputCommand(audio_io_handle_t output,
269                                                     audio_stream_type_t stream,
270                                                     audio_session_t session);
271                    status_t    sendCommand(sp<AudioCommand>& command, int delayMs = 0);
272                    void        insertCommand_l(sp<AudioCommand>& command, int delayMs = 0);
273                    status_t    createAudioPatchCommand(const struct audio_patch *patch,
274                                                        audio_patch_handle_t *handle,
275                                                        int delayMs);
276                    status_t    releaseAudioPatchCommand(audio_patch_handle_t handle,
277                                                         int delayMs);
278                    void        updateAudioPortListCommand();
279                    void        updateAudioPatchListCommand();
280                    status_t    setAudioPortConfigCommand(const struct audio_port_config *config,
281                                                          int delayMs);
282                    void        insertCommand_l(AudioCommand *command, int delayMs = 0);
283
284    private:
285        class AudioCommandData;
286
287        // descriptor for requested tone playback event
288        class AudioCommand: public RefBase {
289
290        public:
291            AudioCommand()
292            : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {}
293
294            void dump(char* buffer, size_t size);
295
296            int mCommand;   // START_TONE, STOP_TONE ...
297            nsecs_t mTime;  // time stamp
298            Mutex mLock;    // mutex associated to mCond
299            Condition mCond; // condition for status return
300            status_t mStatus; // command status
301            bool mWaitStatus; // true if caller is waiting for status
302            sp<AudioCommandData> mParam;     // command specific parameter data
303        };
304
305        class AudioCommandData: public RefBase {
306        public:
307            virtual ~AudioCommandData() {}
308        protected:
309            AudioCommandData() {}
310        };
311
312        class ToneData : public AudioCommandData {
313        public:
314            ToneGenerator::tone_type mType; // tone type (START_TONE only)
315            audio_stream_type_t mStream;    // stream type (START_TONE only)
316        };
317
318        class VolumeData : public AudioCommandData {
319        public:
320            audio_stream_type_t mStream;
321            float mVolume;
322            audio_io_handle_t mIO;
323        };
324
325        class ParametersData : public AudioCommandData {
326        public:
327            audio_io_handle_t mIO;
328            String8 mKeyValuePairs;
329        };
330
331        class VoiceVolumeData : public AudioCommandData {
332        public:
333            float mVolume;
334        };
335
336        class StopOutputData : public AudioCommandData {
337        public:
338            audio_io_handle_t mIO;
339            audio_stream_type_t mStream;
340            audio_session_t mSession;
341        };
342
343        class ReleaseOutputData : public AudioCommandData {
344        public:
345            audio_io_handle_t mIO;
346            audio_stream_type_t mStream;
347            audio_session_t mSession;
348        };
349
350        class CreateAudioPatchData : public AudioCommandData {
351        public:
352            struct audio_patch mPatch;
353            audio_patch_handle_t mHandle;
354        };
355
356        class ReleaseAudioPatchData : public AudioCommandData {
357        public:
358            audio_patch_handle_t mHandle;
359        };
360
361        class SetAudioPortConfigData : public AudioCommandData {
362        public:
363            struct audio_port_config mConfig;
364        };
365
366        Mutex   mLock;
367        Condition mWaitWorkCV;
368        Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands
369        ToneGenerator *mpToneGenerator;     // the tone generator
370        sp<AudioCommand> mLastCommand;      // last processed command (used by dump)
371        String8 mName;                      // string used by wake lock fo delayed commands
372        wp<AudioPolicyService> mService;
373    };
374
375    class AudioPolicyClient : public AudioPolicyClientInterface
376    {
377     public:
378        AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {}
379        virtual ~AudioPolicyClient() {}
380
381        //
382        // Audio HW module functions
383        //
384
385        // loads a HW module.
386        virtual audio_module_handle_t loadHwModule(const char *name);
387
388        //
389        // Audio output Control functions
390        //
391
392        // opens an audio output with the requested parameters. The parameter values can indicate to use the default values
393        // in case the audio policy manager has no specific requirements for the output being opened.
394        // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream.
395        // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly.
396        virtual status_t openOutput(audio_module_handle_t module,
397                                    audio_io_handle_t *output,
398                                    audio_config_t *config,
399                                    audio_devices_t *devices,
400                                    const String8& address,
401                                    uint32_t *latencyMs,
402                                    audio_output_flags_t flags);
403        // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by
404        // a special mixer thread in the AudioFlinger.
405        virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2);
406        // closes the output stream
407        virtual status_t closeOutput(audio_io_handle_t output);
408        // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in
409        // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded.
410        virtual status_t suspendOutput(audio_io_handle_t output);
411        // restores a suspended output.
412        virtual status_t restoreOutput(audio_io_handle_t output);
413
414        //
415        // Audio input Control functions
416        //
417
418        // opens an audio input
419        virtual audio_io_handle_t openInput(audio_module_handle_t module,
420                                            audio_io_handle_t *input,
421                                            audio_config_t *config,
422                                            audio_devices_t *devices,
423                                            const String8& address,
424                                            audio_source_t source,
425                                            audio_input_flags_t flags);
426        // closes an audio input
427        virtual status_t closeInput(audio_io_handle_t input);
428        //
429        // misc control functions
430        //
431
432        // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes
433        // for each output (destination device) it is attached to.
434        virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0);
435
436        // invalidate a stream type, causing a reroute to an unspecified new output
437        virtual status_t invalidateStream(audio_stream_type_t stream);
438
439        // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface.
440        virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0);
441        // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager.
442        virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys);
443
444        // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing
445        // over a telephony device during a phone call.
446        virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream);
447        virtual status_t stopTone();
448
449        // set down link audio volume.
450        virtual status_t setVoiceVolume(float volume, int delayMs = 0);
451
452        // move effect to the specified output
453        virtual status_t moveEffects(int session,
454                                         audio_io_handle_t srcOutput,
455                                         audio_io_handle_t dstOutput);
456
457        /* Create a patch between several source and sink ports */
458        virtual status_t createAudioPatch(const struct audio_patch *patch,
459                                           audio_patch_handle_t *handle,
460                                           int delayMs);
461
462        /* Release a patch */
463        virtual status_t releaseAudioPatch(audio_patch_handle_t handle,
464                                           int delayMs);
465
466        /* Set audio port configuration */
467        virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs);
468
469        virtual void onAudioPortListUpdate();
470        virtual void onAudioPatchListUpdate();
471
472        virtual audio_unique_id_t newAudioUniqueId();
473
474     private:
475        AudioPolicyService *mAudioPolicyService;
476    };
477
478    // --- Notification Client ---
479    class NotificationClient : public IBinder::DeathRecipient {
480    public:
481                            NotificationClient(const sp<AudioPolicyService>& service,
482                                                const sp<IAudioPolicyServiceClient>& client,
483                                                uid_t uid);
484        virtual             ~NotificationClient();
485
486                            void        onAudioPortListUpdate();
487                            void        onAudioPatchListUpdate();
488
489                // IBinder::DeathRecipient
490                virtual     void        binderDied(const wp<IBinder>& who);
491
492    private:
493                            NotificationClient(const NotificationClient&);
494                            NotificationClient& operator = (const NotificationClient&);
495
496        const wp<AudioPolicyService>        mService;
497        const uid_t                         mUid;
498        const sp<IAudioPolicyServiceClient> mAudioPolicyServiceClient;
499    };
500
501    // Internal dump utilities.
502    status_t dumpPermissionDenial(int fd);
503
504
505    mutable Mutex mLock;    // prevents concurrent access to AudioPolicy manager functions changing
506                            // device connection state  or routing
507    sp<AudioCommandThread> mAudioCommandThread;     // audio commands thread
508    sp<AudioCommandThread> mTonePlaybackThread;     // tone playback thread
509    sp<AudioCommandThread> mOutputCommandThread;    // process stop and release output
510    struct audio_policy_device *mpAudioPolicyDev;
511    struct audio_policy *mpAudioPolicy;
512    AudioPolicyInterface *mAudioPolicyManager;
513    AudioPolicyClient *mAudioPolicyClient;
514
515    DefaultKeyedVector< uid_t, sp<NotificationClient> >    mNotificationClients;
516    Mutex mNotificationClientsLock;  // protects mNotificationClients
517    // Manage all effects configured in audio_effects.conf
518    sp<AudioPolicyEffects> mAudioPolicyEffects;
519    audio_mode_t mPhoneState;
520};
521
522}; // namespace android
523
524#endif // ANDROID_AUDIOPOLICYSERVICE_H
525