• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 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 OHOS_AVSESSION_SERVICE_H
17 #define OHOS_AVSESSION_SERVICE_H
18 
19 #include <atomic>
20 #include <mutex>
21 #include <map>
22 
23 #include "iremote_stub.h"
24 #include "system_ability.h"
25 #include "audio_info.h"
26 #include "avsession_service_stub.h"
27 #include "avsession_item.h"
28 #include "avcontroller_item.h"
29 #include "session_container.h"
30 #include "iclient_death.h"
31 #include "isession_listener.h"
32 #include "focus_session_strategy.h"
33 #include "background_audio_controller.h"
34 #include "ability_manager_adapter.h"
35 #include "device_manager.h"
36 #include "dm_device_info.h"
37 #include "audio_adapter.h"
38 #include "remote_session_command_process.h"
39 #include "i_avsession_service_listener.h"
40 
41 namespace OHOS::AVSession {
42 class AVSessionDumper;
43 class AVSessionInitDMCallback : public OHOS::DistributedHardware::DmInitCallback {
44 public:
45     AVSessionInitDMCallback() = default;
46     ~AVSessionInitDMCallback() override = default;
OnRemoteDied()47     void OnRemoteDied() override {};
48 };
49 
50 class AudioDeviceDescriptorComp {
51 public:
operator()52     bool operator()(const AudioStandard::AudioDeviceDescriptor& left,
53                     const AudioStandard::AudioDeviceDescriptor& right) const
54     {
55         return left.networkId_ == right.networkId_;
56     }
57 };
58 
59 class AVSessionService : public SystemAbility, public AVSessionServiceStub, public IAVSessionServiceListener {
60     DECLARE_SYSTEM_ABILITY(AVSessionService);
61 
62 public:
63     DISALLOW_COPY_AND_MOVE(AVSessionService);
64 
65     explicit AVSessionService(int32_t systemAbilityId, bool runOnCreate = true);
66 
67     ~AVSessionService() override;
68 
69     void OnDump() override;
70 
71     void OnStart() override;
72 
73     void OnStop() override;
74 
75     void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
76 
77     sptr<IRemoteObject> CreateSessionInner(const std::string& tag, int32_t type,
78                                            const AppExecFwk::ElementName& elementName) override;
79 
80     int32_t GetAllSessionDescriptors(std::vector<AVSessionDescriptor>& descriptors) override;
81 
82     int32_t GetSessionDescriptorsBySessionId(const std::string& sessionId, AVSessionDescriptor& descriptor) override;
83 
84     int32_t GetHistoricalSessionDescriptors(int32_t maxSize, std::vector<AVSessionDescriptor>& descriptors) override;
85 
86     int32_t CreateControllerInner(const std::string& sessionId, sptr<IRemoteObject>& object) override;
87 
88 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
89     int32_t GetAVCastControllerInner(const std::string& sessionId, sptr<IRemoteObject>& object) override;
90 #endif
91 
92     int32_t RegisterSessionListener(const sptr<ISessionListener>& listener) override;
93 
94     int32_t SendSystemAVKeyEvent(const MMI::KeyEvent& keyEvent) override;
95 
96     int32_t SendSystemControlCommand(const AVControlCommand& command) override;
97 
98     int32_t RegisterClientDeathObserver(const sptr<IClientDeath>& observer) override;
99 
100     void OnClientDied(pid_t pid);
101 
102     void HandleSessionRelease(AVSessionItem& session);
103 
104     void HandleControllerRelease(AVControllerItem& controller);
105 
106     std::int32_t Dump(std::int32_t fd, const std::vector<std::u16string>& args) override;
107 
108     int32_t CastAudio(const SessionToken& token,
109                       const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors) override;
110 
111     int32_t CastAudioForAll(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors) override;
112 
NotifyAudioSessionCheckTrigger(const int32_t uid)113     void NotifyAudioSessionCheckTrigger(const int32_t uid)
114     {
115         return NotifyAudioSessionCheck(uid);
116     }
117 
118 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
119     void ReleaseCastSession() override;
120 
121     void CreateSessionByCast(const int64_t castHandle) override;
122 
123     void NotifyDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo) override;
124 
125     void NotifyDeviceOffline(const std::string& deviceId) override;
126 
127     int32_t StartCast(const SessionToken& sessionToken, const OutputDeviceInfo& outputDeviceInfo) override;
128 
129     int32_t StopCast(const SessionToken& sessionToken) override;
130 #endif
131 
132 private:
133     static SessionContainer& GetContainer();
134 
135     std::string AllocSessionId();
136 
137     bool AbilityHasSession(pid_t pid);
138 
139     sptr<AVControllerItem> GetPresentController(pid_t pid, const std::string& sessionId);
140 
141     void NotifySessionCreate(const AVSessionDescriptor& descriptor);
142     void NotifySessionRelease(const AVSessionDescriptor& descriptor);
143     void NotifyTopSessionChanged(const AVSessionDescriptor& descriptor);
144     void NotifyAudioSessionCheck(const int32_t uid);
145 
146     void AddClientDeathObserver(pid_t pid, const sptr<IClientDeath>& observer);
147     void RemoveClientDeathObserver(pid_t pid);
148 
149     void AddSessionListener(pid_t pid, const sptr<ISessionListener>& listener);
150     void RemoveSessionListener(pid_t pid);
151 
152     void AddInnerSessionListener(SessionListener* listener);
153 
154     sptr<AVSessionItem> SelectSessionByUid(const AudioStandard::AudioRendererChangeInfo& info);
155 
156     void OutputDeviceChangeListener(const AudioRendererChangeInfos& infos);
157 
158     sptr<AVSessionItem> CreateSessionInner(const std::string& tag, int32_t type, bool thirdPartyApp,
159                                            const AppExecFwk::ElementName& elementName);
160 
161     sptr<AVSessionItem> CreateNewSession(const std::string& tag, int32_t type, bool thirdPartyApp,
162                                          const AppExecFwk::ElementName& elementName);
163 
164     sptr<AVControllerItem> CreateNewControllerForSession(pid_t pid, sptr<AVSessionItem>& session);
165 
166     int32_t CancelCastAudioForClientExit(pid_t pid, const sptr<AVSessionItem>& session);
167 
168     void ClearSessionForClientDiedNoLock(pid_t pid);
169 
170     void ClearControllerForClientDiedNoLock(pid_t pid);
171 
172     void ClearSessionNoLock(const std::string& sessionId);
173 
174     void InitKeyEvent();
175 
176     void InitAudio();
177 
178     void InitAMS();
179 
180     void InitDM();
181 
182     void InitBMS();
183 
184     bool SelectFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo& info);
185 
186     void UpdateTopSession(const sptr<AVSessionItem>& newTopSession);
187 
188     void HandleFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo& info);
189 
190     sptr<RemoteSessionCommandProcess> GetService(const std::string& deviceId);
191 
192     int32_t CastAudioProcess(const std::vector<AudioStandard::AudioDeviceDescriptor>& descriptors,
193                              const std::string& sourceSessionInfo,
194                              sptr<AVSessionItem>& session);
195 
196     int32_t CastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors,
197                            const std::string& sourceSessionInfo,
198                            const sptr<AVSessionItem>& session);
199 
200     int32_t CancelCastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkDevices,
201                                  const std::string& sourceSessionInfo,
202                                  const sptr<AVSessionItem>& session);
203 
204     int32_t RemoteCastAudioInner(const std::string& sourceSessionInfo, std::string& sinkSessionInfo);
205 
206     int32_t RemoteCancelCastAudioInner(const std::string& sessionInfo);
207 
208     int32_t ProcessCastAudioCommand(const RemoteServiceCommand command, const std::string& input,
209                                     std::string& output) override;
210 
211     int32_t CastAudioForNewSession(const sptr<AVSessionItem>& session);
212 
213     bool IsLocalDevice(const std::string& networkId);
214 
215     int32_t GetLocalNetworkId(std::string& networkId);
216 
217     int32_t GetTrustedDeviceName(const std::string& networkId, std::string& deviceName);
218 
219     int32_t GetTrustedDevicesInfo(std::vector<OHOS::DistributedHardware::DmDeviceInfo>& deviceList);
220 
221     int32_t SetBasicInfo(std::string& sessionInfo);
222 
223     void SetDeviceInfo(const std::vector<AudioStandard::AudioDeviceDescriptor>& castAudioDescriptors,
224                            sptr<AVSessionItem>& session);
225 
226     int32_t GetAudioDescriptor(const std::string deviceId,
227                                std::vector<AudioStandard::AudioDeviceDescriptor>& audioDeviceDescriptors);
228 
229     bool GetAudioDescriptorByDeviceId(const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>>& descriptors,
230                                       const std::string& deviceId,
231                                       AudioStandard::AudioDeviceDescriptor& audioDescriptor);
232 
233     void GetDeviceInfo(const sptr<AVSessionItem>& session,
234                            const std::vector<AudioStandard::AudioDeviceDescriptor>& descriptors,
235                            std::vector<AudioStandard::AudioDeviceDescriptor>& castSinkDescriptors,
236                            std::vector<AudioStandard::AudioDeviceDescriptor>& cancelSinkDescriptors);
237 
238     int32_t SelectOutputDevice(const int32_t uid, const AudioStandard::AudioDeviceDescriptor& descriptor);
239 
240     int32_t StartDefaultAbilityByCall(std::string& sessionId);
241 
242     int32_t StartAbilityByCall(const std::string& sessionIdNeeded, std::string& sessionId);
243 
244     void HandleEventHandlerCallBack();
245 
246     bool IsHistoricalSession(const std::string& sessionId);
247 
248     void DeleteHistoricalRecord(const std::string& bundleName);
249 
250     const nlohmann::json& GetSubNode(const nlohmann::json& node, const std::string& name);
251 
252     void refreshSortFileOnCreateSession(const std::string& sessionId, const AppExecFwk::ElementName& elementName);
253 
254     bool LoadStringFromFileEx(const std::string& filePath, std::string& content);
255 
256     bool SaveStringToFileEx(const std::string& filePath, const std::string& content);
257 
258     std::atomic<uint32_t> sessionSeqNum_ {};
259 
260     std::recursive_mutex sessionAndControllerLock_;
261     sptr<AVSessionItem> topSession_;
262     std::map<pid_t, std::list<sptr<AVControllerItem>>> controllers_;
263 
264     std::recursive_mutex clientDeathObserversLock_;
265     std::map<pid_t, sptr<IClientDeath>> clientDeathObservers_;
266 
267     std::recursive_mutex sessionListenersLock_;
268     std::map<pid_t, sptr<ISessionListener>> sessionListeners_;
269     std::list<SessionListener*> innerSessionListeners_;
270 
271     std::recursive_mutex abilityManagerLock_;
272     std::map<std::string, std::shared_ptr<AbilityManagerAdapter>> abilityManager_;
273 
274     FocusSessionStrategy focusSessionStrategy_;
275     BackgroundAudioController backgroundAudioController_;
276 
277     std::recursive_mutex castAudioSessionMapLock_;
278     std::map<std::string, std::string> castAudioSessionMap_;
279 
280     std::recursive_mutex isAllSessionCastLock_;
281     bool isAllSessionCast_ {};
282 
283     std::recursive_mutex outputDeviceIdLock_;
284     std::string outputDeviceId_;
285 
286     std::unique_ptr<AVSessionDumper> dumpHelper_ {};
287     friend class AVSessionDumper;
288 
289     std::recursive_mutex sortFileReadWriteLock_;
290 
291 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
292     std::recursive_mutex castDeviceInfoMapLock_;
293     std::map<std::string, DeviceInfo> castDeviceInfoMap_;
294 #endif
295 
296     static constexpr const char *SORT_FILE_NAME = "sortinfo";
297     static constexpr const char *ABILITY_FILE_NAME = "abilityinfo";
298     static constexpr const char *DEFAULT_SESSION_ID = "default";
299     static constexpr const char *DEFAULT_BUNDLE_NAME = "com.example.himusicdemo";
300     static constexpr const char *DEFAULT_ABILITY_NAME = "MainAbility";
301 
302     const std::string AVSESSION_FILE_DIR = "/data/service/el1/public/av_session/";
303 
304     int32_t pressCount_ {};
305     int32_t maxHistoryNums = 10;
306     bool isFirstPress_ = true;
307 
308     const int32_t ONE_CLICK = 1;
309     const int32_t DOUBLE_CLICK = 2;
310     const int32_t THREE_CLICK = 3;
311     const int32_t unSetHistoryNum = 3;
312     const int32_t CLICK_TIMEOUT = 500;
313     const int32_t defMaxHistoryNum = 10;
314     const int32_t maxFileLength = 32 * 1024 * 1024;
315     const int32_t allocSpace = 2;
316 };
317 
318 class ClientDeathRecipient : public IRemoteObject::DeathRecipient {
319 public:
320     explicit ClientDeathRecipient(const std::function<void()>& callback);
321 
322     void OnRemoteDied(const wptr<IRemoteObject>& object) override;
323 
324 private:
325     std::function<void()> callback_;
326 };
327 } // namespace OHOS::AVSession
328 #endif // OHOS_AVSESSION_SERVICE_H
329