1 /* 2 * Copyright (c) 2023-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 AUDIO_SERVICE_H 17 #define AUDIO_SERVICE_H 18 19 #include <condition_variable> 20 #include <sstream> 21 #include <set> 22 #include <map> 23 #include <mutex> 24 #include <vector> 25 26 #ifdef SUPPORT_LOW_LATENCY 27 #include "audio_process_in_server.h" 28 #include "audio_endpoint.h" 29 #endif 30 31 #include "i_audio_process_stream.h" 32 #include "audio_info.h" 33 #include "audio_device_descriptor.h" 34 #include "ipc_stream_in_server.h" 35 #include "playback_capturer_filter_listener.h" 36 37 namespace OHOS { 38 namespace AudioStandard { 39 namespace { 40 enum InnerCapFilterPolicy : uint32_t { 41 POLICY_INVALID = 0, 42 POLICY_USAGES_ONLY, 43 POLICY_USAGES_AND_PIDS 44 }; 45 46 enum ReuseEndpointType : uint32_t { 47 CREATE_ENDPOINT = 0, 48 RECREATE_ENDPOINT, 49 REUSE_ENDPOINT, 50 }; 51 } // anonymous namespace 52 53 using MuteStateChangeCallbck = std::function<void(bool)>; 54 55 #ifdef SUPPORT_LOW_LATENCY 56 class AudioService : public ProcessReleaseCallback, public ICapturerFilterListener 57 #else 58 class AudioService : public ICapturerFilterListener 59 #endif 60 { 61 public: 62 static AudioService *GetInstance(); 63 ~AudioService(); 64 65 // override for ICapturerFilterListener 66 int32_t OnCapturerFilterChange(uint32_t sessionId, const AudioPlaybackCaptureConfig &newConfig, 67 int32_t innerCapId) override; 68 int32_t OnCapturerFilterRemove(uint32_t sessionId, int32_t innerCapId) override; 69 void InitAllDupBuffer(int32_t innerCapId) override; 70 71 void SaveForegroundList(std::vector<std::string> list); 72 // if match, keep uid for speed up, used in create process. 73 bool MatchForegroundList(const std::string &bundleName, uint32_t uid); 74 // used in start process. 75 bool InForegroundList(uint32_t uid); 76 bool UpdateForegroundState(uint32_t appTokenId, bool isActive); 77 void DumpForegroundList(std::string &dumpString); 78 void SaveRenderWhitelist(std::vector<std::string> list); 79 bool InRenderWhitelist(const std::string bundleName); 80 81 int32_t GetStandbyStatus(uint32_t sessionId, bool &isStandby, int64_t &enterStandbyTime); 82 sptr<IpcStreamInServer> GetIpcStream(const AudioProcessConfig &config, int32_t &ret); 83 int32_t NotifyStreamVolumeChanged(AudioStreamType streamType, float volume); 84 85 #ifdef SUPPORT_LOW_LATENCY 86 sptr<AudioProcessInServer> GetAudioProcess(const AudioProcessConfig &config); 87 // override for ProcessReleaseCallback, do release process work. 88 int32_t OnProcessRelease(IAudioProcessStream *process, bool isSwitchStream = false) override; 89 void ReleaseProcess(const std::string endpointName, const int32_t delayTime); 90 91 void CheckBeforeRecordEndpointCreate(bool isRecord); 92 AudioDeviceDescriptor GetDeviceInfoForProcess(const AudioProcessConfig &config, 93 AudioStreamInfo &streamInfo, bool isReloadProcess = false); 94 std::shared_ptr<AudioEndpoint> GetAudioEndpointForDevice(AudioDeviceDescriptor &deviceInfo, 95 const AudioProcessConfig &clientConfig, AudioStreamInfo &streamInfo, bool isVoipStream); 96 97 int32_t LinkProcessToEndpoint(sptr<AudioProcessInServer> process, std::shared_ptr<AudioEndpoint> endpoint); 98 int32_t UnlinkProcessToEndpoint(sptr<AudioProcessInServer> process, std::shared_ptr<AudioEndpoint> endpoint); 99 void ResetAudioEndpoint(); 100 #endif 101 102 void Dump(std::string &dumpString); 103 float GetMaxAmplitude(bool isOutputDevice); 104 105 void RemoveRenderer(uint32_t sessionId, bool isSwitchStream = false); 106 void RemoveCapturer(uint32_t sessionId, bool isSwitchStream = false); 107 int32_t EnableDualToneList(uint32_t sessionId); 108 int32_t DisableDualToneList(uint32_t sessionId); 109 int32_t SetOffloadMode(uint32_t sessionId, int32_t state, bool isAppBack); 110 int32_t UnsetOffloadMode(uint32_t sessionId); 111 void UpdateAudioSinkState(uint32_t sinkId, bool started); 112 void CheckHibernateState(bool onHibernate); 113 bool GetHibernateState(); 114 std::shared_ptr<RendererInServer> GetRendererBySessionID(const uint32_t &session); 115 std::shared_ptr<CapturerInServer> GetCapturerBySessionID(const uint32_t &session); 116 void SetNonInterruptMute(const uint32_t SessionId, const bool muteFlag); 117 void SetNonInterruptMuteForProcess(const uint32_t SessionId, const bool muteFlag); 118 void UpdateMuteControlSet(uint32_t sessionId, bool muteFlag); 119 int32_t UpdateSourceType(SourceType sourceType); 120 void SetIncMaxRendererStreamCnt(AudioMode audioMode); 121 int32_t GetCurrentRendererStreamCnt(); 122 void SetDecMaxRendererStreamCnt(); 123 int32_t GetCurrentLoopbackStreamCnt(AudioMode audioMode); 124 void SetIncMaxLoopbackStreamCnt(AudioMode audioMode); 125 void SetDecMaxLoopbackStreamCnt(AudioMode audioMode); 126 void DisableLoopback(); 127 bool IsExceedingMaxStreamCntPerUid(int32_t callingUid, int32_t appUid, int32_t maxStreamCntPerUid); 128 void GetCreatedAudioStreamMostUid(int32_t &mostAppUid, int32_t &mostAppNum); 129 void CleanAppUseNumMap(int32_t appUid); 130 bool HasBluetoothEndpoint(); 131 void GetAllSinkInputs(std::vector<SinkInput> &sinkInputs); 132 void SetDefaultAdapterEnable(bool isEnable); 133 bool GetDefaultAdapterEnable(); 134 RestoreStatus RestoreSession(uint32_t sessionId, RestoreInfo restoreInfo); 135 int32_t ForceStopAudioStream(StopAudioType audioType); 136 void SaveAdjustStreamVolumeInfo(float volume, uint32_t sessionId, std::string adjustTime, uint32_t code); 137 void RegisterMuteStateChangeCallback(uint32_t sessionId, const MuteStateChangeCallbck &callback); 138 void SetSessionMuteState(const uint32_t sessionId, const bool insert, const bool muteFlag); 139 void SetLatestMuteState(const uint32_t sessionId, const bool muteFlag); 140 #ifdef HAS_FEATURE_INNERCAPTURER 141 int32_t UnloadModernInnerCapSink(int32_t innerCapId); 142 #endif 143 void RenderersCheckForAudioWorkgroup(int32_t pid); 144 145 private: 146 AudioService(); 147 void DelayCallReleaseEndpoint(std::string endpointName); 148 ReuseEndpointType GetReuseEndpointType(AudioDeviceDescriptor &deviceInfo, 149 const std::string &deviceKey, AudioStreamInfo &streamInfo); 150 void InsertRenderer(uint32_t sessionId, std::shared_ptr<RendererInServer> renderer); 151 void InsertCapturer(uint32_t sessionId, std::shared_ptr<CapturerInServer> capturer); 152 #ifdef HAS_FEATURE_INNERCAPTURER 153 // for inner-capturer 154 void CheckInnerCapForRenderer(uint32_t sessionId, std::shared_ptr<RendererInServer> renderer); 155 #ifdef SUPPORT_LOW_LATENCY 156 void CheckInnerCapForProcess(sptr<AudioProcessInServer> process, std::shared_ptr<AudioEndpoint> endpoint); 157 void FilterAllFastProcess(); 158 int32_t CheckDisableFastInner(std::shared_ptr<AudioEndpoint> endpoint); 159 int32_t HandleFastCapture(std::set<int32_t> captureIds, sptr<AudioProcessInServer> audioProcessInServer, 160 std::shared_ptr<AudioEndpoint> audioEndpoint); 161 162 void CheckFastSessionMuteState(uint32_t sessionId, sptr<AudioProcessInServer> process); 163 int32_t GetReleaseDelayTime(std::shared_ptr<AudioEndpoint> endpoint, bool isSwitchStream, bool isRecord); 164 #endif 165 InnerCapFilterPolicy GetInnerCapFilterPolicy(int32_t innerCapId); 166 bool ShouldBeInnerCap(const AudioProcessConfig &rendererConfig, int32_t innerCapId); 167 bool ShouldBeInnerCap(const AudioProcessConfig &rendererConfig, std::set<int32_t> &beCapIds); 168 bool CheckShouldCap(const AudioProcessConfig &rendererConfig, int32_t innerCapId); 169 #endif 170 bool ShouldBeDualTone(const AudioProcessConfig &config); 171 #ifdef HAS_FEATURE_INNERCAPTURER 172 int32_t OnInitInnerCapList(int32_t innerCapId); // for first InnerCap filter take effect. 173 int32_t OnUpdateInnerCapList(int32_t innerCapId); // for some InnerCap filter has already take effect. 174 #endif 175 bool IsEndpointTypeVoip(const AudioProcessConfig &config, AudioDeviceDescriptor &deviceInfo); 176 void RemoveIdFromMuteControlSet(uint32_t sessionId); 177 void CheckRenderSessionMuteState(uint32_t sessionId, std::shared_ptr<RendererInServer> renderer); 178 void CheckCaptureSessionMuteState(uint32_t sessionId, std::shared_ptr<CapturerInServer> capturer); 179 void ReLinkProcessToEndpoint(); 180 void AddFilteredRender(int32_t innerCapId, std::shared_ptr<RendererInServer> renderer); 181 bool IsMuteSwitchStream(uint32_t sessionId); 182 float GetSystemVolume(); 183 void UpdateSystemVolume(AudioStreamType streamType, float volume); 184 185 private: 186 std::mutex foregroundSetMutex_; 187 std::set<std::string> foregroundSet_; 188 std::set<uint32_t> foregroundUidSet_; 189 std::mutex processListMutex_; 190 std::mutex releaseEndpointMutex_; 191 std::condition_variable releaseEndpointCV_; 192 std::set<std::string> releasingEndpointSet_; 193 std::mutex renderWhitelistMutex_; 194 std::set<std::string> renderWhitelist_; 195 196 #ifdef SUPPORT_LOW_LATENCY 197 std::vector<std::pair<sptr<AudioProcessInServer>, std::shared_ptr<AudioEndpoint>>> linkedPairedList_; 198 std::map<std::string, std::shared_ptr<AudioEndpoint>> endpointList_; 199 #endif 200 201 // for inner-capturer 202 bool isRegisterCapturerFilterListened_ = false; 203 bool isDefaultAdapterEnable_ = false; 204 uint32_t workingDualToneId_ = 0; // invalid sessionId 205 AudioPlaybackCaptureConfig workingConfig_; 206 std::unordered_map<int32_t, AudioPlaybackCaptureConfig> workingConfigs_; 207 208 std::mutex rendererMapMutex_; 209 std::mutex capturerMapMutex_; 210 std::mutex muteSwitchStreamSetMutex_; 211 std::mutex workingConfigsMutex_; 212 std::unordered_map<int32_t, std::vector<std::weak_ptr<RendererInServer>>> filteredRendererMap_ = {}; 213 std::map<uint32_t, std::weak_ptr<RendererInServer>> allRendererMap_ = {}; 214 std::map<uint32_t, std::weak_ptr<CapturerInServer>> allCapturerMap_ = {}; 215 216 std::vector<std::weak_ptr<RendererInServer>> filteredDualToneRendererMap_ = {}; 217 218 std::mutex mutedSessionsMutex_; 219 std::set<uint32_t> mutedSessions_ = {}; 220 int32_t currentRendererStreamCnt_ = 0; 221 int32_t currentLoopbackRendererStreamCnt_ = 0; 222 int32_t currentLoopbackCapturerStreamCnt_ = 0; 223 std::mutex streamLifeCycleMutex_ {}; 224 std::map<int32_t, std::int32_t> appUseNumMap_; 225 std::mutex allRunningSinksMutex_; 226 std::condition_variable allRunningSinksCV_; 227 std::set<uint32_t> allRunningSinks_; 228 bool onHibernate_ = false; 229 std::set<uint32_t> muteSwitchStreams_ = {}; 230 std::map<uint32_t, MuteStateChangeCallbck> muteStateCallbacks_{}; 231 std::mutex muteStateMapMutex_; 232 std::map<uint32_t, bool> muteStateMap_{}; 233 std::mutex musicOrVoipSystemVolumeMutex_; 234 float musicOrVoipSystemVolume_ = 0.0f; 235 }; 236 } // namespace AudioStandard 237 } // namespace OHOS 238 #endif // AUDIO_SERVICE_H 239