From cbf583c46528bc10406feea0a0aaa3ebd4dd64a8 Mon Sep 17 00:00:00 2001 From: zhuzhihui7 Date: Mon, 17 Feb 2025 10:58:03 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=86=E5=B8=83=E5=BC=8F=E9=9F=B3=E9=A2=91?= =?UTF-8?q?=E6=8E=A5=E5=85=A5=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/dfx_utils/include/daudio_radar.h | 119 +++++++++ common/dfx_utils/src/daudio_radar.cpp | 244 ++++++++++++++++++ common/dfx_utils/test/unittest/BUILD.gn | 1 + .../test/unittest/src/daudio_radar_test.cpp | 226 ++++++++++++++++ common/include/daudio_errorcode.h | 80 +++--- hisysevent.yaml | 26 +- .../audio_source/src/daudio_ipc_callback.cpp | 4 +- .../src/daudio_source_handler.cpp | 3 + .../src/daudio_ipc_callback_test.cpp | 4 +- .../audiohdiproxy/src/daudio_hdi_handler.cpp | 9 +- .../src/daudio_manager_callback.cpp | 3 +- .../managersource/src/daudio_source_dev.cpp | 17 ++ .../src/daudio_source_manager.cpp | 3 + .../managersource/src/dmic_dev.cpp | 11 + .../managersource/src/dspeaker_dev.cpp | 11 + .../src/daudio_source_service.cpp | 5 + services/common/BUILD.gn | 1 + 17 files changed, 721 insertions(+), 46 deletions(-) create mode 100644 common/dfx_utils/include/daudio_radar.h create mode 100644 common/dfx_utils/src/daudio_radar.cpp create mode 100644 common/dfx_utils/test/unittest/src/daudio_radar_test.cpp diff --git a/common/dfx_utils/include/daudio_radar.h b/common/dfx_utils/include/daudio_radar.h new file mode 100644 index 00000000..f06d85be --- /dev/null +++ b/common/dfx_utils/include/daudio_radar.h @@ -0,0 +1,119 @@ +/* + * 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. + */ + +#ifndef OHOS_DISTRIBUTED_AUDIO_COMMON_DFX_UTILS_INCLUDE_DAUDIO_RADAR_H +#define OHOS_DISTRIBUTED_AUDIO_COMMON_DFX_UTILS_INCLUDE_DAUDIO_RADAR_H + +#include +#include +#include +#include + +#include "single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +const std::string ORG_PKG_NAME = "ohos.daudio"; +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_AUDIO_BEHAVIOR = "DISTRIBUTED_AUDIO_BEHAVIOR"; +constexpr char DISTRIBUTED_AUDIO[] = "DISTAUDIO"; + +enum class BizScene : int32_t { + AUDIO_INIT = 1, + SPEAKER_OPEN = 2, + MIC_OPEN = 3, + SPEAKER_CLOSE = 4, + MIC_CLOSE = 5, + AUDIO_UNINIT = 6, +}; + +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_PROGRESS = 0, + BIZ_STATE_START = 1, + BIZ_STATE_END = 2, +}; + +enum class AudioInit : int32_t { + SERVICE_INIT = 1, + SOURCE_AUDIO_INIT = 2, + LOAD_HDF_DRIVER = 3, +}; + +enum class SpeakerOpen : int32_t { + CREATE_STREAM = 1, + INIT_ENGINE = 2, + TRANS_CONTROL = 3, + TRANS_START = 4, + NOTIFY_HDF = 5, +}; + +enum class MicOpen : int32_t { + CREATE_STREAM = 1, + INIT_ENGINE = 2, + TRANS_CONTROL = 3, + TRANS_START = 4, + NOTIFY_HDF = 5, +}; + +enum class SpeakerClose : int32_t { + DESTROY_STREAM = 1, + STOP_TRANS = 2, + RELEASE_TRANS = 3, + NOTIFY_HDF = 4, +}; + +enum class MicClose : int32_t { + DESTROY_STREAM = 1, + STOP_TRANS = 2, + RELEASE_TRANS = 3, + NOTIFY_HDF = 4, +}; + +enum class AudioUnInit : int32_t { + UNREGISTER = 1, + UNLOAD_HDF_DRIVER = 2, + DISABLED = 3, +}; + +class DaudioRadar { + DECLARE_SINGLE_INSTANCE(DaudioRadar); +public: + bool ReportDaudioInit(const std::string& func, AudioInit bizStage, BizState bizState, int32_t errCode); + bool ReportSpeakerOpen(const std::string& func, SpeakerOpen bizStage, BizState bizState, int32_t errCode); + bool ReportSpeakerClose(const std::string& func, SpeakerClose bizStage, BizState bizState, int32_t errCode); + bool ReportMicOpen(const std::string& func, MicOpen bizStage, BizState bizState, int32_t errCode); + bool ReportMicClose(const std::string& func, MicClose bizStage, BizState bizState, int32_t errCode); + bool ReportDaudioUnInit(const std::string& func, AudioUnInit bizStage, BizState bizState, int32_t errCode); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DISTRIBUTED_AUDIO_COMMON_DFX_UTILS_INCLUDE_DAUDIO_RADAR_H \ No newline at end of file diff --git a/common/dfx_utils/src/daudio_radar.cpp b/common/dfx_utils/src/daudio_radar.cpp new file mode 100644 index 00000000..84a60aca --- /dev/null +++ b/common/dfx_utils/src/daudio_radar.cpp @@ -0,0 +1,244 @@ +/* + * 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 "daudio_radar.h" + +#include "hisysevent.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DAudioRadar" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DaudioRadar); + +bool DaudioRadar::ReportDaudioInit(const std::string& func, AudioInit bizStage, BizState bizState, int32_t errCode) +{ + int32_t res = DH_SUCCESS; + StageRes stageRes = (errCode == DH_SUCCESS) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::AUDIO_INIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::AUDIO_INIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DH_SUCCESS) { + DHLOGE("ReportDaudioInit error, res:%{public}d", res); + return false; + } + return true; +} + +bool DaudioRadar::ReportSpeakerOpen(const std::string& func, SpeakerOpen bizStage, + BizState bizState, int32_t errCode) +{ + int32_t res = DH_SUCCESS; + StageRes stageRes = (errCode == DH_SUCCESS) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::SPEAKER_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::SPEAKER_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DH_SUCCESS) { + DHLOGE("ReportSpeakerOpen error, res:%{public}d", res); + return false; + } + return true; +} + +bool DaudioRadar::ReportSpeakerClose(const std::string& func, SpeakerClose bizStage, + BizState bizState, int32_t errCode) +{ + int32_t res = DH_SUCCESS; + StageRes stageRes = (errCode == DH_SUCCESS) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::SPEAKER_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::SPEAKER_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DH_SUCCESS) { + DHLOGE("ReportSpeakerClose error, res:%{public}d", res); + return false; + } + return true; +} + +bool DaudioRadar::ReportMicOpen(const std::string& func, MicOpen bizStage, + BizState bizState, int32_t errCode) +{ + int32_t res = DH_SUCCESS; + StageRes stageRes = (errCode == DH_SUCCESS) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::MIC_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::MIC_OPEN), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DH_SUCCESS) { + DHLOGE("ReportMicOpen error, res:%{public}d", res); + return false; + } + return true; +} + +bool DaudioRadar::ReportMicClose(const std::string& func, MicClose bizStage, + BizState bizState, int32_t errCode) +{ + int32_t res = DH_SUCCESS; + StageRes stageRes = (errCode == DH_SUCCESS) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::MIC_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::MIC_CLOSE), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DH_SUCCESS) { + DHLOGE("ReportMicClose error, res:%{public}d", res); + return false; + } + return true; +} + +bool DaudioRadar::ReportDaudioUnInit(const std::string& func, AudioUnInit bizStage, BizState bizState, + int32_t errCode) +{ + int32_t res = DH_SUCCESS; + StageRes stageRes = (errCode == DH_SUCCESS) ? StageRes::STAGE_SUCC : StageRes::STAGE_FAIL; + if (stageRes == StageRes::STAGE_SUCC) { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::AUDIO_UNINIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_SUCC), + BIZ_STATE, static_cast(bizState)); + } else { + res = HiSysEventWrite( + DISTRIBUTED_AUDIO, + DISTRIBUTED_AUDIO_BEHAVIOR, + HiviewDFX::HiSysEvent::EventType::BEHAVIOR, + ORG_PKG, ORG_PKG_NAME, + FUNC, func, + BIZ_SCENE, static_cast(BizScene::AUDIO_UNINIT), + BIZ_STAGE, static_cast(bizStage), + STAGE_RES, static_cast(StageRes::STAGE_FAIL), + BIZ_STATE, static_cast(bizState), + ERROR_CODE, errCode); + } + if (res != DH_SUCCESS) { + DHLOGE("ReportDaudioUnInit error, res:%{public}d", res); + return false; + } + return true; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/common/dfx_utils/test/unittest/BUILD.gn b/common/dfx_utils/test/unittest/BUILD.gn index 90eef2fb..e8ddddea 100644 --- a/common/dfx_utils/test/unittest/BUILD.gn +++ b/common/dfx_utils/test/unittest/BUILD.gn @@ -61,6 +61,7 @@ ohos_unittest("DAudioDfxTest") { sources = [ "${common_path}/dfx_utils/test/unittest/src/daudio_hidumper_test.cpp", "${common_path}/dfx_utils/test/unittest/src/daudio_hitrace_test.cpp", + "${common_path}/dfx_utils/test/unittest/src/daudio_radar_test.cpp", ] configs = [ ":module_private_config" ] diff --git a/common/dfx_utils/test/unittest/src/daudio_radar_test.cpp b/common/dfx_utils/test/unittest/src/daudio_radar_test.cpp new file mode 100644 index 00000000..84c36f34 --- /dev/null +++ b/common/dfx_utils/test/unittest/src/daudio_radar_test.cpp @@ -0,0 +1,226 @@ +/* + * 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 "daudio_radar.h" +#include "daudio_errorcode.h" +#include "daudio_log.h" +#include "gtest/gtest.h" + +#undef DH_LOG_TAG +#define DH_LOG_TAG "DAudioRadarTest" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { + +class DaudioRadarTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void DaudioRadarTest::SetUpTestCase(void) +{ + DHLOGI("enter"); +} + +void DaudioRadarTest::TearDownTestCase(void) +{ + DHLOGI("enter"); +} + +void DaudioRadarTest::SetUp(void) +{ + DHLOGI("enter"); +} + +void DaudioRadarTest::TearDown(void) +{ + DHLOGI("enter"); +} + +/** + * @tc.name: ReportDaudioInit_001 + * @tc.desc: check ReportDaudioInit + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportDaudioInit_001, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportDaudioInit_001 begin"); + bool ret = DaudioRadar::GetInstance().ReportDaudioInit(FUNC, AudioInit::SERVICE_INIT, + BizState::BIZ_STATE_START, DH_SUCCESS); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportDaudioInit_001 end"); +} + +/** + * @tc.name: ReportDaudioInit_002 + * @tc.desc: check ReportDaudioInit + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportDaudioInit_002, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportDaudioInit_002 begin"); + bool ret = DaudioRadar::GetInstance().ReportDaudioInit(FUNC, AudioInit::SERVICE_INIT, + BizState::BIZ_STATE_START, ERR_DH_AUDIO_FAILED); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportDaudioInit_002 end"); +} + +/** + * @tc.name: ReportSpeakerOpen_001 + * @tc.desc: check ReportSpeakerOpen + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportSpeakerOpen_001, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportSpeakerOpen_001 begin"); + bool ret = DaudioRadar::GetInstance().ReportSpeakerOpen(FUNC, SpeakerOpen::CREATE_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportSpeakerOpen_001 end"); +} + +/** + * @tc.name: ReportSpeakerOpen_002 + * @tc.desc: check ReportSpeakerOpen + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportSpeakerOpen_002, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportSpeakerOpen_002 begin"); + bool ret = DaudioRadar::GetInstance().ReportSpeakerOpen(FUNC, SpeakerOpen::CREATE_STREAM, + BizState::BIZ_STATE_START, ERR_DH_AUDIO_FAILED); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportSpeakerOpen_002 end"); +} + +/** + * @tc.name: ReportSpeakerClose_001 + * @tc.desc: check ReportSpeakerClose + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportSpeakerClose_001, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportSpeakerClose_001 begin"); + bool ret = DaudioRadar::GetInstance().ReportSpeakerClose(FUNC, SpeakerClose::DESTROY_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportSpeakerClose_001 end"); +} + +/** + * @tc.name: ReportSpeakerClose_002 + * @tc.desc: check ReportSpeakerClose + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportSpeakerClose_002, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportSpeakerClose_002 begin"); + bool ret = DaudioRadar::GetInstance().ReportSpeakerClose(FUNC, SpeakerClose::DESTROY_STREAM, + BizState::BIZ_STATE_START, ERR_DH_AUDIO_FAILED); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportSpeakerClose_002 end"); +} + +/** + * @tc.name: ReportMicOpen_001 + * @tc.desc: check ReportMicOpen + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportMicOpen_001, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportMicOpen_001 begin"); + bool ret = DaudioRadar::GetInstance().ReportMicOpen(FUNC, MicOpen::CREATE_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportMicOpen_001 end"); +} + +/** + * @tc.name: ReportMicOpen_002 + * @tc.desc: check ReportMicOpen + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportMicOpen_002, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportMicOpen_002 begin"); + bool ret = DaudioRadar::GetInstance().ReportMicOpen(FUNC, MicOpen::CREATE_STREAM, + BizState::BIZ_STATE_START, ERR_DH_AUDIO_FAILED); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportMicOpen_002 end"); +} + +/** + * @tc.name: ReportMicClose_001 + * @tc.desc: check ReportMicClose + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportMicClose_001, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportMicClose_001 begin"); + bool ret = DaudioRadar::GetInstance().ReportMicClose(FUNC, MicClose::DESTROY_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportMicClose_001 end"); +} + +/** + * @tc.name: ReportMicClose_002 + * @tc.desc: check ReportMicClose + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportMicClose_002, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportMicClose_002 begin"); + bool ret = DaudioRadar::GetInstance().ReportMicClose(FUNC, MicClose::DESTROY_STREAM, + BizState::BIZ_STATE_START, ERR_DH_AUDIO_FAILED); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportMicClose_002 end"); +} + +/** + * @tc.name: ReportDaudioUnInit_001 + * @tc.desc: check ReportDaudioUnInit + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportDaudioUnInit_001, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportDaudioUnInit_001 begin"); + bool ret = DaudioRadar::GetInstance().ReportDaudioUnInit(FUNC, AudioUnInit::UNREGISTER, + BizState::BIZ_STATE_START, DH_SUCCESS); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportDaudioUnInit_001 end"); +} + +/** + * @tc.name: ReportDaudioUnInit_002 + * @tc.desc: check ReportDaudioUnInit + * @tc.type: FUNC + */ +HWTEST_F(DaudioRadarTest, ReportDaudioUnInit_002, TestSize.Level1) +{ + DHLOGI("DaudioRadarTest ReportDaudioUnInit_002 begin"); + bool ret = DaudioRadar::GetInstance().ReportDaudioUnInit(FUNC, AudioUnInit::UNREGISTER, + BizState::BIZ_STATE_START, ERR_DH_AUDIO_FAILED); + EXPECT_EQ(ret, true); + DHLOGI("DaudioRadarTest ReportDaudioUnInit_002 end"); +} +} +} \ No newline at end of file diff --git a/common/include/daudio_errorcode.h b/common/include/daudio_errorcode.h index f7ad7874..a7dbe894 100644 --- a/common/include/daudio_errorcode.h +++ b/common/include/daudio_errorcode.h @@ -20,56 +20,58 @@ namespace OHOS { namespace DistributedHardware { enum DAudioErrorCode { DH_SUCCESS = 0, - ERR_DH_AUDIO_NULLPTR = -40000, - ERR_DH_AUDIO_FAILED = -40001, - ERR_DH_AUDIO_NOT_SUPPORT = -40002, + ERR_DH_AUDIO_BASE = 0x05C40000, + ERR_DH_AUDIO_NULLPTR = ERR_DH_AUDIO_BASE + 1, + ERR_DH_AUDIO_FAILED = ERR_DH_AUDIO_BASE + 2, + ERR_DH_AUDIO_NOT_SUPPORT = ERR_DH_AUDIO_BASE + 3, - ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED = -40003, - ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED = -40004, - ERR_DH_AUDIO_SA_CALLBACK_NOT_FOUND = -40005, - ERR_DH_AUDIO_SA_INVALID_INTERFACE_TOKEN = -40006, - ERR_DH_AUDIO_SA_WAIT_TIMEOUT = -40007, - ERR_DH_AUDIO_SA_PARAM_INVALID = -40008, - ERR_DH_AUDIO_SA_DEVICE_NOT_EXIST = -40009, - ERR_DH_AUDIO_SA_PROXY_NOT_INIT = -40010, - ERR_DH_AUDIO_SA_LOAD_FAILED = -40011, - ERR_DH_AUDIO_SA_STATUS_ERR = -40012, - ERR_DH_AUDIO_NOT_FOUND_KEY = -40013, - ERR_DH_AUDIO_SA_DEVID_ILLEGAL = -40014, - ERR_DH_AUDIO_SA_PERMISSION_FAIED = -40015, + ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED = ERR_DH_AUDIO_BASE + 5, + ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED = ERR_DH_AUDIO_BASE + 6, + ERR_DH_AUDIO_SA_REGISTERCALLBACK_NOT_FOUND = ERR_DH_AUDIO_BASE + 8, + ERR_DH_AUDIO_SA_UNREGISTERCALLBACK_NOT_FOUND = ERR_DH_AUDIO_BASE + 9, + ERR_DH_AUDIO_SA_INVALID_INTERFACE_TOKEN = ERR_DH_AUDIO_BASE + 10, + ERR_DH_AUDIO_SA_WAIT_TIMEOUT = ERR_DH_AUDIO_BASE + 15, + ERR_DH_AUDIO_SA_PARAM_INVALID = ERR_DH_AUDIO_BASE + 16, + ERR_DH_AUDIO_SA_DEVICE_NOT_EXIST = ERR_DH_AUDIO_BASE + 17, + ERR_DH_AUDIO_SA_PROXY_NOT_INIT = ERR_DH_AUDIO_BASE + 18, + ERR_DH_AUDIO_SA_LOAD_FAILED = ERR_DH_AUDIO_BASE + 19, + ERR_DH_AUDIO_SA_STATUS_ERR = ERR_DH_AUDIO_BASE + 20, + ERR_DH_AUDIO_NOT_FOUND_KEY = ERR_DH_AUDIO_BASE + 21, + ERR_DH_AUDIO_SA_DEVID_ILLEGAL = ERR_DH_AUDIO_BASE + 22, + ERR_DH_AUDIO_SA_PERMISSION_FAIED = ERR_DH_AUDIO_BASE + 23, // trans error - ERR_DH_AUDIO_TRANS_ERROR = -40015, - ERR_DH_AUDIO_TRANS_ILLEGAL_OPERATION = -40016, - ERR_DH_AUDIO_TRANS_SESSION_NOT_OPEN = -40017, + ERR_DH_AUDIO_TRANS_ERROR = ERR_DH_AUDIO_BASE + 24, + ERR_DH_AUDIO_TRANS_ILLEGAL_OPERATION = ERR_DH_AUDIO_BASE + 26, + ERR_DH_AUDIO_TRANS_SESSION_NOT_OPEN = ERR_DH_AUDIO_BASE + 27, // codec error - ERR_DH_AUDIO_BAD_VALUE = -42000, - ERR_DH_AUDIO_BAD_OPERATE = -42001, - ERR_DH_AUDIO_CODEC_CONFIG = -42002, - ERR_DH_AUDIO_CODEC_START = -42003, - ERR_DH_AUDIO_CODEC_STOP = -42004, - ERR_DH_AUDIO_CODEC_RELEASE = -42005, - ERR_DH_AUDIO_CODEC_INPUT = -42006, + ERR_DH_AUDIO_BAD_VALUE = ERR_DH_AUDIO_BASE + 28, + ERR_DH_AUDIO_BAD_OPERATE = ERR_DH_AUDIO_BASE + 29, + ERR_DH_AUDIO_CODEC_CONFIG = ERR_DH_AUDIO_BASE + 30, + ERR_DH_AUDIO_CODEC_START = ERR_DH_AUDIO_BASE + 31, + ERR_DH_AUDIO_CODEC_STOP = ERR_DH_AUDIO_BASE + 32, + ERR_DH_AUDIO_CODEC_RELEASE = ERR_DH_AUDIO_BASE + 33, + ERR_DH_AUDIO_CODEC_INPUT = ERR_DH_AUDIO_BASE + 34, // spk client error - ERR_DH_AUDIO_CLIENT_PARAM_ERROR = -43000, - ERR_DH_AUDIO_CLIENT_RENDER_CREATE_FAILED = -43001, - ERR_DH_AUDIO_CLIENT_RENDER_STARTUP_FAILURE = -43002, - ERR_DH_AUDIO_CLIENT_RENDER_STOP_FAILED = -43003, - ERR_DH_AUDIO_CLIENT_RENDER_RELEASE_FAILED = -43004, - ERR_DH_AUDIO_CLIENT_SET_VOLUME_FAILED = -43005, - ERR_DH_AUDIO_CLIENT_SET_MUTE_FAILED = -43006, + ERR_DH_AUDIO_CLIENT_PARAM_ERROR = ERR_DH_AUDIO_BASE + 35, + ERR_DH_AUDIO_CLIENT_RENDER_CREATE_FAILED = ERR_DH_AUDIO_BASE + 36, + ERR_DH_AUDIO_CLIENT_RENDER_STARTUP_FAILURE = ERR_DH_AUDIO_BASE + 37, + ERR_DH_AUDIO_CLIENT_RENDER_STOP_FAILED = ERR_DH_AUDIO_BASE + 38, + ERR_DH_AUDIO_CLIENT_RENDER_RELEASE_FAILED = ERR_DH_AUDIO_BASE + 39, + ERR_DH_AUDIO_CLIENT_SET_VOLUME_FAILED = ERR_DH_AUDIO_BASE + 40, + ERR_DH_AUDIO_CLIENT_SET_MUTE_FAILED = ERR_DH_AUDIO_BASE + 41, // mic client error - ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED = -43007, - ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED = -43008, + ERR_DH_AUDIO_CLIENT_CAPTURER_CREATE_FAILED = ERR_DH_AUDIO_BASE + 42, + ERR_DH_AUDIO_CLIENT_CAPTURER_START_FAILED = ERR_DH_AUDIO_BASE + 43, // other error - ERR_DH_AUDIO_HDI_CALL_FAILED = -44000, - ERR_DH_AUDIO_HDI_INVALID_PARAM = -44001, - ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED = -44002, - ERR_DH_AUDIO_ACCESS_PERMISSION_CHECK_FAIL = -44003, + ERR_DH_AUDIO_HDI_CALL_FAILED = ERR_DH_AUDIO_BASE + 44, + ERR_DH_AUDIO_HDI_INVALID_PARAM = ERR_DH_AUDIO_BASE + 45, + ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED = ERR_DH_AUDIO_BASE + 46, + ERR_DH_AUDIO_ACCESS_PERMISSION_CHECK_FAIL = ERR_DH_AUDIO_BASE + 47, }; } // namespace DistributedHardware } // namespace OHOS diff --git a/hisysevent.yaml b/hisysevent.yaml index 15e047a7..fa7be9d3 100644 --- a/hisysevent.yaml +++ b/hisysevent.yaml @@ -97,4 +97,28 @@ DAUDIO_UNREGISTER_FAIL: DAUDIO_OPT_FAIL: __BASE: {type: FAULT, level: CRITICAL, desc: daudio operate fail occured} ERROR_CODE: {type: INT32, desc: daudio init process fail error code} - MSG: {type: STRING, desc: daudio operate fail info} \ No newline at end of file + MSG: {type: STRING, desc: daudio operate fail info} + +DISTRIBUTED_AUDIO_BEHAVIOR: + __BASE: {type: BEHAVIOR, level: CRITICAL, desc: distributed audio behavior, preserve: false} + ORG_PKG: {type: STRING, desc: The package 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 result} + BIZ_STATE: {type: INT32, desc: state of business} + TO_CALL_PKG: {type: STRING, desc: call module} + ERROR_CODE: {type: INT32, desc: 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: Credible state} + LOCAL_SESS_NAME: {type: STRING, desc: Local session name} + PEER_SESS_NAME: {type: STRING, desc: Peer session name} + CONFIG_INFO: {type: STRING, desc: Config information} + CONCURRENT_ID: {type: STRING, desc: Concurrent transaction ID} + SERVICE_DURATION: {type: STRING, desc: Duration time of service} \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_ipc_callback.cpp b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_ipc_callback.cpp index a147742f..269bcf6f 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_ipc_callback.cpp +++ b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_ipc_callback.cpp @@ -51,7 +51,7 @@ int32_t DAudioIpcCallback::OnNotifyRegResult(const std::string &devId, const std return DH_SUCCESS; } - return ERR_DH_AUDIO_SA_CALLBACK_NOT_FOUND; + return ERR_DH_AUDIO_SA_REGISTERCALLBACK_NOT_FOUND; } int32_t DAudioIpcCallback::OnNotifyUnregResult(const std::string &devId, const std::string &dhId, @@ -75,7 +75,7 @@ int32_t DAudioIpcCallback::OnNotifyUnregResult(const std::string &devId, const s unregisterCallbackMap_.erase(reqId); return DH_SUCCESS; } - return ERR_DH_AUDIO_SA_CALLBACK_NOT_FOUND; + return ERR_DH_AUDIO_SA_UNREGISTERCALLBACK_NOT_FOUND; } int32_t DAudioIpcCallback::OnHardwareStateChanged(const std::string &devId, const std::string &dhId, int32_t status) diff --git a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp index 624a9ef5..9798d8ed 100644 --- a/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp +++ b/interfaces/inner_kits/native_cpp/audio_source/src/daudio_source_handler.cpp @@ -23,6 +23,7 @@ #include "daudio_hisysevent.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_radar.h" #include "daudio_util.h" #include "daudio_source_load_callback.h" @@ -58,6 +59,8 @@ int32_t DAudioSourceHandler::InitSource(const std::string ¶ms) sptr loadCallback = sptr( new DAudioSourceLoadCallback(params)); int32_t ret = samgr->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, loadCallback); + DaudioRadar::GetInstance().ReportDaudioInit("LoadSystemAbility", AudioInit::SERVICE_INIT, + BizState::BIZ_STATE_START, ret); if (ret != ERR_OK) { DHLOGE("Failed to Load systemAbility, ret code: %{public}d", ret); DAudioHisysevent::GetInstance().SysEventWriteFault(DAUDIO_INIT_FAIL, diff --git a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_ipc_callback_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_ipc_callback_test.cpp index 378c9907..5768c77a 100644 --- a/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_ipc_callback_test.cpp +++ b/interfaces/inner_kits/native_cpp/test/unittest/audiosourcetest/src/daudio_ipc_callback_test.cpp @@ -72,7 +72,7 @@ HWTEST_F(DAudioIpcCallbackTest, OnNotifyRegResult_002, TestSize.Level1) int32_t status = 0; const std::string data = "data"; int32_t ret = dAudioIpcCallback_->OnNotifyRegResult(devId, dhId, reqId, status, data); - EXPECT_EQ(ERR_DH_AUDIO_SA_CALLBACK_NOT_FOUND, ret); + EXPECT_EQ(ERR_DH_AUDIO_SA_REGISTERCALLBACK_NOT_FOUND, ret); } /** @@ -140,7 +140,7 @@ HWTEST_F(DAudioIpcCallbackTest, OnNotifyUnregResult_002, TestSize.Level1) int32_t status = 0; const std::string data = "data"; int32_t ret = dAudioIpcCallback_->OnNotifyUnregResult(devId, dhId, reqId, status, data); - EXPECT_EQ(ERR_DH_AUDIO_SA_CALLBACK_NOT_FOUND, ret); + EXPECT_EQ(ERR_DH_AUDIO_SA_UNREGISTERCALLBACK_NOT_FOUND, ret); } /** diff --git a/services/audiohdiproxy/src/daudio_hdi_handler.cpp b/services/audiohdiproxy/src/daudio_hdi_handler.cpp index 1da683b1..70c31114 100644 --- a/services/audiohdiproxy/src/daudio_hdi_handler.cpp +++ b/services/audiohdiproxy/src/daudio_hdi_handler.cpp @@ -28,6 +28,7 @@ #include "daudio_hdi_handler.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_radar.h" #include "daudio_util.h" #undef DH_LOG_TAG @@ -57,6 +58,8 @@ int32_t DAudioHdiHandler::InitHdiHandler() DHLOGD("Load hdf driver start."); int32_t ret = DaudioHdfOperate::GetInstance().LoadDaudioHDFImpl(); + DaudioRadar::GetInstance().ReportDaudioInit("LoadDaudioHDFImpl", AudioInit::LOAD_HDF_DRIVER, + BizState::BIZ_STATE_END, ret); if (ret != DH_SUCCESS) { DHLOGE("Load hdf driver failed, ret: %{public}d", ret); return ret; @@ -80,6 +83,8 @@ int32_t DAudioHdiHandler::UninitHdiHandler() CHECK_NULL_RETURN(audioSrvHdf_, DH_SUCCESS); int32_t ret = DaudioHdfOperate::GetInstance().UnLoadDaudioHDFImpl(); + DaudioRadar::GetInstance().ReportDaudioUnInit("UnLoadDaudioHDFImpl", AudioUnInit::UNLOAD_HDF_DRIVER, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Unload hdf driver failed, ret: %{public}d", ret); return ret; @@ -139,6 +144,8 @@ int32_t DAudioHdiHandler::UnRegisterAudioDevice(const std::string &devId, const DHLOGI("Unregister audio device, adpname: %{public}s, dhId: %{public}d", GetAnonyString(devId).c_str(), dhId); CHECK_NULL_RETURN(audioSrvHdf_, ERR_DH_AUDIO_NULLPTR); int32_t res = audioSrvHdf_->UnRegisterAudioDevice(devId, dhId); + DaudioRadar::GetInstance().ReportDaudioUnInit("UnRegisterAudioDevice", AudioUnInit::UNLOAD_HDF_DRIVER, + BizState::BIZ_STATE_PROGRESS, res); if (res != HDF_SUCCESS) { DHLOGE("Call hdf proxy unregister failed, res: %{public}d", res); return ERR_DH_AUDIO_HDI_CALL_FAILED; @@ -149,7 +156,7 @@ int32_t DAudioHdiHandler::UnRegisterAudioDevice(const std::string &devId, const auto iter = mapAudioMgrDhIds_.find(devId); if (iter == mapAudioMgrDhIds_.end()) { DHLOGE("Can not find register devId. devId: %{public}s", GetAnonyString(devId).c_str()); - return ERR_DH_AUDIO_SA_CALLBACK_NOT_FOUND; + return ERR_DH_AUDIO_SA_UNREGISTERCALLBACK_NOT_FOUND; } iter->second.erase(dhId); diff --git a/services/audiohdiproxy/src/daudio_manager_callback.cpp b/services/audiohdiproxy/src/daudio_manager_callback.cpp index ce50485e..a9feb995 100644 --- a/services/audiohdiproxy/src/daudio_manager_callback.cpp +++ b/services/audiohdiproxy/src/daudio_manager_callback.cpp @@ -36,7 +36,8 @@ int32_t DAudioManagerCallback::CreateStream(int32_t streamId /* for multistream { DHLOGI("Open device."); CHECK_NULL_RETURN(callback_, HDF_FAILURE); - if (callback_->CreateStream(streamId) != DH_SUCCESS) { + int32_t ret = callback_->CreateStream(streamId); + if (ret != DH_SUCCESS) { DHLOGE("Call hdi callback failed."); return HDF_FAILURE; } diff --git a/services/audiomanager/managersource/src/daudio_source_dev.cpp b/services/audiomanager/managersource/src/daudio_source_dev.cpp index 166f43be..eed49953 100644 --- a/services/audiomanager/managersource/src/daudio_source_dev.cpp +++ b/services/audiomanager/managersource/src/daudio_source_dev.cpp @@ -23,6 +23,7 @@ #include "daudio_errorcode.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_radar.h" #include "daudio_source_manager.h" #include "daudio_util.h" @@ -896,11 +897,15 @@ int32_t DAudioSourceDev::CreateSpkEngine(std::shared_ptr speaker) { CHECK_NULL_RETURN(speaker, ERR_DH_AUDIO_NULLPTR); int32_t ret = speaker->InitSenderEngine(DAudioSourceManager::GetInstance().getSenderProvider()); + DaudioRadar::GetInstance().ReportSpeakerOpen("InitSenderEngine", SpeakerOpen::INIT_ENGINE, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Speaker init sender Engine, error code %{public}d.", ret); return ret; } ret = speaker->InitCtrlTrans(); + DaudioRadar::GetInstance().ReportSpeakerOpen("InitCtrlTrans", SpeakerOpen::TRANS_CONTROL, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Speaker InitCtrlTrans, error code %{public}d.", ret); return ret; @@ -999,6 +1004,8 @@ int32_t DAudioSourceDev::OpenDSpeakerInner(std::shared_ptr &speaker return ret; } ret = speaker->Start(); + DaudioRadar::GetInstance().ReportSpeakerOpen("Start", SpeakerOpen::NOTIFY_HDF, + BizState::BIZ_STATE_END, ret); if (ret != DH_SUCCESS) { DHLOGE("Speaker start failed, error code %{public}d.", ret); speaker->Stop(); @@ -1055,6 +1062,8 @@ int32_t DAudioSourceDev::TaskCloseDSpeaker(const std::string &args) return ERR_DH_AUDIO_SA_PARAM_INVALID; } int32_t ret = CloseSpkNew(args); + DaudioRadar::GetInstance().ReportSpeakerClose("CloseSpkNew", SpeakerClose::NOTIFY_HDF, + BizState::BIZ_STATE_END, ret); if (ret != DH_SUCCESS) { DHLOGE("Close spk failed."); NotifyHDF(NOTIFY_CLOSE_SPEAKER_RESULT, HDF_EVENT_RESULT_FAILED, dhId); @@ -1072,11 +1081,15 @@ int32_t DAudioSourceDev::CreateMicEngine(std::shared_ptr mic) return ERR_DH_AUDIO_NULLPTR; } int32_t ret = mic->InitReceiverEngine(DAudioSourceManager::GetInstance().getReceiverProvider()); + DaudioRadar::GetInstance().ReportMicOpen("InitReceiverEngine", MicOpen::INIT_ENGINE, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Init receiver engine failed."); return ret; } ret = mic->InitCtrlTrans(); + DaudioRadar::GetInstance().ReportMicOpen("InitCtrlTrans", MicOpen::TRANS_CONTROL, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("mic InitCtrlTrans, error code %{public}d.", ret); return ret; @@ -1126,6 +1139,8 @@ int32_t DAudioSourceDev::TaskOpenDMic(const std::string &args) return ret; } ret = mic->Start(); + DaudioRadar::GetInstance().ReportMicOpen("Start", MicOpen::NOTIFY_HDF, + BizState::BIZ_STATE_END, ret); if (ret != DH_SUCCESS) { DHLOGE("Mic start failed, error code %{public}d.", ret); mic->Stop(); @@ -1176,6 +1191,8 @@ int32_t DAudioSourceDev::TaskCloseDMic(const std::string &args) return DH_SUCCESS; } int32_t ret = CloseMicNew(args); + DaudioRadar::GetInstance().ReportMicClose("CloseMicNew", MicClose::NOTIFY_HDF, + BizState::BIZ_STATE_END, ret); if (ret != DH_SUCCESS) { DHLOGE("Task close mic error."); NotifyHDF(NOTIFY_CLOSE_MIC_RESULT, HDF_EVENT_RESULT_FAILED, dhId); diff --git a/services/audiomanager/managersource/src/daudio_source_manager.cpp b/services/audiomanager/managersource/src/daudio_source_manager.cpp index e7a3a46f..2e96640f 100644 --- a/services/audiomanager/managersource/src/daudio_source_manager.cpp +++ b/services/audiomanager/managersource/src/daudio_source_manager.cpp @@ -24,6 +24,7 @@ #include "daudio_errorcode.h" #include "daudio_log.h" #include "daudio_util.h" +#include "daudio_radar.h" #undef DH_LOG_TAG #define DH_LOG_TAG "DAudioSourceManager" @@ -398,6 +399,8 @@ int32_t DAudioSourceManager::OnDisableDAudio(const std::string &devId, const std } CHECK_NULL_RETURN(ipcCallback_, ERR_DH_AUDIO_NULLPTR); + DaudioRadar::GetInstance().ReportDaudioUnInit("OnDisableDAudio", AudioUnInit::DISABLED, + BizState::BIZ_STATE_PROGRESS, result); return ipcCallback_->OnNotifyUnregResult(devId, dhId, reqId, result, ""); } diff --git a/services/audiomanager/managersource/src/dmic_dev.cpp b/services/audiomanager/managersource/src/dmic_dev.cpp index 7c5d0548..ef844927 100644 --- a/services/audiomanager/managersource/src/dmic_dev.cpp +++ b/services/audiomanager/managersource/src/dmic_dev.cpp @@ -26,6 +26,7 @@ #include "daudio_hisysevent.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_radar.h" #include "daudio_source_manager.h" #include "daudio_util.h" @@ -220,6 +221,8 @@ int32_t DMicDev::CreateStream(const int32_t streamId) streamId_ = streamId; cJSON_Delete(jParam); cJSON_free(jsonData); + DaudioRadar::GetInstance().ReportMicOpen("Start", MicOpen::CREATE_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); return DH_SUCCESS; } @@ -246,6 +249,8 @@ int32_t DMicDev::DestroyStream(const int32_t streamId) cJSON_Delete(jParam); cJSON_free(jsonData); curPort_ = 0; + DaudioRadar::GetInstance().ReportMicClose("DestroyStream", MicClose::DESTROY_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); return DH_SUCCESS; } @@ -347,6 +352,8 @@ int32_t DMicDev::Start() DHLOGI("Start mic device."); CHECK_NULL_RETURN(micTrans_, ERR_DH_AUDIO_NULLPTR); int32_t ret = micTrans_->Start(); + DaudioRadar::GetInstance().ReportMicOpen("Start", MicOpen::TRANS_START, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Mic trans start failed, ret: %{public}d.", ret); return ret; @@ -387,6 +394,8 @@ int32_t DMicDev::Stop() #ifdef ECHO_CANNEL_ENABLE CHECK_NULL_RETURN(echoManager_, DH_SUCCESS); ret = echoManager_->Stop(); + DaudioRadar::GetInstance().ReportMicClose("Stop", MicClose::STOP_TRANS, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Echo manager stop failed. ret: %{public}d.", ret); return ret; @@ -411,6 +420,8 @@ int32_t DMicDev::Release() CHECK_NULL_RETURN(micTrans_, DH_SUCCESS); int32_t ret = micTrans_->Release(); + DaudioRadar::GetInstance().ReportMicClose("Release", MicClose::RELEASE_TRANS, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Release mic trans failed, ret: %{public}d.", ret); return ret; diff --git a/services/audiomanager/managersource/src/dspeaker_dev.cpp b/services/audiomanager/managersource/src/dspeaker_dev.cpp index 564dc2f4..05568a2b 100644 --- a/services/audiomanager/managersource/src/dspeaker_dev.cpp +++ b/services/audiomanager/managersource/src/dspeaker_dev.cpp @@ -28,6 +28,7 @@ #include "daudio_hisysevent.h" #include "daudio_hitrace.h" #include "daudio_log.h" +#include "daudio_radar.h" #include "daudio_source_manager.h" #include "daudio_util.h" @@ -165,6 +166,8 @@ int32_t DSpeakerDev::CreateStream(const int32_t streamId) streamId_ = streamId; cJSON_Delete(jParam); cJSON_free(jsonData); + DaudioRadar::GetInstance().ReportSpeakerOpen("CreateStream", SpeakerOpen::CREATE_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); return DH_SUCCESS; } @@ -191,6 +194,8 @@ int32_t DSpeakerDev::DestroyStream(const int32_t streamId) curPort_ = 0; cJSON_Delete(jParam); cJSON_free(jsonData); + DaudioRadar::GetInstance().ReportSpeakerClose("DestroyStream", SpeakerClose::DESTROY_STREAM, + BizState::BIZ_STATE_START, DH_SUCCESS); return DH_SUCCESS; } @@ -248,6 +253,8 @@ int32_t DSpeakerDev::Start() DHLOGI("Start speaker device."); CHECK_NULL_RETURN(speakerTrans_, ERR_DH_AUDIO_NULLPTR); int32_t ret = speakerTrans_->Start(); + DaudioRadar::GetInstance().ReportSpeakerOpen("Start", SpeakerOpen::TRANS_START, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Speaker trans start failed, ret: %{public}d.", ret); return ret; @@ -270,6 +277,8 @@ int32_t DSpeakerDev::Stop() isOpened_.store(false); isTransReady_.store(false); int32_t ret = speakerTrans_->Stop(); + DaudioRadar::GetInstance().ReportSpeakerClose("Stop", SpeakerClose::STOP_TRANS, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Stop speaker trans failed, ret: %{public}d.", ret); return ret; @@ -292,6 +301,8 @@ int32_t DSpeakerDev::Release() } CHECK_NULL_RETURN(speakerTrans_, DH_SUCCESS); int32_t ret = speakerTrans_->Release(); + DaudioRadar::GetInstance().ReportSpeakerClose("Release", SpeakerClose::RELEASE_TRANS, + BizState::BIZ_STATE_PROGRESS, ret); if (ret != DH_SUCCESS) { DHLOGE("Release speaker trans failed, ret: %{public}d.", ret); } diff --git a/services/audiomanager/servicesource/src/daudio_source_service.cpp b/services/audiomanager/servicesource/src/daudio_source_service.cpp index 6ec8226c..e466876c 100644 --- a/services/audiomanager/servicesource/src/daudio_source_service.cpp +++ b/services/audiomanager/servicesource/src/daudio_source_service.cpp @@ -26,6 +26,7 @@ #include "daudio_errorcode.h" #include "daudio_hisysevent.h" #include "daudio_log.h" +#include "daudio_radar.h" #include "daudio_source_manager.h" #include "daudio_util.h" @@ -70,6 +71,8 @@ int32_t DAudioSourceService::InitSource(const std::string ¶ms, const sptr