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