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 #include "device_manager.h"
25
26 namespace OHOS::AVSession {
AVRouterImpl()27 AVRouterImpl::AVRouterImpl()
28 {
29 SLOGD("AVRouter construct");
30 }
31
GetLocalDeviceType()32 int32_t AVRouterImpl::GetLocalDeviceType()
33 {
34 int32_t deviceType = -1;
35 int32_t ret = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceType("av_session", deviceType);
36 CHECK_AND_RETURN_RET_LOG(ret == 0, deviceType, "get local device type failed with ret:%{public}d", ret);
37 return deviceType;
38 }
39
Init(IAVSessionServiceListener * servicePtr)40 int32_t AVRouterImpl::Init(IAVSessionServiceListener *servicePtr)
41 {
42 SLOGI("Start init AVRouter");
43 deviceType_ = GetLocalDeviceType();
44 {
45 std::lock_guard lockGuard(servicePtrLock_);
46 servicePtr_ = servicePtr;
47 }
48 castSessionListener_ = std::make_shared<CastSessionListener>(this);
49 hwProvider_ = std::make_shared<HwCastProvider>();
50 if (hwProvider_ != nullptr && hwProvider_->Init() != AVSESSION_ERROR) {
51 SLOGI("init pvd success");
52 } else {
53 hwProvider_ = nullptr;
54 SLOGE("init with null pvd to init");
55 return AVSESSION_ERROR;
56 }
57 providerNumber_ = providerNumberEnableDefault_;
58 std::shared_ptr<AVCastProviderManager> avCastProviderManager = std::make_shared<AVCastProviderManager>();
59 if (avCastProviderManager == nullptr) {
60 SLOGE("init with null manager");
61 return AVSESSION_ERROR;
62 }
63 avCastProviderManager->Init(providerNumber_, hwProvider_);
64 providerManagerMap_[providerNumber_] = avCastProviderManager;
65 if (hwProvider_ != nullptr) {
66 hwProvider_->RegisterCastStateListener(avCastProviderManager);
67 } else {
68 SLOGE("init with null pvd to registerlistener");
69 return AVSESSION_ERROR;
70 }
71 std::lock_guard lockGuard(providerManagerLock_);
72 if (cacheStartDiscovery_) {
73 SLOGI("cacheStartDiscovery check do discovery");
74 StartCastDiscovery(cacheCastDeviceCapability_, cacheDrmSchemes_);
75 cacheStartDiscovery_ = false;
76 }
77 SLOGI("init AVRouter done");
78 return AVSESSION_SUCCESS;
79 }
80
Release()81 bool AVRouterImpl::Release()
82 {
83 SLOGI("Start Release AVRouter");
84 if (hwProvider_ == nullptr) {
85 SLOGE("Start Release AVRouter err for no provider");
86 return false;
87 }
88 std::lock_guard lockGuard(providerManagerLock_);
89
90 if (hwProvider_ == nullptr) {
91 SLOGE("repeat check for no pvd");
92 return false;
93 }
94 SLOGI("repeat check for pvd alive");
95 hwProvider_->Release();
96 hwProvider_ = nullptr;
97 providerNumber_ = providerNumberDisable_;
98 providerManagerMap_.clear();
99 castHandleToInfoMap_.clear();
100 SLOGD("Release AVRouter done");
101 return false;
102 }
103
StartDeviceLogging(int32_t fd,uint32_t maxSize)104 int32_t AVRouterImpl::StartDeviceLogging(int32_t fd, uint32_t maxSize)
105 {
106 SLOGI("AVRouterImpl StartDeviceLogging");
107 std::lock_guard lockGuard(providerManagerLock_);
108
109 if (providerManagerMap_.empty()) {
110 cacheStartDeviceLogging_ = true;
111 return AVSESSION_SUCCESS;
112 }
113 for (const auto& [number, providerManager] : providerManagerMap_) {
114 CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
115 AVSESSION_ERROR, "provider is nullptr");
116 providerManager->provider_->StartDeviceLogging(fd, maxSize);
117 }
118 return AVSESSION_SUCCESS;
119 }
120
StopDeviceLogging()121 int32_t AVRouterImpl::StopDeviceLogging()
122 {
123 SLOGI("AVRouterImpl StopDeviceLogging");
124 std::lock_guard lockGuard(providerManagerLock_);
125
126 if (cacheStartDeviceLogging_) {
127 SLOGI("clear cacheStartDeviceLogging_ when stop discovery");
128 cacheStartDeviceLogging_ = false;
129 }
130 for (const auto& [number, providerManager] : providerManagerMap_) {
131 CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
132 AVSESSION_ERROR, "provider is nullptr");
133 providerManager->provider_->StopDeviceLogging();
134 }
135 return AVSESSION_SUCCESS;
136 }
137
StartCastDiscovery(int32_t castDeviceCapability,std::vector<std::string> drmSchemes)138 int32_t AVRouterImpl::StartCastDiscovery(int32_t castDeviceCapability, std::vector<std::string> drmSchemes)
139 {
140 SLOGI("AVRouterImpl StartCastDiscovery");
141
142 std::lock_guard lockGuard(providerManagerLock_);
143
144 auto pid = IPCSkeleton::GetCallingPid();
145 cacheStartDiscoveryPids_.insert(pid);
146 cacheCastDeviceCapability_ = castDeviceCapability;
147 cacheDrmSchemes_ = drmSchemes;
148 if (providerManagerMap_.empty()) {
149 SLOGI("set cacheStartDiscovery with no element with cap %{public}d", static_cast<int>(castDeviceCapability));
150 cacheStartDiscovery_ = true;
151 return AVSESSION_SUCCESS;
152 }
153 for (const auto& [number, providerManager] : providerManagerMap_) {
154 CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
155 AVSESSION_ERROR, "provider is nullptr");
156 providerManager->provider_->StartDiscovery(castDeviceCapability, drmSchemes);
157 }
158 return AVSESSION_SUCCESS;
159 }
160
StopCastDiscovery()161 int32_t AVRouterImpl::StopCastDiscovery()
162 {
163 SLOGI("AVRouterImpl StopCastDiscovery");
164
165 std::lock_guard lockGuard(providerManagerLock_);
166
167 auto pid = IPCSkeleton::GetCallingPid();
168 CHECK_AND_RETURN_RET_LOG(IsStopCastDiscovery(pid), AVSESSION_SUCCESS,
169 "StopCastDiscovery is invalid");
170 if (cacheStartDiscovery_) {
171 SLOGI("clear cacheStartDiscovery when stop discovery");
172 cacheStartDiscovery_ = false;
173 }
174 for (const auto& [number, providerManager] : providerManagerMap_) {
175 CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
176 AVSESSION_ERROR, "provider is nullptr");
177 providerManager->provider_->StopDiscovery();
178 }
179 return AVSESSION_SUCCESS;
180 }
181
IsStopCastDiscovery(pid_t pid)182 bool AVRouterImpl::IsStopCastDiscovery(pid_t pid)
183 {
184 std::lock_guard lockGuard(providerManagerLock_);
185 if (cacheStartDiscoveryPids_.find(pid) != cacheStartDiscoveryPids_.end()) {
186 cacheStartDiscoveryPids_.erase(pid);
187 if (cacheStartDiscoveryPids_.empty()) {
188 return true;
189 } else {
190 SLOGI("other pid is not calling StopCastDiscovery");
191 }
192 } else {
193 SLOGI("pid:%{public}d is not include in cacheStartDiscoveryPids", static_cast<int>(pid));
194 }
195 return false;
196 }
197
SetDiscoverable(const bool enable)198 int32_t AVRouterImpl::SetDiscoverable(const bool enable)
199 {
200 SLOGI("AVRouterImpl SetDiscoverable %{public}d", enable);
201 std::lock_guard lockGuard(providerManagerLock_);
202
203 for (const auto& [number, providerManager] : providerManagerMap_) {
204 CHECK_AND_RETURN_RET_LOG(providerManager != nullptr && providerManager->provider_ != nullptr,
205 AVSESSION_ERROR, "provider is nullptr");
206 providerManager->provider_->SetDiscoverable(enable);
207 }
208
209 return AVSESSION_SUCCESS;
210 }
211
OnDeviceAvailable(OutputDeviceInfo & castOutputDeviceInfo)212 int32_t AVRouterImpl::OnDeviceAvailable(OutputDeviceInfo& castOutputDeviceInfo)
213 {
214 SLOGI("AVRouterImpl received OnDeviceAvailable event");
215
216 std::lock_guard lockGuard(servicePtrLock_);
217 if (servicePtr_ == nullptr) {
218 return ERR_SERVICE_NOT_EXIST;
219 }
220 servicePtr_->NotifyDeviceAvailable(castOutputDeviceInfo);
221 return AVSESSION_SUCCESS;
222 }
223
OnDeviceLogEvent(const DeviceLogEventCode eventId,const int64_t param)224 int32_t AVRouterImpl::OnDeviceLogEvent(const DeviceLogEventCode eventId, const int64_t param)
225 {
226 SLOGI("AVRouterImpl received OnDeviceLogEvent event");
227
228 std::lock_guard lockGuard(servicePtrLock_);
229 if (servicePtr_ == nullptr) {
230 return ERR_SERVICE_NOT_EXIST;
231 }
232 servicePtr_->NotifyDeviceLogEvent(eventId, param);
233 return AVSESSION_SUCCESS;
234 }
235
ReleaseCurrentCastSession()236 void AVRouterImpl::ReleaseCurrentCastSession()
237 {
238 SLOGI("Start ReleaseCurrentCastSession");
239 std::lock_guard lockGuard(servicePtrLock_);
240 servicePtr_->ReleaseCastSession();
241 }
242
OnCastSessionCreated(const int32_t castId)243 int32_t AVRouterImpl::OnCastSessionCreated(const int32_t castId)
244 {
245 SLOGI("AVRouterImpl On cast session created, cast id is %{public}d", castId);
246
247 castHandleToInfoMap_.clear();
248 int64_t castHandle = -1;
249 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) !=
250 providerManagerMap_.end(), castHandle, "Can not find corresponding provider");
251 CHECK_AND_RETURN_RET_LOG((providerManagerMap_[providerNumberEnableDefault_] != nullptr) &&
252 (providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr),
253 AVSESSION_ERROR, "provider is nullptr");
254 int64_t tempId = 1;
255 // The first 32 bits are providerId, the last 32 bits are castId
256 castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
257 static_cast<const uint32_t>(castId));
258 CastHandleInfo castHandleInfo;
259 OutputDeviceInfo outputDeviceInfo;
260 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
261 castHandleToInfoMap_[castHandle] = castHandleInfo;
262 {
263 std::lock_guard lockGuard(servicePtrLock_);
264 servicePtr_->CreateSessionByCast(castHandle);
265 }
266 return AVSESSION_SUCCESS;
267 }
268
OnDeviceOffline(const std::string & deviceId)269 int32_t AVRouterImpl::OnDeviceOffline(const std::string& deviceId)
270 {
271 SLOGI("AVRouterImpl received OnDeviceOffline event");
272
273 std::lock_guard lockGuard(servicePtrLock_);
274 if (servicePtr_ == nullptr) {
275 return ERR_SERVICE_NOT_EXIST;
276 }
277 servicePtr_->NotifyDeviceOffline(deviceId);
278 return AVSESSION_SUCCESS;
279 }
280
OnDeviceStateChange(const DeviceState & deviceState)281 int32_t AVRouterImpl::OnDeviceStateChange(const DeviceState& deviceState)
282 {
283 SLOGI("AVRouterImpl received OnDeviceStateChange event");
284
285 std::lock_guard lockGuard(servicePtrLock_);
286 if (servicePtr_ == nullptr) {
287 return ERR_SERVICE_NOT_EXIST;
288 }
289 servicePtr_->NotifyDeviceStateChange(deviceState);
290 return AVSESSION_SUCCESS;
291 }
292
OnCastServerDied(int32_t providerNumber)293 int32_t AVRouterImpl::OnCastServerDied(int32_t providerNumber)
294 {
295 SLOGI("AVRouterImpl received OnCastServerDied event %{public}d", providerNumber);
296 {
297 std::lock_guard lockGuard(servicePtrLock_);
298 if (servicePtr_ == nullptr) {
299 return ERR_SERVICE_NOT_EXIST;
300 }
301 servicePtr_->setInCast(false);
302 }
303 std::lock_guard lockGuard(providerManagerLock_);
304 providerNumber_ = providerNumberDisable_;
305 providerManagerMap_.clear();
306
307 DeviceInfo deviceInfo(AVCastCategory::CATEGORY_LOCAL, "-1", "RemoteCast");
308 OnCastStateChange(disconnectStateFromCast_, deviceInfo);
309 castHandleToInfoMap_.clear();
310
311 if (deviceType_ == DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE) {
312 std::this_thread::sleep_for(std::chrono::milliseconds(castEngineServiceRestartWaitTime));
313 StartCastDiscovery(cacheCastDeviceCapability_, cacheDrmSchemes_);
314 std::lock_guard lockGuard(servicePtrLock_);
315 if (servicePtr_ != nullptr) {
316 servicePtr_->checkEnableCast(true);
317 }
318 }
319
320 return AVSESSION_SUCCESS;
321 }
322
GetRemoteController(const int64_t castHandle)323 std::shared_ptr<IAVCastControllerProxy> AVRouterImpl::GetRemoteController(const int64_t castHandle)
324 {
325 SLOGI("AVRouterImpl start get remote controller process");
326
327 // The first 32 bits are providerId, the last 32 bits are castId
328 int32_t providerNumber = static_cast<int32_t>(static_cast<const uint64_t>(castHandle) >> 32);
329 SLOGD("Get remote controller of provider %{public}d", providerNumber);
330 // The first 32 bits are providerId, the last 32 bits are castId
331 int32_t castId = static_cast<int32_t>((static_cast<const uint64_t>(castHandle) << 32) >> 32);
332 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
333 nullptr, "Can not find corresponding provider");
334 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr &&
335 providerManagerMap_[providerNumber]->provider_ != nullptr, nullptr, "provider is nullptr");
336 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
337 if (number == castHandle && castHandleInfo.avCastControllerProxy_ != nullptr) {
338 return castHandleInfo.avCastControllerProxy_;
339 }
340 }
341
342 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
343 castHandleToInfoMap_[castHandle].avCastControllerProxy_ =
344 providerManagerMap_[providerNumber]->provider_->GetRemoteController(castId);
345 }
346 return providerManagerMap_[providerNumber]->provider_->GetRemoteController(castId);
347 }
348
StartCast(const OutputDeviceInfo & outputDeviceInfo,std::pair<std::string,std::string> & serviceNameStatePair,std::string sessionId)349 int64_t AVRouterImpl::StartCast(const OutputDeviceInfo& outputDeviceInfo,
350 std::pair<std::string, std::string>& serviceNameStatePair, std::string sessionId)
351 {
352 SLOGI("AVRouterImpl start cast process");
353 castServiceNameStatePair_ = serviceNameStatePair;
354 int64_t castHandle = -1;
355 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(outputDeviceInfo.deviceInfos_[0].providerId_) !=
356 providerManagerMap_.end(), castHandle, "Can not find corresponding provider");
357 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_] != nullptr
358 && providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_ != nullptr,
359 AVSESSION_ERROR, "provider is nullptr");
360 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
361 if (castHandleInfo.sessionId_ != sessionId && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
362 castHandleInfo.outputDeviceInfo_.deviceInfos_[0].deviceId_ == outputDeviceInfo.deviceInfos_[0].deviceId_) {
363 castHandleToInfoMap_[number].sessionId_ = sessionId;
364 return number;
365 }
366 }
367 int32_t castId = providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_->StartCastSession(
368 static_cast<uint32_t>(outputDeviceInfo.deviceInfos_[0].supportedProtocols_) &
369 ProtocolType::TYPE_CAST_PLUS_AUDIO);
370 CHECK_AND_RETURN_RET_LOG(castId != AVSESSION_ERROR, AVSESSION_ERROR, "StartCast failed");
371 int64_t tempId = outputDeviceInfo.deviceInfos_[0].providerId_;
372 // The first 32 bits are providerId, the last 32 bits are castId
373 castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) | static_cast<uint32_t>(castId));
374
375 CastHandleInfo castHandleInfo;
376 castHandleInfo.sessionId_ = sessionId;
377 OutputDeviceInfo localDevice;
378 DeviceInfo localInfo;
379 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
380 localInfo.deviceId_ = "-1";
381 localInfo.deviceName_ = "LocalDevice";
382 localDevice.deviceInfos_.emplace_back(localInfo);
383 castHandleInfo.outputDeviceInfo_ = localDevice;
384 castHandleToInfoMap_[castHandle] = castHandleInfo;
385 return castHandle;
386 }
387
AddDevice(const int32_t castId,const OutputDeviceInfo & outputDeviceInfo,uint32_t spid)388 int32_t AVRouterImpl::AddDevice(const int32_t castId, const OutputDeviceInfo& outputDeviceInfo,
389 uint32_t spid)
390 {
391 SLOGI("AVRouterImpl AddDevice process");
392
393 int64_t tempId = outputDeviceInfo.deviceInfos_[0].providerId_;
394 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
395 static_cast<uint32_t>(castId));
396 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
397 if (castHandle == number && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
398 castHandleInfo.outputDeviceInfo_.deviceInfos_[0].deviceId_ == outputDeviceInfo.deviceInfos_[0].deviceId_) {
399 return AVSESSION_SUCCESS;
400 }
401 }
402 bool ret = providerManagerMap_[outputDeviceInfo.deviceInfos_[0].providerId_]->provider_->AddCastDevice(castId,
403 outputDeviceInfo.deviceInfos_[0], spid);
404 SLOGI("AVRouterImpl AddDevice process with ret %{public}d", static_cast<int32_t>(ret));
405 if (ret && castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
406 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = outputDeviceInfo;
407 }
408 return ret ? AVSESSION_SUCCESS : ERR_DEVICE_CONNECTION_FAILED;
409 }
410
StopCast(const int64_t castHandle,bool continuePlay)411 int32_t AVRouterImpl::StopCast(const int64_t castHandle, bool continuePlay)
412 {
413 SLOGI("AVRouterImpl stop cast process");
414
415 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
416 SLOGI("Stop cast, the provider number is %{public}d", providerNumber);
417 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
418 castHandle, "Can not find corresponding provider");
419 // The first 32 bits are providerId, the last 32 bits are castId
420 int32_t castId = static_cast<int32_t>((static_cast<const uint64_t>(castHandle) << 32) >> 32);
421 SLOGI("Stop cast, the castId is %{public}d", castId);
422 CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end(),
423 AVSESSION_ERROR, "Can not find corresponding castHandle");
424 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
425 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
426 CHECK_AND_RETURN_RET_LOG(castHandleToInfoMap_[castHandle].outputDeviceInfo_.deviceInfos_.size() > 0,
427 AVSESSION_ERROR, "deviceInfos is empty");
428 providerManagerMap_[providerNumber]->provider_->RemoveCastDevice(castId,
429 castHandleToInfoMap_[castHandle].outputDeviceInfo_.deviceInfos_[0], continuePlay);
430 SLOGI("AVRouterImpl stop cast process remove device done");
431
432 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
433 OutputDeviceInfo localDevice;
434 DeviceInfo localInfo;
435 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
436 localInfo.deviceId_ = "-1";
437 localInfo.deviceName_ = "LocalDevice";
438 localDevice.deviceInfos_.emplace_back(localInfo);
439 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = localDevice;
440 }
441 return AVSESSION_SUCCESS;
442 }
443
StopCastSession(const int64_t castHandle)444 int32_t AVRouterImpl::StopCastSession(const int64_t castHandle)
445 {
446 SLOGI("AVRouterImpl stop cast session");
447
448 isInMirrorToStream_ = false;
449 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
450
451 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
452 castHandle, "Can not find corresponding provider");
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(castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end(),
456 AVSESSION_ERROR, "Can not find corresponding castHandle");
457 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
458 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
459 providerManagerMap_[providerNumber]->provider_->StopCastSession(castId);
460
461 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
462 if (number == castHandle) {
463 castHandleToInfoMap_[number].avCastControllerProxy_ = nullptr;
464 }
465 }
466 return AVSESSION_SUCCESS;
467 }
468
SetServiceAllConnectState(int64_t castHandle,DeviceInfo deviceInfo)469 int32_t AVRouterImpl::SetServiceAllConnectState(int64_t castHandle, DeviceInfo deviceInfo)
470 {
471 int64_t realCastHandle = castHandle == noMirrorCastHandle_ ? GetMirrorCastHandle() : castHandle;
472 if (castHandleToInfoMap_.find(realCastHandle) != castHandleToInfoMap_.end()) {
473 OutputDeviceInfo device;
474 device.deviceInfos_.emplace_back(deviceInfo);
475 castHandleToInfoMap_[realCastHandle].outputDeviceInfo_ = device;
476 }
477 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) != providerManagerMap_.end(),
478 AVSESSION_ERROR, "Can not find corresponding provider");
479 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumberEnableDefault_] != nullptr
480 && providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr,
481 AVSESSION_ERROR, "provider is nullptr");
482 providerManagerMap_[providerNumberEnableDefault_]->provider_->SetStreamState(castHandle, deviceInfo);
483 return AVSESSION_SUCCESS;
484 }
485
GetRemoteNetWorkId(int64_t castHandle,std::string deviceId,std::string & networkId)486 int32_t AVRouterImpl::GetRemoteNetWorkId(int64_t castHandle, std::string deviceId, std::string &networkId)
487 {
488 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
489 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
490 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
491 AVSESSION_ERROR, "Can not find corresponding provider");
492 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
493 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
494 providerManagerMap_[providerNumber]->provider_->GetRemoteNetWorkId(castId, deviceId, networkId);
495 return AVSESSION_SUCCESS;
496 }
497
GetRemoteDrmCapabilities(int64_t castHandle,std::string deviceId,std::vector<std::string> & drmCapabilities)498 int32_t AVRouterImpl::GetRemoteDrmCapabilities(int64_t castHandle, std::string deviceId,
499 std::vector<std::string> &drmCapabilities)
500 {
501 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
502 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
503 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
504 AVSESSION_ERROR, "Can not find corresponding provider");
505 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
506 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
507 providerManagerMap_[providerNumber]->provider_->GetRemoteDrmCapabilities(castId, deviceId, drmCapabilities);
508 return AVSESSION_SUCCESS;
509 }
510
RegisterCallback(int64_t castHandle,const std::shared_ptr<IAVRouterListener> callback,std::string sessionId,DeviceInfo deviceInfo)511 int32_t AVRouterImpl::RegisterCallback(int64_t castHandle, const std::shared_ptr<IAVRouterListener> callback,
512 std::string sessionId, DeviceInfo deviceInfo)
513 {
514 SLOGI("AVRouterImpl register IAVRouterListener callback to provider");
515 // The first 32 bits are providerId, the last 32 bits are castId
516 int32_t providerNumber = static_cast<int32_t>(static_cast<uint64_t>(castHandle) >> 32);
517 // The first 32 bits are providerId, the last 32 bits are castId
518 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
519 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
520 AVSESSION_ERROR, "Can not find corresponding provider");
521 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
522 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
523 if (GetMirrorCastHandle() == noMirrorCastHandle_) {
524 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
525 if (number == castHandle && castHandleInfo.outputDeviceInfo_.deviceInfos_.size() > 0 &&
526 castHandleInfo.avRouterListener_ != nullptr) {
527 SLOGI("trigger the OnCastStateChange for disconnected/connected avRouterListener");
528 castHandleInfo.avRouterListener_->OnCastStateChange(disconnectStateFromCast_,
529 castHandleInfo.outputDeviceInfo_.deviceInfos_[0], false);
530 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
531 callback->OnCastStateChange(connectStateFromCast_,
532 castHandleInfo.outputDeviceInfo_.deviceInfos_[0], false);
533 return AVSESSION_SUCCESS;
534 }
535 }
536 providerManagerMap_[providerNumber]->provider_->RegisterCastSessionStateListener(castId, castSessionListener_);
537 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end()) {
538 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
539 castHandleToInfoMap_[castHandle].sessionId_ = sessionId;
540 }
541 } else {
542 if (castHandleToInfoMap_.find(castHandle) != castHandleToInfoMap_.end() &&
543 castHandleToInfoMap_[castHandle].avRouterListener_ == nullptr) {
544 providerManagerMap_[providerNumber]->provider_->RegisterCastSessionStateListener(castId,
545 castSessionListener_);
546 OutputDeviceInfo outputDevice;
547 outputDevice.deviceInfos_.emplace_back(deviceInfo);
548 castHandleToInfoMap_[castHandle].outputDeviceInfo_ = outputDevice;
549 castHandleToInfoMap_[castHandle].avRouterListener_ = callback;
550 castHandleToInfoMap_[castHandle].sessionId_ = sessionId;
551 } else {
552 mirrorSessionMap_[sessionId] = callback;
553 }
554 callback->OnCastStateChange(connectStateFromCast_, deviceInfo, false);
555 }
556 SLOGD("AVRouter impl register callback finished");
557 return AVSESSION_SUCCESS;
558 }
559
UnRegisterCallback(int64_t castHandle,const std::shared_ptr<IAVRouterListener> callback,std::string sessionId)560 int32_t AVRouterImpl::UnRegisterCallback(int64_t castHandle,
561 const std::shared_ptr<IAVRouterListener> callback, std::string sessionId)
562 {
563 SLOGI("AVRouterImpl UnRegisterCallback IAVRouterListener callback to provider");
564 // The first 32 bits are providerId, the last 32 bits are castId
565 int32_t providerNumber = static_cast<uint64_t>(static_cast<uint64_t>(castHandle)) >> 32;
566 // The first 32 bits are providerId, the last 32 bits are castId
567 int32_t castId = static_cast<int32_t>((static_cast<uint64_t>(castHandle) << 32) >> 32);
568 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumber) != providerManagerMap_.end(),
569 AVSESSION_ERROR, "Can not find corresponding provider");
570 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumber] != nullptr
571 && providerManagerMap_[providerNumber]->provider_ != nullptr, AVSESSION_ERROR, "provider is nullptr");
572 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
573 if (castHandleInfo.sessionId_ == sessionId && number == castHandle) {
574 providerManagerMap_[providerNumber]->provider_->UnRegisterCastSessionStateListener(castId,
575 castSessionListener_);
576 castHandleToInfoMap_[number].avRouterListener_ = nullptr;
577 }
578 }
579 if (mirrorSessionMap_.find(sessionId) != mirrorSessionMap_.end()) {
580 mirrorSessionMap_.erase(sessionId);
581 }
582 return AVSESSION_SUCCESS;
583 }
584
GetMirrorCastHandle()585 int64_t AVRouterImpl::GetMirrorCastHandle()
586 {
587 CHECK_AND_RETURN_RET_LOG(providerManagerMap_.find(providerNumberEnableDefault_) != providerManagerMap_.end(),
588 providerNumberEnableDefault_, "Can not find corresponding provider");
589 CHECK_AND_RETURN_RET_LOG(providerManagerMap_[providerNumberEnableDefault_] != nullptr &&
590 providerManagerMap_[providerNumberEnableDefault_]->provider_ != nullptr,
591 AVSESSION_ERROR, "provider is nullptr");
592 return providerManagerMap_[providerNumberEnableDefault_]->provider_->GetMirrorCastHandle();
593 }
594
IsInMirrorToStreamState()595 bool AVRouterImpl::IsInMirrorToStreamState()
596 {
597 return isInMirrorToStream_;
598 }
599
IsRemoteCasting()600 bool AVRouterImpl::IsRemoteCasting()
601 {
602 return isRemoteCasting_;
603 }
604
UpdateConnectState(int32_t castState)605 void AVRouterImpl::UpdateConnectState(int32_t castState)
606 {
607 if (castState == static_cast<int32_t>(CastEngine::DeviceState::MIRROR_TO_STREAM) ||
608 castState == static_cast<int32_t>(CastEngine::DeviceState::STREAM_TO_MIRROR)) {
609 isInMirrorToStream_ = (castState == static_cast<int32_t>(CastEngine::DeviceState::MIRROR_TO_STREAM));
610 }
611 if (castState == static_cast<int32_t>(CastEngine::DeviceState::STREAM) ||
612 castState == static_cast<int32_t>(CastEngine::DeviceState::DISCONNECTED)) {
613 isRemoteCasting_ = (castState == static_cast<int32_t>(CastEngine::DeviceState::STREAM));
614 }
615 }
616
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo)617 void AVRouterImpl::OnCastStateChange(int32_t castState, DeviceInfo deviceInfo)
618 {
619 UpdateConnectState(castState);
620 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
621 if (castHandleInfo.avRouterListener_ != nullptr) {
622 SLOGI("trigger the OnCastStateChange for registered avRouterListener");
623 std::shared_ptr<IAVRouterListener> listener = castHandleInfo.avRouterListener_;
624 AVSessionEventHandler::GetInstance().AVSessionPostTask([listener, castState, deviceInfo]() {
625 CHECK_AND_RETURN_LOG(listener != nullptr, "listener is nullptr");
626 listener->OnCastStateChange(castState, deviceInfo, true);
627 }, "OnCastStateChange", 0);
628 if (castState == disconnectStateFromCast_) {
629 OutputDeviceInfo localDevice;
630 DeviceInfo localInfo;
631 localInfo.castCategory_ = AVCastCategory::CATEGORY_LOCAL;
632 localInfo.deviceId_ = "-1";
633 localInfo.deviceName_ = "LocalDevice";
634 localDevice.deviceInfos_.emplace_back(localInfo);
635 castHandleToInfoMap_[number].outputDeviceInfo_ = localDevice;
636 }
637 }
638 }
639 if (castState == disconnectStateFromCast_) {
640 servicePtr_->SetIsSupportMirrorToStream(false);
641 }
642 }
643
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)644 void AVRouterImpl::OnCastEventRecv(int32_t errorCode, std::string& errorMsg)
645 {
646 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
647 if (castHandleInfo.avRouterListener_ != nullptr) {
648 SLOGI("trigger the OnCastEventRecv for registered avRouterListener");
649 castHandleInfo.avRouterListener_->OnCastEventRecv(errorCode, errorMsg);
650 }
651 }
652 }
653
DisconnectOtherSession(std::string sessionId,DeviceInfo deviceInfo)654 void AVRouterImpl::DisconnectOtherSession(std::string sessionId, DeviceInfo deviceInfo)
655 {
656 for (const auto& [string, avRouterListener] : mirrorSessionMap_) {
657 if (string != sessionId && avRouterListener != nullptr) {
658 avRouterListener->OnCastStateChange(disconnectStateFromCast_, deviceInfo, false);
659 }
660 }
661 for (const auto& [number, castHandleInfo] : castHandleToInfoMap_) {
662 if (castHandleInfo.sessionId_ != sessionId) {
663 if (castHandleInfo.avRouterListener_ != nullptr) {
664 castHandleInfo.avRouterListener_->OnCastStateChange(disconnectStateFromCast_, deviceInfo, false);
665 }
666 castHandleToInfoMap_[number].sessionId_ = sessionId;
667 castHandleToInfoMap_[number].avRouterListener_ = mirrorSessionMap_[sessionId];
668 }
669 }
670 mirrorSessionMap_.clear();
671 }
672 } // namespace OHOS::AVSession
673