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