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