1 /* 2 * Copyright (c) 2024 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_INTERRUPT_SERVICE_H 17 #define ST_AUDIO_INTERRUPT_SERVICE_H 18 19 #include <mutex> 20 21 #include "iremote_object.h" 22 23 #include "i_audio_interrupt_event_dispatcher.h" 24 #include "audio_interrupt_info.h" 25 #include "audio_policy_server_handler.h" 26 #include "audio_policy_server.h" 27 #include "audio_session_service.h" 28 #include "client_type_manager.h" 29 30 namespace OHOS { 31 namespace AudioStandard { 32 33 typedef struct { 34 int32_t zoneId; // Zone ID value should 0 on local device. 35 std::set<int32_t> pids; // When Zone ID is 0, there does not need to be a value. 36 std::set<uint32_t> interruptCbSessionIdsMap; 37 std::set<int32_t> audioPolicyClientProxyCBClientPidMap; 38 std::unordered_map<uint32_t /* sessionID */, std::shared_ptr<AudioInterruptCallback>> interruptCbsMap; 39 std::unordered_map<int32_t /* clientPid */, sptr<IAudioPolicyClient>> audioPolicyClientProxyCBMap; 40 std::list<std::pair<AudioInterrupt, AudioFocuState>> audioFocusInfoList; 41 } AudioInterruptZone; 42 43 class AudioPolicyServerHandler; 44 45 class SessionTimeOutCallback; 46 47 class AudioInterruptService : public std::enable_shared_from_this<AudioInterruptService>, 48 public IAudioInterruptEventDispatcher, 49 public SessionTimeOutCallback { 50 public: 51 AudioInterruptService(); 52 virtual ~AudioInterruptService(); 53 54 const sptr<IStandardAudioService> GetAudioServerProxy(); 55 56 // callback run in handler thread 57 void DispatchInterruptEventWithSessionId( 58 uint32_t sessionId, InterruptEventInternal &interruptEvent) override; 59 60 void Init(sptr<AudioPolicyServer> server); 61 void AddDumpInfo(std::unordered_map<int32_t, std::shared_ptr<AudioInterruptZone>> &audioInterruptZonesMapDump); 62 void SetCallbackHandler(std::shared_ptr<AudioPolicyServerHandler> handler); 63 64 // interfaces of SessionTimeOutCallback 65 void OnSessionTimeout(const int32_t pid) override; 66 67 // interfaces for AudioSessionService 68 int32_t ActivateAudioSession(const int32_t callerPid, const AudioSessionStrategy &strategy); 69 int32_t DeactivateAudioSession(const int32_t callerPid); 70 bool IsAudioSessionActivated(const int32_t callerPid); 71 72 // deprecated interrupt interfaces 73 int32_t SetAudioManagerInterruptCallback(const sptr<IRemoteObject> &object); 74 int32_t UnsetAudioManagerInterruptCallback(); 75 int32_t RequestAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt); 76 int32_t AbandonAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt); 77 78 // modern interrupt interfaces 79 int32_t SetAudioInterruptCallback(const int32_t zoneId, const uint32_t sessionId, 80 const sptr<IRemoteObject> &object, uint32_t uid); 81 int32_t UnsetAudioInterruptCallback(const int32_t zoneId, const uint32_t sessionId); 82 bool AudioInterruptIsActiveInFocusList(const int32_t zoneId, const uint32_t incomingSessionId); 83 int32_t ActivateAudioInterrupt( 84 const int32_t zoneId, const AudioInterrupt &audioInterrupt, const bool isUpdatedAudioStrategy = false); 85 int32_t DeactivateAudioInterrupt(const int32_t zoneId, const AudioInterrupt &audioInterrupt); 86 void ResetNonInterruptControl(uint32_t sessionId); 87 88 // zone debug interfaces 89 int32_t CreateAudioInterruptZone(const int32_t zoneId, const std::set<int32_t> &pids); 90 int32_t ReleaseAudioInterruptZone(const int32_t zoneId); 91 int32_t AddAudioInterruptZonePids(const int32_t zoneId, const std::set<int32_t> &pids); 92 int32_t RemoveAudioInterruptZonePids(const int32_t zoneId, const std::set<int32_t> &pids); 93 94 int32_t GetAudioFocusInfoList(const int32_t zoneId, 95 std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList); 96 int32_t SetAudioFocusInfoCallback(const int32_t zoneId, const sptr<IRemoteObject> &object); 97 int32_t GetStreamTypePriority(AudioStreamType streamType); 98 unordered_map<AudioStreamType, int> GetStreamPriorityMap() const; 99 AudioStreamType GetStreamInFocus(const int32_t zoneId); 100 int32_t GetSessionInfoInFocus(AudioInterrupt &audioInterrupt, const int32_t zoneId); 101 102 void ClearAudioFocusInfoListOnAccountsChanged(const int &id); 103 104 void AudioInterruptZoneDump(std::string &dumpString); 105 AudioScene GetHighestPriorityAudioScene(const int32_t zoneId) const; 106 ClientType GetClientTypeBySessionId(int32_t sessionId); 107 void ProcessRemoteInterrupt(std::set<int32_t> sessionIds, InterruptEventInternal interruptEvent); 108 109 private: 110 static constexpr int32_t ZONEID_DEFAULT = 0; 111 static constexpr float DUCK_FACTOR = 0.2f; 112 static constexpr int32_t DEFAULT_APP_PID = -1; 113 static constexpr int64_t OFFLOAD_NO_SESSION_ID = -1; 114 static constexpr uid_t UID_AUDIO = 1041; 115 static constexpr int32_t STREAM_DEFAULT_PRIORITY = 100; 116 std::mutex audioServerProxyMutex_; 117 118 // Inner class for death handler 119 class AudioInterruptDeathRecipient : public IRemoteObject::DeathRecipient { 120 public: 121 explicit AudioInterruptDeathRecipient( 122 const std::shared_ptr<AudioInterruptService> &service, 123 uint32_t sessionId); 124 virtual ~AudioInterruptDeathRecipient() = default; 125 126 DISALLOW_COPY_AND_MOVE(AudioInterruptDeathRecipient); 127 128 void OnRemoteDied(const wptr<IRemoteObject> &remote); 129 130 private: 131 const std::weak_ptr<AudioInterruptService> service_; 132 const uint32_t sessionId_; 133 }; 134 135 // Inner class for callback 136 class AudioInterruptClient { 137 public: 138 explicit AudioInterruptClient( 139 const std::shared_ptr<AudioInterruptCallback> &callback, 140 const sptr<IRemoteObject> &object, 141 const sptr<AudioInterruptDeathRecipient> &deathRecipient); 142 virtual ~AudioInterruptClient(); 143 144 DISALLOW_COPY_AND_MOVE(AudioInterruptClient); 145 146 void OnInterrupt(const InterruptEventInternal &interruptEvent); 147 148 void SetCallingUid(uint32_t uid); 149 uint32_t GetCallingUid(); 150 151 private: 152 const std::shared_ptr<AudioInterruptCallback> callback_; 153 const sptr<IRemoteObject> object_; 154 sptr<AudioInterruptDeathRecipient> deathRecipient_; 155 uint32_t callingUid_ = 0; 156 }; 157 158 // deprecated interrupt interfaces 159 void NotifyFocusGranted(const int32_t clientId, const AudioInterrupt &audioInterrupt); 160 int32_t NotifyFocusAbandoned(const int32_t clientId, const AudioInterrupt &audioInterrupt); 161 int32_t AbandonAudioFocusInternal(const int32_t clientId, const AudioInterrupt &audioInterrupt); 162 163 // modern interrupt interfaces 164 void ProcessAudioScene(const AudioInterrupt &audioInterrupt, const uint32_t &incomingSessionId, 165 const int32_t &zoneId, bool &shouldReturnSuccess); 166 bool IsAudioSourceConcurrency(const SourceType &existSourceType, const SourceType &incomingSourceType, 167 const std::vector<SourceType> &existConcurrentSources, 168 const std::vector<SourceType> &incomingConcurrentSources); 169 int32_t ProcessFocusEntry(const int32_t zoneId, const AudioInterrupt &incomingInterrupt); 170 void SendInterruptEventToIncomingStream(InterruptEventInternal &interruptEvent, 171 const AudioInterrupt &incomingInterrupt); 172 void AddToAudioFocusInfoList(std::shared_ptr<AudioInterruptZone> &audioInterruptZone, 173 const int32_t &zoneId, const AudioInterrupt &incomingInterrupt, const AudioFocuState &incomingState); 174 void HandleIncomingState(const int32_t &zoneId, AudioFocuState &incomingState, 175 InterruptEventInternal &interruptEvent, const AudioInterrupt &incomingInterrupt); 176 void ProcessExistInterrupt(std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator 177 &iterActive, AudioFocusEntry &focusEntry, const AudioInterrupt &incomingInterrupt, 178 bool &removeFocusInfo, InterruptEventInternal &interruptEvent); 179 void ProcessActiveInterrupt(const int32_t zoneId, const AudioInterrupt &incomingInterrupt); 180 void ResumeAudioFocusList(const int32_t zoneId, bool isSessionTimeout = false); 181 bool EvaluateWhetherContinue(const AudioInterrupt &incoming, const AudioInterrupt 182 &inprocessing, AudioFocusEntry &focusEntry, bool bConcurrency); 183 std::list<std::pair<AudioInterrupt, AudioFocuState>> SimulateFocusEntry(const int32_t zoneId); 184 void SendActiveInterruptEvent(const uint32_t activeSessionId, const InterruptEventInternal &interruptEvent, 185 const AudioInterrupt &incomingInterrupt); 186 void DeactivateAudioInterruptInternal(const int32_t zoneId, const AudioInterrupt &audioInterrupt, 187 bool isSessionTimeout = false); 188 void SendInterruptEvent(AudioFocuState oldState, AudioFocuState newState, 189 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive, bool &removeFocusInfo); 190 bool IsSameAppInShareMode(const AudioInterrupt incomingInterrupt, const AudioInterrupt activeInterrupt); 191 void UpdateAudioSceneFromInterrupt(const AudioScene audioScene, AudioInterruptChangeType changeType); 192 void SendFocusChangeEvent(const int32_t zoneId, int32_t callbackCategory, const AudioInterrupt &audioInterrupt); 193 void RemoveClient(const int32_t zoneId, uint32_t sessionId); 194 195 // zone debug interfaces 196 bool CheckAudioInterruptZonePermission(); 197 int32_t CreateAudioInterruptZoneInternal(const int32_t zoneId, const std::set<int32_t> &pids); 198 int32_t HitZoneId(const std::set<int32_t> &pids, const std::shared_ptr<AudioInterruptZone> &audioInterruptZone, 199 const int32_t &zoneId, int32_t &hitZoneId, bool &haveSamePids); 200 int32_t HitZoneIdHaveTheSamePidsZone(const std::set<int32_t> &pids, int32_t &hitZoneId); 201 int32_t DealAudioInterruptZoneData(const int32_t pid, 202 const std::shared_ptr<AudioInterruptZone> &audioInterruptZoneTmp, 203 std::shared_ptr<AudioInterruptZone> &audioInterruptZone); 204 int32_t NewAudioInterruptZoneByPids(std::shared_ptr<AudioInterruptZone> &audioInterruptZone, 205 const std::set<int32_t> &pids, const int32_t &zoneId); 206 int32_t ArchiveToNewAudioInterruptZone(const int32_t &fromZoneId, const int32_t &toZoneId); 207 void WriteFocusMigrateEvent(const int32_t &toZoneId); 208 void WriteServiceStartupError(); 209 210 // interfaces about audio session. 211 void AddActiveInterruptToSession(const int32_t callerPid); 212 void RemovePlaceholderInterruptForSession(const int32_t callerPid, bool isSessionTimeout = false); 213 bool CanMixForSession(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, 214 const AudioFocusEntry &focusEntry); 215 bool CanMixForIncomingSession(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, 216 const AudioFocusEntry &focusEntry); 217 bool CanMixForActiveSession(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, 218 const AudioFocusEntry &focusEntry); 219 bool IsIncomingStreamLowPriority(const AudioFocusEntry &focusEntry); 220 bool IsActiveStreamLowPriority(const AudioFocusEntry &focusEntry); 221 void UpdateHintTypeForExistingSession(const AudioInterrupt &incomingInterrupt, AudioFocusEntry &focusEntry); 222 void HandleSessionTimeOutEvent(const int32_t pid); 223 void HandleLowPriorityEvent(const int32_t pid, const uint32_t streamId); 224 void SendSessionTimeOutStopEvent(const int32_t zoneId, const AudioInterrupt &audioInterrupt, 225 const std::list<std::pair<AudioInterrupt, AudioFocuState>> &audioFocusInfoList); 226 bool ShouldCallbackToClient(uint32_t uid, int32_t sessionId, InterruptEventInternal &interruptEvent); 227 228 bool IsCanMixInterrupt(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt); 229 bool HadVoipStatus(const AudioInterrupt &audioInterrupt, const std::list<std::pair<AudioInterrupt, AudioFocuState>> 230 &audioFocusInfoList); 231 232 bool CheckAudioSessionExistence(const AudioInterrupt &incomingInterrupt, AudioFocusEntry &focusEntry); 233 234 void SwitchHintType(std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive, 235 InterruptEventInternal &interruptEvent, std::list<std::pair<AudioInterrupt, AudioFocuState>> &tmpFocusInfoList); 236 237 bool IsHandleIter(std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive, 238 AudioFocuState oldState, std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterNew); 239 240 // interrupt members 241 sptr<AudioPolicyServer> policyServer_; 242 std::shared_ptr<AudioPolicyServerHandler> handler_; 243 std::shared_ptr<AudioSessionService> sessionService_; 244 245 std::map<std::pair<AudioFocusType, AudioFocusType>, AudioFocusEntry> focusCfgMap_ = {}; 246 std::unordered_map<int32_t, std::shared_ptr<AudioInterruptZone>> zonesMap_; 247 248 std::map<int32_t, std::shared_ptr<AudioInterruptClient>> interruptClients_; 249 250 // deprecated interrupt members 251 std::unique_ptr<AudioInterrupt> focussedAudioInterruptInfo_; 252 int32_t clientOnFocus_ = 0; 253 254 std::mutex mutex_; 255 }; 256 } // namespace AudioStandard 257 } // namespace OHOS 258 259 #endif // ST_AUDIO_INTERRUPT_SERVICE_H 260