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