• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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 
40 namespace OHOS::AVSession {
41 class AVSessionDumper;
42 class AVSessionInitDMCallback : public OHOS::DistributedHardware::DmInitCallback {
43 public:
44     AVSessionInitDMCallback() = default;
45     ~AVSessionInitDMCallback() override = default;
OnRemoteDied()46     void OnRemoteDied() override {};
47 };
48 
49 class AudioDeviceDescriptorComp {
50 public:
operator()51     bool operator()(const AudioStandard::AudioDeviceDescriptor& left,
52                     const AudioStandard::AudioDeviceDescriptor& right) const
53     {
54         return left.networkId_ == right.networkId_;
55     }
56 };
57 
58 class AVSessionService : public SystemAbility, public AVSessionServiceStub {
59     DECLARE_SYSTEM_ABILITY(AVSessionService);
60 
61 public:
62     DISALLOW_COPY_AND_MOVE(AVSessionService);
63 
64     explicit AVSessionService(int32_t systemAbilityId, bool runOnCreate = true);
65 
66     ~AVSessionService() override;
67 
68     void OnDump() override;
69 
70     void OnStart() override;
71 
72     void OnStop() override;
73 
74     void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
75 
76     sptr<IRemoteObject> CreateSessionInner(const std::string& tag, int32_t type,
77                                            const AppExecFwk::ElementName& elementName) override;
78 
79     int32_t GetAllSessionDescriptors(std::vector<AVSessionDescriptor>& descriptors) override;
80 
81     int32_t GetSessionDescriptorsBySessionId(const std::string& sessionId, AVSessionDescriptor& descriptor) override;
82 
83     int32_t CreateControllerInner(const std::string& sessionId, sptr<IRemoteObject>& object) override;
84 
85     int32_t RegisterSessionListener(const sptr<ISessionListener>& listener) override;
86 
87     int32_t SendSystemAVKeyEvent(const MMI::KeyEvent& keyEvent) override;
88 
89     int32_t SendSystemControlCommand(const AVControlCommand& command) override;
90 
91     int32_t RegisterClientDeathObserver(const sptr<IClientDeath>& observer) override;
92 
93     void OnClientDied(pid_t pid);
94 
95     void HandleSessionRelease(AVSessionItem& session);
96 
97     void HandleControllerRelease(AVControllerItem& controller);
98 
99     std::int32_t Dump(std::int32_t fd, const std::vector<std::u16string>& args) override;
100 
101     int32_t CastAudio(const SessionToken& token,
102                       const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors) override;
103 
104     int32_t CastAudioForAll(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors) override;
105 
106 private:
107     static SessionContainer& GetContainer();
108 
109     std::string AllocSessionId();
110 
111     bool AbilityHasSession(pid_t pid, const std::string& abilityName);
112 
113     sptr<AVControllerItem> GetPresentController(pid_t pid, const std::string& sessionId);
114 
115     void NotifySessionCreate(const AVSessionDescriptor& descriptor);
116     void NotifySessionRelease(const AVSessionDescriptor& descriptor);
117     void NotifyTopSessionChanged(const AVSessionDescriptor& descriptor);
118 
119     void AddClientDeathObserver(pid_t pid, const sptr<IClientDeath>& observer);
120     void RemoveClientDeathObserver(pid_t pid);
121 
122     void AddSessionListener(pid_t pid, const sptr<ISessionListener>& listener);
123     void RemoveSessionListener(pid_t pid);
124 
125     void AddInnerSessionListener(SessionListener* listener);
126 
127     sptr<AVSessionItem> SelectSessionByUid(const AudioStandard::AudioRendererChangeInfo& info);
128 
129     void OutputDeviceChangeListener(const AudioRendererChangeInfos& infos);
130 
131     sptr<AVSessionItem> CreateSessionInner(const std::string& tag, int32_t type, bool thirdPartyApp,
132                                            const AppExecFwk::ElementName& elementName);
133 
134     sptr<AVSessionItem> CreateNewSession(const std::string& tag, int32_t type, bool thirdPartyApp,
135                                          const AppExecFwk::ElementName& elementName);
136 
137     sptr<AVControllerItem> CreateNewControllerForSession(pid_t pid, sptr<AVSessionItem>& session);
138 
139     int32_t CancelCastAudioForClientExit(pid_t pid, const sptr<AVSessionItem>& session);
140 
141     void ClearSessionForClientDiedNoLock(pid_t pid);
142 
143     void ClearControllerForClientDiedNoLock(pid_t pid);
144 
145     void ClearSessionNoLock(const std::string& sessionId);
146 
147     void InitKeyEvent();
148 
149     void InitAudio();
150 
151     void InitAMS();
152 
153     void InitDM();
154 
155     bool SelectFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo& info);
156 
157     void UpdateTopSession(const sptr<AVSessionItem>& newTopSession);
158 
159     void HandleFocusSession(const FocusSessionStrategy::FocusSessionChangeInfo& info);
160 
161     sptr<RemoteSessionCommandProcess> GetService(const std::string& deviceId);
162 
163     int32_t CastAudioProcess(const std::vector<AudioStandard::AudioDeviceDescriptor>& descriptors,
164                              const std::string& sourceSessionInfo,
165                              sptr<AVSessionItem>& session);
166 
167     int32_t CastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkAudioDescriptors,
168                            const std::string& sourceSessionInfo,
169                            const sptr<AVSessionItem>& session);
170 
171     int32_t CancelCastAudioInner(const std::vector<AudioStandard::AudioDeviceDescriptor>& sinkDevices,
172                                  const std::string& sourceSessionInfo,
173                                  const sptr<AVSessionItem>& session);
174 
175     int32_t RemoteCastAudioInner(const std::string& sourceSessionInfo, std::string& sinkSessionInfo);
176 
177     int32_t RemoteCancelCastAudioInner(const std::string& sessionInfo);
178 
179     int32_t ProcessCastAudioCommand(const RemoteServiceCommand command, const std::string& input,
180                                     std::string& output) override;
181 
182     int32_t CastAudioForNewSession(const sptr<AVSessionItem>& session);
183 
184     bool IsLocalDevice(const std::string& networkId);
185 
186     int32_t GetLocalNetworkId(std::string& networkId);
187 
188     int32_t GetTrustedDeviceName(const std::string& networkId, std::string& deviceName);
189 
190     int32_t GetTrustedDevicesInfo(std::vector<OHOS::DistributedHardware::DmDeviceInfo>& deviceList);
191 
192     int32_t SetBasicInfo(std::string& sessionInfo);
193 
194     void SetCastDeviceInfo(const std::vector<AudioStandard::AudioDeviceDescriptor>& castAudioDescriptors,
195                            sptr<AVSessionItem>& session);
196 
197     int32_t GetAudioDescriptor(const std::string deviceId,
198                                std::vector<AudioStandard::AudioDeviceDescriptor>& audioDeviceDescriptors);
199 
200     bool GetAudioDescriptorByDeviceId(const std::vector<sptr<AudioStandard::AudioDeviceDescriptor>>& descriptors,
201                                       const std::string& deviceId,
202                                       AudioStandard::AudioDeviceDescriptor& audioDescriptor);
203 
204     void GetCastDeviceInfo(const sptr<AVSessionItem>& session,
205                            const std::vector<AudioStandard::AudioDeviceDescriptor>& descriptors,
206                            std::vector<AudioStandard::AudioDeviceDescriptor>& castSinkDescriptors,
207                            std::vector<AudioStandard::AudioDeviceDescriptor>& cancelSinkDescriptors);
208 
209     int32_t SelectOutputDevice(const int32_t uid, const AudioStandard::AudioDeviceDescriptor& descriptor);
210 
211     int32_t StartDefaultAbilityByCall(std::string& sessionId);
212 
213     void HandleEventHandlerCallBack();
214 
215     const nlohmann::json& GetSubNode(const nlohmann::json& node, const std::string& name);
216 
217     std::atomic<uint32_t> sessionSeqNum_ {};
218 
219     std::recursive_mutex sessionAndControllerLock_;
220     sptr<AVSessionItem> topSession_;
221     std::map<pid_t, std::list<sptr<AVControllerItem>>> controllers_;
222 
223     std::recursive_mutex clientDeathObserversLock_;
224     std::map<pid_t, sptr<IClientDeath>> clientDeathObservers_;
225 
226     std::recursive_mutex sessionListenersLock_;
227     std::map<pid_t, sptr<ISessionListener>> sessionListeners_;
228     std::list<SessionListener*> innerSessionListeners_;
229 
230     std::recursive_mutex abilityManagerLock_;
231     std::map<std::string, std::shared_ptr<AbilityManagerAdapter>> abilityManager_;
232 
233     FocusSessionStrategy focusSessionStrategy_;
234     BackgroundAudioController backgroundAudioController_;
235 
236     std::recursive_mutex castAudioSessionMapLock_;
237     std::map<std::string, std::string> castAudioSessionMap_;
238 
239     std::recursive_mutex isAllSessionCastLock_;
240     bool isAllSessionCast_ {};
241 
242     std::recursive_mutex outputDeviceIdLock_;
243     std::string outputDeviceId_;
244 
245     std::unique_ptr<AVSessionDumper> dumpHelper_ {};
246     friend class AVSessionDumper;
247 
248     static constexpr const char *ABILITY_FILE_NAME = "abilityinfo";
249     static constexpr const char *DEFAULT_BUNDLE_NAME = "com.example.himusicdemo";
250     static constexpr const char *DEFAULT_ABILITY_NAME = "MainAbility";
251 
252     const std::string AVSESSION_FILE_DIR = "/data/service/el1/public/av_session/";
253 
254     int32_t pressCount_ {};
255     bool isFirstPress_ = true;
256 
257     const int32_t ONE_CLICK = 1;
258     const int32_t DOUBLE_CLICK = 2;
259     const int32_t THREE_CLICK = 3;
260     const int32_t CLICK_TIMEOUT = 500;
261 };
262 
263 class ClientDeathRecipient : public IRemoteObject::DeathRecipient {
264 public:
265     explicit ClientDeathRecipient(const std::function<void()>& callback);
266 
267     void OnRemoteDied(const wptr<IRemoteObject>& object) override;
268 
269 private:
270     std::function<void()> callback_;
271 };
272 } // namespace OHOS::AVSession
273 #endif // OHOS_AVSESSION_SERVICE_H