diff --git a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h index 5e81f69d21d189f4825bc1c2dcee7435bfcc32cf..91d9542dc39c5cc4093215d33231baaf712ae61a 100644 --- a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h +++ b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h @@ -108,6 +108,14 @@ public: void OnGetDescriptors(const std::string &realNetworkId, const std::vector &descriptors); void SetAVSyncScene(const DHTopic topic); void UpdateSinkBusinessState(const std::string &networkId, const std::string &dhId, BusinessSinkState state); + int32_t InitAVSyncSharedMemory(); + void DeinitAVSyncSharedMemory(); + int32_t GetDHIdByDHSubtype(const DHSubtype dhSubtype, std::string &networkId, std::string &dhId); + int32_t GetDHSubtypeByDHId(DHSubtype &dhSubtype, const std::string &networkId, const std::string &dhId); + void HandleIdleStateChange(const std::string &networkId, const std::string &dhId, const DHType dhType); + void HandleBusinessStateChange(const std::string &networkId, const std::string &dhId, const DHSubtype dhSubType, + const BusinessState state); + void NotifyBusinessStateChange(const DHSubtype dhSubType, const BusinessState state); class ComponentManagerEventHandler : public AppExecFwk::EventHandler { public: ComponentManagerEventHandler(const std::shared_ptr runner); @@ -327,6 +335,7 @@ private: std::shared_ptr syncShareData_ = nullptr; DHTopic dhTopic_; + std::mutex dhTopicMtx_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp index c73eecc22c05721fa410f90beeea369e24c3accb..08a23bd72cacd8c030a07c76ae43f18dc9f23096 100644 --- a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp +++ b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp @@ -686,9 +686,226 @@ bool ComponentManager::IsIdenticalAccount(const std::string &networkId) return false; } +int32_t ComponentManager::InitAVSyncSharedMemory() +{ + uint32_t memLen = sizeof(SyncShareData); + std::string memName = "AVSyncSharedMemory"; + syncSharedMem_ = OHOS::Ashmem::CreateAshmem(memName.c_str(), memLen); + if (syncSharedMem_ == nullptr) { + DHLOGE("create ashmem failed"); + return ERR_DH_FWK_POINTER_IS_NULL; + } + if (!syncSharedMem_->MapReadAndWriteAshmem()) { + DHLOGE("mmap ashmem failed"); + return ERR_DH_FWK_PARA_INVALID; + } + { + std::mutex workModeParamMtx_; + workModeParam_.isAVsync = true; + workModeParam_.sharedMemLen = sizeof(SyncShareData); + workModeParam_.fd = syncSharedMem_->GetAshmemFd(); + } + + syncShareData_ = std::make_shared(); + syncShareData_->lock = 1; + syncShareData_->audio_current_pts = 0; + syncShareData_->audio_update_clock= 0; + syncShareData_->audio_speed = 1.0; + syncShareData_->video_current_pts= 0; + syncShareData_->video_update_clock= 0; + syncShareData_->video_speed = 1.0; + syncShareData_->sync_strategy= 1; + syncShareData_->reset = false; + + bool ret = syncSharedMem_->WriteToAshmem(static_cast(syncShareData_.get()), + sizeof(SyncShareData), 0); + if (!ret) { + DHLOGE("init sync info failed"); + return ERR_DH_FWK_BAD_OPERATION; + } + return DH_FWK_SUCCESS; +} + +void ComponentManager::DeinitAVSyncSharedMemory() +{ + if (syncSharedMem_ != nullptr) { + syncSharedMem_->UnmapAshmem(); + syncSharedMem_->CloseAshmem(); + syncSharedMem_ = nullptr; + } +} + +int32_t ComponentManager::GetDHIdByDHSubtype(const DHSubtype dhSubtype, std::string &networkId, std::string &dhId) +{ + std::lock_guard lock(bizStateMtx_); + for (const auto &iter : dhBizStates_) { + const auto devInfo = iter.first; + DHSubtype subType; + GetDHSubtypeByDHId(subType, devInfo.first, devInfo.second); + if (subType == dhSubtype) { + networkId = devInfo.first; + dhId = devInfo.second; + return DH_FWK_SUCCESS; + } + } + DHLOGE("unable to obtain dhId that matches dhSubtype."); + return ERR_DH_FWK_BAD_OPERATION; +} + +int32_t ComponentManager::GetDHSubtypeByDHId(DHSubtype &dhSubtype, const std::string &networkId, + const std::string &dhId) +{ + std::string str = LocalCapabilityInfoManager::GetInstance()->GetDhSubtype(networkId, dhId); + if (str.empty()) + { + DHLOGE("Get dhSubtype by dhId failed"); + return ERR_DH_FWK_BAD_OPERATION; + } + if(str == "mic") { + dhSubtype = DHSubtype::AUDIO_MIC; + } else if(str == "camera") { + dhSubtype = DHSubtype::CAMERA; + } else { + DHLOGE("unable to obtain dhSubtype that matches dhId."); + return ERR_DH_FWK_BAD_OPERATION; + } + return DH_FWK_SUCCESS; +} + +void ComponentManager::HandleIdleStateChange(const std::string &networkId, const std::string &dhId, const DHType dhType) +{ + if (dhId.empty() || networkId.empty()) { + DHLOGE("targetDHId or targetNetworkId is empty"); + DeinitAVSyncSharedMemory(); + return; + } + if (compSource_.find(dhType) == compSource_.end()) { + DHLOGE("can not find targetHandler by targetType"); + DeinitAVSyncSharedMemory(); + return; + } + auto targetHandler = compSource_.find(dhType)->second; + if (targetHandler == nullptr) { + DHLOGE("targetHandler is nullptr"); + DeinitAVSyncSharedMemory(); + return; + } + { + std::mutex workModeParamMtx_; + workModeParam_.isAVsync = false; + } + targetHandler->UpdateDistributedHardwareWorkMode(networkId, dhId, workModeParam_); + DeinitAVSyncSharedMemory(); + DHLOGI("handle idle state change success."); +} + +void ComponentManager::HandleBusinessStateChange(const std::string &networkId, const std::string &dhId, + const DHSubtype dhSubType, const BusinessState state) +{ + DHType sourceType = (dhSubType == DHSubtype::AUDIO_MIC) ? DHType::AUDIO : DHType::CAMERA; + DHType targetType = (dhSubType == DHSubtype::AUDIO_MIC) ? DHType::CAMERA : DHType::AUDIO; + DHSubtype targetSubType = (dhSubType == DHSubtype::AUDIO_MIC) ? DHSubtype::CAMERA : DHSubtype::AUDIO_MIC; + std::string targetDHId = ""; + std::string targetNetworkId = ""; + GetDHIdByDHSubtype(targetSubType, targetNetworkId, targetDHId); + DHLOGI("targetNetworkId: %{public}s, targetDHId: %{public}s, targetSubType: %{public}" PRIu32, + GetAnonyString(targetNetworkId).c_str(), GetAnonyString(targetDHId).c_str(), (uint32_t)targetSubType); + if (state == BusinessState::IDLE) { + HandleIdleStateChange(targetNetworkId, targetDHId, targetType); + } else if (state == BusinessState::RUNNING) { + if (targetDHId.empty() || targetNetworkId.empty()) { + DHLOGE("target dhardware is not online"); + return; + } + BusinessState targetState = QueryBusinessState(targetNetworkId, targetDHId); + if (targetState != BusinessState::RUNNING) { + DHLOGE("target dhardware is not ready"); + return; + } + + if (compSource_.find(targetType) == compSource_.end() || + compSource_.find(sourceType) == compSource_.end()) { + DHLOGE("can not find cameraHandler or audioHandler"); + return; + } + + int32_t ret = InitAVSyncSharedMemory(); + if (ret != DH_FWK_SUCCESS) { + DHLOGE("InitAVSyncSharedMemory failed"); + DeinitAVSyncSharedMemory(); + return; + } + auto targetHandler = compSource_.find(targetType)->second; + ret = targetHandler->UpdateDistributedHardwareWorkMode(targetNetworkId, targetDHId, workModeParam_); + if (ret != DH_FWK_SUCCESS) { + DeinitAVSyncSharedMemory(); + return; + } + auto sourceHandler = compSource_.find(sourceType)->second; + ret = sourceHandler->UpdateDistributedHardwareWorkMode(networkId, dhId, workModeParam_); + if (ret != DH_FWK_SUCCESS) { + DeinitAVSyncSharedMemory(); + HandleIdleStateChange(targetNetworkId, targetDHId, targetType); + return; + } + } +} + +void ComponentManager::NotifyBusinessStateChange(const DHSubtype dhSubType, const BusinessState state) +{ + DHLOGI("NotifyBusinessStateChange, dhSubType:%{public}" PRIu32", state:%{public}" PRIu32, + static_cast(dhSubType), static_cast(state)); + cJSON *root = cJSON_CreateObject(); + if (root == nullptr) { + DHLOGE("cJSON_CreateObject failed"); + return; + } + if (cJSON_AddNumberToObject(root, DH_SUBTYPE, static_cast(dhSubType)) == nullptr) { + DHLOGE("failed to add dhSubType to json"); + cJSON_Delete(root); + return; + } + if (cJSON_AddNumberToObject(root, BUSINESS_STATE, static_cast(state)) == nullptr) { + DHLOGE("failed to add state to json"); + cJSON_Delete(root); + return; + } + char *json = cJSON_Print(root); + if(json == nullptr) { + DHLOGE("failed to print json"); + cJSON_Delete(root); + return; + } + std::lock_guard lock(dhTopicMtx_); + Publisher::GetInstance().PublishMessage(dhTopic_, json); + cJSON_Delete(root); + free(json); + return; +} + +void ComponentManager::UpdateSinkBusinessState(const std::string &networkId, const std::string &dhId, BusinessSinkState state) +{ + if (!IsIdLengthValid(networkId) || !IsIdLengthValid(dhId)) { + return; + } + DHLOGI("UpdateSinkBusinessState, networkId: %{public}s, dhId: %{public}s, state: %{public}" PRIu32, + GetAnonyString(networkId).c_str(), GetAnonyString(dhId).c_str(), (uint32_t)state); + DHSubtype dhSubtype; + GetDHSubtypeByDHId(dhSubtype, networkId, dhId); + DHLOGI("UpdateSinkBusinessState::get dhSubtype:%{public}" PRIu32, static_cast(dhSubtype)); + if (state == BusinessSinkState::IDLE) { + NotifyBusinessStateChange(dhSubtype, BusinessState::IDLE); + } else if (state == BusinessSinkState::RUNNING) { + NotifyBusinessStateChange(dhSubtype, BusinessState::RUNNING); + } else { + DHLOGI("unsupported sink business state"); + } +} + void ComponentManager::SetAVSyncScene(const DHTopic topic) { DHLOGI("set AVSync scene : %{public}" PRIu32, topic); + std::lock_guard lock(dhTopicMtx_); switch (topic) { case DHTopic::TOPIC_AV_LOW_LATENCY: { dhTopic_ = topic; @@ -708,16 +925,6 @@ void ComponentManager::SetAVSyncScene(const DHTopic topic) } } -void ComponentManager::UpdateSinkBusinessState(const std::string &networkId, const std::string &dhId, - BusinessSinkState state) -{ - if (!IsIdLengthValid(networkId) || !IsIdLengthValid(dhId)) { - return; - } - DHLOGI("UpdateSinkBusinessState, networkId: %{public}s, dhId: %{public}s, state: %{public}" PRIu32, - GetAnonyString(networkId).c_str(), GetAnonyString(dhId).c_str(), (uint32_t)state); -} - void ComponentManager::UpdateBusinessState(const std::string &networkId, const std::string &dhId, BusinessState state) { if (!IsIdLengthValid(networkId) || !IsIdLengthValid(dhId)) { @@ -729,7 +936,13 @@ void ComponentManager::UpdateBusinessState(const std::string &networkId, const s std::lock_guard lock(bizStateMtx_); dhBizStates_[{networkId, dhId}] = state; } - + DHSubtype dhSubtype; + GetDHSubtypeByDHId(dhSubtype, networkId, dhId); + DHLOGI("UpdateBusinessState::get dhSubtype:%{public}" PRIu32, static_cast(dhSubtype)); + if (dhSubtype == DHSubtype::CAMERA || dhSubtype == DHSubtype::AUDIO_MIC) { + NotifyBusinessStateChange(dhSubtype, state); + HandleBusinessStateChange(networkId, dhId, dhSubtype, state); + } if (state == BusinessState::IDLE) { TaskParam taskParam; if (!FetchNeedRefreshTask({networkId, dhId}, taskParam)) { diff --git a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp index b3fdfd05095da69b063a5bfc4a7222219f4d1b8f..5a4582170abd21eaa1448055f86f4eaaef6946b7 100644 --- a/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp +++ b/services/distributedhardwarefwkservice/src/distributed_hardware_service.cpp @@ -181,6 +181,7 @@ int32_t DistributedHardwareService::RegisterPublisherListener(const DHTopic topi const sptr listener) { Publisher::GetInstance().RegisterListener(topic, listener); + ComponentManager::GetInstance().SetAVSyncScene(topic); return DH_FWK_SUCCESS; } diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp index 71d7c200e0c3d2593dd8bba2bb9cefd92b1cf5a3..86d0d2054569314c9dfcb471393fed7c99aa2ec3 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp @@ -75,6 +75,7 @@ const std::string DH_SUBTYPE_TEST = "camera"; const std::string TEST_SOURCE_VERSION_1 = "2.2"; const std::string TEST_SINK_VERSION_1 = "2.4"; const std::string TEST_DH_VERSION = "3.1"; +constexpr uint16_t DEV_TYPE_TEST = 14; const std::shared_ptr CAP_INFO_TEST = std::make_shared(DH_ID_TEST, DEV_ID_TEST, DEVICE_NAME, TEST_DEV_TYPE_PAD, DHType::CAMERA, DH_ATTR_1, DH_SUBTYPE_TEST); @@ -1059,6 +1060,144 @@ HWTEST_F(ComponentManagerTest, UpdateBusinessState_002, TestSize.Level1) EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateBusinessState(NETWORK_TEST, DH_ID_TEST, state)); } +HWTEST_F(ComponentManagerTest, UpdateBusinessState_003, TestSize.Level1) +{ + std::string peeruuid = "123456789"; + std::string dhid = "audio_132"; + std::string deviceId = Sha256(peeruuid); + BusinessState state = BusinessState::IDLE; + std::shared_ptr capInfo1 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic"); + std::string key = deviceId + "###" + dhid; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1; + EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateBusinessState(deviceId, dhid, state)); + + dhid = "camera_132"; + std::shared_ptr capInfo2 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera"); + key = deviceId + "###" + dhid; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2; + EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateBusinessState(deviceId, dhid, state)); +} + +HWTEST_F(ComponentManagerTest, GetDHSubtypeByDHId_001, TestSize.Level1) +{ + std::string peeruuid = "123456789"; + std::string dhid = "audio_132"; + std::string deviceId = Sha256(peeruuid); + DHSubtype dhSubtype; + std::shared_ptr capInfo1 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic"); + std::string key = deviceId + "###" + dhid; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1; + auto ret = ComponentManager::GetInstance().GetDHSubtypeByDHId(dhSubtype, deviceId, dhid); + EXPECT_EQ(DHSubtype::AUDIO_MIC, dhSubtype); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + dhid = "camera_132"; + std::shared_ptr capInfo2 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera"); + key = deviceId + "###" + dhid; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2; + ret = ComponentManager::GetInstance().GetDHSubtypeByDHId(dhSubtype, deviceId, dhid); + EXPECT_EQ(DHSubtype::CAMERA, dhSubtype); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + dhid = "unknown_132"; + std::shared_ptr capInfo3 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::UNKNOWN, "attrs", "unknown"); + key = deviceId + "###" + dhid; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo3; + ret = ComponentManager::GetInstance().GetDHSubtypeByDHId(dhSubtype, deviceId, dhid); + EXPECT_EQ(ret, ERR_DH_FWK_BAD_OPERATION); +} + +HWTEST_F(ComponentManagerTest, InitAVSyncSharedMemory_001, TestSize.Level1) +{ + auto ret = ComponentManager::GetInstance().InitAVSyncSharedMemory(); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, DeinitAVSyncSharedMemory_001, TestSize.Level1) +{ + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().DeinitAVSyncSharedMemory()); +} + +HWTEST_F(ComponentManagerTest, GetDHIdByDHSubtype_001, TestSize.Level1) +{ + std::string peeruuid = "123456789"; + std::string dhid = "audio_132"; + std::string deviceId = Sha256(peeruuid); + std::shared_ptr capInfo1 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic"); + std::string key = deviceId + "###" + dhid; + BusinessState state = BusinessState::IDLE; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1; + ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), state); + auto ret = ComponentManager::GetInstance().GetDHIdByDHSubtype(DHSubtype::AUDIO_MIC, deviceId, dhid); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + ret = ComponentManager::GetInstance().GetDHIdByDHSubtype(DHSubtype::CAMERA, deviceId, dhid); + EXPECT_EQ(ret, ERR_DH_FWK_BAD_OPERATION); +} + +HWTEST_F(ComponentManagerTest, HandleIdleStateChange_001, TestSize.Level1) +{ + std::string networkId = ""; + std::string dhId = ""; + DHType dhType = DHType::UNKNOWN; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType)); + + networkId = "networkId_1"; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType)); + + networkId = ""; + dhId = "dhId_1"; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType)); + + networkId = "networkId_1"; + IDistributedHardwareSource *sourcePtr = nullptr; + ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr)); + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, dhType)); + + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleIdleStateChange(networkId, dhId, DHType::CAMERA)); + ComponentManager::GetInstance().compSource_.clear(); +} + +HWTEST_F(ComponentManagerTest, HandleBusinessStateChange_001, TestSize.Level1) +{ + std::string networkId = "networkId_1"; + std::string dhid = "audio_132"; + DHSubtype dhSubType = DHSubtype::AUDIO_MIC; + BusinessState state = BusinessState::IDLE; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state)); + + state = BusinessState::RUNNING; + std::string peeruuid = "123456789"; + std::string deviceId = Sha256(peeruuid); + std::shared_ptr capInfo1 = std::make_shared( + dhid, deviceId, "devName_test", DEV_TYPE_TEST, DHType::AUDIO, "attrs", "mic"); + std::string key = deviceId + "###" + dhid; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo1; + ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid), BusinessState::IDLE); + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state)); + + std::string dhid2 = "camera_132"; + std::shared_ptr capInfo2 = std::make_shared( + dhid2, deviceId, "devName_test", DEV_TYPE_TEST, DHType::CAMERA, "attrs", "camera"); + key = deviceId + "###" + dhid2; + LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capInfo2; + ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::UNKNOWN); + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state)); + + ComponentManager::GetInstance().dhBizStates_.emplace(std::make_pair(deviceId, dhid2), BusinessState::RUNNING); + IDistributedHardwareSource *sourcePtr1 = nullptr; + ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::CAMERA, sourcePtr1)); + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state)); + + IDistributedHardwareSource *sourcePtr2 = nullptr; + ComponentManager::GetInstance().compSource_.insert(std::make_pair(DHType::AUDIO, sourcePtr2)); + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().HandleBusinessStateChange(networkId, dhid, dhSubType, state)); + ComponentManager::GetInstance().dhBizStates_.clear(); + ComponentManager::GetInstance().compSource_.clear(); +} HWTEST_F(ComponentManagerTest, QueryBusinessState_001, TestSize.Level1) { BusinessState ret = ComponentManager::GetInstance().QueryBusinessState("", ""); @@ -1361,6 +1500,19 @@ HWTEST_F(ComponentManagerTest, UpdateSinkBusinessState_001, testing::ext::TestSi networkId = "networkId_1"; ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state)); + + state = BusinessSinkState::RUNNING; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state)); + + state = BusinessSinkState::IDLE; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UpdateSinkBusinessState(networkId, dhId, state)); +} + +HWTEST_F(ComponentManagerTest, NotifyBusinessStateChange_001, testing::ext::TestSize.Level1) +{ + BusinessState state = BusinessState::UNKNOWN; + DHSubtype dhSubType = DHSubtype::CAMERA; + ASSERT_NO_FATAL_FAILURE(ComponentManager::GetInstance().NotifyBusinessStateChange(dhSubType, state)); } } // namespace DistributedHardware } // namespace OHOS