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/Vector.h> 23 #include <utils/SortedVector.h> 24 #include <binder/BinderService.h> 25 #include <system/audio.h> 26 #include <system/audio_policy.h> 27 #include <hardware/audio_policy.h> 28 #include <media/IAudioPolicyService.h> 29 #include <media/ToneGenerator.h> 30 #include <media/AudioEffect.h> 31 32 namespace android { 33 34 class String8; 35 36 // ---------------------------------------------------------------------------- 37 38 class AudioPolicyService : 39 public BinderService<AudioPolicyService>, 40 public BnAudioPolicyService, 41 // public AudioPolicyClientInterface, 42 public IBinder::DeathRecipient 43 { 44 friend class BinderService<AudioPolicyService>; 45 46 public: 47 // for BinderService getServiceName()48 static const char *getServiceName() { 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(int state); 63 virtual status_t setRingerMode(uint32_t mode, uint32_t mask); 64 virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 65 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 66 virtual audio_io_handle_t getOutput(audio_stream_type_t stream, 67 uint32_t samplingRate = 0, 68 uint32_t format = AUDIO_FORMAT_DEFAULT, 69 uint32_t channels = 0, 70 audio_policy_output_flags_t flags = 71 AUDIO_POLICY_OUTPUT_FLAG_INDIRECT); 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(int inputSource, 80 uint32_t samplingRate = 0, 81 uint32_t format = AUDIO_FORMAT_DEFAULT, 82 uint32_t channels = 0, 83 audio_in_acoustics_t acoustics = 84 (audio_in_acoustics_t)0, 85 int audioSession = 0); 86 virtual status_t startInput(audio_io_handle_t input); 87 virtual status_t stopInput(audio_io_handle_t input); 88 virtual void releaseInput(audio_io_handle_t input); 89 virtual status_t initStreamVolume(audio_stream_type_t stream, 90 int indexMin, 91 int indexMax); 92 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index); 93 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index); 94 95 virtual uint32_t getStrategyForStream(audio_stream_type_t stream); 96 virtual uint32_t getDevicesForStream(audio_stream_type_t stream); 97 98 virtual audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc); 99 virtual status_t registerEffect(effect_descriptor_t *desc, 100 audio_io_handle_t io, 101 uint32_t strategy, 102 int session, 103 int id); 104 virtual status_t unregisterEffect(int id); 105 virtual status_t setEffectEnabled(int id, bool enabled); 106 virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const; 107 108 virtual status_t queryDefaultPreProcessing(int audioSession, 109 effect_descriptor_t *descriptors, 110 uint32_t *count); 111 virtual status_t onTransact( 112 uint32_t code, 113 const Parcel& data, 114 Parcel* reply, 115 uint32_t flags); 116 117 // IBinder::DeathRecipient 118 virtual void binderDied(const wp<IBinder>& who); 119 120 // 121 // Helpers for the struct audio_policy_service_ops implementation. 122 // This is used by the audio policy manager for certain operations that 123 // are implemented by the policy service. 124 // 125 virtual void setParameters(audio_io_handle_t ioHandle, 126 const char *keyValuePairs, 127 int delayMs); 128 129 virtual status_t setStreamVolume(audio_stream_type_t stream, 130 float volume, 131 audio_io_handle_t output, 132 int delayMs = 0); 133 virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); 134 virtual status_t stopTone(); 135 virtual status_t setVoiceVolume(float volume, int delayMs = 0); 136 137 private: 138 AudioPolicyService(); 139 virtual ~AudioPolicyService(); 140 141 status_t dumpInternals(int fd); 142 143 // Thread used for tone playback and to send audio config commands to audio flinger 144 // For tone playback, using a separate thread is necessary to avoid deadlock with mLock because startTone() 145 // and stopTone() are normally called with mLock locked and requesting a tone start or stop will cause 146 // calls to AudioPolicyService and an attempt to lock mLock. 147 // For audio config commands, it is necessary because audio flinger requires that the calling process (user) 148 // has permission to modify audio settings. 149 class AudioCommandThread : public Thread { 150 class AudioCommand; 151 public: 152 153 // commands for tone AudioCommand 154 enum { 155 START_TONE, 156 STOP_TONE, 157 SET_VOLUME, 158 SET_PARAMETERS, 159 SET_VOICE_VOLUME 160 }; 161 162 AudioCommandThread (String8 name); 163 virtual ~AudioCommandThread(); 164 165 status_t dump(int fd); 166 167 // Thread virtuals 168 virtual void onFirstRef(); 169 virtual bool threadLoop(); 170 171 void exit(); 172 void startToneCommand(int type = 0, int stream = 0); 173 void stopToneCommand(); 174 status_t volumeCommand(int stream, float volume, int output, int delayMs = 0); 175 status_t parametersCommand(int ioHandle, const char *keyValuePairs, int delayMs = 0); 176 status_t voiceVolumeCommand(float volume, int delayMs = 0); 177 void insertCommand_l(AudioCommand *command, int delayMs = 0); 178 179 private: 180 // descriptor for requested tone playback event 181 class AudioCommand { 182 183 public: AudioCommand()184 AudioCommand() 185 : mCommand(-1) {} 186 187 void dump(char* buffer, size_t size); 188 189 int mCommand; // START_TONE, STOP_TONE ... 190 nsecs_t mTime; // time stamp 191 Condition mCond; // condition for status return 192 status_t mStatus; // command status 193 bool mWaitStatus; // true if caller is waiting for status 194 void *mParam; // command parameter (ToneData, VolumeData, ParametersData) 195 }; 196 197 class ToneData { 198 public: 199 int mType; // tone type (START_TONE only) 200 int mStream; // stream type (START_TONE only) 201 }; 202 203 class VolumeData { 204 public: 205 int mStream; 206 float mVolume; 207 int mIO; 208 }; 209 210 class ParametersData { 211 public: 212 int mIO; 213 String8 mKeyValuePairs; 214 }; 215 216 class VoiceVolumeData { 217 public: 218 float mVolume; 219 }; 220 221 Mutex mLock; 222 Condition mWaitWorkCV; 223 Vector <AudioCommand *> mAudioCommands; // list of pending commands 224 ToneGenerator *mpToneGenerator; // the tone generator 225 AudioCommand mLastCommand; // last processed command (used by dump) 226 String8 mName; // string used by wake lock fo delayed commands 227 }; 228 229 class EffectDesc { 230 public: EffectDesc()231 EffectDesc() {} ~EffectDesc()232 virtual ~EffectDesc() {} 233 char *mName; 234 effect_uuid_t mUuid; 235 Vector <effect_param_t *> mParams; 236 }; 237 238 class InputSourceDesc { 239 public: InputSourceDesc()240 InputSourceDesc() {} ~InputSourceDesc()241 virtual ~InputSourceDesc() {} 242 Vector <EffectDesc *> mEffects; 243 }; 244 245 246 class InputDesc { 247 public: InputDesc()248 InputDesc() {} ~InputDesc()249 virtual ~InputDesc() {} 250 int mSessionId; 251 Vector< sp<AudioEffect> >mEffects; 252 }; 253 254 static const char *kInputSourceNames[AUDIO_SOURCE_CNT -1]; 255 256 void setPreProcessorEnabled(InputDesc *inputDesc, bool enabled); 257 status_t loadPreProcessorConfig(const char *path); 258 status_t loadEffects(cnode *root, Vector <EffectDesc *>& effects); 259 EffectDesc *loadEffect(cnode *root); 260 status_t loadInputSources(cnode *root, const Vector <EffectDesc *>& effects); 261 audio_source_t inputSourceNameToEnum(const char *name); 262 InputSourceDesc *loadInputSource(cnode *root, const Vector <EffectDesc *>& effects); 263 void loadEffectParameters(cnode *root, Vector <effect_param_t *>& params); 264 effect_param_t *loadEffectParameter(cnode *root); 265 size_t readParamValue(cnode *node, 266 char *param, 267 size_t *curSize, 268 size_t *totSize); 269 size_t growParamSize(char *param, 270 size_t size, 271 size_t *curSize, 272 size_t *totSize); 273 274 // Internal dump utilities. 275 status_t dumpPermissionDenial(int fd); 276 277 278 mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing 279 // device connection state or routing 280 sp <AudioCommandThread> mAudioCommandThread; // audio commands thread 281 sp <AudioCommandThread> mTonePlaybackThread; // tone playback thread 282 struct audio_policy_device *mpAudioPolicyDev; 283 struct audio_policy *mpAudioPolicy; 284 KeyedVector< audio_source_t, InputSourceDesc* > mInputSources; 285 KeyedVector< audio_io_handle_t, InputDesc* > mInputs; 286 }; 287 288 }; // namespace android 289 290 #endif // ANDROID_AUDIOPOLICYSERVICE_H 291