1 /*
2 * Copyright (c) 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 "avcast_controller_item.h"
17 #include "avsession_radar.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "avsession_trace.h"
21 #include "av_router.h"
22 #include "avsession_sysevent.h"
23 #include "avmedia_description.h"
24 #include "bundle_status_adapter.h"
25
26 #include <string>
27
28 namespace OHOS::AVSession {
AVCastControllerItem()29 AVCastControllerItem::AVCastControllerItem()
30 {
31 SLOGD("AVCastControllerItem construct");
32 }
33
~AVCastControllerItem()34 AVCastControllerItem::~AVCastControllerItem()
35 {
36 SLOGD("AVCastControllerItem destruct");
37 }
38
Init(std::shared_ptr<IAVCastControllerProxy> castControllerProxy,const std::function<void (int32_t,std::vector<int32_t> &)> & validCommandsChangecallback)39 void AVCastControllerItem::Init(std::shared_ptr<IAVCastControllerProxy> castControllerProxy,
40 const std::function<void(int32_t, std::vector<int32_t>&)>& validCommandsChangecallback)
41 {
42 castControllerProxy_ = castControllerProxy;
43 castControllerProxy_->RegisterControllerListener(shared_from_this());
44 validCommandsChangecallback_ = validCommandsChangecallback;
45 {
46 std::lock_guard<std::mutex> lock(callbackToSessionLock_);
47 isSessionCallbackAvailable_ = true;
48 }
49 }
50
OnCastPlaybackStateChange(const AVPlaybackState & state)51 void AVCastControllerItem::OnCastPlaybackStateChange(const AVPlaybackState& state)
52 {
53 SLOGI("OnCastPlaybackStateChange with state: %{public}d", state.GetState());
54 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
55 if (state.GetState() == AVPlaybackState::PLAYBACK_STATE_PLAY) {
56 AVSessionRadarInfo info("AVCastControllerItem::OnCastPlaybackStateChange");
57 AVSessionRadar::GetInstance().PlayerStarted(info);
58 } else if (state.GetState() != currentState_) {
59 currentState_ = state.GetState();
60 AVSessionRadarInfo info("AVCastControllerItem::OnCastPlaybackStateChange");
61 AVSessionRadar::GetInstance().ControlCommandRespond(info);
62 }
63 AVPlaybackState stateOut;
64 std::lock_guard lockGuard(itemCallbackLock_);
65 if (state.CopyToByMask(castPlaybackMask_, stateOut)) {
66 SLOGI("update cast playback state");
67 AVSESSION_TRACE_SYNC_START("AVCastControllerItem::OnCastPlaybackStateChange");
68 callback_->OnCastPlaybackStateChange(stateOut);
69 }
70 SLOGI("OnCastPlaybackStateChange done with state: %{public}d", state.GetState());
71 }
72
OnMediaItemChange(const AVQueueItem & avQueueItem)73 void AVCastControllerItem::OnMediaItemChange(const AVQueueItem& avQueueItem)
74 {
75 SLOGI("OnMediaItemChange");
76 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
77 std::lock_guard lockGuard(itemCallbackLock_);
78 callback_->OnMediaItemChange(avQueueItem);
79 SLOGI("OnMediaItemChange done");
80 }
81
OnPlayNext()82 void AVCastControllerItem::OnPlayNext()
83 {
84 SLOGI("OnPlayNext");
85 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback is nullptr");
86 AVSessionRadarInfo info("AVCastControllerItem::OnPlayNext");
87 AVSessionRadar::GetInstance().ControlCommandRespond(info);
88 std::lock_guard lockGuard(itemCallbackLock_);
89 callback_->OnPlayNext();
90 }
91
OnPlayPrevious()92 void AVCastControllerItem::OnPlayPrevious()
93 {
94 SLOGI("OnPlayPrevious");
95 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
96 AVSessionRadarInfo info("AVCastControllerItem::OnPlayPrevious");
97 AVSessionRadar::GetInstance().ControlCommandRespond(info);
98 std::lock_guard lockGuard(itemCallbackLock_);
99 callback_->OnPlayPrevious();
100 }
101
OnSeekDone(const int32_t seekNumber)102 void AVCastControllerItem::OnSeekDone(const int32_t seekNumber)
103 {
104 SLOGI("OnSeekDone");
105 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
106 AVSessionRadarInfo info("AVCastControllerItem::OnSeekDone");
107 AVSessionRadar::GetInstance().ControlCommandRespond(info);
108 std::lock_guard lockGuard(itemCallbackLock_);
109 callback_->OnSeekDone(seekNumber);
110 }
111
OnVideoSizeChange(const int32_t width,const int32_t height)112 void AVCastControllerItem::OnVideoSizeChange(const int32_t width, const int32_t height)
113 {
114 SLOGI("OnVideoSizeChange");
115 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
116 std::lock_guard lockGuard(itemCallbackLock_);
117 callback_->OnVideoSizeChange(width, height);
118 }
119
OnPlayerError(const int32_t errorCode,const std::string & errorMsg)120 void AVCastControllerItem::OnPlayerError(const int32_t errorCode, const std::string& errorMsg)
121 {
122 SLOGI("OnPlayerError error:%{public}d", errorCode);
123 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
124 AVSessionRadarInfo info("AVCastControllerItem::OnPlayerError");
125 info.errorCode_ = errorCode;
126 AVSessionRadar::GetInstance().ControlCommandError(info);
127 std::lock_guard lockGuard(itemCallbackLock_);
128 callback_->OnPlayerError(errorCode, errorMsg);
129 }
130
OnEndOfStream(const int32_t isLooping)131 void AVCastControllerItem::OnEndOfStream(const int32_t isLooping)
132 {
133 SLOGI("OnEndOfStream");
134 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
135 std::lock_guard lockGuard(itemCallbackLock_);
136 callback_->OnEndOfStream(isLooping);
137 }
138
OnPlayRequest(const AVQueueItem & avQueueItem)139 void AVCastControllerItem::OnPlayRequest(const AVQueueItem& avQueueItem)
140 {
141 SLOGI("OnPlayRequest");
142 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
143 AVSessionRadarInfo info("AVCastControllerItem::OnPlayRequest");
144 AVSessionRadar::GetInstance().ControlCommandRespond(info);
145 std::lock_guard lockGuard(itemCallbackLock_);
146 callback_->OnPlayRequest(avQueueItem);
147 }
148
OnKeyRequest(const std::string & assetId,const std::vector<uint8_t> & keyRequestData)149 void AVCastControllerItem::OnKeyRequest(const std::string &assetId, const std::vector<uint8_t> &keyRequestData)
150 {
151 SLOGI("OnKeyRequest");
152 CHECK_AND_RETURN_LOG(callback_ != nullptr, "callback_ is nullptr");
153 std::lock_guard lockGuard(itemCallbackLock_);
154 callback_->OnKeyRequest(assetId, keyRequestData);
155 }
156
OnValidCommandChange(const std::vector<int32_t> & cmds)157 void AVCastControllerItem::OnValidCommandChange(const std::vector<int32_t>& cmds)
158 {
159 SLOGI("OnValidCommandChange");
160 HandleCastValidCommandChange(cmds);
161 }
162
SendControlCommand(const AVCastControlCommand & cmd)163 int32_t AVCastControllerItem::SendControlCommand(const AVCastControlCommand& cmd)
164 {
165 SLOGI("Call SendControlCommand of cast controller proxy");
166 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
167 AVSessionRadarInfo info("AVCastControllerItem::SendControlCommand");
168 AVSessionRadar::GetInstance().SendControlCommandBegin(info);
169 castControllerProxy_->SendControlCommand(cmd);
170 AVSessionRadar::GetInstance().SendControlCommandEnd(info);
171 std::string API_PARAM_STRING = "cmd: " + std::to_string(cmd.GetCommand());
172 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
173 "API_NAME", "SendControlCommand",
174 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
175 "API_PARAM", API_PARAM_STRING,
176 "ERROR_CODE", AVSESSION_SUCCESS,
177 "ERROR_MSG", "SUCCESS");
178 return AVSESSION_SUCCESS;
179 }
180
Start(const AVQueueItem & avQueueItem)181 int32_t AVCastControllerItem::Start(const AVQueueItem& avQueueItem)
182 {
183 SLOGI("Call Start of cast controller proxy");
184 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
185 AVSessionRadarInfo info("AVCastControllerItem::Start");
186 int32_t ret = castControllerProxy_->Start(avQueueItem);
187 std::string errMsg = (ret == AVSESSION_SUCCESS) ? "SUCCESS" : "start failed";
188 std::string mediaIcon = "false";
189 std::string API_PARAM_STRING = "";
190 std::string startPosition = "";
191 std::string duration = "";
192 std::string mediauri = "";
193 if (avQueueItem.GetDescription() != nullptr) {
194 startPosition = std::to_string(avQueueItem.GetDescription()->GetStartPosition());
195 duration = std::to_string(avQueueItem.GetDescription()->GetDuration());
196 if (avQueueItem.GetDescription()->GetIcon() != nullptr ||
197 !(avQueueItem.GetDescription()->GetIconUri().empty())) {
198 mediaIcon = "true";
199 }
200 mediauri = avQueueItem.GetDescription()->GetMediaUri().empty() ? "false" : "true";
201 API_PARAM_STRING = "mediauri: " + mediauri + "," + "iconImage: " + mediaIcon + ","
202 + "mediaId: " + avQueueItem.GetDescription()->GetMediaId() + ","
203 + "title: " + avQueueItem.GetDescription()->GetTitle() + ","
204 + "subtitle: " + avQueueItem.GetDescription()->GetSubtitle() + ","
205 + "mediaType: " + avQueueItem.GetDescription()->GetMediaType() + ","
206 + "startPosition: " + startPosition + ","
207 + "duration: " + duration;
208 }
209 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
210 "API_NAME", "Start",
211 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
212 "API_PARAM", API_PARAM_STRING,
213 "ERROR_CODE", ret,
214 "ERROR_MSG", errMsg);
215 if (ret != AVSESSION_SUCCESS) {
216 info.errorCode_ = AVSessionRadar::GetRadarErrorCode(ret);
217 AVSessionRadar::GetInstance().StartPlayFailed(info);
218 } else {
219 AVSessionRadar::GetInstance().StartPlayBegin(info);
220 }
221 currentAVQueueItem_ = avQueueItem;
222 return AVSESSION_SUCCESS;
223 }
224
Prepare(const AVQueueItem & avQueueItem)225 int32_t AVCastControllerItem::Prepare(const AVQueueItem& avQueueItem)
226 {
227 SLOGI("Call prepare of cast controller proxy");
228 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
229 auto ret = castControllerProxy_->Prepare(avQueueItem);
230 std::string errMsg = (ret == AVSESSION_SUCCESS) ? "SUCCESS" : "prepare failed";
231 std::string mediaIcon = "false";
232 std::string API_PARAM_STRING = "";
233 std::string startPosition = "";
234 std::string duration = "";
235 std::string mediauri = "";
236 if (avQueueItem.GetDescription() != nullptr) {
237 startPosition = std::to_string(avQueueItem.GetDescription()->GetStartPosition());
238 duration = std::to_string(avQueueItem.GetDescription()->GetDuration());
239 if (avQueueItem.GetDescription()->GetIcon() != nullptr ||
240 !(avQueueItem.GetDescription()->GetIconUri().empty())) {
241 mediaIcon = "true";
242 }
243 mediauri = avQueueItem.GetDescription()->GetMediaUri().empty() ? "false" : "true";
244 API_PARAM_STRING = "mediauri: " + mediauri + "," + "iconImage: " + mediaIcon + ","
245 + "mediaId: " + avQueueItem.GetDescription()->GetMediaId() + ","
246 + "title: " + avQueueItem.GetDescription()->GetTitle() + ","
247 + "subtitle: " + avQueueItem.GetDescription()->GetSubtitle() + ","
248 + "mediaType: " + avQueueItem.GetDescription()->GetMediaType() + ","
249 + "startPosition: " + startPosition + ","
250 + "duration: " + duration;
251 }
252 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
253 "API_NAME", "Prepare",
254 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
255 "API_PARAM", API_PARAM_STRING,
256 "ERROR_CODE", ret,
257 "ERROR_MSG", errMsg);
258 return AVSESSION_SUCCESS;
259 }
260
GetDuration(int32_t & duration)261 int32_t AVCastControllerItem::GetDuration(int32_t& duration)
262 {
263 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
264 return castControllerProxy_->GetDuration(duration);
265 }
266
GetCastAVPlaybackState(AVPlaybackState & avPlaybackState)267 int32_t AVCastControllerItem::GetCastAVPlaybackState(AVPlaybackState& avPlaybackState)
268 {
269 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
270 auto ret = castControllerProxy_->GetCastAVPlaybackState(avPlaybackState);
271 std::string errMsg = (ret == AVSESSION_SUCCESS) ? "SUCCESS" : "GetCastAVPlaybackState failed";
272 int64_t avElapsedTime = avPlaybackState.GetPosition().elapsedTime_;
273 int64_t avUpdateTime = avPlaybackState.GetPosition().updateTime_;
274 std::string isFavor = avPlaybackState.GetFavorite() ? "true" : "false";
275 std::string API_PARAM_STRING = "state: " + std::to_string(avPlaybackState.GetState()) + ", "
276 + "elapsedTime: " + std::to_string(avElapsedTime) + ", "
277 + "updateTime: " + std::to_string(avUpdateTime) + ", "
278 + "loopMode: " + std::to_string(avPlaybackState.GetLoopMode()) + ", "
279 + "isFavorite: " + isFavor;
280 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
281 "API_NAME", "GetCastAVPlaybackState",
282 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
283 "API_PARAM", API_PARAM_STRING,
284 "ERROR_CODE", ret,
285 "ERROR_MSG", errMsg);
286 return ret;
287 }
288
GetCurrentItem(AVQueueItem & currentItem)289 int32_t AVCastControllerItem::GetCurrentItem(AVQueueItem& currentItem)
290 {
291 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR,
292 "cast controller proxy is nullptr");
293 currentItem = castControllerProxy_->GetCurrentItem();
294 return AVSESSION_SUCCESS;
295 }
296
GetValidCommands(std::vector<int32_t> & cmds)297 int32_t AVCastControllerItem::GetValidCommands(std::vector<int32_t>& cmds)
298 {
299 if (sessionTag_ == "RemoteCast") {
300 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR,
301 "cast controller proxy is nullptr");
302 castControllerProxy_->GetValidAbility(cmds);
303 SLOGI("get available commands from cast with size %{public}zd", cmds.size());
304 return AVSESSION_SUCCESS;
305 }
306 {
307 std::lock_guard<std::mutex> lock(callbackToSessionLock_);
308 CHECK_AND_RETURN_RET_LOG(isSessionCallbackAvailable_, AVSESSION_ERROR, "sessionCallback not available");
309 }
310 validCommandsChangecallback_(AVCastControlCommand::CAST_CONTROL_CMD_MAX, cmds);
311 SLOGI("get available command with size %{public}zd", cmds.size());
312 return AVSESSION_SUCCESS;
313 }
314
SetDisplaySurface(std::string & surfaceId)315 int32_t AVCastControllerItem::SetDisplaySurface(std::string& surfaceId)
316 {
317 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
318 return castControllerProxy_->SetDisplaySurface(surfaceId);
319 }
320
SetCastPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType & filter)321 int32_t AVCastControllerItem::SetCastPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType& filter)
322 {
323 castPlaybackMask_ = filter;
324 return AVSESSION_SUCCESS;
325 }
326
ProcessMediaKeyResponse(const std::string & assetId,const std::vector<uint8_t> & response)327 int32_t AVCastControllerItem::ProcessMediaKeyResponse(const std::string &assetId, const std::vector<uint8_t> &response)
328 {
329 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
330 auto ret = castControllerProxy_->ProcessMediaKeyResponse(assetId, response);
331 std::string API_PARAM_STRING = "assetId: " + assetId;
332 std::string errMsg = (ret == AVSESSION_SUCCESS) ? "SUCCESS" : "ProcessMediaKeyResponse failed";
333 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
334 "API_NAME", "ProcessMediaKeyResponse",
335 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
336 "API_PARAM", API_PARAM_STRING,
337 "ERROR_CODE", ret,
338 "ERROR_MSG", errMsg);
339 return ret;
340 }
341
AddAvailableCommand(const int32_t cmd)342 int32_t AVCastControllerItem::AddAvailableCommand(const int32_t cmd)
343 {
344 SLOGI("add available command %{public}d with isSessionCallbackAvailable check %{public}d",
345 cmd, static_cast<int>(isSessionCallbackAvailable_));
346 std::vector<int32_t> cmds(AVCastControlCommand::CAST_CONTROL_CMD_MAX);
347 {
348 std::lock_guard<std::mutex> lock(callbackToSessionLock_);
349 CHECK_AND_RETURN_RET_LOG(isSessionCallbackAvailable_, AVSESSION_ERROR, "sessionCallback not available");
350 }
351 validCommandsChangecallback_(cmd, cmds);
352 SLOGI("add available command with size %{public}d", static_cast<int32_t>(cmds.size()));
353 if (cmds.empty()) {
354 SLOGI("check is sink session with empty, not set");
355 } else {
356 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR,
357 "cast controller proxy is nullptr");
358 auto ret = castControllerProxy_->SetValidAbility(cmds);
359 std::string errMsg = (ret == AVSESSION_SUCCESS) ? "SUCCESS" : "onCastEvent failed";
360 std::string API_PARAM_STRING = "cmd: " + std::to_string(cmd);
361 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
362 "API_NAME", "onCastEvent",
363 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
364 "API_PARAM", API_PARAM_STRING,
365 "ERROR_CODE", ret,
366 "ERROR_MSG", errMsg);
367 }
368 return AVSESSION_SUCCESS;
369 }
370
RemoveAvailableCommand(const int32_t cmd)371 int32_t AVCastControllerItem::RemoveAvailableCommand(const int32_t cmd)
372 {
373 SLOGI("remove available command %{public}d", cmd);
374 std::vector<int32_t> cmds(AVCastControlCommand::CAST_CONTROL_CMD_MAX);
375 {
376 std::lock_guard<std::mutex> lock(callbackToSessionLock_);
377 CHECK_AND_RETURN_RET_LOG(isSessionCallbackAvailable_, AVSESSION_ERROR, "sessionCallback not available");
378 }
379 validCommandsChangecallback_(cmd + removeCmdStep_, cmds);
380 SLOGI("remove available command with size %{public}d", static_cast<int32_t>(cmds.size()));
381 if (cmds.empty()) {
382 SLOGI("check is sink session with empty, not set");
383 } else {
384 CHECK_AND_RETURN_RET_LOG(castControllerProxy_ != nullptr, AVSESSION_ERROR,
385 "cast controller proxy is nullptr");
386 auto ret = castControllerProxy_->SetValidAbility(cmds);
387 std::string errMsg = (ret == AVSESSION_SUCCESS) ? "SUCCESS" : "offCastEvent failed";
388 std::string API_PARAM_STRING = "cmd: " + std::to_string(cmd);
389 HISYSEVENT_BEHAVIOR("SESSION_API_BEHAVIOR",
390 "API_NAME", "offCastEvent",
391 "BUNDLE_NAME", BundleStatusAdapter::GetInstance().GetBundleNameFromUid(GetCallingUid()),
392 "API_PARAM", API_PARAM_STRING,
393 "ERROR_CODE", ret,
394 "ERROR_MSG", errMsg);
395 }
396 return AVSESSION_SUCCESS;
397 }
398
HandleCastValidCommandChange(const std::vector<int32_t> & cmds)399 int32_t AVCastControllerItem::HandleCastValidCommandChange(const std::vector<int32_t>& cmds)
400 {
401 SLOGI("HandleCastValidCommandChange cmd size:%{public}zd", cmds.size());
402 CHECK_AND_RETURN_RET_LOG(callback_ != nullptr, AVSESSION_ERROR, "callback_ is nullptr");
403 std::lock_guard lockGuard(itemCallbackLock_);
404 callback_->OnCastValidCommandChanged(cmds);
405 return AVSESSION_SUCCESS;
406 }
407
SetSessionTag(const std::string & tag)408 void AVCastControllerItem::SetSessionTag(const std::string& tag)
409 {
410 sessionTag_ = tag;
411 }
412
RegisterControllerListener(std::shared_ptr<IAVCastControllerProxy> castControllerProxy)413 bool AVCastControllerItem::RegisterControllerListener(std::shared_ptr<IAVCastControllerProxy> castControllerProxy)
414 {
415 SLOGI("Call RegisterControllerListener of cast controller proxy");
416 CHECK_AND_RETURN_RET_LOG(castControllerProxy != nullptr, AVSESSION_ERROR, "cast controller proxy is nullptr");
417 return castControllerProxy->RegisterControllerListener(shared_from_this());
418 }
419
RegisterCallbackInner(const sptr<IRemoteObject> & callback)420 int32_t AVCastControllerItem::RegisterCallbackInner(const sptr<IRemoteObject>& callback)
421 {
422 SLOGI("call RegisterCallbackInner of cast controller proxy");
423 std::lock_guard lockGuard(itemCallbackLock_);
424 callback_ = iface_cast<AVCastControllerCallbackProxy>(callback);
425 CHECK_AND_RETURN_RET_LOG(callback_ != nullptr, AVSESSION_ERROR, "callback_ is nullptr");
426 return AVSESSION_SUCCESS;
427 }
428
Destroy()429 int32_t AVCastControllerItem::Destroy()
430 {
431 SLOGI("Start cast controller destroy process with sessionCallback available set");
432 if (castControllerProxy_) {
433 castControllerProxy_ = nullptr;
434 }
435 {
436 std::lock_guard lockGuard(itemCallbackLock_);
437 if (callback_) {
438 callback_ = nullptr;
439 }
440 }
441 {
442 std::lock_guard<std::mutex> lock(callbackToSessionLock_);
443 isSessionCallbackAvailable_ = false;
444 }
445 return AVSESSION_SUCCESS;
446 }
447 } // namespace OHOS::AVSession
448