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 #include "avcontroller_item.h"
17 #include "ipc_skeleton.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "avsession_trace.h"
21 #include "command_send_limit.h"
22 #include "avsession_utils.h"
23 #include "permission_checker.h"
24 #include "avsession_sysevent.h"
25 #include "want_params.h"
26
27 #if !defined(WINDOWS_PLATFORM) and !defined(MAC_PLATFORM) and !defined(IOS_PLATFORM)
28 #include <malloc.h>
29 #endif
30
31 namespace OHOS::AVSession {
AVControllerItem(pid_t pid,const sptr<AVSessionItem> & session)32 AVControllerItem::AVControllerItem(pid_t pid, const sptr<AVSessionItem>& session)
33 : pid_(pid), session_(session)
34 {
35 sessionId_ = session_->GetSessionId();
36 SLOGD("construct sessionId=%{public}s", sessionId_.c_str());
37 }
38
~AVControllerItem()39 AVControllerItem::~AVControllerItem()
40 {
41 SLOGI("destroy sessionId=%{public}s", sessionId_.c_str());
42 }
43
RegisterCallbackInner(const sptr<IRemoteObject> & callback)44 int32_t AVControllerItem::RegisterCallbackInner(const sptr<IRemoteObject>& callback)
45 {
46 std::lock_guard lockGuard(callbackMutex_);
47 SLOGD("do register callback for controller %{public}d", static_cast<int>(pid_));
48 callback_ = iface_cast<AVControllerCallbackProxy>(callback);
49 CHECK_AND_RETURN_RET_LOG(callback_ != nullptr, AVSESSION_ERROR, "RegisterCallbackInner callback_ is nullptr");
50 return AVSESSION_SUCCESS;
51 }
52
RegisterAVControllerCallback(const std::shared_ptr<AVControllerCallback> & callback)53 int32_t AVControllerItem::RegisterAVControllerCallback(const std::shared_ptr<AVControllerCallback> &callback)
54 {
55 std::lock_guard lockGuard(callbackMutex_);
56 innerCallback_ = callback;
57 CHECK_AND_RETURN_RET_LOG(innerCallback_ != nullptr, AVSESSION_ERROR, "RegisterCallbackInner callback_ is nullptr");
58 return AVSESSION_SUCCESS;
59 }
60
GetAVCallMetaData(AVCallMetaData & avCallMetaData)61 int32_t AVControllerItem::GetAVCallMetaData(AVCallMetaData& avCallMetaData)
62 {
63 std::lock_guard lockGuard(sessionMutex_);
64 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
65 avCallMetaData = session_->GetAVCallMetaData();
66 return AVSESSION_SUCCESS;
67 }
68
GetAVCallState(AVCallState & avCallState)69 int32_t AVControllerItem::GetAVCallState(AVCallState& avCallState)
70 {
71 std::lock_guard lockGuard(sessionMutex_);
72 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
73 avCallState = session_->GetAVCallState();
74 return AVSESSION_SUCCESS;
75 }
76
GetAVPlaybackState(AVPlaybackState & state)77 int32_t AVControllerItem::GetAVPlaybackState(AVPlaybackState& state)
78 {
79 std::lock_guard lockGuard(sessionMutex_);
80 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
81 state = session_->GetPlaybackState();
82 return AVSESSION_SUCCESS;
83 }
84
GetAVMetaData(AVMetaData & data)85 int32_t AVControllerItem::GetAVMetaData(AVMetaData& data)
86 {
87 std::lock_guard lockGuard(sessionMutex_);
88 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
89 data = session_->GetMetaData();
90 return AVSESSION_SUCCESS;
91 }
92
GetAVQueueItems(std::vector<AVQueueItem> & items)93 int32_t AVControllerItem::GetAVQueueItems(std::vector<AVQueueItem>& items)
94 {
95 std::lock_guard lockGuard(sessionMutex_);
96 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
97 items = session_->GetQueueItems();
98 return AVSESSION_SUCCESS;
99 }
100
GetAVQueueTitle(std::string & title)101 int32_t AVControllerItem::GetAVQueueTitle(std::string& title)
102 {
103 std::lock_guard lockGuard(sessionMutex_);
104 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
105 title = session_->GetQueueTitle();
106 return AVSESSION_SUCCESS;
107 }
108
SkipToQueueItem(int32_t & itemId)109 int32_t AVControllerItem::SkipToQueueItem(int32_t& itemId)
110 {
111 std::lock_guard lockGuard(sessionMutex_);
112 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
113 session_->HandleSkipToQueueItem(itemId);
114 return AVSESSION_SUCCESS;
115 }
116
GetExtras(AAFwk::WantParams & extras)117 int32_t AVControllerItem::GetExtras(AAFwk::WantParams& extras)
118 {
119 std::lock_guard lockGuard(sessionMutex_);
120 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
121 CHECK_AND_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(OHOS::IPCSkeleton::GetCallingPid()),
122 ERR_COMMAND_SEND_EXCEED_MAX, "command send number exceed max");
123 extras = session_->GetExtras();
124 return AVSESSION_SUCCESS;
125 }
126
SendAVKeyEvent(const MMI::KeyEvent & keyEvent)127 int32_t AVControllerItem::SendAVKeyEvent(const MMI::KeyEvent& keyEvent)
128 {
129 std::lock_guard lockGuard(sessionMutex_);
130 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
131 session_->HandleMediaKeyEvent(keyEvent);
132 return AVSESSION_SUCCESS;
133 }
134
GetLaunchAbility(AbilityRuntime::WantAgent::WantAgent & ability)135 int32_t AVControllerItem::GetLaunchAbility(AbilityRuntime::WantAgent::WantAgent& ability)
136 {
137 std::lock_guard lockGuard(sessionMutex_);
138 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
139 ability = session_->GetLaunchAbility();
140 return AVSESSION_SUCCESS;
141 }
142
GetValidCommands(std::vector<int32_t> & cmds)143 int32_t AVControllerItem::GetValidCommands(std::vector<int32_t>& cmds)
144 {
145 std::lock_guard lockGuard(sessionMutex_);
146 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
147 cmds = session_->GetSupportCommand();
148 return AVSESSION_SUCCESS;
149 }
150
IsSessionActive(bool & isActive)151 int32_t AVControllerItem::IsSessionActive(bool& isActive)
152 {
153 std::lock_guard lockGuard(sessionMutex_);
154 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
155 isActive = session_->IsActive();
156 return AVSESSION_SUCCESS;
157 }
158
SendControlCommand(const AVControlCommand & cmd)159 int32_t AVControllerItem::SendControlCommand(const AVControlCommand& cmd)
160 {
161 std::lock_guard lockGuard(sessionMutex_);
162 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "session not exist");
163 std::vector<int32_t> cmds = session_->GetSupportCommand();
164 CHECK_AND_RETURN_RET_LOG(std::find(cmds.begin(), cmds.end(), cmd.GetCommand()) != cmds.end(),
165 ERR_COMMAND_NOT_SUPPORT, "command not support");
166 CHECK_AND_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(OHOS::IPCSkeleton::GetCallingPid()),
167 ERR_COMMAND_SEND_EXCEED_MAX, "command send number exceed max");
168 session_->ExecuteControllerCommand(cmd);
169 return AVSESSION_SUCCESS;
170 }
171
SendCommonCommand(const std::string & commonCommand,const AAFwk::WantParams & commandArgs)172 int32_t AVControllerItem::SendCommonCommand(const std::string& commonCommand, const AAFwk::WantParams& commandArgs)
173 {
174 std::lock_guard lockGuard(sessionMutex_);
175 CHECK_AND_RETURN_RET_LOG(session_ != nullptr, ERR_SESSION_NOT_EXIST, "Session not exist");
176 CHECK_AND_RETURN_RET_LOG(CommandSendLimit::GetInstance().IsCommandSendEnable(OHOS::IPCSkeleton::GetCallingPid()),
177 ERR_COMMAND_SEND_EXCEED_MAX, "common command send number exceed max");
178 session_->ExecueCommonCommand(commonCommand, commandArgs);
179 return AVSESSION_SUCCESS;
180 }
181
SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType & filter)182 int32_t AVControllerItem::SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType& filter)
183 {
184 std::lock_guard lockGuard(avCallMetaMaskMutex_);
185 avCallMetaMask_ = filter;
186 return AVSESSION_SUCCESS;
187 }
188
SetAVCallStateFilter(const AVCallState::AVCallStateMaskType & filter)189 int32_t AVControllerItem::SetAVCallStateFilter(const AVCallState::AVCallStateMaskType& filter)
190 {
191 std::lock_guard lockGuard(avCallStateMaskMutex_);
192 avCallStateMask_ = filter;
193 return AVSESSION_SUCCESS;
194 }
195
SetMetaFilter(const AVMetaData::MetaMaskType & filter)196 int32_t AVControllerItem::SetMetaFilter(const AVMetaData::MetaMaskType& filter)
197 {
198 std::lock_guard lockGuard(metaMaskMutex_);
199 metaMask_ = filter;
200 return AVSESSION_SUCCESS;
201 }
202
SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType & filter)203 int32_t AVControllerItem::SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType& filter)
204 {
205 std::lock_guard lockGuard(playbackMaskMutex_);
206 playbackMask_ = filter;
207 return AVSESSION_SUCCESS;
208 }
209
Destroy()210 int32_t AVControllerItem::Destroy()
211 {
212 SLOGI("do controller destroyfor pid %{public}d", static_cast<int>(pid_));
213 {
214 std::lock_guard callbackLockGuard(callbackMutex_);
215 callback_ = nullptr;
216 innerCallback_ = nullptr;
217 }
218 {
219 std::lock_guard sessionLockGuard(sessionMutex_);
220 if (session_ != nullptr) {
221 session_->HandleControllerRelease(pid_);
222 session_ = nullptr;
223 sessionId_.clear();
224 }
225 }
226 {
227 std::lock_guard serviceCallbacklockGuard(serviceCallbackMutex_);
228 if (serviceCallback_) {
229 serviceCallback_(*this);
230 }
231 }
232 return AVSESSION_SUCCESS;
233 }
234
GetSessionId()235 std::string AVControllerItem::GetSessionId()
236 {
237 return sessionId_;
238 }
239
HandleSessionDestroy()240 void AVControllerItem::HandleSessionDestroy()
241 {
242 {
243 std::lock_guard callbackLockGuard(callbackMutex_);
244 if (callback_ != nullptr) {
245 callback_->OnSessionDestroy();
246 }
247 if (innerCallback_ != nullptr) {
248 innerCallback_->OnSessionDestroy();
249 }
250 }
251 std::lock_guard sessionLockGuard(sessionMutex_);
252 session_ = nullptr;
253 sessionId_.clear();
254 }
255
HandleAVCallStateChange(const AVCallState & avCallState)256 void AVControllerItem::HandleAVCallStateChange(const AVCallState& avCallState)
257 {
258 std::lock_guard callbackLockGuard(callbackMutex_);
259 AVCallState stateOut;
260 std::lock_guard avCallStateLockGuard(avCallStateMaskMutex_);
261 if (avCallState.CopyToByMask(avCallStateMask_, stateOut)) {
262 SLOGI("update avcall state");
263 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnAVCallStateChange");
264 if (callback_ != nullptr) {
265 callback_->OnAVCallStateChange(stateOut);
266 }
267 if (innerCallback_ != nullptr) {
268 innerCallback_->OnAVCallStateChange(stateOut);
269 }
270 }
271 }
272
HandleAVCallMetaDataChange(const AVCallMetaData & avCallMetaData)273 void AVControllerItem::HandleAVCallMetaDataChange(const AVCallMetaData& avCallMetaData)
274 {
275 std::lock_guard callbackLockGuard(callbackMutex_);
276 AVCallMetaData metaOut;
277 std::lock_guard avCallMetaDataMaskLockGuard(avCallMetaMaskMutex_);
278 if (avCallMetaData.CopyToByMask(avCallMetaMask_, metaOut)) {
279 if (avCallMetaMask_.test(AVCallMetaData::AVCALL_META_KEY_MEDIA_IMAGE)) {
280 std::shared_ptr<AVSessionPixelMap> innerPixelMap = nullptr;
281 if (metaOut.GetMediaImage() != nullptr) {
282 std::string fileName =
283 AVSessionUtils::GetCachePathName() + sessionId_ + AVSessionUtils::GetFileSuffix();
284 innerPixelMap = metaOut.GetMediaImage();
285 AVSessionUtils::ReadImageFromFile(innerPixelMap, fileName);
286 }
287 metaOut.SetMediaImage(innerPixelMap);
288 }
289
290 if (avCallMetaMask_.test(AVCallMetaData::AVCALL_META_KEY_NAME)) {
291 metaOut.SetName(avCallMetaData.GetName());
292 }
293
294 if (avCallMetaMask_.test(AVCallMetaData::AVCALL_META_KEY_PHONE_NUMBER)) {
295 metaOut.SetPhoneNumber(avCallMetaData.GetPhoneNumber());
296 }
297 SLOGI("update avcall meta data");
298 }
299
300 if (callback_ != nullptr) {
301 callback_->OnAVCallMetaDataChange(metaOut);
302 }
303 if (innerCallback_ != nullptr) {
304 innerCallback_->OnAVCallMetaDataChange(metaOut);
305 }
306 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnAVCallMetaDataChange");
307 }
308
HandlePlaybackStateChange(const AVPlaybackState & state)309 void AVControllerItem::HandlePlaybackStateChange(const AVPlaybackState& state)
310 {
311 std::lock_guard callbackLockGuard(callbackMutex_);
312 AVPlaybackState stateOut;
313 std::lock_guard playbackLockGuard(playbackMaskMutex_);
314 if (state.CopyToByMask(playbackMask_, stateOut)) {
315 SLOGI("update playback state");
316 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnPlaybackStateChange");
317 if (callback_ != nullptr) {
318 callback_->OnPlaybackStateChange(stateOut);
319 }
320 if (innerCallback_ != nullptr) {
321 innerCallback_->OnPlaybackStateChange(stateOut);
322 }
323 }
324 }
325
HandleMetaDataChange(const AVMetaData & data)326 void AVControllerItem::HandleMetaDataChange(const AVMetaData& data)
327 {
328 std::lock_guard callbackLockGuard(callbackMutex_);
329 AVMetaData metaOut;
330 std::lock_guard metaMaskLockGuard(metaMaskMutex_);
331 if (data.CopyToByMask(metaMask_, metaOut)) {
332 if ((metaMask_.test(AVMetaData::META_KEY_MEDIA_IMAGE)) && (metaOut.GetMediaImage() != nullptr)) {
333 std::string fileName = AVSessionUtils::GetCachePathName() + sessionId_ + AVSessionUtils::GetFileSuffix();
334 std::shared_ptr<AVSessionPixelMap> innerPixelMap = metaOut.GetMediaImage();
335 AVSessionUtils::ReadImageFromFile(innerPixelMap, fileName);
336 metaOut.SetMediaImage(innerPixelMap);
337 }
338 if ((metaMask_.test(AVMetaData::META_KEY_AVQUEUE_IMAGE)) && (metaOut.GetAVQueueImage() != nullptr)) {
339 std::string avQueueFile = AVSessionUtils::GetFixedPathName() + session_->GetBundleName() + "_" +
340 metaOut.GetAVQueueId() + AVSessionUtils::GetFileSuffix();
341 std::shared_ptr<AVSessionPixelMap> avQueuePixelMap = metaOut.GetAVQueueImage();
342 AVSessionUtils::ReadImageFromFile(avQueuePixelMap, avQueueFile);
343 metaOut.SetAVQueueImage(avQueuePixelMap);
344 }
345 if (!metaMask_.test(AVMetaData::META_KEY_ASSET_ID)) {
346 metaOut.SetAssetId(data.GetAssetId());
347 }
348 SLOGI("update meta data for pid %{public}d with title %{public}s", static_cast<int>(pid_),
349 metaOut.GetTitle().c_str());
350 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnMetaDataChange");
351 if (callback_ != nullptr) {
352 callback_->OnMetaDataChange(metaOut);
353 }
354 if (innerCallback_ != nullptr) {
355 innerCallback_->OnMetaDataChange(metaOut);
356 }
357 }
358 }
359
HandleOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & outputDeviceInfo)360 void AVControllerItem::HandleOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo)
361 {
362 SLOGD("Connection state %{public}d", connectionState);
363 std::lock_guard lockGuard(callbackMutex_);
364 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
365 callback_->OnOutputDeviceChange(connectionState, outputDeviceInfo);
366 }
367
HandleActiveStateChange(bool isActive)368 void AVControllerItem::HandleActiveStateChange(bool isActive)
369 {
370 std::lock_guard lockGuard(callbackMutex_);
371 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
372 callback_->OnActiveStateChange(isActive);
373 }
374
HandleValidCommandChange(const std::vector<int32_t> & cmds)375 void AVControllerItem::HandleValidCommandChange(const std::vector<int32_t>& cmds)
376 {
377 std::lock_guard lockGuard(callbackMutex_);
378 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
379 callback_->OnValidCommandChange(cmds);
380 }
381
HandleSetSessionEvent(const std::string & event,const AAFwk::WantParams & args)382 void AVControllerItem::HandleSetSessionEvent(const std::string& event, const AAFwk::WantParams& args)
383 {
384 std::lock_guard lockGuard(callbackMutex_);
385 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
386 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnSessionEventChange");
387 callback_->OnSessionEventChange(event, args);
388 }
389
HandleQueueItemsChange(const std::vector<AVQueueItem> & items)390 void AVControllerItem::HandleQueueItemsChange(const std::vector<AVQueueItem>& items)
391 {
392 std::lock_guard lockGuard(callbackMutex_);
393 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
394 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnQueueItemsChange");
395 callback_->OnQueueItemsChange(items);
396 }
397
HandleQueueTitleChange(const std::string & title)398 void AVControllerItem::HandleQueueTitleChange(const std::string& title)
399 {
400 std::lock_guard lockGuard(callbackMutex_);
401 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
402 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnQueueTitleChange");
403 callback_->OnQueueTitleChange(title);
404 }
405
HandleExtrasChange(const AAFwk::WantParams & extras)406 void AVControllerItem::HandleExtrasChange(const AAFwk::WantParams& extras)
407 {
408 std::lock_guard lockGuard(callbackMutex_);
409 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
410 AVSESSION_TRACE_SYNC_START("AVControllerItem::OnSetExtras");
411 callback_->OnExtrasChange(extras);
412 }
413
GetPid() const414 pid_t AVControllerItem::GetPid() const
415 {
416 return pid_;
417 }
418
HasSession(const std::string & sessionId)419 bool AVControllerItem::HasSession(const std::string& sessionId)
420 {
421 return sessionId_ == sessionId;
422 }
423
SetServiceCallbackForRelease(const std::function<void (AVControllerItem &)> & callback)424 void AVControllerItem::SetServiceCallbackForRelease(const std::function<void(AVControllerItem&)>& callback)
425 {
426 std::lock_guard lockGuard(serviceCallbackMutex_);
427 serviceCallback_ = callback;
428 }
429 } // namespace OHOS::AVSession
430