1 /*
2  * Copyright (c) 2023-2024 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 "avrouter_impl.h"
17 #include "ipc_skeleton.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "avsession_trace.h"
21 #include "permission_checker.h"
22 #include "avcast_provider_manager.h"
23 #include "avsession_sysevent.h"
24 
25 static std::shared_ptr<OHOS::AVSession::HwCastProvider> hwProvider_;
26 
27 namespace OHOS::AVSession {
AVRouterImpl()28 AVRouterImpl::AVRouterImpl()
29 {
30     SLOGD("AVRouter construct");
31 }
32 
Init(IAVSessionServiceListener * servicePtr)33 int32_t AVRouterImpl::Init(IAVSessionServiceListener *servicePtr)
34 {
35     SLOGI("Start init AVRouter");
36     {
37         std::lock_guard lockGuard(servicePtrLock_);
38         servicePtr_ = servicePtr;
39     }
40     castSessionListener_ = std::make_shared<CastSessionListener>(this);
41     hwProvider_ = std::make_shared<HwCastProvider>();
42     if (hwProvider_ != nullptr && hwProvider_->Init() != AVSESSION_ERROR) {
43         SLOGI("init pvd success");
44     } else {
45         hwProvider_ = nullptr;
46         SLOGE("init with null pvd to init");
47         return AVSESSION_ERROR;
48     }
49     providerNumber_ = providerNumberEnableDefault_;
50     std::shared_ptr<AVCastProviderManager> avCastProviderManager = std::make_shared<AVCastProviderManager>();
51     if (avCastProviderManager == nullptr) {
52         SLOGE("init with null manager");
53         return AVSESSION_ERROR;
54     }
55     avCastProviderManager->Init(providerNumber_, hwProvider_);
56     providerManagerMap_[providerNumber_] = avCastProviderManager;
57     if (hwProvider_ != nullptr) {
58         hwProvider_->RegisterCastStateListener(avCastProviderManager);
59     } else {
60         SLOGE("init with null pvd to registerlistener");
61         return AVSESSION_ERROR;
62     }
63     if (cacheStartDiscovery_) {
64         SLOGI("cacheStartDiscovery check do discovery");
65         std::lock_guard lockGuard(providerManagerLock_);
66         StartCastDiscovery(cacheCastDeviceCapability_, cacheDrmSchemes_);
67         cacheStartDiscovery_ = false;
68     }
69     SLOGI("init AVRouter done");
70     return AVSESSION_SUCCESS;
71 }
72 
Release()73 bool AVRouterImpl::Release()
74 {
75     SLOGI("Start Release AVRouter");
76     if (hasSessionAlive_) {
77         SLOGE("has session alive, but continue");
78     }
79     if (hwProvider_ == nullptr) {
80         SLOGE("Start Release AVRouter err for no provider");
81         return false;
82     }
83     std::lock_guard lockGuard(providerManagerLock_);
84 
85     if (hwProvider_ == nullptr) {
86         SLOGE("repeat check for no pvd");
87         return false;
88     }
89     SLOGI("repeat check for pvd alive");
90     hwProvider_->Release();
91     hwProvider_ = nullptr;
92     providerNumber_ = providerNumberDisable_;
93     providerManagerMap_.clear();
94     castHandleToInfoMap_.clear();
95     SLOGD("Release AVRouter done");
96     return false;
97 }
98 
StartDeviceLogging(int32_t fd,uint32_t maxSize)99 int32_t AVRouterImpl::StartDeviceLogging(int32_t fd, uint32_t maxSize)
100 {
101     SLOGI("AVRouterImpl StartDeviceLogging");
102     std::lock_guard lockGuard(providerManagerLock_);
103 
104     if (providerManagerMap_.empty()) {
105         cacheStartDeviceLogging_ = true;
106         return AVSESSION_SUCCESS;
107     }
108     for (const auto& [number, providerManager] : providerManagerMap_) {
109         CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
110             AVSESSION_ERROR, "provider is nullptr");
111         providerManager->provider_->StartDeviceLogging(fd, maxSize);
112     }
113     return AVSESSION_SUCCESS;
114 }
115 
StopDeviceLogging()116 int32_t AVRouterImpl::StopDeviceLogging()
117 {
118     SLOGI("AVRouterImpl StopDeviceLogging");
119     std::lock_guard lockGuard(providerManagerLock_);
120 
121     if (cacheStartDeviceLogging_) {
122         SLOGI("clear cacheStartDeviceLogging_ when stop discovery");
123         cacheStartDeviceLogging_ = false;
124     }
125     for (const auto& [number, providerManager] : providerManagerMap_) {
126         CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
127             AVSESSION_ERROR, "provider is nullptr");
128         providerManager->provider_->StopDeviceLogging();
129     }
130     return AVSESSION_SUCCESS;
131 }
132 
StartCastDiscovery(int32_t castDeviceCapability,std::vector<std::string> drmSchemes)133 int32_t AVRouterImpl::StartCastDiscovery(int32_t castDeviceCapability, std::vector<std::string> drmSchemes)
134 {
135     SLOGI("AVRouterImpl StartCastDiscovery");
136 
137     std::lock_guard lockGuard(providerManagerLock_);
138 
139     if (providerManagerMap_.empty()) {
140         SLOGI("set cacheStartDiscovery with no element with cap %{public}d", static_cast<int>(castDeviceCapability));
141         cacheStartDiscovery_ = true;
142         cacheCastDeviceCapability_ = castDeviceCapability;
143         cacheDrmSchemes_ = drmSchemes;
144         return AVSESSION_SUCCESS;
145     }
146     for (const auto& [number, providerManager] : providerManagerMap_) {
147         CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
148             AVSESSION_ERROR, "provider is nullptr");
149         providerManager->provider_->StartDiscovery(castDeviceCapability, drmSchemes);
150     }
151     return AVSESSION_SUCCESS;
152 }
153 
StopCastDiscovery()154 int32_t AVRouterImpl::StopCastDiscovery()
155 {
156     SLOGI("AVRouterImpl StopCastDiscovery");
157 
158     std::lock_guard lockGuard(providerManagerLock_);
159 
160     if (cacheStartDiscovery_) {
161         SLOGI("clear cacheStartDiscovery when stop discovery");
162         cacheStartDiscovery_ = false;
163     }
164     for (const auto& [number, providerManager] : providerManagerMap_) {
165         CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
166             AVSESSION_ERROR, "provider is nullptr");
167         providerManager->provider_->StopDiscovery();
168     }
169     return AVSESSION_SUCCESS;
170 }
171 
SetDiscoverable(const bool enable)172 int32_t AVRouterImpl::SetDiscoverable(const bool enable)
173 {
174     SLOGI("AVRouterImpl SetDiscoverable %{public}d", enable);
175     std::lock_guard lockGuard(providerManagerLock_);
176 
177     for (const auto& [number, providerManager] : providerManagerMap_) {
178         CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
179             AVSESSION_ERROR, "provider is nullptr");
180         providerManager->provider_->SetDiscoverable(enable);
181     }
182 
183     return AVSESSION_SUCCESS;
184 }
185 
OnDeviceAvailable(OutputDeviceInfo & castOutputDeviceInfo)186 int32_t AVRouterImpl::OnDeviceAvailable(OutputDeviceInfo& castOutputDeviceInfo)
187 {
188     SLOGI("AVRouterImpl received OnDeviceAvailable event");
189 
190     std::lock_guard lockGuard(servicePtrLock_);
191     if (servicePtr_ == nullptr) {
192         return ERR_SERVICE_NOT_EXIST;
193     }
194     servicePtr_->NotifyDeviceAvailable(castOutputDeviceInfo);
195     return AVSESSION_SUCCESS;
196 }
197 
OnDeviceLogEvent(const DeviceLogEventCode eventId,const int64_t param)198 int32_t AVRouterImpl::OnDeviceLogEvent(const DeviceLogEventCode eventId, const int64_t param)
199 {
200     SLOGI("AVRouterImpl received OnDeviceLogEvent event");
201 
202     std::lock_guard lockGuard(servicePtrLock_);
203     if (servicePtr_ == nullptr) {
204         return ERR_SERVICE_NOT_EXIST;
205     }
206     servicePtr_->NotifyDeviceLogEvent(eventId, param);
207     return AVSESSION_SUCCESS;
208 }
209 
ReleaseCurrentCastSession()210 void AVRouterImpl::ReleaseCurrentCastSession()
211 {
212     SLOGI("Start ReleaseCurrentCastSession");
213     std::lock_guard lockGuard(servicePtrLock_);
214     servicePtr_->ReleaseCastSession();
215 }
216 
OnCastSessionCreated(const int32_t castId)217 int32_t AVRouterImpl::OnCastSessionCreated(const int32_t castId)
218 {
219     SLOGI("AVRouterImpl On cast session created, cast id is %{public}d", castId);
220 
221     castHandleToInfoMap_.clear();
222     int64_t castHandle = -1;
223     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) !=
224         providerManagerMap_.end(), castHandle, "Can not find corresponding provider");
225     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[1] != nullptr
226         && providerManagerMap_[1]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
227     int64_t tempId = 1;
228     // The first 32 bits are providerId, the last 32 bits are castId
229     castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
230         static_cast<const uint32_t>(castId));
231     CastHandleInfo castHandleInfo;
232     OutputDeviceInfo outputDeviceInfo;
233     castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
234     castHandleToInfoMap_[castHandle] = castHandleInfo;
235     {
236         std::lock_guard lockGuard(servicePtrLock_);
237         servicePtr_->CreateSessionByCast(castHandle);
238     }
239     return AVSESSION_SUCCESS;
240 }
241 
OnDeviceOffline(const std::string & deviceId)242 int32_t AVRouterImpl::OnDeviceOffline(const std::string& deviceId)
243 {
244     SLOGI("AVRouterImpl received OnDeviceOffline event");
245 
246     std::lock_guard lockGuard(servicePtrLock_);
247     if (servicePtr_ == nullptr) {
248         return ERR_SERVICE_NOT_EXIST;
249     }
250     servicePtr_->NotifyDeviceOffline(deviceId);
251     return AVSESSION_SUCCESS;
252 }
253 
OnCastServerDied(int32_t providerNumber)254 int32_t AVRouterImpl::OnCastServerDied(int32_t providerNumber)
255 {
256     SLOGI("AVRouterImpl received OnCastServerDied event");
257     hasSessionAlive_ = false;
258     std::lock_guard lockGuard(providerManagerLock_);
259     if (providerManagerMap_.find(providerNumber) != providerManagerMap_.end()) {
260         providerManagerMap_.erase(providerNumber);
261     } else {
262         return AVSESSION_ERROR;
263     }
264     return AVSESSION_SUCCESS;
265 }
266 
GetRemoteController(const int64_t castHandle)267 std::shared_ptr<IAVCastControllerProxy> AVRouterImpl::GetRemoteController(const int64_t castHandle)
268 {
269     SLOGI("AVRouterImpl start get remote controller process");
270 
271     // The first 32 bits are providerId, the last 32 bits are castId
272     int32_t providerNumber = static_cast<int32_t>(static_cast<const uint64_t>(castHandle) >> 32);
273     SLOGD("Get remote controller of provider %{public}d", providerNumber);
274     // The first 32 bits are providerId, the last 32 bits are castId
275     int32_t castId = static_cast<int32_t>((static_cast<const uint64_t>(castHandle) << 32) >> 32);
276     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
277         nullptr, "Can not find corresponding provider");
278     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr &&
279         providerManagerMap_[providerNumber]->provider_ != nullptr, nullptr, "provider is nullptr");
280     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
281         if (number == castHandle && castHandleInfo.avCastControllerProxy_ != nullptr) {
282             return castHandleInfo.avCastControllerProxy_;
283         }
284     }
285 
286     if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
287         castHandleToInfoMap_[castHandle].avCastControllerProxy_ =
288             providerManagerMap_[providerNumber]->provider_->GetRemoteController(castId);
289     }
290     return providerManagerMap_[providerNumber]->provider_->GetRemoteController(castId);
291 }
292 
StartCast(const OutputDeviceInfo & outputDeviceInfo,std::map<std::string,std::string> & serviceNameMapState,std::string sessionId)293 int64_t AVRouterImpl::StartCast(const OutputDeviceInfo& outputDeviceInfo,
294     std::map<std::string, std::string>& serviceNameMapState, std::string sessionId)
295 {
296     SLOGI("AVRouterImpl start cast process");
297     castServiceNameMapState_ = serviceNameMapState;
298     int64_t castHandle = -1;
299     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(outputDeviceInfo.deviceInfos_[0].providerId_) !=
300         providerManagerMap_.end(), castHandle, "Can not find corresponding provider");
301     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_] != nullptr
302         && providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_ != nullptr,
303         AVSESSION_ERROR, "provider is nullptr");
304     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
305         if (castHandleInfo.sessionId_ != sessionId && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
306             castHandleInfo.outputDeviceInfo_.deviceInfos_[0].deviceId_ == outputDeviceInfo.deviceInfos_[0].deviceId_) {
307             castHandleToInfoMap_[number].sessionId_ = sessionId;
308             return number;
309         }
310     }
311     castHandleToInfoMap_.clear();
312     int32_t castId = providerManagerMap_[outputDeviceInfo.deviceInfos_[0].
313         providerId_]->provider_->StartCastSession();
314     CHECK_AND_RETURN_RET_LOG(castId != AVSESSION_ERROR, AVSESSION_ERROR, "StartCast failed");
315     int64_t tempId = outputDeviceInfo.deviceInfos_[0].providerId_;
316     // The first 32 bits are providerId, the last 32 bits are castId
317     castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) | static_cast<uint32_t>(castId));
318     hasSessionAlive_ = true;
319 
320     CastHandleInfo castHandleInfo;
321     castHandleInfo.sessionId_ = sessionId;
322     OutputDeviceInfo localDevice;
323     DeviceInfo localInfo;
324     localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
325     localInfo.deviceId_ = "-1";
326     localInfo.deviceName_ = "LocalDevice";
327     localDevice.deviceInfos_.emplace_back(localInfo);
328     castHandleInfo.outputDeviceInfo_ = localDevice;
329     castHandleToInfoMap_[castHandle] = castHandleInfo;
330     return castHandle;
331 }
332 
AddDevice(const int32_t castId,const OutputDeviceInfo & outputDeviceInfo)333 int32_t AVRouterImpl::AddDevice(const int32_t castId, const OutputDeviceInfo& outputDeviceInfo)
334 {
335     SLOGI("AVRouterImpl AddDevice process");
336 
337     int64_t tempId = outputDeviceInfo.deviceInfos_[0].providerId_;
338     int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
339         static_cast<uint32_t>(castId));
340     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
341         if (castHandle == number && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
342             castHandleInfo.outputDeviceInfo_.deviceInfos_[0].deviceId_ == outputDeviceInfo.deviceInfos_[0].deviceId_) {
343             return AVSESSION_SUCCESS;
344         }
345     }
346     bool ret = providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_->AddCastDevice(castId,
347         outputDeviceInfo.deviceInfos_[0]);
348     SLOGI("AVRouterImpl AddDevice process with ret %{public}d", static_cast<int32_t>(ret));
349     if (ret && castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
350         castHandleToInfoMap_[castHandle].outputDeviceInfo_ = outputDeviceInfo;
351     }
352     return ret ? AVSESSION_SUCCESS : ERR_DEVICE_CONNECTION_FAILED;
353 }
354 
StopCast(const int64_t castHandle)355 int32_t AVRouterImpl::StopCast(const int64_t castHandle)
356 {
357     SLOGI("AVRouterImpl stop cast process");
358 
359     int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
360     SLOGI("Stop cast, the provider number is %{public}d", providerNumber);
361     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
362         castHandle, "Can not find corresponding provider");
363     // The first 32 bits are providerId, the last 32 bits are castId
364     int32_t castId = static_cast<int32_t>((static_cast<const uint64_t>(castHandle) << 32) >> 32);
365     SLOGI("Stop cast, the castId is %{public}d", castId);
366     CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end(),
367         AVSESSION_ERROR, "Can not find corresponding castHandle");
368     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
369         && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
370     CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_[castHandle].outputDeviceInfo_.deviceInfos_.size() > 0,
371         AVSESSION_ERROR, "deviceInfos is empty");
372     providerManagerMap_[providerNumber]->provider_->RemoveCastDevice(castId,
373         castHandleToInfoMap_[castHandle].outputDeviceInfo_.deviceInfos_[0]);
374     hasSessionAlive_ = false;
375     SLOGI("AVRouterImpl stop cast process remove device done");
376 
377     if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
378         OutputDeviceInfo localDevice;
379         DeviceInfo localInfo;
380         localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
381         localInfo.deviceId_ = "-1";
382         localInfo.deviceName_ = "LocalDevice";
383         localDevice.deviceInfos_.emplace_back(localInfo);
384         castHandleToInfoMap_[castHandle].outputDeviceInfo_ = localDevice;
385     }
386     return AVSESSION_SUCCESS;
387 }
388 
StopCastSession(const int64_t castHandle)389 int32_t AVRouterImpl::StopCastSession(const int64_t castHandle)
390 {
391     SLOGI("AVRouterImpl stop cast session");
392 
393     int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
394 
395     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
396         castHandle, "Can not find corresponding provider");
397     // The first 32 bits are providerId, the last 32 bits are castId
398     int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
399     CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end(),
400         AVSESSION_ERROR, "Can not find corresponding castHandle");
401     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
402         && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
403     providerManagerMap_[providerNumber]->provider_->StopCastSession(castId);
404     hasSessionAlive_ = false;
405 
406     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
407         if (number == castHandle) {
408             castHandleToInfoMap_[number].avCastControllerProxy_ = nullptr;
409         }
410     }
411     return AVSESSION_SUCCESS;
412 }
413 
SetServiceAllConnectState(int64_t castHandle,DeviceInfo deviceInfo)414 int32_t AVRouterImpl::SetServiceAllConnectState(int64_t castHandle, DeviceInfo deviceInfo)
415 {
416     if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
417         OutputDeviceInfo device;
418         device.deviceInfos_.emplace_back(deviceInfo);
419         castHandleToInfoMap_[castHandle].outputDeviceInfo_ = device;
420     }
421     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) != providerManagerMap_.end(),
422         AVSESSION_ERROR, "Can not find corresponding provider");
423     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumberEnableDefault_] != nullptr
424         && providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr,
425         AVSESSION_ERROR, "provider is nullptr");
426     providerManagerMap_[providerNumberEnableDefault_]->provider_->SetStreamState(castHandle, deviceInfo);
427     return AVSESSION_SUCCESS;
428 }
429 
GetRemoteNetWorkId(int64_t castHandle,std::string deviceId,std::string & networkId)430 int32_t AVRouterImpl::GetRemoteNetWorkId(int64_t castHandle, std::string deviceId, std::string &networkId)
431 {
432     int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
433     int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
434     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
435         AVSESSION_ERROR, "Can not find corresponding provider");
436     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
437         && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
438     providerManagerMap_[providerNumber]->provider_->GetRemoteNetWorkId(castId, deviceId, networkId);
439     return AVSESSION_SUCCESS;
440 }
441 
RegisterCallback(int64_t castHandle,const std::shared_ptr<IAVRouterListener> callback,std::string sessionId,DeviceInfo deviceInfo)442 int32_t AVRouterImpl::RegisterCallback(int64_t castHandle, const std::shared_ptr<IAVRouterListener> callback,
443     std::string sessionId, DeviceInfo deviceInfo)
444 {
445     SLOGI("AVRouterImpl register IAVRouterListener callback to provider");
446     // The first 32 bits are providerId, the last 32 bits are castId
447     int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
448     // The first 32 bits are providerId, the last 32 bits are castId
449     int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
450     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
451         AVSESSION_ERROR, "Can not find corresponding provider");
452     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
453         && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
454     if (GetMirrorCastHandle() == -1) {
455         for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
456             if (number == castHandle && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
457                 castHandleInfo.avRouterListener_ != nullptr) {
458                 SLOGI("trigger the OnCastStateChange for disconnected/connected avRouterListener");
459                 castHandleInfo.avRouterListener_->OnCastStateChange(castConnectStateForDisconnect_,
460                     castHandleInfo.outputDeviceInfo_.deviceInfos_[0], false);
461                 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
462                 callback->OnCastStateChange(castConnectStateForConnected_,
463                     castHandleInfo.outputDeviceInfo_.deviceInfos_[0], false);
464                 return AVSESSION_SUCCESS;
465             }
466         }
467         providerManagerMap_[providerNumber]->provider_->RegisterCastSessionStateListener(castId, castSessionListener_);
468         if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
469             castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
470             castHandleToInfoMap_[castHandle].sessionId_ = sessionId;
471         }
472     } else {
473         mirrorSessionMap_[sessionId] = callback;
474         callback->OnCastStateChange(castConnectStateForConnected_, deviceInfo, false);
475     }
476     SLOGD("AVRouter impl register callback finished");
477     return AVSESSION_SUCCESS;
478 }
479 
UnRegisterCallback(int64_t castHandle,const std::shared_ptr<IAVRouterListener> callback,std::string sessionId)480 int32_t AVRouterImpl::UnRegisterCallback(int64_t castHandle,
481     const std::shared_ptr<IAVRouterListener> callback, std::string sessionId)
482 {
483     SLOGI("AVRouterImpl UnRegisterCallback IAVRouterListener callback to provider");
484     // The first 32 bits are providerId, the last 32 bits are castId
485     int32_t providerNumber = static_cast<uint64_t>(static_cast<uint64_t>(castHandle)) >> 32;
486     // The first 32 bits are providerId, the last 32 bits are castId
487     int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
488     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
489         AVSESSION_ERROR, "Can not find corresponding provider");
490     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
491         && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
492     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
493         if (castHandleInfo.sessionId_ == sessionId && number == castHandle) {
494             providerManagerMap_[providerNumber]->provider_->UnRegisterCastSessionStateListener(castId,
495                 castSessionListener_);
496             castHandleToInfoMap_[number].avRouterListener_ = nullptr;
497         }
498     }
499     if (mirrorSessionMap_.find(sessionId) != mirrorSessionMap_.end()) {
500         mirrorSessionMap_.erase(sessionId);
501     }
502     return AVSESSION_SUCCESS;
503 }
504 
GetMirrorCastHandle()505 int64_t AVRouterImpl::GetMirrorCastHandle()
506 {
507     CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) != providerManagerMap_.end(),
508         providerNumberEnableDefault_, "Can not find corresponding provider");
509     CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumberEnableDefault_] != nullptr &&
510         providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr,
511         AVSESSION_ERROR, "provider is nullptr");
512     return providerManagerMap_[providerNumberEnableDefault_]->provider_->GetMirrorCastHandle();
513 }
514 
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo)515 void AVRouterImpl::OnCastStateChange(int32_t castState, DeviceInfo deviceInfo)
516 {
517     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
518         if (castHandleInfo.avRouterListener_ != nullptr) {
519             SLOGI("trigger the OnCastStateChange for registered avRouterListener");
520             std::shared_ptr<IAVRouterListener> listener = castHandleInfo.avRouterListener_;
521             AVSessionEventHandler::GetInstance().AVSessionPostTask([listener, castState, deviceInfo]() {
522                 listener->OnCastStateChange(castState, deviceInfo, true);
523                 }, "OnCastStateChange", 0);
524             if (castState == castConnectStateForDisconnect_) {
525                 OutputDeviceInfo localDevice;
526                 DeviceInfo localInfo;
527                 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
528                 localInfo.deviceId_ = "-1";
529                 localInfo.deviceName_ = "LocalDevice";
530                 localDevice.deviceInfos_.emplace_back(localInfo);
531                 castHandleToInfoMap_[number].outputDeviceInfo_ = localDevice;
532             }
533         }
534     }
535 }
536 
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)537 void AVRouterImpl::OnCastEventRecv(int32_t errorCode, std::string& errorMsg)
538 {
539     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
540         if (castHandleInfo.avRouterListener_ != nullptr) {
541             SLOGI("trigger the OnCastEventRecv for registered avRouterListener");
542             castHandleInfo.avRouterListener_->OnCastEventRecv(errorCode, errorMsg);
543         }
544     }
545 }
546 
DisconnetOtherSession(std::string sessionId,DeviceInfo deviceInfo)547 void AVRouterImpl::DisconnetOtherSession(std::string sessionId, DeviceInfo deviceInfo)
548 {
549     for (const auto& [string, avRouterListener] : mirrorSessionMap_) {
550         if (string != sessionId && avRouterListener != nullptr) {
551             std::shared_ptr<IAVRouterListener> listener = avRouterListener;
552             avRouterListener->OnCastStateChange(castConnectStateForDisconnect_, deviceInfo, false);
553         }
554     }
555     for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
556         if (castHandleInfo.sessionId_ != sessionId) {
557             if (castHandleInfo.avRouterListener_ != nullptr) {
558                 castHandleInfo.avRouterListener_->OnCastStateChange(castConnectStateForDisconnect_, deviceInfo, false);
559             }
560             castHandleToInfoMap_[number].sessionId_ = sessionId;
561             castHandleToInfoMap_[number].avRouterListener_ = mirrorSessionMap_[sessionId];
562         }
563     }
564     mirrorSessionMap_.clear();
565 }
566 } // namespace OHOS::AVSession
567