From 12d9d868fa242c4ca7d432098338c76426a74c7c Mon Sep 17 00:00:00 2001 From: zhuzhihui7 Date: Wed, 15 Jan 2025 19:43:48 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=86=E5=B8=83=E5=BC=8F=E7=9B=B8=E6=9C=BA?= =?UTF-8?q?=E4=BA=92=E8=81=94=E9=9B=B7=E8=BE=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhuzhihui7 --- common/BUILD.gn | 1 + .../constants/distributed_camera_errno.h | 31 +- common/include/utils/dcamera_radar.h | 101 +++++++ common/src/utils/dcamera_radar.cpp | 271 ++++++++++++++++++ common/test/unittest/common/utils/BUILD.gn | 1 + .../common/utils/dcamera_radar_test.cpp | 165 +++++++++++ hisysevent.yaml | 24 ++ .../src/dcamera_source_handler.cpp | 3 + .../distributed_camera_sink_stub.cpp | 2 + .../distributed_camera_source_service.cpp | 7 + .../distributed_camera_source_stub.cpp | 2 + .../dcamera_source_dev.cpp | 10 + .../decoder/decode_data_process.cpp | 2 + .../encoder/encode_data_process.cpp | 3 + 14 files changed, 608 insertions(+), 15 deletions(-) create mode 100644 common/include/utils/dcamera_radar.h create mode 100644 common/src/utils/dcamera_radar.cpp create mode 100644 common/test/unittest/common/utils/dcamera_radar_test.cpp diff --git a/common/BUILD.gn b/common/BUILD.gn index 4eccff8b..4b6c2b7e 100644 --- a/common/BUILD.gn +++ b/common/BUILD.gn @@ -50,6 +50,7 @@ ohos_shared_library("distributed_camera_utils") { "src/utils/dcamera_hidumper.cpp", "src/utils/dcamera_hisysevent_adapter.cpp", "src/utils/dcamera_hitrace_adapter.cpp", + "src/utils/dcamera_radar.cpp", "src/utils/dcamera_utils_tools.cpp", "src/utils/dh_log.cpp", ] diff --git a/common/include/constants/distributed_camera_errno.h b/common/include/constants/distributed_camera_errno.h index 1e2929ee..dbe42db2 100644 --- a/common/include/constants/distributed_camera_errno.h +++ b/common/include/constants/distributed_camera_errno.h @@ -20,21 +20,22 @@ namespace OHOS { namespace DistributedHardware { enum DistributedCameraErrno { DCAMERA_OK = 0, - DCAMERA_MEMORY_OPT_ERROR = -1, - DCAMERA_BAD_VALUE = -2, - DCAMERA_BAD_TYPE = -3, - DCAMERA_ALREADY_EXISTS = -4, - DCAMERA_INIT_ERR = -5, - DCAMERA_NOT_FOUND = -6, - DCAMERA_WRONG_STATE = -7, - DCAMERA_BAD_OPERATE = -8, - DCAMERA_OPEN_CONFLICT = -9, - DCAMERA_DISABLE_PROCESS = -10, - DCAMERA_INDEX_OVERFLOW = -11, - DCAMERA_REGIST_HAL_FAILED = -12, - DCAMERA_UNREGIST_HAL_FAILED = -13, - DCAMERA_ALLOC_ERROR = -14, - DCAMERA_DEVICE_BUSY = -15, + ERR_DH_CAMERA_BASE = 0x05C20000, + DCAMERA_MEMORY_OPT_ERROR = ERR_DH_CAMERA_BASE + 1, + DCAMERA_BAD_VALUE = ERR_DH_CAMERA_BASE + 2, + DCAMERA_BAD_TYPE = ERR_DH_CAMERA_BASE + 3, + DCAMERA_ALREADY_EXISTS = ERR_DH_CAMERA_BASE + 4, + DCAMERA_INIT_ERR = ERR_DH_CAMERA_BASE + 5, + DCAMERA_NOT_FOUND = ERR_DH_CAMERA_BASE + 6, + DCAMERA_WRONG_STATE = ERR_DH_CAMERA_BASE + 7, + DCAMERA_BAD_OPERATE = ERR_DH_CAMERA_BASE + 8, + DCAMERA_OPEN_CONFLICT = ERR_DH_CAMERA_BASE + 9, + DCAMERA_DISABLE_PROCESS = ERR_DH_CAMERA_BASE + 10, + DCAMERA_INDEX_OVERFLOW = ERR_DH_CAMERA_BASE + 11, + DCAMERA_REGIST_HAL_FAILED = ERR_DH_CAMERA_BASE + 12, + DCAMERA_UNREGIST_HAL_FAILED = ERR_DH_CAMERA_BASE + 13, + DCAMERA_ALLOC_ERROR = ERR_DH_CAMERA_BASE + 14, + DCAMERA_DEVICE_BUSY = ERR_DH_CAMERA_BASE + 15, }; } // namespace DistributedHardware } // namespace OHOS diff --git a/common/include/utils/dcamera_radar.h b/common/include/utils/dcamera_radar.h new file mode 100644 index 00000000..16ab3a64 --- /dev/null +++ b/common/include/utils/dcamera_radar.h @@ -0,0 +1,101 @@ +/* + * 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_DISTRIBUTED_CAMERA_COMMON_INCLUDE_UTILS_DCAMERA_RADAR_H +#define OHOS_DISTRIBUTED_CAMERA_COMMON_INCLUDE_UTILS_DCAMERA_RADAR_H + +#include +#include +#include +#include + +#include "single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +const std::string ORG_PKG_NAME = "ohos.dhardware.dcamera"; +const std::string DSOFTBUS_PKG_NAME = "dsoftbus"; +const std::string ORG_PKG = "ORG_PKG"; +const std::string FUNC = "FUNC"; +const std::string BIZ_SCENE = "BIZ_SCENE"; +const std::string BIZ_STAGE = "BIZ_STAGE"; +const std::string STAGE_RES = "STAGE_RES"; +const std::string BIZ_STATE = "BIZ_STATE"; +const std::string TO_CALL_PKG = "TO_CALL_PKG"; +const std::string HOST_PKG = "HOST_PKG"; +const std::string ERROR_CODE = "ERROR_CODE"; +const std::string DISTRIBUTED_CAMERA_BEHAVIOR = "DISTRIBUTED_CAMERA_BEHAVIOR"; +constexpr char DISTRIBUTED_CAMERA[] = "DISTCAMERA"; + +enum class BizScene : int32_t { + CAMERA_INIT = 1, + CAMERA_OPEN = 2, + CAMERA_CLOSE = 3, + CAMERA_UNINIT = 4, +}; + +enum class StageRes : int32_t { + STAGE_IDLE = 0, + STAGE_SUCC = 1, + STAGE_FAIL = 2, + STAGE_CANCEL = 3, + STAGE_UNKNOW = 4, +}; + +enum class BizState : int32_t { + BIZ_STATE_START = 1, + BIZ_STATE_END = 2, +}; + +enum class CameraInit : int32_t { + SERVICE_INIT = 1, + SOURCE_CAMERA_INIT = 2, + SINK_CAMERA_INIT = 3, + LOAD_HDF_DRIVER = 4, +}; + +enum class CameraOpen : int32_t { + OPEN_CAMERA = 1, + OPEN_CHANNEL = 2, + START_CAPTURE = 3, + INIT_DECODE = 4, + INIT_ENCODE = 5, +}; + +enum class CameraClose : int32_t { + STOP_CAPTURE = 1, + RELEASE_STREAM = 2, + CLOSE_CAMERA = 3, +}; + +enum class CameraUnInit : int32_t { + UNLOAD_HDF_DRIVER = 1, + SERVICE_RELEASE = 2, +}; + +class DcameraRadar { + DECLARE_SINGLE_INSTANCE(DcameraRadar); +public: + bool ReportDcameraInit(const std::string& func, CameraInit bizStage, BizState bizState, int32_t errCode); + bool ReportDcameraInitProgress(const std::string& func, CameraInit bizStage, int32_t errCode); + bool ReportDcameraOpen(const std::string& func, CameraOpen bizStage, BizState bizState, int32_t errCode); + bool ReportDcameraOpenProgress(const std::string& func, CameraOpen bizStage, int32_t errCode); + bool ReportDcameraClose(const std::string& func, CameraClose bizStage, BizState bizState, int32_t errCode); + bool ReportDcameraCloseProgress(const std::string& func, CameraClose bizStage, int32_t errCode); + bool ReportDcameraUnInit(const std::string& func, CameraUnInit bizStage, BizState bizState, int32_t errCode); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DISTRIBUTED_CAMERA_COMMON_INCLUDE_UTILS_DCAMERA_RADAR_H \ No newline at end of file diff --git a/common/src/utils/dcamera_radar.cpp b/common/src/utils/dcamera_radar.cpp new file mode 100644 index 00000000..fc64f9fb --- /dev/null +++ b/common/src/utils/dcamera_radar.cpp @@ -0,0 +1,271 @@ +/* + * 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. + */ + +#include "dcamera_radar.h" + +#include "hisysevent.h" +#include "securec.h" + +#include "anonymous_string.h" +#include "dcamera_hisysevent_adapter.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DcameraRadar); + +bool DcameraRadar::ReportDcameraInit(const std::string& func, CameraInit bizStage, BizState bizState, int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_INIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_INIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraInit error, res:%{public}d", res); + return false; + } + return true; +} + +bool DcameraRadar::ReportDcameraInitProgress(const std::string& func, CameraInit bizStage, int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_INIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_INIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraInitProgress error, res:%{public}d", res); + return false; + } + return true; +} + +bool DcameraRadar::ReportDcameraOpen(const std::string& func, CameraOpen bizStage, BizState bizState, int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraOpen error, res:%{public}d", res); + return false; + } + return true; +} + +bool DcameraRadar::ReportDcameraOpenProgress(const std::string& func, CameraOpen bizStage, int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraOpenProgress error, res:%{public}d", res); + return false; + } + return true; +} + +bool DcameraRadar::ReportDcameraClose(const std::string& func, CameraClose bizStage, BizState bizState, + int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraClose error, res:%{public}d", res); + return false; + } + return true; +} + +bool DcameraRadar::ReportDcameraCloseProgress(const std::string& func, CameraClose bizStage, int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraCloseProgress error, res:%{public}d", res); + return false; + } + return true; +} + +bool DcameraRadar::ReportDcameraUnInit(const std::string& func, CameraUnInit bizStage, BizState bizState, + int32_t errCode) +{ + int32_t res = DCAMERA_OK; + StageRes stageRes = (errCode == DCAMERA_OK) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_UNINIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_CAMERA, + DISTRIBUTED_CAMERA_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::CAMERA_UNINIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DCAMERA_OK) { + DHLOGE("ReportDcameraUnInit error, res:%{public}d", res); + return false; + } + return true; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/common/test/unittest/common/utils/BUILD.gn b/common/test/unittest/common/utils/BUILD.gn index 79f86df5..864d79fe 100644 --- a/common/test/unittest/common/utils/BUILD.gn +++ b/common/test/unittest/common/utils/BUILD.gn @@ -37,6 +37,7 @@ ohos_unittest("CommonUtilsTest") { "dcamera_buffer_handle_test.cpp", "dcamera_hidumper_test.cpp", "dcamera_hisysevent_adapter_test.cpp", + "dcamera_radar_test.cpp", "dcamera_utils_tools_test.cpp", ] diff --git a/common/test/unittest/common/utils/dcamera_radar_test.cpp b/common/test/unittest/common/utils/dcamera_radar_test.cpp new file mode 100644 index 00000000..dfcb4d5e --- /dev/null +++ b/common/test/unittest/common/utils/dcamera_radar_test.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2024 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. + */ + +#include "dcamera_radar.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" +#include "gtest/gtest.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { + +class DcameraRadarTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void DcameraRadarTest::SetUpTestCase(void) +{ + DHLOGI("enter"); +} + +void DcameraRadarTest::TearDownTestCase(void) +{ + DHLOGI("enter"); +} + +void DcameraRadarTest::SetUp(void) +{ + DHLOGI("enter"); +} + +void DcameraRadarTest::TearDown(void) +{ + DHLOGI("enter"); +} + +/** + * @tc.name: ReportDcameraInit_001 + * @tc.desc: check ReportDcameraInit + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraInit_001, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraInit_001 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraInit(FUNC, CameraInit::SERVICE_INIT, + BizState::BIZ_STATE_START, DCAMERA_OK); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraInit_001 end"); +} + +/** + * @tc.name: ReportDcameraInit_002 + * @tc.desc: check ReportDcameraInit + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraInit_002, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraInit_002 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraInit(FUNC, CameraInit::SERVICE_INIT, + BizState::BIZ_STATE_START, DCAMERA_MEMORY_OPT_ERROR); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraInit_002 end"); +} + +/** + * @tc.name: ReportDcameraOpen_001 + * @tc.desc: check ReportDcameraOpen + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraOpen_001, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraOpen_001 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraOpen(FUNC, CameraOpen::OPEN_CAMERA, + BizState::BIZ_STATE_START, DCAMERA_OK); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraOpen_001 end"); +} +/** + * @tc.name: ReportDcameraOpen_002 + * @tc.desc: check ReportDcameraOpen + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraOpen_002, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraOpen_002 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraOpen(FUNC, CameraOpen::INIT_DECODE, + BizState::BIZ_STATE_START, DCAMERA_MEMORY_OPT_ERROR); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraOpen_002 end"); +} + +/** + * @tc.name: ReportDcameraClose_001 + * @tc.desc: check ReportDcameraClose + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraClose_001, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraClose_001 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraClose(FUNC, CameraClose::STOP_CAPTURE, + BizState::BIZ_STATE_START, DCAMERA_OK); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraClose_001 end"); +} +/** + * @tc.name: ReportDcameraClose_002 + * @tc.desc: check ReportDcameraClose + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraClose_002, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraClose_002 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraClose(FUNC, CameraClose::RELEASE_STREAM, + BizState::BIZ_STATE_START, DCAMERA_MEMORY_OPT_ERROR); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraClose_002 end"); +} + +/** + * @tc.name: ReportDcameraUnInit_001 + * @tc.desc: check ReportDcameraUnInit + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraUnInit_001, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraUnInit_001 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraUnInit(FUNC, CameraUnInit::UNLOAD_HDF_DRIVER, + BizState::BIZ_STATE_START, DCAMERA_OK); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraUnInit_001 end"); +} + +/** + * @tc.name: ReportDcameraUnInit_002 + * @tc.desc: check ReportDcameraUnInit + * @tc.type: FUNC + */ +HWTEST_F(DcameraRadarTest, ReportDcameraUnInit_002, TestSize.Level1) +{ + DHLOGI("DcameraRadarTest ReportDcameraUnInit_002 begin"); + bool ret = DcameraRadar::GetInstance().ReportDcameraUnInit(FUNC, CameraUnInit::SERVICE_RELEASE, + BizState::BIZ_STATE_START, DCAMERA_MEMORY_OPT_ERROR); + EXPECT_EQ(ret, true); + DHLOGI("DcameraRadarTest ReportDcameraUnInit_002 end"); +} +} +} \ No newline at end of file diff --git a/hisysevent.yaml b/hisysevent.yaml index 62668524..4cee4941 100644 --- a/hisysevent.yaml +++ b/hisysevent.yaml @@ -101,3 +101,27 @@ DCAMERA_CAPTURE: ENCODETYPE: {type: STRING, desc: dcamera encodeType} STREAMTYPE: {type: STRING, desc: dcamera streamType} MSG: {type: STRING, desc: dcamera capture event} + +DISTRIBUTED_CAMERA_BEHAVIOR: + __BASE: {type: BEHAVIOR, level: CRITICAL, desc: distributed camera events, preserve: false} + ORG_PKG: {type: STRING, desc: The package name of the current module} + FUNC: {type: STRING, desc: function name} + BIZ_SCENE: {type: INT32, desc: Identify the current business scenario} + BIZ_STAGE: {type: INT32, desc: process stage} + STAGE_RES: {type: INT32, desc: stage results} + BIZ_STATE: {type: INT32, desc: The beginning or end of the entire module} + TO_CALL_PKG: {type: STRING, desc: call module} + ERROR_CODE: {type: INT32, desc: Unified error code} + LOCAL_UDID: {type: STRING, desc: local device udid} + PEER_UDID: {type: STRING, desc: Peer device udid} + LOCAL_DEV_TYPE: {type: STRING, desc: Local device type} + PEER_DEV_TYPE: {type: STRING, desc: Peer device type} + LOCAL_NET_ID: {type: STRING, desc: Local device NET_ID} + PEER_NET_ID: {type: STRING, desc: Peer device NET_ID} + PEER_BT_MAC: {type: STRING, desc: Peer device btMac} + IS_TRUST: {type: INT32, desc: Is it credible} + LOCAL_SESS_NAME: {type: STRING, desc: Local session name} + PEER_SESS_NAME: {type: STRING, desc: Peer session name} + CONFIG_INFO: {type: STRING, desc: config infomation} + SERVICE_DURATION: {type: STRING, desc: service duration} + CONCURRENT_ID: {type: STRING, desc: Concurrent transaction ID} \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp index ca20af13..ca8014dd 100644 --- a/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp +++ b/interfaces/inner_kits/native_cpp/camera_source/src/dcamera_source_handler.cpp @@ -17,6 +17,7 @@ #include "anonymous_string.h" #include "dcamera_hisysevent_adapter.h" +#include "dcamera_radar.h" #include "dcamera_source_callback.h" #include "dcamera_source_handler_ipc.h" #include "dcamera_source_load_callback.h" @@ -58,6 +59,8 @@ int32_t DCameraSourceHandler::InitSource(const std::string& params) ReportSaEvent(INIT_SA_EVENT, DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "init source sa event."); sptr loadCallback(new DCameraSourceLoadCallback(params)); int32_t ret = sm->LoadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, loadCallback); + DcameraRadar::GetInstance().ReportDcameraInit("LoadSystemAbility", CameraInit::SERVICE_INIT, + BizState::BIZ_STATE_START, ret); if (ret != ERR_OK) { DHLOGE("systemAbilityId: %{public}d load failed, result code: %{public}d.", DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, ret); diff --git a/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_stub.cpp b/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_stub.cpp index be87cebd..f0eb5113 100644 --- a/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_stub.cpp +++ b/services/cameraservice/sinkservice/src/distributedcamera/distributed_camera_sink_stub.cpp @@ -15,6 +15,7 @@ #include "accesstoken_kit.h" #include "dcamera_ipc_interface_code.h" +#include "dcamera_radar.h" #include "distributed_camera_sink_stub.h" #include "distributed_camera_errno.h" #include "distributed_hardware_log.h" @@ -131,6 +132,7 @@ int32_t DistributedCameraSinkStub::InitSinkInner(MessageParcel &data, MessagePar sptr dCameraSinkCallbackProxy(new DCameraSinkCallbackProxy(remoteObject)); ret = InitSink(params, dCameraSinkCallbackProxy); + DcameraRadar::GetInstance().ReportDcameraInitProgress("InitSink", CameraInit::SINK_CAMERA_INIT, ret); } while (0); reply.WriteInt32(ret); return DCAMERA_OK; diff --git a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp index b0bc57e4..2ce90967 100644 --- a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp +++ b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_service.cpp @@ -29,6 +29,7 @@ #include "dcamera_hdf_operate.h" #include "dcamera_hisysevent_adapter.h" #include "dcamera_hitrace_adapter.h" +#include "dcamera_radar.h" #include "dcamera_service_state_listener.h" #include "dcamera_source_service_ipc.h" #include "dcamera_utils_tools.h" @@ -109,6 +110,8 @@ int32_t DistributedCameraSourceService::InitSource(const std::string& params, { DHLOGI("DistributedCameraSourceService InitSource param: %{public}s", params.c_str()); int32_t ret = LoadDCameraHDF(); + DcameraRadar::GetInstance().ReportDcameraInit("LoadDCameraHDF", CameraInit::LOAD_HDF_DRIVER, + BizState::BIZ_STATE_END, ret); if (ret != DCAMERA_OK) { DHLOGE("DistributedCameraSourceService InitSource LoadHDF failed, ret: %{public}d", ret); return ret; @@ -124,6 +127,8 @@ int32_t DistributedCameraSourceService::ReleaseSource() { DHLOGI("enter"); int32_t ret = UnLoadCameraHDF(); + DcameraRadar::GetInstance().ReportDcameraUnInit("UnLoadCameraHDF", CameraUnInit::UNLOAD_HDF_DRIVER, + BizState::BIZ_STATE_START, ret); if (ret != DCAMERA_OK) { DHLOGE("DistributedCameraSourceService ReleaseSource UnLoadHDF failed, ret: %{public}d", ret); return ret; @@ -135,6 +140,8 @@ int32_t DistributedCameraSourceService::ReleaseSource() return DCAMERA_BAD_VALUE; } ret = systemAbilityMgr->UnloadSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID); + DcameraRadar::GetInstance().ReportDcameraUnInit("UnloadSystemAbility", CameraUnInit::SERVICE_RELEASE, + BizState::BIZ_STATE_END, ret); if (ret != DCAMERA_OK) { DHLOGE("source systemAbilityMgr UnLoadSystemAbility failed, ret: %{public}d", ret); return DCAMERA_BAD_VALUE; diff --git a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_stub.cpp b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_stub.cpp index 41b41e7a..d6533938 100644 --- a/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_stub.cpp +++ b/services/cameraservice/sourceservice/src/distributedcamera/distributed_camera_source_stub.cpp @@ -17,6 +17,7 @@ #include "distributed_camera_source_stub.h" #include "dcamera_ipc_interface_code.h" +#include "dcamera_radar.h" #include "dcamera_source_callback_proxy.h" #include "distributed_camera_errno.h" #include "distributed_hardware_log.h" @@ -110,6 +111,7 @@ int32_t DistributedCameraSourceStub::InitSourceInner(MessageParcel &data, Messag } ret = InitSource(params, callbackProxy); + DcameraRadar::GetInstance().ReportDcameraInitProgress("InitSource", CameraInit::SOURCE_CAMERA_INIT, ret); } while (0); reply.WriteInt32(ret); return DCAMERA_OK; diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp index cad2f59b..d6996f4e 100644 --- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp +++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp @@ -18,6 +18,7 @@ #include "anonymous_string.h" #include "dcamera_hisysevent_adapter.h" #include "dcamera_hitrace_adapter.h" +#include "dcamera_radar.h" #include "distributed_camera_constants.h" #include "distributed_camera_errno.h" #include "distributed_hardware_log.h" @@ -463,6 +464,8 @@ int32_t DCameraSourceDev::OpenCamera() ReportCameraOperaterEvent(OPEN_CAMERA_EVENT, GetAnonyString(devId_), dhId_, "execute open camera event."); std::shared_ptr openInfo = std::make_shared(); int32_t ret = GetLocalDeviceNetworkId(openInfo->sourceDevId_); + DcameraRadar::GetInstance().ReportDcameraOpen("GetLocalDeviceNetworkId", CameraOpen::OPEN_CAMERA, + BizState::BIZ_STATE_START, ret); if (ret != DCAMERA_OK) { DHLOGE("DCameraSourceDev getMyId failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); @@ -471,6 +474,7 @@ int32_t DCameraSourceDev::OpenCamera() DcameraStartAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID); ret = controller_->OpenChannel(openInfo); + DcameraRadar::GetInstance().ReportDcameraOpenProgress("OpenChannel", CameraOpen::OPEN_CHANNEL, ret); if (ret != DCAMERA_OK) { DHLOGE("DCameraSourceDev Execute OpenCamera OpenChannel failed, ret: %{public}d, devId: %{public}s dhId: " "%{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); @@ -493,6 +497,8 @@ int32_t DCameraSourceDev::CloseCamera() "dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); } ret = controller_->CloseChannel(); + DcameraRadar::GetInstance().ReportDcameraClose("CloseChannel", CameraClose::CLOSE_CAMERA, + BizState::BIZ_STATE_END, ret); if (ret != DCAMERA_OK) { DHLOGE("DCameraSourceDev Execute CloseCamera controller CloseChannel failed, ret: %{public}d, devId: " "%{public}s dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); @@ -552,6 +558,7 @@ int32_t DCameraSourceDev::ReleaseStreams(std::vector& streamIds, bool& isAl DHLOGI("DCameraSourceDev Execute ReleaseStreams devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); int32_t ret = input_->ReleaseStreams(streamIds, isAllRelease); + DcameraRadar::GetInstance().ReportDcameraCloseProgress("ReleaseStreams", CameraClose::RELEASE_STREAM, ret); if (ret != DCAMERA_OK) { DHLOGE("DCameraSourceDev Execute ReleaseStreams failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); @@ -579,6 +586,7 @@ int32_t DCameraSourceDev::StartCapture(std::vectorStartCapture(captureInfos); + DcameraRadar::GetInstance().ReportDcameraOpenProgress("StartCapture", CameraOpen::START_CAPTURE, ret); if (ret != DCAMERA_OK) { DHLOGE("DCameraSourceDev input StartCapture failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); @@ -648,6 +656,8 @@ int32_t DCameraSourceDev::StopCapture(std::vector& streamIds, bool& isAllSt DHLOGI("DCameraSourceDev Execute StopCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); int32_t ret = input_->StopCapture(streamIds, isAllStop); + DcameraRadar::GetInstance().ReportDcameraClose("StopCapture", CameraClose::STOP_CAPTURE, + BizState::BIZ_STATE_START, ret); if (ret != DCAMERA_OK) { DHLOGE("DCameraSourceDev Execute StopCapture input StopCapture failed, ret: %{public}d, devId: %{public}s " "dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); diff --git a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp index aec9b900..7c87f4fb 100644 --- a/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp +++ b/services/data_process/src/pipeline_node/multimedia_codec/decoder/decode_data_process.cpp @@ -19,6 +19,7 @@ #include "distributed_hardware_log.h" #include "dcamera_hisysevent_adapter.h" #include "dcamera_hidumper.h" +#include "dcamera_radar.h" #include "decode_surface_listener.h" #include "decode_video_callback.h" #include "graphic_common_c.h" @@ -68,6 +69,7 @@ int32_t DecodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const InitCodecEvent(); int32_t err = InitDecoder(); + DcameraRadar::GetInstance().ReportDcameraOpenProgress("InitDecoder", CameraOpen::INIT_DECODE, err); if (err != DCAMERA_OK) { DHLOGE("Init video decoder failed."); ReleaseProcessNode(); diff --git a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp index 09bbc934..0976e84d 100644 --- a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp +++ b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp @@ -15,6 +15,7 @@ #include #include "dcamera_hisysevent_adapter.h" +#include "dcamera_radar.h" #include "dcamera_utils_tools.h" #include "distributed_hardware_log.h" #include "encode_data_process.h" @@ -78,6 +79,8 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const } int32_t err = InitEncoder(); + DcameraRadar::GetInstance().ReportDcameraOpen("InitEncoder", CameraOpen::INIT_ENCODE, + BizState::BIZ_STATE_END, err); if (err != DCAMERA_OK) { DHLOGE("Init video encoder failed."); ReleaseProcessNode(); -- Gitee