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 %{public}d", providerNumber);
257 {
258 std::lock_guard lockGuard(servicePtrLock_);
259 if (servicePtr_ == nullptr) {
260 return ERR_SERVICE_NOT_EXIST;
261 }
262 servicePtr_->setInCast(false);
263 }
264 std::lock_guard lockGuard(providerManagerLock_);
265 hasSessionAlive_ = false;
266 providerNumber_ = providerNumberDisable_;
267 providerManagerMap_.clear();
268 castHandleToInfoMap_.clear();
269 return AVSESSION_SUCCESS;
270 }
271
GetRemoteController(const int64_t castHandle)272 std::shared_ptr<IAVCastControllerProxy> AVRouterImpl::GetRemoteController(const int64_t castHandle)
273 {
274 SLOGI("AVRouterImpl start get remote controller process");
275
276 // The first 32 bits are providerId, the last 32 bits are castId
277 int32_t providerNumber = static_cast<int32_t>(static_cast<const uint64_t>(castHandle) >> 32);
278 SLOGD("Get remote controller of provider %{public}d", providerNumber);
279 // The first 32 bits are providerId, the last 32 bits are castId
280 int32_t castId = static_cast<int32_t>((static_cast<const uint64_t>(castHandle) << 32) >> 32);
281 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
282 nullptr, "Can not find corresponding provider");
283 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr &&
284 providerManagerMap_[providerNumber]->provider_ != nullptr, nullptr, "provider is nullptr");
285 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
286 if (number == castHandle && castHandleInfo.avCastControllerProxy_ != nullptr) {
287 return castHandleInfo.avCastControllerProxy_;
288 }
289 }
290
291 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
292 castHandleToInfoMap_[castHandle].avCastControllerProxy_ =
293 providerManagerMap_[providerNumber]->provider_->GetRemoteController(castId);
294 }
295 return providerManagerMap_[providerNumber]->provider_->GetRemoteController(castId);
296 }
297
StartCast(const OutputDeviceInfo & outputDeviceInfo,std::map<std::string,std::string> & serviceNameMapState,std::string sessionId)298 int64_t AVRouterImpl::StartCast(const OutputDeviceInfo& outputDeviceInfo,
299 std::map<std::string, std::string>& serviceNameMapState, std::string sessionId)
300 {
301 SLOGI("AVRouterImpl start cast process");
302 castServiceNameMapState_ = serviceNameMapState;
303 int64_t castHandle = -1;
304 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(outputDeviceInfo.deviceInfos_[0].providerId_) !=
305 providerManagerMap_.end(), castHandle, "Can not find corresponding provider");
306 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_] != nullptr
307 && providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_ != nullptr,
308 AVSESSION_ERROR, "provider is nullptr");
309 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
310 if (castHandleInfo.sessionId_ != sessionId && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
311 castHandleInfo.outputDeviceInfo_.deviceInfos_[0].deviceId_ == outputDeviceInfo.deviceInfos_[0].deviceId_) {
312 castHandleToInfoMap_[number].sessionId_ = sessionId;
313 return number;
314 }
315 }
316 castHandleToInfoMap_.clear();
317 int32_t castId = providerManagerMap_[outputDeviceInfo.deviceInfos_[0].
318 providerId_]->provider_->StartCastSession();
319 CHECK_AND_RETURN_RET_LOG(castId != AVSESSION_ERROR, AVSESSION_ERROR, "StartCast failed");
320 int64_t tempId = outputDeviceInfo.deviceInfos_[0].providerId_;
321 // The first 32 bits are providerId, the last 32 bits are castId
322 castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) | static_cast<uint32_t>(castId));
323 hasSessionAlive_ = true;
324
325 CastHandleInfo castHandleInfo;
326 castHandleInfo.sessionId_ = sessionId;
327 OutputDeviceInfo localDevice;
328 DeviceInfo localInfo;
329 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
330 localInfo.deviceId_ = "-1";
331 localInfo.deviceName_ = "LocalDevice";
332 localDevice.deviceInfos_.emplace_back(localInfo);
333 castHandleInfo.outputDeviceInfo_ = localDevice;
334 castHandleToInfoMap_[castHandle] = castHandleInfo;
335 return castHandle;
336 }
337
AddDevice(const int32_t castId,const OutputDeviceInfo & outputDeviceInfo)338 int32_t AVRouterImpl::AddDevice(const int32_t castId, const OutputDeviceInfo& outputDeviceInfo)
339 {
340 SLOGI("AVRouterImpl AddDevice process");
341
342 int64_t tempId = outputDeviceInfo.deviceInfos_[0].providerId_;
343 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
344 static_cast<uint32_t>(castId));
345 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
346 if (castHandle == number && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
347 castHandleInfo.outputDeviceInfo_.deviceInfos_[0].deviceId_ == outputDeviceInfo.deviceInfos_[0].deviceId_) {
348 return AVSESSION_SUCCESS;
349 }
350 }
351 bool ret = providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_->AddCastDevice(castId,
352 outputDeviceInfo.deviceInfos_[0]);
353 SLOGI("AVRouterImpl AddDevice process with ret %{public}d", static_cast<int32_t>(ret));
354 if (ret && castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
355 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = outputDeviceInfo;
356 }
357 return ret ? AVSESSION_SUCCESS : ERR_DEVICE_CONNECTION_FAILED;
358 }
359
StopCast(const int64_t castHandle,bool continuePlay)360 int32_t AVRouterImpl::StopCast(const int64_t castHandle, bool continuePlay)
361 {
362 SLOGI("AVRouterImpl stop cast process");
363
364 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
365 SLOGI("Stop cast, the provider number is %{public}d", providerNumber);
366 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
367 castHandle, "Can not find corresponding provider");
368 // The first 32 bits are providerId, the last 32 bits are castId
369 int32_t castId = static_cast<int32_t>((static_cast<const uint64_t>(castHandle) << 32) >> 32);
370 SLOGI("Stop cast, the castId is %{public}d", castId);
371 CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end(),
372 AVSESSION_ERROR, "Can not find corresponding castHandle");
373 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
374 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
375 CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_[castHandle].outputDeviceInfo_.deviceInfos_.size() > 0,
376 AVSESSION_ERROR, "deviceInfos is empty");
377 providerManagerMap_[providerNumber]->provider_->RemoveCastDevice(castId,
378 castHandleToInfoMap_[castHandle].outputDeviceInfo_.deviceInfos_[0], continuePlay);
379 hasSessionAlive_ = false;
380 SLOGI("AVRouterImpl stop cast process remove device done");
381
382 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
383 OutputDeviceInfo localDevice;
384 DeviceInfo localInfo;
385 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
386 localInfo.deviceId_ = "-1";
387 localInfo.deviceName_ = "LocalDevice";
388 localDevice.deviceInfos_.emplace_back(localInfo);
389 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = localDevice;
390 }
391 return AVSESSION_SUCCESS;
392 }
393
StopCastSession(const int64_t castHandle)394 int32_t AVRouterImpl::StopCastSession(const int64_t castHandle)
395 {
396 SLOGI("AVRouterImpl stop cast session");
397
398 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
399
400 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
401 castHandle, "Can not find corresponding provider");
402 // The first 32 bits are providerId, the last 32 bits are castId
403 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
404 CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end(),
405 AVSESSION_ERROR, "Can not find corresponding castHandle");
406 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
407 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
408 providerManagerMap_[providerNumber]->provider_->StopCastSession(castId);
409 hasSessionAlive_ = false;
410
411 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
412 if (number == castHandle) {
413 castHandleToInfoMap_[number].avCastControllerProxy_ = nullptr;
414 }
415 }
416 return AVSESSION_SUCCESS;
417 }
418
SetServiceAllConnectState(int64_t castHandle,DeviceInfo deviceInfo)419 int32_t AVRouterImpl::SetServiceAllConnectState(int64_t castHandle, DeviceInfo deviceInfo)
420 {
421 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
422 OutputDeviceInfo device;
423 device.deviceInfos_.emplace_back(deviceInfo);
424 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = device;
425 }
426 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) != providerManagerMap_.end(),
427 AVSESSION_ERROR, "Can not find corresponding provider");
428 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumberEnableDefault_] != nullptr
429 && providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr,
430 AVSESSION_ERROR, "provider is nullptr");
431 providerManagerMap_[providerNumberEnableDefault_]->provider_->SetStreamState(castHandle, deviceInfo);
432 return AVSESSION_SUCCESS;
433 }
434
GetRemoteNetWorkId(int64_t castHandle,std::string deviceId,std::string & networkId)435 int32_t AVRouterImpl::GetRemoteNetWorkId(int64_t castHandle, std::string deviceId, std::string &networkId)
436 {
437 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
438 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
439 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
440 AVSESSION_ERROR, "Can not find corresponding provider");
441 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
442 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
443 providerManagerMap_[providerNumber]->provider_->GetRemoteNetWorkId(castId, deviceId, networkId);
444 return AVSESSION_SUCCESS;
445 }
446
RegisterCallback(int64_t castHandle,const std::shared_ptr<IAVRouterListener> callback,std::string sessionId,DeviceInfo deviceInfo)447 int32_t AVRouterImpl::RegisterCallback(int64_t castHandle, const std::shared_ptr<IAVRouterListener> callback,
448 std::string sessionId, DeviceInfo deviceInfo)
449 {
450 SLOGI("AVRouterImpl register IAVRouterListener callback to provider");
451 // The first 32 bits are providerId, the last 32 bits are castId
452 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
453 // The first 32 bits are providerId, the last 32 bits are castId
454 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
455 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
456 AVSESSION_ERROR, "Can not find corresponding provider");
457 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
458 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
459 if (GetMirrorCastHandle() == -1) {
460 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
461 if (number == castHandle && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
462 castHandleInfo.avRouterListener_ != nullptr) {
463 SLOGI("trigger the OnCastStateChange for disconnected/connected avRouterListener");
464 castHandleInfo.avRouterListener_->OnCastStateChange(castConnectStateForDisconnect_,
465 castHandleInfo.outputDeviceInfo_.deviceInfos_[0], false);
466 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
467 callback->OnCastStateChange(castConnectStateForConnected_,
468 castHandleInfo.outputDeviceInfo_.deviceInfos_[0], false);
469 return AVSESSION_SUCCESS;
470 }
471 }
472 providerManagerMap_[providerNumber]->provider_->RegisterCastSessionStateListener(castId, castSessionListener_);
473 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
474 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
475 castHandleToInfoMap_[castHandle].sessionId_ = sessionId;
476 }
477 } else {
478 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end() &&
479 castHandleToInfoMap_[castHandle].avRouterListener_ == nullptr) {
480 providerManagerMap_[providerNumber]->provider_->RegisterCastSessionStateListener(castId,
481 castSessionListener_);
482 OutputDeviceInfo outputDevice;
483 outputDevice.deviceInfos_.emplace_back(deviceInfo);
484 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = outputDevice;
485 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
486 castHandleToInfoMap_[castHandle].sessionId_ = sessionId;
487 } else {
488 mirrorSessionMap_[sessionId] = callback;
489 }
490 callback->OnCastStateChange(castConnectStateForConnected_, deviceInfo, false);
491 }
492 SLOGD("AVRouter impl register callback finished");
493 return AVSESSION_SUCCESS;
494 }
495
UnRegisterCallback(int64_t castHandle,const std::shared_ptr<IAVRouterListener> callback,std::string sessionId)496 int32_t AVRouterImpl::UnRegisterCallback(int64_t castHandle,
497 const std::shared_ptr<IAVRouterListener> callback, std::string sessionId)
498 {
499 SLOGI("AVRouterImpl UnRegisterCallback IAVRouterListener callback to provider");
500 // The first 32 bits are providerId, the last 32 bits are castId
501 int32_t providerNumber = static_cast<uint64_t>(static_cast<uint64_t>(castHandle)) >> 32;
502 // The first 32 bits are providerId, the last 32 bits are castId
503 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
504 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
505 AVSESSION_ERROR, "Can not find corresponding provider");
506 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
507 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
508 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
509 if (castHandleInfo.sessionId_ == sessionId && number == castHandle) {
510 providerManagerMap_[providerNumber]->provider_->UnRegisterCastSessionStateListener(castId,
511 castSessionListener_);
512 castHandleToInfoMap_[number].avRouterListener_ = nullptr;
513 }
514 }
515 if (mirrorSessionMap_.find(sessionId) != mirrorSessionMap_.end()) {
516 mirrorSessionMap_.erase(sessionId);
517 }
518 return AVSESSION_SUCCESS;
519 }
520
GetMirrorCastHandle()521 int64_t AVRouterImpl::GetMirrorCastHandle()
522 {
523 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) != providerManagerMap_.end(),
524 providerNumberEnableDefault_, "Can not find corresponding provider");
525 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumberEnableDefault_] != nullptr &&
526 providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr,
527 AVSESSION_ERROR, "provider is nullptr");
528 return providerManagerMap_[providerNumberEnableDefault_]->provider_->GetMirrorCastHandle();
529 }
530
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo)531 void AVRouterImpl::OnCastStateChange(int32_t castState, DeviceInfo deviceInfo)
532 {
533 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
534 if (castHandleInfo.avRouterListener_ != nullptr) {
535 SLOGI("trigger the OnCastStateChange for registered avRouterListener");
536 std::shared_ptr<IAVRouterListener> listener = castHandleInfo.avRouterListener_;
537 AVSessionEventHandler::GetInstance().AVSessionPostTask([listener, castState, deviceInfo]() {
538 listener->OnCastStateChange(castState, deviceInfo, true);
539 }, "OnCastStateChange", 0);
540 if (castState == castConnectStateForDisconnect_) {
541 OutputDeviceInfo localDevice;
542 DeviceInfo localInfo;
543 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
544 localInfo.deviceId_ = "-1";
545 localInfo.deviceName_ = "LocalDevice";
546 localDevice.deviceInfos_.emplace_back(localInfo);
547 castHandleToInfoMap_[number].outputDeviceInfo_ = localDevice;
548 }
549 }
550 }
551 }
552
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)553 void AVRouterImpl::OnCastEventRecv(int32_t errorCode, std::string& errorMsg)
554 {
555 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
556 if (castHandleInfo.avRouterListener_ != nullptr) {
557 SLOGI("trigger the OnCastEventRecv for registered avRouterListener");
558 castHandleInfo.avRouterListener_->OnCastEventRecv(errorCode, errorMsg);
559 }
560 }
561 }
562
DisconnetOtherSession(std::string sessionId,DeviceInfo deviceInfo)563 void AVRouterImpl::DisconnetOtherSession(std::string sessionId, DeviceInfo deviceInfo)
564 {
565 for (const auto& [string, avRouterListener] : mirrorSessionMap_) {
566 if (string != sessionId && avRouterListener != nullptr) {
567 std::shared_ptr<IAVRouterListener> listener = avRouterListener;
568 avRouterListener->OnCastStateChange(castConnectStateForDisconnect_, deviceInfo, false);
569 }
570 }
571 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
572 if (castHandleInfo.sessionId_ != sessionId) {
573 if (castHandleInfo.avRouterListener_ != nullptr) {
574 castHandleInfo.avRouterListener_->OnCastStateChange(castConnectStateForDisconnect_, deviceInfo, false);
575 }
576 castHandleToInfoMap_[number].sessionId_ = sessionId;
577 castHandleToInfoMap_[number].avRouterListener_ = mirrorSessionMap_[sessionId];
578 }
579 }
580 mirrorSessionMap_.clear();
581 }
582 } // namespace OHOS::AVSession
583