1 /* 2 * Copyright (C) 2024-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 <gtest/gtest.h> 17 #include "cJSON.h" 18 #include "cs_call.h" 19 #include "common_type.h" 20 #include "telephony_errors.h" 21 #include "call_manager_base.h" 22 #include "distributed_data_controller.h" 23 #include "distributed_device_observer.h" 24 #include "distributed_communication_manager.h" 25 #include "call_manager_disconnected_details.h" 26 #include "distributed_data_sink_controller.h" 27 #include "distributed_sink_switch_controller.h" 28 29 namespace OHOS { 30 namespace Telephony { 31 using namespace testing::ext; 32 33 class DistributedCommunicationManagerTest : public testing::Test { 34 public: SetUpTestCase()35 static void SetUpTestCase() {} TearDownTestCase()36 static void TearDownTestCase() {} SetUp()37 virtual void SetUp() {} TearDown()38 virtual void TearDown() {} 39 }; 40 41 /** 42 * @tc.number Telephony_DcManagerTest_001 43 * @tc.name test normal branch 44 * @tc.desc normal branch test 45 */ 46 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManagerTest_001, Function | MediumTest | Level1) 47 { 48 int32_t direction = 1; 49 DialParaInfo mDialParaInfo; 50 DisconnectedDetails details; 51 sptr<CallBase> csCall = nullptr; 52 std::string devId = "UnitTestDeviceId"; 53 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 54 std::shared_ptr<IDistributedDeviceCallback> deviceListener = std::make_shared<DistributedDeviceCallback>(); 55 56 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 57 58 auto deviceObserver = dcManager->GetDistributedDeviceObserver(); 59 ASSERT_TRUE(deviceObserver == nullptr); 60 61 ASSERT_NO_THROW(dcManager->Init()); 62 csCall = new CSCall(mDialParaInfo); 63 64 int32_t ret = dcManager->RegDevCallbackWrapper(deviceListener); 65 ASSERT_TRUE(ret == TELEPHONY_ERROR); 66 67 ret = dcManager->UnRegDevCallbackWrapper(); 68 ASSERT_TRUE(ret == TELEPHONY_ERROR); 69 70 ret = dcManager->SwitchDevWrapper(devId, direction); 71 ASSERT_TRUE(ret == TELEPHONY_ERROR); 72 73 ASSERT_NO_THROW(dcManager->InitExtWrapper()); 74 ASSERT_NO_THROW(dcManager->InitExtWrapper()); // extWrapperHandler_ != nullptr case 75 76 ret = dcManager->RegDevCallbackWrapper(deviceListener); 77 ASSERT_FALSE(ret != TELEPHONY_ERROR); 78 79 dcManager->UnRegDevCallbackWrapper(); 80 81 dcManager->SwitchDevWrapper(devId, direction); 82 83 ASSERT_FALSE(dcManager->IsDistributedDev(devId)); 84 85 deviceObserver = dcManager->GetDistributedDeviceObserver(); 86 ASSERT_TRUE(deviceObserver != nullptr); 87 ASSERT_NO_THROW(dcManager->SetMuted(true)); 88 ASSERT_NO_THROW(dcManager->MuteRinger()); 89 ASSERT_NO_THROW(dcManager->ProcessCallInfo(csCall, DistributedDataType::LOCATION)); 90 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 91 ASSERT_NO_THROW(dcManager->CallDestroyed(details)); 92 ASSERT_NO_THROW(dcManager->DeInitExtWrapper()); 93 ASSERT_NO_THROW(dcManager->dataController_ = std::make_shared<DistributedDataSinkController>()); 94 ASSERT_NO_THROW(dcManager->SetMuted(true)); 95 ASSERT_NO_THROW(dcManager->MuteRinger()); 96 ASSERT_NO_THROW(dcManager->ProcessCallInfo(csCall, DistributedDataType::LOCATION)); 97 csCall->SetCallType(CallType::TYPE_CS); 98 dcManager->role_ = DistributedRole::SINK; 99 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 100 dcManager->peerDevices_.push_back("device"); 101 ASSERT_NO_THROW(dcManager->NewCallCreated(csCall)); 102 ASSERT_NO_THROW(dcManager->CallDestroyed(details)); 103 ASSERT_NO_THROW(dcManager->peerDevices_.clear()); 104 } 105 106 /** 107 * @tc.number Telephony_DcManager_DeviceOnline_001 108 * @tc.name test dc device online 109 * @tc.desc Function test 110 */ 111 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_DeviceOnline_001, Function | MediumTest | Level1) 112 { 113 int32_t devRole = 0; // sink 114 std::string devId = "UnitTestDeviceId"; 115 std::string devName = "UnitTestDeviceName"; 116 AudioDeviceType deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE; 117 118 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 119 dcManager->devObserver_ = nullptr; 120 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 121 ASSERT_FALSE(dcManager->IsConnected()); 122 123 ASSERT_NO_THROW(dcManager->Init()); 124 125 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 126 ASSERT_TRUE(dcManager->IsConnected()); 127 ASSERT_TRUE(dcManager->IsSinkRole()); 128 129 devRole = 1; // source 130 deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD; 131 dcManager->dataController_ = nullptr; 132 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 133 ASSERT_FALSE(dcManager->IsSinkRole()); 134 } 135 136 /** 137 * @tc.number Telephony_DcManager_DeviceOffline_001 138 * @tc.name test dc device offline 139 * @tc.desc Function test 140 */ 141 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_DeviceOffline_001, Function | MediumTest | Level1) 142 { 143 int32_t devRole = 0; 144 std::string devId = "UnitTestDeviceId"; 145 std::string devName = "UnitTestDeviceName"; 146 AudioDeviceType deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE; 147 148 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 149 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 150 ASSERT_NO_THROW(dcManager->IsConnected()); 151 152 ASSERT_NO_THROW(dcManager->Init()); 153 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 154 ASSERT_TRUE(dcManager->IsConnected()); 155 156 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 157 ASSERT_FALSE(dcManager->IsConnected()); 158 159 dcManager->devObserver_ = nullptr; 160 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 161 162 dcManager->devObserver_ = std::make_shared<DistributedDeviceObserver>(); 163 dcManager->peerDevices_.push_back("hello"); 164 ASSERT_NO_THROW(dcManager->OnDeviceOffline(devId, devName, deviceType, devRole)); 165 dcManager->peerDevices_.clear(); 166 } 167 168 /** 169 * @tc.number Telephony_DcManager_SwitchDevice_001 170 * @tc.name test switch device 171 * @tc.desc Function test 172 */ 173 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_SwitchDevice_001, Function | MediumTest | Level1) 174 { 175 int32_t devRole = 1; 176 std::string devId = "UnitTestDeviceId"; 177 std::string devName = "UnitTestDeviceName"; 178 AudioDeviceType deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD; 179 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 180 ASSERT_NO_THROW(dcManager->SwitchToSourceDevice()); 181 ASSERT_NO_THROW(dcManager->Init()); 182 ASSERT_NO_THROW(dcManager->OnDeviceOnline(devId, devName, deviceType, devRole)); 183 ASSERT_TRUE(dcManager->SwitchToSourceDevice()); 184 dcManager->devSwitchController_->isAudioOnSink_ = true; 185 ASSERT_NO_THROW(dcManager->SwitchToSourceDevice()); 186 dcManager->devSwitchController_->isAudioOnSink_ = false; 187 } 188 189 /** 190 * @tc.number Telephony_DcManager_SwitchToSinkDevice 191 * @tc.name test switch to sink device 192 * @tc.desc Function test 193 */ 194 HWTEST_F(DistributedCommunicationManagerTest, Telephony_DcManager_SwitchToSinkDevice, Function | MediumTest | Level1) 195 { 196 AudioDevice device; 197 std::string deviceId = "{ \"devId\": \"101\" }"; 198 std::string deviceName = "deviceName"; 199 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PAD; 200 auto dcManager = DelayedSingleton<DistributedCommunicationManager>::GetInstance(); 201 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); // deviceId is empty 202 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK); 203 ASSERT_EQ(memcpy_s(device.deviceName, kMaxDeviceNameLen + 1, deviceName.c_str(), deviceName.size()), EOK); 204 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); // not dc device 205 dcManager->peerDevices_.push_back("101"); 206 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); 207 dcManager->devSwitchController_ = nullptr; 208 ASSERT_FALSE(dcManager->SwitchToSinkDevice(device)); 209 dcManager->devSwitchController_ = std::make_shared<DistributedSinkSwitchController>(); 210 dcManager->devSwitchController_->isAudioOnSink_ = true; 211 ASSERT_TRUE(dcManager->SwitchToSinkDevice(device)); 212 dcManager->devSwitchController_->isAudioOnSink_ = false; 213 dcManager->peerDevices_.clear(); 214 deviceId = "not Json string"; 215 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK); 216 ASSERT_EQ(dcManager->ParseDevIdFromAudioDevice(device), ""); 217 } 218 } // namespace Telephony 219 } // namespace OHOS 220