1 /* 2 * Copyright (c) 2021-2025 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_SERVICE_H 17 #define ST_AUDIO_POLICY_SERVICE_H 18 19 #include <bitset> 20 #include <list> 21 #include <string> 22 #include <unordered_map> 23 #include <unordered_set> 24 #include <mutex> 25 #include "singleton.h" 26 #include "audio_group_handle.h" 27 #include "audio_manager_base.h" 28 #include "audio_policy_manager_factory.h" 29 #include "audio_stream_collector.h" 30 #include "audio_router_center.h" 31 #include "datashare_helper.h" 32 #include "ipc_skeleton.h" 33 #include "power_mgr_client.h" 34 #include "common_event_manager.h" 35 #ifdef FEATURE_DTMF_TONE 36 #include "audio_tone_parser.h" 37 #endif 38 39 #include "device_status_listener.h" 40 #include "iaudio_policy_interface.h" 41 #include "audio_effect_service.h" 42 #include "audio_volume_config.h" 43 #include "policy_provider_stub.h" 44 #include "audio_device_manager.h" 45 #include "audio_device_parser.h" 46 #include "audio_state_manager.h" 47 #include "audio_pnp_server.h" 48 #include "audio_policy_server_handler.h" 49 #include "audio_affinity_manager.h" 50 #include "audio_ec_info.h" 51 52 #ifdef BLUETOOTH_ENABLE 53 #include "audio_server_death_recipient.h" 54 #include "audio_bluetooth_manager.h" 55 #include "bluetooth_device_manager.h" 56 #endif 57 58 #include "audio_a2dp_offload_manager.h" 59 #include "audio_iohandle_map.h" 60 #include "audio_router_map.h" 61 #include "audio_policy_config_manager.h" 62 #include "audio_connected_device.h" 63 #include "audio_tone_manager.h" 64 #include "audio_microphone_descriptor.h" 65 #include "audio_active_device.h" 66 #include "audio_a2dp_device.h" 67 #include "audio_scene_manager.h" 68 #include "audio_offload_stream.h" 69 #include "audio_volume_manager.h" 70 #include "audio_ec_manager.h" 71 #include "audio_device_common.h" 72 #include "audio_recovery_device.h" 73 #include "audio_device_lock.h" 74 #include "audio_capturer_session.h" 75 #include "audio_device_status.h" 76 #include "audio_background_manager.h" 77 #include "audio_global_config_manager.h" 78 #include "sle_audio_device_manager.h" 79 80 namespace OHOS { 81 namespace AudioStandard { 82 83 class AudioA2dpOffloadManager; 84 85 class AudioPolicyService : public IDeviceStatusObserver, public IPolicyProvider { 86 public: GetAudioPolicyService()87 static AudioPolicyService& GetAudioPolicyService() 88 { 89 static AudioPolicyService audioPolicyService; 90 return audioPolicyService; 91 } 92 93 bool Init(void); 94 void Deinit(void); 95 96 void OnMicrophoneBlockedUpdate(DeviceType devType, DeviceBlockStatus status); 97 98 int32_t SetAppVolumeLevel(int32_t appUid, int32_t volumeLevel); 99 100 int32_t SetSourceOutputStreamMute(int32_t uid, bool setMute) const; 101 102 std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType); 103 104 std::vector<std::shared_ptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag); 105 106 std::vector<std::shared_ptr<AudioDeviceDescriptor>> GetOutputDevice(sptr<AudioRendererFilter> audioRendererFilter); 107 108 std::vector<std::shared_ptr<AudioDeviceDescriptor>> GetInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter); 109 110 int32_t NotifyCapturerAdded(AudioCapturerInfo capturerInfo, AudioStreamInfo streamInfo, uint32_t sessionId); 111 112 int32_t NotifyWakeUpCapturerRemoved(); 113 114 AudioStreamInfo GetFastStreamInfo(); 115 116 bool IsAbsVolumeSupported(); 117 118 shared_ptr<AudioDeviceDescriptor> GetActiveOutputDeviceDescriptor(); 119 120 int32_t GetPreferredOutputStreamType(AudioRendererInfo &rendererInfo, const std::string &bundleName); 121 122 void OnUpdateAnahsSupport(std::string anahsShowType); 123 124 void GetAllSinkInputs(std::vector<SinkInput> &sinkInputs); 125 126 void OnDeviceStatusUpdated(DeviceType devType, bool isConnected, 127 const std::string &macAddress, const std::string &deviceName, 128 const AudioStreamInfo &streamInfo, DeviceRole role = DEVICE_ROLE_NONE, bool hasPair = false); 129 void OnDeviceStatusUpdated(AudioDeviceDescriptor &desc, bool isConnected); 130 131 void OnPnpDeviceStatusUpdated(AudioDeviceDescriptor &desc, bool isConnected); 132 133 void OnDeviceConfigurationChanged(DeviceType deviceType, 134 const std::string &macAddress, const std::string &deviceName, 135 const AudioStreamInfo &streamInfo); 136 137 void OnDeviceStatusUpdated(DStatusInfo statusInfo, bool isStop = false); 138 139 void OnServiceDisconnected(AudioServiceIndex serviceIndex); 140 141 void OnForcedDeviceSelected(DeviceType devType, const std::string &macAddress); 142 143 void LoadEffectLibrary(); 144 145 int32_t RegisterAudioRendererEventListener(int32_t clientPid, const sptr<IRemoteObject> &object, 146 bool hasBTPermission, bool hasSysPermission); 147 148 int32_t UnregisterAudioRendererEventListener(int32_t clientPid); 149 150 int32_t RegisterAudioCapturerEventListener(int32_t clientPid, const sptr<IRemoteObject> &object, 151 bool hasBTPermission, bool hasSysPermission); 152 153 int32_t UnregisterAudioCapturerEventListener(int32_t clientPid); 154 155 int32_t SetAvailableDeviceChangeCallback(const int32_t clientId, const AudioDeviceUsage usage, 156 const sptr<IRemoteObject> &object, bool hasBTPermission); 157 158 int32_t SetQueryDeviceVolumeBehaviorCallback(const sptr<IRemoteObject> &object); 159 160 int32_t SetQueryClientTypeCallback(const sptr<IRemoteObject> &object); 161 162 int32_t GetCurrentCapturerChangeInfos(vector<shared_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos, 163 bool hasBTPermission, bool hasSystemPermission); 164 165 void SetParameterCallback(const std::shared_ptr<AudioParameterCallback>& callback); 166 167 void RegiestPolicy(); 168 169 // override for IPolicyProvider 170 int32_t GetProcessDeviceInfo(const AudioProcessConfig &config, bool lockFlag, AudioDeviceDescriptor &deviceInfo); 171 172 int32_t InitSharedVolume(std::shared_ptr<AudioSharedMemory> &buffer); 173 174 #ifdef BLUETOOTH_ENABLE 175 static void BluetoothServiceCrashedCallback(pid_t pid, pid_t uid); 176 #endif 177 178 void RegisterBluetoothListener(); 179 180 void SubscribeAccessibilityConfigObserver(); 181 182 void RegisterRemoteDevStatusCallback(); 183 184 std::vector<std::shared_ptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescriptors( 185 AudioCapturerInfo &captureInfo, std::string networkId = LOCAL_NETWORK_ID); 186 187 std::vector<std::shared_ptr<AudioDeviceDescriptor>> GetPreferredOutputDeviceDescInner( 188 AudioRendererInfo &rendererInfo, std::string networkId = LOCAL_NETWORK_ID); 189 190 std::vector<std::shared_ptr<AudioDeviceDescriptor>> GetPreferredInputDeviceDescInner( 191 AudioCapturerInfo &captureInfo, std::string networkId = LOCAL_NETWORK_ID); 192 193 int32_t GetMaxRendererInstances(); 194 195 void RegisterDataObserver(); 196 197 int32_t QueryEffectManagerSceneMode(SupportedEffectConfig &supportedEffectConfig); 198 199 void UpdateDescWhenNoBTPermission(vector<std::shared_ptr<AudioDeviceDescriptor>> &desc); 200 201 int32_t GetHardwareOutputSamplingRate(const std::shared_ptr<AudioDeviceDescriptor> &desc); 202 203 int32_t OffloadStopPlaying(const std::vector<int32_t> &sessionIds); 204 205 int32_t OffloadGetRenderPosition(uint32_t &delayValue, uint64_t &sendDataSize, uint32_t &timeStamp); 206 207 int32_t NearlinkGetRenderPosition(uint32_t &delayValue); 208 209 int32_t GetAndSaveClientType(uint32_t uid, const std::string &bundleName); 210 211 DistributedRoutingInfo GetDistributedRoutingRoleInfo(); 212 213 void OnDeviceInfoUpdated(AudioDeviceDescriptor &desc, const DeviceInfoUpdateCommand command); 214 215 void UpdateA2dpOffloadFlagBySpatialService( 216 const std::string& macAddress, std::unordered_map<uint32_t, bool> &sessionIDToSpatializationEnableMap); 217 218 std::vector<std::shared_ptr<AudioDeviceDescriptor>> DeviceFilterByUsageInner(AudioDeviceUsage usage, 219 const std::vector<std::shared_ptr<AudioDeviceDescriptor>>& descs); 220 221 void NotifyAccountsChanged(const int &id); 222 223 int32_t DynamicUnloadModule(const AudioPipeType pipeType); 224 // for effect V3 225 int32_t GetSupportedAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray); 226 int32_t SetAudioEffectProperty(const AudioEffectPropertyArrayV3 &propertyArray); 227 int32_t GetAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray); 228 // for effect 229 int32_t GetSupportedAudioEffectProperty(AudioEffectPropertyArray &propertyArray); 230 int32_t SetAudioEffectProperty(const AudioEffectPropertyArray &propertyArray); 231 int32_t GetAudioEffectProperty(AudioEffectPropertyArray &propertyArray); 232 // for enhance 233 int32_t GetSupportedAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray); 234 int32_t SetAudioEnhanceProperty(const AudioEnhancePropertyArray &propertyArray); 235 int32_t GetAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray); 236 bool getFastControlParam(); 237 238 void OnReceiveEvent(const EventFwk::CommonEventData &eventData); 239 void SubscribeSafeVolumeEvent(); 240 int32_t NotifyCapturerRemoved(uint64_t sessionId); 241 void UpdateSpatializationSupported(const std::string macAddress, const bool support); 242 #ifdef HAS_FEATURE_INNERCAPTURER 243 int32_t LoadModernInnerCapSink(int32_t innerCapId); 244 int32_t UnloadModernInnerCapSink(int32_t innerCapId); 245 #endif 246 void RestoreSession(const uint32_t &sessionID, RestoreInfo restoreInfo); 247 248 int32_t SetSleAudioOperationCallback(const sptr<IRemoteObject> &object); 249 int32_t ClearAudioFocusBySessionID(const int32_t &sessionID); 250 int32_t CaptureConcurrentCheck(const uint32_t &sessionID); 251 private: AudioPolicyService()252 AudioPolicyService() 253 :audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), 254 streamCollector_(AudioStreamCollector::GetAudioStreamCollector()), 255 audioRouterCenter_(AudioRouterCenter::GetAudioRouterCenter()), 256 audioEffectService_(AudioEffectService::GetAudioEffectService()), 257 audioDeviceManager_(AudioDeviceManager::GetAudioDeviceManager()), 258 audioAffinityManager_(AudioAffinityManager::GetAudioAffinityManager()), 259 audioStateManager_(AudioStateManager::GetAudioStateManager()), 260 audioPolicyServerHandler_(DelayedSingleton<AudioPolicyServerHandler>::GetInstance()), 261 #ifdef AUDIO_WIRED_DETECT 262 audioPnpServer_(AudioPnpServer::GetAudioPnpServer()), 263 #endif 264 audioGlobalConfigManager_(AudioGlobalConfigManager::GetAudioGlobalConfigManager()), 265 audioIOHandleMap_(AudioIOHandleMap::GetInstance()), 266 audioRouteMap_(AudioRouteMap::GetInstance()), 267 audioConfigManager_(AudioPolicyConfigManager::GetInstance()), 268 audioConnectedDevice_(AudioConnectedDevice::GetInstance()), 269 audioToneManager_(AudioToneManager::GetInstance()), 270 audioMicrophoneDescriptor_(AudioMicrophoneDescriptor::GetInstance()), 271 audioActiveDevice_(AudioActiveDevice::GetInstance()), 272 audioA2dpDevice_(AudioA2dpDevice::GetInstance()), 273 audioSceneManager_(AudioSceneManager::GetInstance()), 274 audioBackgroundManager_(AudioBackgroundManager::GetInstance()), 275 audioOffloadStream_(AudioOffloadStream::GetInstance()), 276 audioVolumeManager_(AudioVolumeManager::GetInstance()), 277 audioEcManager_(AudioEcManager::GetInstance()), 278 audioDeviceCommon_(AudioDeviceCommon::GetInstance()), 279 audioRecoveryDevice_(AudioRecoveryDevice::GetInstance()), 280 audioCapturerSession_(AudioCapturerSession::GetInstance()), 281 audioDeviceLock_(AudioDeviceLock::GetInstance()), 282 audioDeviceStatus_(AudioDeviceStatus::GetInstance()), 283 sleAudioDeviceManager_(SleAudioDeviceManager::GetInstance()) 284 { 285 deviceStatusListener_ = std::make_unique<DeviceStatusListener>(*this); 286 } 287 288 ~AudioPolicyService(); 289 290 void GetSupportedEffectProperty(AudioEffectPropertyArrayV3 &propertyArray); 291 void GetSupportedEnhanceProperty(AudioEffectPropertyArrayV3 &propertyArray); 292 int32_t CheckSupportedAudioEffectProperty(const AudioEffectPropertyArrayV3 &propertyArray, const EffectFlag& flag); 293 int32_t GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 &propertyArray); 294 295 void RegisterNameMonitorHelper(); 296 297 void RegisterAccessibilityMonitorHelper(); 298 299 PipeInfo& GetPipeInfoByPipeName(std::string &supportPipe, AudioAdapterInfo &adapterInfo); 300 301 int32_t CheckDeviceCapability(AudioAdapterInfo &adapterInfo, int32_t flag, DeviceType deviceType); 302 303 bool IsConfigInfoHasAttribute(std::list<ConfigInfo> &configInfos, std::string value); 304 305 int32_t GetVoipDeviceInfo(const AudioProcessConfig &config, AudioDeviceDescriptor &deviceInfo, int32_t type, 306 std::vector<std::shared_ptr<AudioDeviceDescriptor>> &preferredDeviceList); 307 308 bool LoadAudioPolicyConfig(); 309 void CreateRecoveryThread(); 310 311 void LoadHdiEffectModel(); 312 313 void UpdateInputDeviceWhenStopping(const bool &isSupported); 314 315 void SetDefaultDeviceLoadFlag(bool isLoad); 316 317 void OnServiceConnected(AudioServiceIndex serviceIndex); 318 319 void UnregisterBluetoothListener(); 320 321 int32_t OffloadStartPlaying(const std::vector<int32_t> &sessionIds); 322 323 BluetoothOffloadState GetA2dpOffloadFlag(); 324 void SetDefaultAdapterEnable(bool isEnable); 325 bool IsDevicePlaybackSupported(const AudioProcessConfig &config, const AudioDeviceDescriptor &deviceInfo); 326 private: 327 328 static bool isBtListenerRegistered; 329 static bool isBtCrashed; 330 bool isPnpDeviceConnected = false; 331 const int32_t G_UNKNOWN_PID = -1; 332 int32_t dAudioClientUid = 3055; 333 int32_t maxRendererInstances_ = 128; 334 bool isFastControlled_ = true; 335 static constexpr int32_t MIN_SERVICE_COUNT = 2; 336 std::bitset<MIN_SERVICE_COUNT> serviceFlag_; 337 std::mutex serviceFlagMutex_; 338 339 IAudioPolicyInterface& audioPolicyManager_; 340 341 AudioStreamCollector& streamCollector_; 342 AudioRouterCenter& audioRouterCenter_; 343 std::unique_ptr<DeviceStatusListener> deviceStatusListener_; 344 345 AudioScene audioScene_ = AUDIO_SCENE_DEFAULT; 346 AudioScene lastAudioScene_ = AUDIO_SCENE_DEFAULT; 347 348 std::vector<DeviceType> outputPriorityList_ = { 349 DEVICE_TYPE_BLUETOOTH_SCO, 350 DEVICE_TYPE_BLUETOOTH_A2DP, 351 DEVICE_TYPE_DP, 352 DEVICE_TYPE_USB_HEADSET, 353 DEVICE_TYPE_WIRED_HEADSET, 354 DEVICE_TYPE_SPEAKER, 355 DEVICE_TYPE_HDMI, 356 DEVICE_TYPE_LINE_DIGITAL 357 }; 358 std::vector<DeviceType> inputPriorityList_ = { 359 DEVICE_TYPE_BLUETOOTH_SCO, 360 DEVICE_TYPE_BLUETOOTH_A2DP, 361 DEVICE_TYPE_USB_HEADSET, 362 DEVICE_TYPE_WIRED_HEADSET, 363 DEVICE_TYPE_WAKEUP, 364 DEVICE_TYPE_MIC, 365 DEVICE_TYPE_ACCESSORY 366 }; 367 368 AudioEffectService& audioEffectService_; 369 370 bool isMicrophoneMuteTemporary_ = false; 371 372 bool isMicrophoneMutePersistent_ = false; 373 374 AudioDeviceManager &audioDeviceManager_; 375 AudioAffinityManager &audioAffinityManager_; 376 AudioStateManager &audioStateManager_; 377 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler_; 378 #ifdef AUDIO_WIRED_DETECT 379 AudioPnpServer &audioPnpServer_; 380 #endif 381 AudioGlobalConfigManager &audioGlobalConfigManager_; 382 DistributedRoutingInfo distributedRoutingInfo_ = { 383 .descriptor = nullptr, 384 .type = CAST_TYPE_NULL 385 }; 386 387 static std::map<std::string, ClassType> classStrToEnum; 388 389 SourceType currentSourceType = SOURCE_TYPE_MIC; 390 uint32_t currentRate = 0; 391 bool updateA2dpOffloadLogFlag = false; 392 std::mutex checkSpatializedMutex_; 393 394 std::unique_ptr<std::thread> RecoveryDevicesThread_ = nullptr; 395 396 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager_ = nullptr; 397 398 AudioIOHandleMap& audioIOHandleMap_; 399 AudioRouteMap& audioRouteMap_; 400 AudioPolicyConfigManager& audioConfigManager_; 401 AudioConnectedDevice& audioConnectedDevice_; 402 AudioToneManager& audioToneManager_; 403 AudioMicrophoneDescriptor& audioMicrophoneDescriptor_; 404 AudioActiveDevice& audioActiveDevice_; 405 AudioA2dpDevice& audioA2dpDevice_; 406 AudioSceneManager& audioSceneManager_; 407 AudioBackgroundManager& audioBackgroundManager_; 408 AudioOffloadStream& audioOffloadStream_; 409 AudioVolumeManager& audioVolumeManager_; 410 AudioEcManager& audioEcManager_; 411 AudioDeviceCommon& audioDeviceCommon_; 412 AudioRecoveryDevice& audioRecoveryDevice_; 413 414 AudioCapturerSession& audioCapturerSession_; 415 AudioDeviceLock& audioDeviceLock_; 416 AudioDeviceStatus& audioDeviceStatus_; 417 SleAudioDeviceManager& sleAudioDeviceManager_; 418 419 }; 420 421 class SafeVolumeEventSubscriber : public EventFwk::CommonEventSubscriber { 422 public: SafeVolumeEventSubscriber(const EventFwk::CommonEventSubscribeInfo & subscribeInfo,std::function<void (const EventFwk::CommonEventData &)> receiver)423 explicit SafeVolumeEventSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo, 424 std::function<void(const EventFwk::CommonEventData&)> receiver) 425 : EventFwk::CommonEventSubscriber(subscribeInfo), eventReceiver_(receiver) {} ~SafeVolumeEventSubscriber()426 ~SafeVolumeEventSubscriber() {} 427 void OnReceiveEvent(const EventFwk::CommonEventData &eventData) override; 428 private: 429 SafeVolumeEventSubscriber() = default; 430 std::function<void(const EventFwk::CommonEventData&)> eventReceiver_; 431 }; 432 } // namespace AudioStandard 433 } // namespace OHOS 434 435 #endif // ST_AUDIO_POLICY_SERVICE_H 436