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_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 <mutex> 24 #include "audio_group_handle.h" 25 #include "audio_info.h" 26 #include "audio_manager_base.h" 27 #include "audio_policy_manager_factory.h" 28 #include "audio_stream_collector.h" 29 #include "audio_tone_parser.h" 30 31 #ifdef ACCESSIBILITY_ENABLE 32 #include "accessibility_config_listener.h" 33 #else 34 #include "iaudio_accessibility_config_observer.h" 35 #endif 36 37 #include "device_status_listener.h" 38 #include "iaudio_policy_interface.h" 39 #include "iport_observer.h" 40 #include "parser_factory.h" 41 42 namespace OHOS { 43 namespace AudioStandard { 44 class AudioPolicyService : public IPortObserver, public IDeviceStatusObserver, 45 public IAudioAccessibilityConfigObserver { 46 public: GetAudioPolicyService()47 static AudioPolicyService& GetAudioPolicyService() 48 { 49 static AudioPolicyService audioPolicyService; 50 return audioPolicyService; 51 } 52 53 bool Init(void); 54 void Deinit(void); 55 void InitKVStore(); 56 bool ConnectServiceAdapter(); 57 58 const sptr<IStandardAudioService> GetAudioPolicyServiceProxy(); 59 60 int32_t SetStreamVolume(AudioStreamType streamType, float volume); 61 62 float GetStreamVolume(AudioStreamType streamType) const; 63 64 int32_t SetLowPowerVolume(int32_t streamId, float volume) const; 65 66 float GetLowPowerVolume(int32_t streamId) const; 67 68 float GetSingleStreamVolume(int32_t streamId) const; 69 70 int32_t SetStreamMute(AudioStreamType streamType, bool mute) const; 71 72 int32_t SetSourceOutputStreamMute(int32_t uid, bool setMute) const; 73 74 bool GetStreamMute(AudioStreamType streamType) const; 75 76 bool IsStreamActive(AudioStreamType streamType) const; 77 78 void NotifyRemoteRenderState(std::string networkId, std::string condition, std::string value); 79 80 int32_t SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter, 81 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors); 82 83 std::string GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType); 84 85 int32_t SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter, 86 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors); 87 88 std::vector<sptr<AudioDeviceDescriptor>> GetDevices(DeviceFlag deviceFlag); 89 90 int32_t SetDeviceActive(InternalDeviceType deviceType, bool active); 91 92 bool IsDeviceActive(InternalDeviceType deviceType) const; 93 94 DeviceType GetActiveOutputDevice() const; 95 96 DeviceType GetActiveInputDevice() const; 97 98 int32_t SetRingerMode(AudioRingerMode ringMode); 99 100 bool IsAudioInterruptEnabled() const; 101 GetAudioFocusMap()102 auto& GetAudioFocusMap() const 103 { 104 return focusMap_; 105 } 106 107 AudioRingerMode GetRingerMode() const; 108 109 int32_t SetMicrophoneMute(bool isMute); 110 111 bool IsMicrophoneMute(); 112 113 int32_t SetAudioScene(AudioScene audioScene); 114 115 AudioScene GetAudioScene() const; 116 117 int32_t GetAudioLatencyFromXml() const; 118 119 uint32_t GetSinkLatencyFromXml() const; 120 121 // Parser callbacks 122 void OnXmlParsingCompleted(const std::unordered_map<ClassType, std::list<AudioModuleInfo>> &xmldata); 123 124 void OnVolumeGroupParsed(std::unordered_map<std::string, std::string>& volumeGroupData); 125 126 void OnInterruptGroupParsed(std::unordered_map<std::string, std::string>& interruptGroupData); 127 128 void OnAudioInterruptEnable(bool enable); 129 130 void OnUpdateRouteSupport(bool isSupported); 131 132 std::vector<int32_t> GetSupportedTones(); 133 134 std::shared_ptr<ToneInfo> GetToneConfig(int32_t ltonetype); 135 136 void OnDeviceStatusUpdated(DeviceType devType, bool isConnected, 137 const std::string &macAddress, const std::string &deviceName, 138 const AudioStreamInfo &streamInfo); 139 140 void OnDeviceConfigurationChanged(DeviceType deviceType, 141 const std::string &macAddress, const std::string &deviceName, 142 const AudioStreamInfo &streamInfo); 143 144 void OnDeviceStatusUpdated(DStatusInfo statusInfo); 145 146 void OnServiceConnected(AudioServiceIndex serviceIndex); 147 148 void OnServiceDisconnected(AudioServiceIndex serviceIndex); 149 150 void OnMonoAudioConfigChanged(bool audioMono); 151 152 void OnAudioBalanceChanged(float audioBalance); 153 154 int32_t SetAudioSessionCallback(AudioSessionCallback *callback); 155 156 int32_t SetDeviceChangeCallback(const int32_t clientId, const DeviceFlag flag, const sptr<IRemoteObject> &object); 157 158 int32_t UnsetDeviceChangeCallback(const int32_t clientId); 159 160 int32_t RegisterAudioRendererEventListener(int32_t clientUID, const sptr<IRemoteObject> &object, 161 bool hasBTPermission); 162 163 int32_t UnregisterAudioRendererEventListener(int32_t clientUID); 164 165 int32_t RegisterAudioCapturerEventListener(int32_t clientUID, const sptr<IRemoteObject> &object, 166 bool hasBTPermission); 167 168 int32_t UnregisterAudioCapturerEventListener(int32_t clientUID); 169 170 int32_t RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo, 171 const sptr<IRemoteObject> &object); 172 173 int32_t UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo); 174 175 int32_t GetCurrentRendererChangeInfos(vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos, 176 bool hasBTPermission); 177 178 int32_t GetCurrentCapturerChangeInfos(vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos, 179 bool hasBTPermission); 180 181 void RegisteredTrackerClientDied(pid_t pid); 182 183 void RegisteredStreamListenerClientDied(pid_t pid); 184 185 int32_t ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType); 186 187 void OnAudioLatencyParsed(uint64_t latency); 188 189 void OnSinkLatencyParsed(uint32_t latency); 190 191 int32_t UpdateStreamState(int32_t clientUid, StreamSetStateEventInternal &streamSetStateEventInternal); 192 193 DeviceType GetDeviceTypeFromPin(AudioPin pin); 194 195 std::vector<sptr<VolumeGroupInfo>> GetVolumeGroupInfos(); 196 197 void SetParameterCallback(const std::shared_ptr<AudioParameterCallback>& callback); 198 199 void RegisterBluetoothListener(); 200 201 void UnregisterBluetoothListener(); 202 203 void SubscribeAccessibilityConfigObserver(); 204 205 std::vector<sptr<AudioDeviceDescriptor>> GetActiveOutputDeviceDescriptors(); 206 207 private: AudioPolicyService()208 AudioPolicyService() 209 : audioPolicyManager_(AudioPolicyManagerFactory::GetAudioPolicyManager()), 210 configParser_(ParserFactory::GetInstance().CreateParser(*this)), 211 streamCollector_(AudioStreamCollector::GetAudioStreamCollector()) 212 { 213 #ifdef ACCESSIBILITY_ENABLE 214 accessibilityConfigListener_ = std::make_shared<AccessibilityConfigListener>(*this); 215 #endif 216 deviceStatusListener_ = std::make_unique<DeviceStatusListener>(*this); 217 } 218 219 ~AudioPolicyService(); 220 221 std::string GetPortName(InternalDeviceType deviceType); 222 223 int32_t RememberRoutingInfo(sptr<AudioRendererFilter> audioRendererFilter, 224 sptr<AudioDeviceDescriptor> deviceDescriptor); 225 226 int32_t MoveToLocalOutputDevice(std::vector<SinkInput> sinkInputIds, 227 sptr<AudioDeviceDescriptor> localDeviceDescriptor); 228 229 int32_t MoveToRemoteOutputDevice(std::vector<SinkInput> sinkInputIds, 230 sptr<AudioDeviceDescriptor> remoteDeviceDescriptor); 231 232 int32_t MoveToLocalInputDevice(std::vector<uint32_t> sourceOutputIds, 233 sptr<AudioDeviceDescriptor> localDeviceDescriptor); 234 235 int32_t MoveToRemoteInputDevice(std::vector<uint32_t> sourceOutputIds, 236 sptr<AudioDeviceDescriptor> remoteDeviceDescriptor); 237 238 AudioModuleInfo ConstructRemoteAudioModuleInfo(std::string networkId, 239 DeviceRole deviceRole, DeviceType deviceType); 240 241 AudioIOHandle GetAudioIOHandle(InternalDeviceType deviceType); 242 243 int32_t OpenRemoteAudioDevice(std::string networkId, DeviceRole deviceRole, DeviceType deviceType, 244 sptr<AudioDeviceDescriptor> remoteDeviceDescriptor); 245 246 InternalDeviceType GetDeviceType(const std::string &deviceName); 247 248 std::string GetGroupName(const std::string& deviceName, const GroupType type); 249 250 InternalDeviceType GetCurrentActiveDevice(DeviceRole role) const; 251 252 DeviceRole GetDeviceRole(DeviceType deviceType) const; 253 254 DeviceRole GetDeviceRole(const std::string &role); 255 256 int32_t SelectNewDevice(DeviceRole deviceRole, DeviceType deviceType); 257 258 int32_t ActivateNewDevice(DeviceType deviceType, bool isSceneActivation); 259 260 DeviceRole GetDeviceRole(AudioPin pin) const; 261 262 int32_t ActivateNewDevice(std::string networkId, DeviceType deviceType, bool isRemote); 263 264 DeviceType FetchHighPriorityDevice(bool isOutputDevice); 265 266 void UpdateConnectedDevices(const AudioDeviceDescriptor& deviceDescriptor, 267 std::vector<sptr<AudioDeviceDescriptor>>& desc, bool status); 268 269 void TriggerDeviceChangedCallback(const std::vector<sptr<AudioDeviceDescriptor>> &devChangeDesc, bool connection); 270 271 std::vector<sptr<AudioDeviceDescriptor>> DeviceFilterByFlag(DeviceFlag flag, 272 const std::vector<sptr<AudioDeviceDescriptor>>& desc); 273 274 void WriteDeviceChangedSysEvents(const std::vector<sptr<AudioDeviceDescriptor>> &desc, bool isConnected); 275 276 bool GetActiveDeviceStreamInfo(DeviceType deviceType, AudioStreamInfo &streamInfo); 277 278 bool IsConfigurationUpdated(DeviceType deviceType, const AudioStreamInfo &streamInfo); 279 280 void UpdateInputDeviceInfo(DeviceType deviceType); 281 282 void UpdateStreamChangeDeviceInfo(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo); 283 284 void UpdateTrackerDeviceChange(const vector<sptr<AudioDeviceDescriptor>> &desc); 285 286 void UpdateGroupInfo(GroupType type, std::string groupName, int32_t& groupId, std::string networkId, 287 bool connected, int32_t mappingId); 288 289 void AddAudioDevice(AudioModuleInfo& moduleInfo, InternalDeviceType devType); 290 291 std::vector<sptr<AudioDeviceDescriptor>> GetDevicesForGroup(GroupType type, int32_t groupId); 292 293 bool interruptEnabled_ = true; 294 bool isUpdateRouteSupported_ = true; 295 bool isCurrentRemoteRenderer = false; 296 bool remoteCapturerSwitch = false; 297 bool isOpenRemoteDevice = false; 298 bool isBtListenerRegistered = false; 299 const int32_t G_UNKNOWN_PID = -1; 300 int32_t dAudioClientUid = 3055; 301 int32_t switchVolumeDelay_ = 500000; // us 302 uint64_t audioLatencyInMsec_ = 50; 303 uint32_t sinkLatencyInMsec_ {0}; 304 std::bitset<MIN_SERVICE_COUNT> serviceFlag_; 305 std::mutex serviceFlagMutex_; 306 DeviceType currentActiveDevice_ = DEVICE_TYPE_NONE; 307 DeviceType activeInputDevice_ = DEVICE_TYPE_NONE; 308 std::unordered_map<int32_t, std::pair<std::string, int32_t>> routerMap_; 309 IAudioPolicyInterface& audioPolicyManager_; 310 Parser& configParser_; 311 std::unordered_map<int32_t, std::shared_ptr<ToneInfo>> toneDescriptorMap; 312 AudioStreamCollector& streamCollector_; 313 #ifdef ACCESSIBILITY_ENABLE 314 std::shared_ptr<AccessibilityConfigListener> accessibilityConfigListener_; 315 #endif 316 std::unique_ptr<DeviceStatusListener> deviceStatusListener_; 317 std::vector<sptr<AudioDeviceDescriptor>> connectedDevices_; 318 std::unordered_map<std::string, AudioStreamInfo> connectedA2dpDeviceMap_; 319 std::string activeBTDevice_; 320 321 std::unordered_map<int32_t, std::pair<DeviceFlag, sptr<IStandardAudioPolicyManagerListener>>> 322 deviceChangeCallbackMap_; 323 AudioScene audioScene_ = AUDIO_SCENE_DEFAULT; 324 std::map<std::pair<AudioStreamType, AudioStreamType>, AudioFocusEntry> focusMap_ = {}; 325 std::unordered_map<ClassType, std::list<AudioModuleInfo>> deviceClassInfo_ = {}; 326 std::unordered_map<std::string, AudioIOHandle> IOHandles_ = {}; 327 std::vector<DeviceType> ioDeviceList = { 328 DEVICE_TYPE_BLUETOOTH_A2DP, 329 DEVICE_TYPE_BLUETOOTH_SCO, 330 DEVICE_TYPE_USB_HEADSET, 331 DEVICE_TYPE_WIRED_HEADSET 332 }; 333 std::vector<DeviceType> outputPriorityList_ = { 334 DEVICE_TYPE_BLUETOOTH_SCO, 335 DEVICE_TYPE_BLUETOOTH_A2DP, 336 DEVICE_TYPE_USB_HEADSET, 337 DEVICE_TYPE_WIRED_HEADSET, 338 DEVICE_TYPE_SPEAKER 339 }; 340 std::vector<DeviceType> inputPriorityList_ = { 341 DEVICE_TYPE_BLUETOOTH_SCO, 342 DEVICE_TYPE_BLUETOOTH_A2DP, 343 DEVICE_TYPE_USB_HEADSET, 344 DEVICE_TYPE_WIRED_HEADSET, 345 DEVICE_TYPE_MIC 346 }; 347 348 std::vector<sptr<VolumeGroupInfo>> volumeGroups_; 349 std::vector<sptr<InterruptGroupInfo>> interruptGroups_; 350 std::unordered_map<std::string, std::string> volumeGroupData_; 351 std::unordered_map<std::string, std::string> interruptGroupData_; 352 }; 353 } // namespace AudioStandard 354 } // namespace OHOS 355 356 #endif // ST_AUDIO_POLICY_SERVICE_H 357