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