1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ST_AUDIO_POLICY_SERVER_H 17 #define ST_AUDIO_POLICY_SERVER_H 18 19 #include <mutex> 20 #include <pthread.h> 21 22 #include "system_ability_definition.h" 23 #include "ipc_skeleton.h" 24 #include "system_ability.h" 25 #include "iservice_registry.h" 26 27 #include "accesstoken_kit.h" 28 #include "perm_state_change_callback_customize.h" 29 30 #include "bundle_mgr_interface.h" 31 #include "bundle_mgr_proxy.h" 32 33 #include "audio_info.h" 34 #include "audio_policy_service.h" 35 #include "audio_session_callback.h" 36 #include "audio_interrupt_callback.h" 37 #include "audio_policy_manager_stub.h" 38 #include "audio_server_death_recipient.h" 39 #include "audio_service_dump.h" 40 41 namespace OHOS { 42 namespace AudioStandard { 43 class AudioPolicyServer : public SystemAbility, public AudioPolicyManagerStub, public AudioSessionCallback { 44 DECLARE_SYSTEM_ABILITY(AudioPolicyServer); 45 public: 46 DISALLOW_COPY_AND_MOVE(AudioPolicyServer); 47 48 enum DeathRecipientId { 49 TRACKER_CLIENT = 0, 50 LISTENER_CLIENT 51 }; 52 53 const std::vector<AudioStreamType> GET_STREAM_ALL_VOLUME_TYPES { 54 STREAM_VOICE_CALL, 55 STREAM_RING, 56 STREAM_MUSIC, 57 STREAM_VOICE_ASSISTANT, 58 STREAM_ALARM, 59 STREAM_ACCESSIBILITY, 60 STREAM_ULTRASONIC 61 }; 62 63 explicit AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate = true); 64 65 virtual ~AudioPolicyServer() = default; 66 67 void OnDump() override; 68 void OnStart() override; 69 void OnStop() override; 70 71 int32_t GetMaxVolumeLevel(AudioVolumeType volumeType) override; 72 73 int32_t GetMinVolumeLevel(AudioVolumeType volumeType) override; 74 75 int32_t SetSystemVolumeLevel(AudioStreamType streamType, int32_t volumeLevel, API_VERSION api_v = API_9) override; 76 77 int32_t GetSystemVolumeLevel(AudioStreamType streamType) override; 78 79 int32_t SetLowPowerVolume(int32_t streamId, float volume) override; 80 81 float GetLowPowerVolume(int32_t streamId) override; 82 83 float GetSingleStreamVolume(int32_t streamId) override; 84 85 int32_t SetStreamMute(AudioStreamType streamType, bool mute, API_VERSION api_v = API_9) override; 86 87 bool GetStreamMute(AudioStreamType streamType) override; 88 89 bool IsStreamActive(AudioStreamType streamType) override; 90 91 bool IsVolumeUnadjustable() override; 92 93 int32_t AdjustVolumeByStep(VolumeAdjustType adjustType) override; 94 95 int32_t AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType) override; 96 97 float GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType) override; 98 99 int32_t SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter, 100 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) override; 101 102 std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType) override; 103 104 int32_t SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter, 105 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors) override; 106 107 std::vector<sptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag) override; 108 109 int32_t SetWakeUpAudioCapturer(InternalAudioCapturerOptions options) override; 110 111 int32_t CloseWakeUpAudioCapturer() override; 112 113 int32_t SetDeviceActive(InternalDeviceType deviceType, bool active) override; 114 115 bool IsDeviceActive(InternalDeviceType deviceType) override; 116 117 InternalDeviceType GetActiveOutputDevice() override; 118 119 InternalDeviceType GetActiveInputDevice() override; 120 121 int32_t SetRingerMode(AudioRingerMode ringMode, API_VERSION api_v = API_9) override; 122 123 #ifdef FEATURE_DTMF_TONE 124 std::vector<int32_t> GetSupportedTones() override; 125 126 std::shared_ptr<ToneInfo> GetToneConfig(int32_t ltonetype) override; 127 #endif 128 129 AudioRingerMode GetRingerMode() override; 130 131 int32_t SetAudioScene(AudioScene audioScene) override; 132 133 int32_t SetMicrophoneMuteCommon(bool isMute, API_VERSION api_v); 134 135 int32_t SetMicrophoneMute(bool isMute) override; 136 137 int32_t SetMicrophoneMuteAudioConfig(bool isMute) override; 138 139 bool IsMicrophoneMute(API_VERSION api_v) override; 140 141 AudioScene GetAudioScene() override; 142 143 int32_t SetRingerModeCallback(const int32_t clientId, const sptr<IRemoteObject> &object, 144 API_VERSION api_v = API_9) override; 145 146 int32_t UnsetRingerModeCallback(const int32_t clientId) override; 147 148 int32_t SetMicStateChangeCallback(const int32_t clientId, const sptr<IRemoteObject> &object) override; 149 150 int32_t SetDeviceChangeCallback(const int32_t clientId, const DeviceFlag flag, const sptr<IRemoteObject> &object) 151 override; 152 153 int32_t UnsetDeviceChangeCallback(const int32_t clientId, DeviceFlag flag) override; 154 155 int32_t SetPreferredOutputDeviceChangeCallback(const int32_t clientId, const sptr<IRemoteObject> &object) override; 156 157 int32_t SetPreferredInputDeviceChangeCallback(const sptr<IRemoteObject> &object) override; 158 159 int32_t UnsetPreferredOutputDeviceChangeCallback(const int32_t clientId) override; 160 161 int32_t UnsetPreferredInputDeviceChangeCallback() override; 162 163 int32_t SetAudioInterruptCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object) override; 164 165 int32_t UnsetAudioInterruptCallback(const uint32_t sessionID) override; 166 167 int32_t ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt) override; 168 169 int32_t DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt) override; 170 171 int32_t SetAudioManagerInterruptCallback(const int32_t clientId, const sptr<IRemoteObject> &object) override; 172 173 int32_t UnsetAudioManagerInterruptCallback(const int32_t clientId) override; 174 175 int32_t RequestAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt) override; 176 177 int32_t AbandonAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt) override; 178 179 AudioStreamType GetStreamInFocus() override; 180 181 int32_t GetSessionInfoInFocus(AudioInterrupt &audioInterrupt) override; 182 183 int32_t SetVolumeKeyEventCallback(const int32_t clientId, 184 const sptr<IRemoteObject> &object, API_VERSION api_v = API_9) override; 185 186 int32_t UnsetVolumeKeyEventCallback(const int32_t clientId) override; 187 188 void OnSessionRemoved(const uint32_t sessionID) override; 189 190 void OnPlaybackCapturerStop() override; 191 192 void OnWakeupCapturerStop() override; 193 194 int32_t Dump(int32_t fd, const std::vector<std::u16string> &args) override; 195 196 bool CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid) override; 197 198 bool CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid, 199 AudioPermissionState state) override; 200 201 int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType) override; 202 203 int32_t GetAudioLatencyFromXml() override; 204 205 uint32_t GetSinkLatencyFromXml() override; 206 207 int32_t RegisterAudioRendererEventListener(int32_t clientPid, const sptr<IRemoteObject> &object) override; 208 209 int32_t UnregisterAudioRendererEventListener(int32_t clientPid) override; 210 211 int32_t RegisterAudioCapturerEventListener(int32_t clientPid, const sptr<IRemoteObject> &object) override; 212 213 int32_t UnregisterAudioCapturerEventListener(int32_t clientPid) override; 214 215 int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo, 216 const sptr<IRemoteObject> &object) override; 217 218 int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo) override; 219 220 int32_t GetCurrentRendererChangeInfos( 221 std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) override; 222 223 int32_t GetCurrentCapturerChangeInfos( 224 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) override; 225 226 void RegisterClientDeathRecipient(const sptr<IRemoteObject> &object, DeathRecipientId id); 227 228 void RegisteredTrackerClientDied(int pid); 229 230 void RegisteredStreamListenerClientDied(int pid); 231 232 bool IsAudioRendererLowLatencySupported(const AudioStreamInfo &audioStreamInfo) override; 233 234 int32_t UpdateStreamState(const int32_t clientUid, StreamSetState streamSetState, 235 AudioStreamType audioStreamType) override; 236 237 int32_t GetVolumeGroupInfos(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos) override; 238 239 int32_t GetNetworkIdByGroupId(int32_t groupId, std::string &networkId) override; 240 241 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredOutputDeviceDescriptors( 242 AudioRendererInfo &rendererInfo) override; 243 244 std::vector<sptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescriptors( 245 AudioCapturerInfo &captureInfo) override; 246 247 int32_t GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList) override; 248 249 int32_t RegisterFocusInfoChangeCallback(const int32_t clientId, const sptr<IRemoteObject>& object) override; 250 251 int32_t UnregisterFocusInfoChangeCallback(const int32_t clientId) override; 252 253 int32_t SetSystemSoundUri(const std::string &key, const std::string &uri) override; 254 255 std::string GetSystemSoundUri(const std::string &key) override; 256 257 float GetMinStreamVolume(void) override; 258 259 float GetMaxStreamVolume(void) override; 260 261 int32_t GetMaxRendererInstances() override; 262 263 void GetStreamVolumeInfoMap(StreamVolumeInfoMap& streamVolumeInfos); 264 265 int32_t QueryEffectSceneMode(SupportedEffectConfig &supportedEffectConfig) override; 266 267 int32_t SetPlaybackCapturerFilterInfos(const AudioPlaybackCaptureConfig &config, 268 uint32_t appTokenId) override; 269 270 class RemoteParameterCallback : public AudioParameterCallback { 271 public: 272 RemoteParameterCallback(sptr<AudioPolicyServer> server); 273 // AudioParameterCallback 274 void OnAudioParameterChange(const std::string networkId, const AudioParamKey key, const std::string& condition, 275 const std::string& value) override; 276 private: 277 sptr<AudioPolicyServer> server_; 278 void VolumeOnChange(const std::string networkId, const std::string& condition); 279 void InterruptOnChange(const std::string networkId, const std::string& condition); 280 void StateOnChange(const std::string networkId, const std::string& condition, const std::string& value); 281 }; 282 283 std::shared_ptr<RemoteParameterCallback> remoteParameterCallback_; 284 285 class PerStateChangeCbCustomizeCallback : public Security::AccessToken::PermStateChangeCallbackCustomize { 286 public: PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope & scopeInfo,sptr<AudioPolicyServer> server)287 explicit PerStateChangeCbCustomizeCallback(const Security::AccessToken::PermStateChangeScope &scopeInfo, 288 sptr<AudioPolicyServer> server) : PermStateChangeCallbackCustomize(scopeInfo), 289 ready_(false), server_(server) {} ~PerStateChangeCbCustomizeCallback()290 ~PerStateChangeCbCustomizeCallback() {} 291 292 void PermStateChangeCallback(Security::AccessToken::PermStateChangeInfo& result); 293 int32_t getUidByBundleName(std::string bundle_name, int user_id); 294 295 bool ready_; 296 private: 297 sptr<AudioPolicyServer> server_; 298 }; 299 300 protected: 301 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 302 303 void RegisterParamCallback(); 304 305 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 306 307 private: 308 static constexpr int32_t MAX_VOLUME_LEVEL = 15; 309 static constexpr int32_t MIN_VOLUME_LEVEL = 0; 310 static constexpr int32_t VOLUME_CHANGE_FACTOR = 1; 311 static constexpr int32_t VOLUME_KEY_DURATION = 0; 312 static constexpr int32_t VOLUME_MUTE_KEY_DURATION = 1; 313 static constexpr int32_t MEDIA_SERVICE_UID = 1013; 314 static constexpr int32_t DEFAULT_APP_PID = -1; 315 316 static const std::map<InterruptHint, AudioFocuState> HINTSTATEMAP; 317 static const std::list<uid_t> RECORD_ALLOW_BACKGROUND_LIST; 318 static const std::list<uid_t> RECORD_PASS_APPINFO_LIST; 319 static std::map<InterruptHint, AudioFocuState> CreateStateMap(); 320 321 // for audio interrupt 322 bool IsSameAppInShareMode(const AudioInterrupt incomingInterrupt, const AudioInterrupt activateInterrupt); 323 int32_t ProcessFocusEntry(const AudioInterrupt &incomingInterrupt); 324 void ProcessCurrentInterrupt(const AudioInterrupt &incomingInterrupt); 325 void ResumeAudioFocusList(); 326 std::list<std::pair<AudioInterrupt, AudioFocuState>> SimulateFocusEntry(); 327 void NotifyStateChangedEvent(AudioFocuState oldState, AudioFocuState newState, 328 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive); 329 void NotifyFocusGranted(const int32_t clientId, const AudioInterrupt &audioInterrupt); 330 int32_t NotifyFocusAbandoned(const int32_t clientId, const AudioInterrupt &audioInterrupt); 331 void OnAudioFocusInfoChange(); 332 void UpdateAudioScene(const AudioInterrupt &audioInterrupt, AudioInterruptChangeType changeType); 333 334 // for audio volume and mute status 335 int32_t SetSystemVolumeLevelInternal(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi); 336 int32_t SetSingleStreamVolume(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi); 337 int32_t GetSystemVolumeLevelInternal(AudioStreamType streamType, bool isFromVolumeKey); 338 float GetSystemVolumeDb(AudioStreamType streamType); 339 int32_t SetStreamMuteInternal(AudioStreamType streamType, bool mute, bool isUpdateUi); 340 int32_t SetSingleStreamMute(AudioStreamType streamType, bool mute, bool isUpdateUi); 341 bool GetStreamMuteInternal(AudioStreamType streamType); 342 AudioVolumeType GetVolumeTypeFromStreamType(AudioStreamType streamType); 343 bool IsVolumeTypeValid(AudioStreamType streamType); 344 bool IsVolumeLevelValid(AudioStreamType streamType, int32_t volumeLevel); 345 346 // Permission and privacy 347 bool VerifyPermission(const std::string &permission, uint32_t tokenId = 0, bool isRecording = false); 348 bool CheckAppBackgroundPermission(uid_t callingUid, uint64_t targetFullTokenId, uint32_t targetTokenId); 349 Security::AccessToken::AccessTokenID GetTargetTokenId(uid_t callingUid, uint32_t callingTokenId, 350 uint32_t appTokenId); 351 uint64_t GetTargetFullTokenId(uid_t callingUid, uint64_t callingFullTokenId, uint64_t appFullTokenId); 352 bool CheckRootCalling(uid_t callingUid, int32_t appUid); 353 void NotifyPrivacy(uint32_t targetTokenId, AudioPermissionState state); 354 355 // common 356 void GetPolicyData(PolicyData &policyData); 357 void GetDeviceInfo(PolicyData &policyData); 358 void GetGroupInfo(PolicyData &policyData); 359 360 // externel function call 361 bool MaxOrMinVolumeOption(const int32_t &volLevel, const int32_t keyType, const AudioStreamType &streamInFocus); 362 void RegisterVolumeKeyEvents(const int32_t keyType); 363 void RegisterVolumeKeyMuteEvents(); 364 void SubscribeVolumeKeyEvents(); 365 void InitKVStore(); 366 void ConnectServiceAdapter(); 367 void LoadEffectLibrary(); 368 void RegisterBluetoothListener(); 369 void SubscribeAccessibilityConfigObserver(); 370 void RegisterDataObserver(); 371 372 AudioPolicyService& mPolicyService; 373 int32_t clientOnFocus_; 374 int32_t volumeStep_; 375 std::unique_ptr<AudioInterrupt> focussedAudioInterruptInfo_; 376 std::recursive_mutex focussedAudioInterruptInfoMutex_; 377 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList_; 378 std::vector<pid_t> clientDiedListenerState_; 379 380 std::unordered_map<int32_t, std::shared_ptr<VolumeKeyEventCallback>> volumeChangeCbsMap_; 381 std::unordered_map<uint32_t, std::shared_ptr<AudioInterruptCallback>> interruptCbsMap_; 382 std::unordered_map<int32_t, std::shared_ptr<AudioInterruptCallback>> amInterruptCbsMap_; 383 std::unordered_map<int32_t, sptr<IStandardAudioPolicyManagerListener>> focusInfoChangeCbsMap_; 384 std::unordered_map<int32_t, std::shared_ptr<AudioRingerModeCallback>> ringerModeCbsMap_; 385 std::unordered_map<int32_t, std::shared_ptr<AudioManagerMicStateChangeCallback>> micStateChangeCbsMap_; 386 387 std::mutex volumeKeyEventMutex_; 388 std::mutex interruptMutex_; 389 std::mutex amInterruptMutex_; 390 std::mutex focusInfoChangeMutex_; 391 std::mutex ringerModeMutex_; 392 std::mutex micStateChangeMutex_; 393 std::mutex clientDiedListenerStateMutex_; 394 }; 395 } // namespace AudioStandard 396 } // namespace OHOS 397 #endif // ST_AUDIO_POLICY_SERVER_H 398