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 108 private: 109 static constexpr int32_t ZONEID_DEFAULT = 0; 110 static constexpr float DUCK_FACTOR = 0.2f; 111 static constexpr int32_t DEFAULT_APP_PID = -1; 112 static constexpr int64_t OFFLOAD_NO_SESSION_ID = -1; 113 static constexpr uid_t UID_AUDIO = 1041; 114 static constexpr int32_t STREAM_DEFAULT_PRIORITY = 100; 115 std::mutex audioServerProxyMutex_; 116 117 // Inner class for death handler 118 class AudioInterruptDeathRecipient : public IRemoteObject::DeathRecipient { 119 public: 120 explicit AudioInterruptDeathRecipient( 121 const std::shared_ptr<AudioInterruptService> &service, 122 uint32_t sessionId); 123 virtual ~AudioInterruptDeathRecipient() = default; 124 125 DISALLOW_COPY_AND_MOVE(AudioInterruptDeathRecipient); 126 127 void OnRemoteDied(const wptr<IRemoteObject> &remote); 128 129 private: 130 const std::weak_ptr<AudioInterruptService> service_; 131 const uint32_t sessionId_; 132 }; 133 134 // Inner class for callback 135 class AudioInterruptClient { 136 public: 137 explicit AudioInterruptClient( 138 const std::shared_ptr<AudioInterruptCallback> &callback, 139 const sptr<IRemoteObject> &object, 140 const sptr<AudioInterruptDeathRecipient> &deathRecipient); 141 virtual ~AudioInterruptClient(); 142 143 DISALLOW_COPY_AND_MOVE(AudioInterruptClient); 144 145 void OnInterrupt(const InterruptEventInternal &interruptEvent); 146 147 void SetCallingUid(uint32_t uid); 148 uint32_t GetCallingUid(); 149 150 private: 151 const std::shared_ptr<AudioInterruptCallback> callback_; 152 const sptr<IRemoteObject> object_; 153 sptr<AudioInterruptDeathRecipient> deathRecipient_; 154 uint32_t callingUid_ = 0; 155 }; 156 157 // deprecated interrupt interfaces 158 void NotifyFocusGranted(const int32_t clientId, const AudioInterrupt &audioInterrupt); 159 int32_t NotifyFocusAbandoned(const int32_t clientId, const AudioInterrupt &audioInterrupt); 160 int32_t AbandonAudioFocusInternal(const int32_t clientId, const AudioInterrupt &audioInterrupt); 161 162 // modern interrupt interfaces 163 void ProcessAudioScene(const AudioInterrupt &audioInterrupt, const uint32_t &incomingSessionId, 164 const int32_t &zoneId, bool &shouldReturnSuccess); 165 bool IsAudioSourceConcurrency(const SourceType &existSourceType, const SourceType &incomingSourceType, 166 const std::vector<SourceType> &existConcurrentSources, 167 const std::vector<SourceType> &incomingConcurrentSources); 168 int32_t ProcessFocusEntry(const int32_t zoneId, const AudioInterrupt &incomingInterrupt); 169 void SendInterruptEventToIncomingStream(InterruptEventInternal &interruptEvent, 170 const AudioInterrupt &incomingInterrupt); 171 void AddToAudioFocusInfoList(std::shared_ptr<AudioInterruptZone> &audioInterruptZone, 172 const int32_t &zoneId, const AudioInterrupt &incomingInterrupt, const AudioFocuState &incomingState); 173 void HandleIncomingState(const int32_t &zoneId, AudioFocuState &incomingState, 174 InterruptEventInternal &interruptEvent, const AudioInterrupt &incomingInterrupt); 175 void ProcessExistInterrupt(std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator 176 &iterActive, AudioFocusEntry &focusEntry, const AudioInterrupt &incomingInterrupt, 177 bool &removeFocusInfo, InterruptEventInternal &interruptEvent); 178 void ProcessActiveInterrupt(const int32_t zoneId, const AudioInterrupt &incomingInterrupt); 179 void ResumeAudioFocusList(const int32_t zoneId, bool isSessionTimeout = false); 180 bool EvaluateWhetherContinue(const AudioInterrupt &incoming, const AudioInterrupt 181 &inprocessing, AudioFocusEntry &focusEntry, bool bConcurrency); 182 std::list<std::pair<AudioInterrupt, AudioFocuState>> SimulateFocusEntry(const int32_t zoneId); 183 void SendActiveInterruptEvent(const uint32_t activeSessionId, const InterruptEventInternal &interruptEvent, 184 const AudioInterrupt &incomingInterrupt); 185 void DeactivateAudioInterruptInternal(const int32_t zoneId, const AudioInterrupt &audioInterrupt, 186 bool isSessionTimeout = false); 187 void SendInterruptEvent(AudioFocuState oldState, AudioFocuState newState, 188 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive, bool &removeFocusInfo); 189 bool IsSameAppInShareMode(const AudioInterrupt incomingInterrupt, const AudioInterrupt activeInterrupt); 190 void UpdateAudioSceneFromInterrupt(const AudioScene audioScene, AudioInterruptChangeType changeType); 191 void SendFocusChangeEvent(const int32_t zoneId, int32_t callbackCategory, const AudioInterrupt &audioInterrupt); 192 void RemoveClient(const int32_t zoneId, uint32_t sessionId); 193 194 // zone debug interfaces 195 bool CheckAudioInterruptZonePermission(); 196 int32_t CreateAudioInterruptZoneInternal(const int32_t zoneId, const std::set<int32_t> &pids); 197 int32_t HitZoneId(const std::set<int32_t> &pids, const std::shared_ptr<AudioInterruptZone> &audioInterruptZone, 198 const int32_t &zoneId, int32_t &hitZoneId, bool &haveSamePids); 199 int32_t HitZoneIdHaveTheSamePidsZone(const std::set<int32_t> &pids, int32_t &hitZoneId); 200 int32_t DealAudioInterruptZoneData(const int32_t pid, 201 const std::shared_ptr<AudioInterruptZone> &audioInterruptZoneTmp, 202 std::shared_ptr<AudioInterruptZone> &audioInterruptZone); 203 int32_t NewAudioInterruptZoneByPids(std::shared_ptr<AudioInterruptZone> &audioInterruptZone, 204 const std::set<int32_t> &pids, const int32_t &zoneId); 205 int32_t ArchiveToNewAudioInterruptZone(const int32_t &fromZoneId, const int32_t &toZoneId); 206 void WriteFocusMigrateEvent(const int32_t &toZoneId); 207 void WriteServiceStartupError(); 208 209 // interfaces about audio session. 210 void AddActiveInterruptToSession(const int32_t callerPid); 211 void RemovePlaceholderInterruptForSession(const int32_t callerPid, bool isSessionTimeout = false); 212 bool CanMixForSession(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, 213 const AudioFocusEntry &focusEntry); 214 bool CanMixForIncomingSession(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, 215 const AudioFocusEntry &focusEntry); 216 bool CanMixForActiveSession(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt, 217 const AudioFocusEntry &focusEntry); 218 bool IsIncomingStreamLowPriority(const AudioFocusEntry &focusEntry); 219 bool IsActiveStreamLowPriority(const AudioFocusEntry &focusEntry); 220 void UpdateHintTypeForExistingSession(const AudioInterrupt &incomingInterrupt, AudioFocusEntry &focusEntry); 221 void HandleSessionTimeOutEvent(const int32_t pid); 222 void HandleLowPriorityEvent(const int32_t pid, const uint32_t streamId); 223 void SendSessionTimeOutStopEvent(const int32_t zoneId, const AudioInterrupt &audioInterrupt, 224 const std::list<std::pair<AudioInterrupt, AudioFocuState>> &audioFocusInfoList); 225 bool ShouldCallbackToClient(uint32_t uid, int32_t sessionId, InterruptEventInternal &interruptEvent); 226 227 bool IsCanMixInterrupt(const AudioInterrupt &incomingInterrupt, const AudioInterrupt &activeInterrupt); 228 bool HadVoipStatus(const AudioInterrupt &audioInterrupt, const std::list<std::pair<AudioInterrupt, AudioFocuState>> 229 &audioFocusInfoList); 230 231 // interrupt members 232 sptr<AudioPolicyServer> policyServer_; 233 std::shared_ptr<AudioPolicyServerHandler> handler_; 234 std::shared_ptr<AudioSessionService> sessionService_; 235 236 std::map<std::pair<AudioFocusType, AudioFocusType>, AudioFocusEntry> focusCfgMap_ = {}; 237 std::unordered_map<int32_t, std::shared_ptr<AudioInterruptZone>> zonesMap_; 238 239 std::map<int32_t, std::shared_ptr<AudioInterruptClient>> interruptClients_; 240 241 // deprecated interrupt members 242 std::unique_ptr<AudioInterrupt> focussedAudioInterruptInfo_; 243 int32_t clientOnFocus_ = 0; 244 245 std::mutex mutex_; 246 }; 247 } // namespace AudioStandard 248 } // namespace OHOS 249 250 #endif // ST_AUDIO_INTERRUPT_SERVICE_H 251