diff --git a/services/cameraservice/base/test/unittest/common/base/BUILD.gn b/services/cameraservice/base/test/unittest/common/base/BUILD.gn index 247e45ab654601bcc256170c720a7003a0c278d4..0d4a405aa99588b1f28c8eccb5626a8bff2ebfe0 100755 --- a/services/cameraservice/base/test/unittest/common/base/BUILD.gn +++ b/services/cameraservice/base/test/unittest/common/base/BUILD.gn @@ -46,6 +46,7 @@ ohos_unittest("DCameraServicesBaseTest") { configs = [ ":module_private_config" ] + cflags = [ "-Dprivate = public" ] deps = [ "${common_path}:distributed_camera_utils", "${services_path}/cameraservice/sourceservice:distributed_camera_source", diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp index 0a24d5608f6ffc2906e35b1331b107c10d478268..47027af2c1c0d6153028cc3bdd3cf05c1bd059b7 100755 --- a/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_capture_info_cmd_test.cpp @@ -464,5 +464,17 @@ HWTEST_F(DCameraCaptureInfoCmdlTest, Unmarshal_003, TestSize.Level1) ret = cmd.Unmarshal(TEST_CAPTURE_INFO_CMD_JSON_VALUE_ARRAY); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); } + +HWTEST_F(DCameraCaptureInfoCmdlTest, Unmarshal_004, TestSize.Level1) +{ + DCameraCaptureInfoCmd cmd; + int32_t ret = cmd.UmarshalValue(nullptr); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + std::shared_ptr captureInfo; + ret = cmd.UmarshalSettings(nullptr, captureInfo); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + } // namespace DistributedHardware } // namespace OHOS diff --git a/services/cameraservice/base/test/unittest/common/base/dcamera_sink_frame_info_test.cpp b/services/cameraservice/base/test/unittest/common/base/dcamera_sink_frame_info_test.cpp index 92915dce7bedad9c5d0f3078aa576c2e22d5c86f..f4cf79218235bdf8b4406ddb3ef325936c8769ee 100644 --- a/services/cameraservice/base/test/unittest/common/base/dcamera_sink_frame_info_test.cpp +++ b/services/cameraservice/base/test/unittest/common/base/dcamera_sink_frame_info_test.cpp @@ -91,6 +91,26 @@ static const std::string TEST_SINK_FRAME_INFO_JSON_SENDT = R"({ "ver": "v1" })"; +static const std::string TEST_SINK_FRAME_INFO_JSON_SENDT2 = R"({ + "type": 0, + "index": 1, + "pts": 1, + "startEncodeT": 1, + "finishEncodeT": 1, + "sendT": 1, + "ver": "v1" +})"; + +static const std::string TEST_SINK_FRAME_INFO_JSON_SENDT3 = R"({ + "type": 0, + "index": 1, + "pts": 1, + "startEncodeT": 1, + "finishEncodeT": 1, + "sendT": 1, + "ver": 1 +})"; + static const std::string TEST_SINK_FRAME_INFO_JSON_VER = R"({ "type": 0, "index": 1, @@ -158,6 +178,12 @@ HWTEST_F(DCameraSinkFrameInfoTest, dcamera_sink_frame_info_test_001, TestSize.Le ret = frame.Unmarshal(TEST_SINK_FRAME_INFO_JSON_SENDT); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + ret = frame.Unmarshal(TEST_SINK_FRAME_INFO_JSON_SENDT2); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = frame.Unmarshal(TEST_SINK_FRAME_INFO_JSON_SENDT3); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + ret = frame.Unmarshal(TEST_SINK_FRAME_INFO_JSON_VER); EXPECT_EQ(DCAMERA_BAD_VALUE, ret); diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp index 45eeeb8a073387b6abb68ed620330bb7d56319c7..e4e6278808d30361fa9c05acdf220532958f753e 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp @@ -46,6 +46,9 @@ std::string g_channelStr = ""; std::string g_outputStr = ""; std::string g_operatorStr = ""; +static const char* DCAMERA_PROTOCOL_CMD_METADATA_RESULT = "METADATA_RESULT"; +static const char* DCAMERA_PROTOCOL_CMD_CAPTURE = "CAPTURE"; + class DCameraSinkControllerTest : public testing::Test { public: static void SetUpTestCase(void); @@ -717,6 +720,18 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_032, TestSize.L std::string srcNetId = ""; std::string dstNetId = ""; EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId)); + + srcNetId = "abc"; + dstNetId = ""; + EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId)); + + srcNetId = ""; + dstNetId = "abc"; + EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId)); + + srcNetId = "abc"; + dstNetId = "abc"; + EXPECT_NE(true, controller_->CheckDeviceSecurityLevel(srcNetId, dstNetId)); } /** @@ -744,5 +759,44 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_034, TestSize.L netId = "netId"; EXPECT_EQ("", controller_->GetUdidByNetworkId(netId)); } + +HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_035, TestSize.Level1) +{ + cJSON *metaJson1 = cJSON_CreateObject(); + cJSON_AddStringToObject(metaJson1, "Command", "skip"); + std::string cjson1 = cJSON_PrintUnformatted(metaJson1); + size_t capacity = cjson1.length() + 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) { + EXPECT_TRUE(false); + } + controller_->HandleReceivedData(dataBuffer); + cJSON_Delete(metaJson1); + + metaJson1 = cJSON_CreateObject(); + cJSON_AddStringToObject(metaJson1, "Command", DCAMERA_PROTOCOL_CMD_METADATA_RESULT); + cjson1 = cJSON_PrintUnformatted(metaJson1); + capacity = cjson1.length() + 1; + dataBuffer = std::make_shared(capacity); + if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) { + EXPECT_TRUE(false); + } + int32_t result = controller_->HandleReceivedData(dataBuffer); + cJSON_Delete(metaJson1); + EXPECT_EQ(result, DCAMERA_BAD_VALUE); + + metaJson1 = cJSON_CreateObject(); + cJSON_AddStringToObject(metaJson1, "Command", DCAMERA_PROTOCOL_CMD_CAPTURE); + cjson1 = cJSON_PrintUnformatted(metaJson1); + capacity = cjson1.length() + 1; + dataBuffer = std::make_shared(capacity); + if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) { + EXPECT_TRUE(false); + } + result = controller_->HandleReceivedData(dataBuffer); + cJSON_Delete(metaJson1); + EXPECT_EQ(result, DCAMERA_BAD_VALUE); +} + } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp index cc43d74ddba50a155e2e56b284ea792b950cda98..f8df62700d3fac68ebf9219d31186489ebcd3148 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp @@ -18,6 +18,8 @@ #include "dcamera_source_controller.h" #undef private +#include + #include "dcamera_source_state.h" #include "dcamera_utils_tools.h" #include "mock_camera_channel.h" @@ -105,6 +107,8 @@ const int32_t TEST_DATASPACE = 8; const int32_t TEST_ISCAPTURE = 0; const int32_t TEST_SLEEP_SEC = 200000; const size_t DATABUFF_MAX_SIZE = 100 * 1024 * 1024; +static const char* DCAMERA_PROTOCOL_CMD_METADATA_RESULT = "METADATA_RESULT"; +static const char* DCAMERA_PROTOCOL_CMD_STATE_NOTIFY = "STATE_NOTIFY"; } void DCameraSourceControllerTest::SetUpTestCase(void) @@ -431,6 +435,17 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012, TestSi EXPECT_EQ(ret, DCAMERA_BAD_OPERATE); } +HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_012_1, TestSize.Level1) +{ + std::shared_ptr events = std::make_shared(); + events->eventType_ = 1; + events->eventResult_ = DCAMERA_EVENT_CAMERA_SUCCESS; + events->eventContent_ = START_CAPTURE_SUCC; + int32_t ret = controller_->DCameraNotify(events); + controller_->UnInit(); + EXPECT_EQ(ret, DCAMERA_BAD_OPERATE); +} + /** * @tc.name: dcamera_source_controller_test_013 * @tc.desc: Verify source controller UpdateSettings. @@ -508,6 +523,24 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015, TestSi EXPECT_EQ(ret, DCAMERA_BAD_OPERATE); } +HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_015_1, TestSize.Level1) +{ + DCameraIndex index1; + index1.devId_ = TEST_DEVICE_ID; + index1.dhId_ = TEST_CAMERA_DH_ID_0; + controller_->indexs_.push_back(index1); + indexs_.push_back(index1); + + bool saved = ManageSelectChannel::GetInstance().GetSrcConnect(); + ManageSelectChannel::GetInstance().SetSrcConnect(true); + std::shared_ptr openInfo = std::make_shared(); + int32_t ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_); + ret = controller_->OpenChannel(openInfo); + controller_->UnInit(); + ManageSelectChannel::GetInstance().SetSrcConnect(saved); + EXPECT_EQ(ret, DCAMERA_OK); +} + /** * @tc.name: dcamera_source_controller_test_016 * @tc.desc: Verify source controller OpenChannel and CloseChannel. @@ -582,6 +615,24 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019, TestSi EXPECT_EQ(ret, DCAMERA_OK); } +HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019_1, TestSize.Level1) +{ + int32_t ret = controller_->Init(indexs_); + std::shared_ptr listener_ = + std::make_shared(controller_); + stateMachine_->UpdateState(DCAMERA_STATE_INIT); + int32_t state = DCAMERA_CHANNEL_STATE_CONNECTED; + listener_->OnSessionState(state, ""); + int32_t eventType = 1; + int32_t eventReason = 1; + std::string detail = "OnSessionErrorTest"; + listener_->OnSessionError(eventType, eventReason, detail); + std::vector> buffers; + listener_->OnDataReceived(buffers); + ret = controller_->UnInit(); + EXPECT_EQ(ret, DCAMERA_OK); +} + /** * @tc.name: dcamera_source_controller_test_020 * @tc.desc: Verify source controller OpenChannel and CloseChannel. @@ -650,5 +701,70 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_021, TestSi controller_->UnInit(); EXPECT_EQ(ret, DCAMERA_BAD_OPERATE); } + +HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_022, TestSize.Level1) +{ + std::vector> captureInfos; + std::shared_ptr capture = std::make_shared(); + capture->width_ = TEST_WIDTH; + capture->height_ = TEST_HEIGTH; + capture->format_ = TEST_FORMAT; + capture->dataspace_ = TEST_DATASPACE; + capture->isCapture_ = TEST_ISCAPTURE; + capture->encodeType_ = DCEncodeType::ENCODE_TYPE_H264; + capture->streamType_ = DCStreamType::SNAPSHOT_FRAME; + captureInfos.push_back(capture); + int32_t ret = controller_->Init(indexs_); + EXPECT_EQ(ret, DCAMERA_INIT_ERR); + DCameraIndex index1; + index1.devId_ = TEST_DEVICE_ID; + index1.dhId_ = TEST_CAMERA_DH_ID_0; + controller_->indexs_.push_back(index1); + int32_t mode = 0; + ret = controller_->StartCapture(captureInfos, mode); + bool saved = ManageSelectChannel::GetInstance().GetSrcConnect(); + ManageSelectChannel::GetInstance().SetSrcConnect(true); + ret = controller_->StopCapture(); + controller_->UnInit(); + ManageSelectChannel::GetInstance().SetSrcConnect(saved); + EXPECT_EQ(ret, DCAMERA_OK); +} + +HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_023, TestSize.Level1) +{ + cJSON *metaJson1 = cJSON_CreateObject(); + cJSON_AddStringToObject(metaJson1, "Command", "skip"); + std::string cjson1 = cJSON_PrintUnformatted(metaJson1); + size_t capacity = cjson1.length() + 1; + std::shared_ptr dataBuffer = std::make_shared(capacity); + if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) { + EXPECT_TRUE(false); + } + controller_->HandleReceivedData(dataBuffer); + cJSON_Delete(metaJson1); + + metaJson1 = cJSON_CreateObject(); + cJSON_AddStringToObject(metaJson1, "Command", DCAMERA_PROTOCOL_CMD_METADATA_RESULT); + cjson1 = cJSON_PrintUnformatted(metaJson1); + capacity = cjson1.length() + 1; + dataBuffer = std::make_shared(capacity); + if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) { + EXPECT_TRUE(false); + } + controller_->HandleReceivedData(dataBuffer); + cJSON_Delete(metaJson1); + + metaJson1 = cJSON_CreateObject(); + cJSON_AddStringToObject(metaJson1, "Command", DCAMERA_PROTOCOL_CMD_STATE_NOTIFY); + cjson1 = cJSON_PrintUnformatted(metaJson1); + capacity = cjson1.length() + 1; + dataBuffer = std::make_shared(capacity); + if (memcpy_s(dataBuffer->Data(), capacity, cjson1.c_str(), capacity) != EOK) { + EXPECT_TRUE(false); + } + controller_->HandleReceivedData(dataBuffer); + cJSON_Delete(metaJson1); +} + } } \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp index b7ab980cea055bfbda5ee96e60b9ef4731b170b5..2247a48c97ee076b11270e6ea67be3d1ed7c61f2 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp @@ -26,6 +26,7 @@ #include "dcamera_source_dev.h" #include "mock_dcamera_source_dev.h" #include "mock_dcamera_source_controller.h" +#include "mock_dcamera_source_input.h" #include "mock_dcamera_source_state_listener.h" #include "nativetoken_kit.h" #include "token_setproc.h" @@ -421,6 +422,24 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_015, TestSize.Level1) EXPECT_EQ(DCAMERA_OK, ret); } +HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_015_1, TestSize.Level1) +{ + SetTokenID(); + std::vector indexs; + camDev_->InitDCameraSourceDev(); + camDev_->controller_ = std::make_shared(); + int32_t ret = camDev_->controller_->Init(indexs); + camDev_->input_->Init(); + DCameraIndex index; + index.devId_ = TEST_DEVICE_ID; + index.dhId_ = TEST_CAMERA_DH_ID_0; + indexs.push_back(index); + ret = camDev_->OpenCamera(); + EXPECT_EQ(DCAMERA_OPEN_CONFLICT, ret); + ret = camDev_->CloseCamera(); + EXPECT_EQ(DCAMERA_OK, ret); +} + /** * @tc.name: dcamera_source_dev_test_016 * @tc.desc: Verify source dev ConfigStreams. @@ -590,6 +609,36 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_020, TestSize.Level1) EXPECT_EQ(DCAMERA_OK, ret); } +HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_020_1, TestSize.Level1) +{ + std::vector> captureInfos; + std::shared_ptr captureInfo = std::make_shared(); + captureInfo->streamIds_.push_back(1); + captureInfo->width_ = TEST_WIDTH; + captureInfo->height_ = TEST_HEIGTH; + captureInfo->stride_ = 1; + captureInfo->format_ = 1; + captureInfo->dataspace_ = 1; + captureInfo->encodeType_ = ENCODE_TYPE_H265; + captureInfo->type_ = CONTINUOUS_FRAME; + captureInfos.push_back(captureInfo); + camDev_->controller_ = std::make_shared(); + auto savedInput = camDev_->input_; + camDev_->input_ = std::make_shared(); + camDev_->input_->Init(); + int32_t ret = camDev_->StartCapture(captureInfos); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); + std::vector streamIds; + int32_t streamId = 1; + streamIds.push_back(streamId); + bool isAllStop = true; + ret = camDev_->StopCapture(streamIds, isAllStop); + EXPECT_EQ(DCAMERA_OK, ret); + ret = camDev_->StopAllCapture(); + EXPECT_EQ(DCAMERA_OK, ret); + camDev_->input_ = savedInput; +} + /** * @tc.name: dcamera_source_dev_test_021 * @tc.desc: Verify source dev UpdateSettings. @@ -627,6 +676,12 @@ HWTEST_F(DCameraSourceDevTest, dcamera_source_dev_test_021, TestSize.Level1) settings.push_back(setting); int32_t ret = camDev_->UpdateSettings(settings); EXPECT_EQ(DCAMERA_OK, ret); + + auto savedInput = camDev_->input_; + camDev_->input_ = std::make_shared(); + ret = camDev_->UpdateSettings(settings); + EXPECT_EQ(DCAMERA_BAD_OPERATE, ret); + camDev_->input_ = savedInput; } /** @@ -678,5 +733,27 @@ HWTEST_F(DCameraSourceDevTest, GetFullCaps_001, TestSize.Level1) camDev1_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener1_); EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->GetFullCaps()); } + +HWTEST_F(DCameraSourceDevTest, OnChannelConnectedEvent_001, TestSize.Level1) +{ + std::shared_ptr camDev1_; + std::shared_ptr stateListener1_; + camDev1_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener1_); + EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->OnChannelConnectedEvent()); + + camDev1_->InitDCameraSourceDev(); + EXPECT_EQ(DCAMERA_OK, camDev1_->OnChannelConnectedEvent()); +} + +HWTEST_F(DCameraSourceDevTest, PostHicollieEvent_001, TestSize.Level1) +{ + std::shared_ptr camDev1_; + std::shared_ptr stateListener1_; + camDev1_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener1_); + EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->PostHicollieEvent()); + + camDev1_->InitDCameraSourceDev(); + EXPECT_EQ(DCAMERA_OK, camDev1_->PostHicollieEvent()); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_controller.h b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_controller.h index 87627d47d04dfb65b1d3154e663db0584518ed4a..a01f611cb4ba38fb7bbdf0670a60884b6b17616d 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_controller.h +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_controller.h @@ -86,6 +86,17 @@ public: return DCAMERA_OK; } }; +class MockDCameraSourceControllerRetErr : public MockDCameraSourceController { +public: + int32_t OpenChannel(std::shared_ptr& openInfo) + { + return DCAMERA_BAD_OPERATE; + } + int32_t CloseChannel() + { + return DCAMERA_BAD_OPERATE; + } +}; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_MOCK_DCAMERA_SINK_CONTROLLER_H diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_input.h b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_input.h new file mode 100644 index 0000000000000000000000000000000000000000..9787f4a37aa63e80ff077ab17024b7bc97e9e39a --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_input.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_MOCK_DCAMERA_SOURCE_INPUT_H +#define OHOS_MOCK_DCAMERA_SOURCE_INPUT_H + +#include "icamera_controller.h" +#include "dcamera_source_dev.h" +#include "dcamera_source_state_machine.h" +#include "distributed_hardware_log.h" + +namespace OHOS { +namespace DistributedHardware { +class MockDCameraSourceInput : public ICameraInput { +public: + int32_t ConfigStreams(std::vector>& streamInfos) + { + return DCAMERA_BAD_OPERATE; + } + int32_t ReleaseStreams(std::vector& streamIds, bool& isAllRelease) + { + return DCAMERA_OK; + } + int32_t ReleaseAllStreams() + { + return DCAMERA_OK; + } + int32_t StartCapture(std::vector>& captureInfos) + { + return DCAMERA_BAD_OPERATE; + } + int32_t StopCapture(std::vector& streamIds, bool& isAllStop) + { + return DCAMERA_BAD_OPERATE; + } + int32_t StopAllCapture() + { + return DCAMERA_BAD_OPERATE; + } + int32_t OpenChannel(std::vector& indexs) + { + return DCAMERA_BAD_OPERATE; + } + int32_t CloseChannel() + { + return DCAMERA_BAD_OPERATE; + } + int32_t Init() + { + return DCAMERA_OK; + } + int32_t UnInit() + { + return DCAMERA_OK; + } + int32_t UpdateSettings(std::vector>& settings) + { + return DCAMERA_BAD_OPERATE; + } + int32_t StopDistributedHardware(const std::string &networkId) + { + return DCAMERA_OK; + } +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_MOCK_DCAMERA_SOURCE_INPUT_H