From 12343bbaf58cf83d7f063d6cfb238ab96f43d55e Mon Sep 17 00:00:00 2001 From: YouZijun97 Date: Fri, 29 Nov 2024 19:30:21 +0800 Subject: [PATCH] add reportSceneInfo Signed-off-by: YouZijun97 --- ...ncurrent_task_service_ipc_interface_code.h | 1 + .../include/concurrent_task_service_proxy.h | 1 + .../include/iconcurrent_task_service.h | 1 + .../src/concurrent_task_client.cpp | 13 ++++ .../src/concurrent_task_service_proxy.cpp | 23 ++++++ interfaces/inner_api/concurrent_task_client.h | 8 ++ .../concurrent_task_controller_interface.h | 3 + services/include/concurrent_task_service.h | 1 + .../include/concurrent_task_service_stub.h | 1 + .../concurrent_task_controller_interface.cpp | 10 +++ services/src/concurrent_task_service.cpp | 5 ++ services/src/concurrent_task_service_stub.cpp | 21 +++++ .../concurrent_fuzzer/concurrent_fuzzer.cpp | 78 +++++++++++++++++++ .../phone/concurrent_task_client_test.cpp | 14 ++++ ...current_task_controller_interface_test.cpp | 13 ++++ test/unittest/phone/func_loader_test.cpp | 1 + 16 files changed, 194 insertions(+) diff --git a/frameworks/concurrent_task_client/include/concurrent_task_service_ipc_interface_code.h b/frameworks/concurrent_task_client/include/concurrent_task_service_ipc_interface_code.h index 84c9351..157a3ab 100644 --- a/frameworks/concurrent_task_client/include/concurrent_task_service_ipc_interface_code.h +++ b/frameworks/concurrent_task_client/include/concurrent_task_service_ipc_interface_code.h @@ -24,6 +24,7 @@ enum class ConcurrentTaskInterfaceCode { QUERY_INTERVAL = 2, QUERY_DEADLINE = 3, REQUEST_AUTH = 4, + REPORT_SCENE_INFO = 5, }; } // namespace ConcurrentTask } // namespace OHOS diff --git a/frameworks/concurrent_task_client/include/concurrent_task_service_proxy.h b/frameworks/concurrent_task_client/include/concurrent_task_service_proxy.h index 1b27fda..57d1bf2 100644 --- a/frameworks/concurrent_task_client/include/concurrent_task_service_proxy.h +++ b/frameworks/concurrent_task_client/include/concurrent_task_service_proxy.h @@ -29,6 +29,7 @@ public: virtual ~ConcurrentTaskServiceProxy() {} void ReportData(uint32_t resType, int64_t value, const Json::Value& payload) override; + void ReportSceneInfo(uint32_t type, const Json::Value& payload) override; void QueryInterval(int queryItem, IntervalReply& queryRs) override; void QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload) override; void RequestAuth(const Json::Value& payload) override; diff --git a/frameworks/concurrent_task_client/include/iconcurrent_task_service.h b/frameworks/concurrent_task_client/include/iconcurrent_task_service.h index 7e70d7b..b133e2d 100644 --- a/frameworks/concurrent_task_client/include/iconcurrent_task_service.h +++ b/frameworks/concurrent_task_client/include/iconcurrent_task_service.h @@ -28,6 +28,7 @@ public: DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.ResourceSchedule.ConcurrentTaskService"); virtual void ReportData(uint32_t resType, int64_t value, const Json::Value& payload) = 0; + virtual void ReportSceneInfo(uint32_t type, const Json::Value& payload) = 0; virtual void QueryInterval(int queryItem, IntervalReply& queryRs) = 0; virtual void QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload) = 0; virtual void RequestAuth(const Json::Value& payload) = 0; diff --git a/frameworks/concurrent_task_client/src/concurrent_task_client.cpp b/frameworks/concurrent_task_client/src/concurrent_task_client.cpp index 08d0f14..e512ead 100644 --- a/frameworks/concurrent_task_client/src/concurrent_task_client.cpp +++ b/frameworks/concurrent_task_client/src/concurrent_task_client.cpp @@ -43,6 +43,19 @@ void ConcurrentTaskClient::ReportData(uint32_t resType, int64_t value, clientService_->ReportData(resType, value, payload); } +void ConcurrentTaskClient::ReportSceneInfo(uint32_t type, + const std::unordered_map& mapPayload) +{ + if (TryConnect() != ERR_OK) { + return; + } + Json::Value payload; + for (auto it = mapPayload.begin(); it != mapPayload.end(); ++it) { + payload[it->first] = it->second; + } + clientService_->ReportSceneInfo(type, payload); +} + void ConcurrentTaskClient::QueryInterval(int queryItem, IntervalReply& queryRs) { if (TryConnect() != ERR_OK) { diff --git a/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp b/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp index 6ba5a9b..a601473 100644 --- a/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp +++ b/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp @@ -42,6 +42,29 @@ void ConcurrentTaskServiceProxy::ReportData(uint32_t resType, int64_t value, con CONCUR_LOGD("ConcurrentTaskServiceProxy::ReportData success."); } +void ConcurrentTaskServiceProxy::ReportSceneInfo(uint32_t type, const Json::Value& payload) +{ + int32_t error; + MessageParcel data; + MessageParcel reply; + MessageOption option = { MessageOption::TF_ASYNC }; + if (!data.WriteInterfaceToken(ConcurrentTaskServiceProxy::GetDescriptor())) { + CONCUR_LOGE("Write interface token failed in ReportSceneInfo Proxy"); + return; + } + if (!data.WriteUint32(type) || !data.WriteString(payload.toStyledString())) { + CONCUR_LOGE("Write info failed in ReportSceneInfo Proxy"); + return; + } + uint32_t code = static_cast(ConcurrentTaskInterfaceCode::REPORT_SCENE_INFO); + error = Remote()->SendRequest(code, data, reply, option); + if (error != NO_ERROR) { + CONCUR_LOGE("Send request error: %{public}d", error); + return; + } + CONCUR_LOGD("ConcurrentTaskServiceProxy::ReportSceneInfo success."); +} + void ConcurrentTaskServiceProxy::QueryInterval(int queryItem, IntervalReply& queryRs) { int32_t error; diff --git a/interfaces/inner_api/concurrent_task_client.h b/interfaces/inner_api/concurrent_task_client.h index a00c3a5..76977fa 100644 --- a/interfaces/inner_api/concurrent_task_client.h +++ b/interfaces/inner_api/concurrent_task_client.h @@ -47,6 +47,14 @@ public: */ void ReportData(uint32_t resType, int64_t value, const std::unordered_map& mapPayload); + /** + * @brief Report scene info to the concurrent task service through inter-process communication. + * + * @param type Indicates the resource type, default is 0. + * @param mapPayload Indicates the context info of the scene data. + */ + void ReportSceneInfo(uint32_t type, const std::unordered_map& mapPayload); + /** * @brief Query rtg id and other info provided by concurrent task service. * diff --git a/services/include/concurrent_task_controller_interface.h b/services/include/concurrent_task_controller_interface.h index 8934f95..4462b32 100644 --- a/services/include/concurrent_task_controller_interface.h +++ b/services/include/concurrent_task_controller_interface.h @@ -28,6 +28,7 @@ namespace OHOS { namespace ConcurrentTask { using ReportDataFunc = void (*)(uint32_t resType, int64_t value, const Json::Value& payload); +using ReportSceneInfoFunc = void (*)(uint32_t type, const Json::Value& payload); using QueryIntervalFunc = void (*)(int queryItem, IntervalReply& queryRs); using QueryDeadlineFunc = void (*)(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload); using RequestAuthFunc = void (*)(const Json::Value& payload); @@ -42,6 +43,7 @@ public: virtual ~TaskControllerInterface() = default; void RequestAuth(const Json::Value& payload); void ReportData(uint32_t resType, int64_t value, const Json::Value& payload); + void ReportSceneInfo(uint32_t type, const Json::Value& payload); void QueryInterval(int queryItem, IntervalReply& queryRs); void QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload); void Init(); @@ -55,6 +57,7 @@ private: QosPolicy qosPolicy_; ReportDataFunc reportDataFunc_ = nullptr; + ReportSceneInfoFunc reportSceneInfoFunc_ = nullptr; QueryIntervalFunc queryIntervalFunc_ = nullptr; QueryDeadlineFunc queryDeadlineFunc_ = nullptr; RequestAuthFunc requestAuthFunc_ = nullptr; diff --git a/services/include/concurrent_task_service.h b/services/include/concurrent_task_service.h index 28b792b..957340c 100644 --- a/services/include/concurrent_task_service.h +++ b/services/include/concurrent_task_service.h @@ -27,6 +27,7 @@ public: ~ConcurrentTaskService() override = default; void ReportData(uint32_t resType, int64_t value, const Json::Value& payload) override; + void ReportSceneInfo(uint32_t type, const Json::Value& payload) override; void QueryInterval(int queryItem, IntervalReply& queryRs) override; void QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload) override; void RequestAuth(const Json::Value& payload) override; diff --git a/services/include/concurrent_task_service_stub.h b/services/include/concurrent_task_service_stub.h index 4da6757..0a7ea6b 100644 --- a/services/include/concurrent_task_service_stub.h +++ b/services/include/concurrent_task_service_stub.h @@ -31,6 +31,7 @@ public: private: int32_t ReportDataInner(MessageParcel& data, MessageParcel& reply); + int32_t ReportSceneInfoInner(MessageParcel& data, MessageParcel& reply); int32_t QueryIntervalInner(MessageParcel& data, MessageParcel& reply); int32_t QueryDeadlineInner(MessageParcel& data, MessageParcel& reply); int32_t RequestAuthInner(MessageParcel& data, MessageParcel& reply); diff --git a/services/src/concurrent_task_controller_interface.cpp b/services/src/concurrent_task_controller_interface.cpp index c60bf74..dd54ed7 100644 --- a/services/src/concurrent_task_controller_interface.cpp +++ b/services/src/concurrent_task_controller_interface.cpp @@ -62,6 +62,15 @@ void TaskControllerInterface::ReportData(uint32_t resType, int64_t value, const reportDataFunc_(resType, value, payload); } +void TaskControllerInterface::ReportSceneInfo(uint32_t type, const Json::Value& payload) +{ + if (!inited_) { + CONCUR_LOGE("[TaskControllerInterface] ReportSceneInfo failed, funcLoader_ load func failed"); + return; + } + reportSceneInfoFunc_(type, payload); +} + void TaskControllerInterface::QueryInterval(int queryItem, IntervalReply& queryRs) { if (!inited_) { @@ -108,6 +117,7 @@ void TaskControllerInterface::Release() bool TaskControllerInterface::LoadFunc() { reportDataFunc_ = ReportDataFunc(funcLoader_.LoadSymbol("ReportData")); + reportSceneInfoFunc_ = ReportSceneInfoFunc(funcLoader_.LoadSymbol("ReportSceneInfo")); queryIntervalFunc_ = QueryIntervalFunc(funcLoader_.LoadSymbol("QueryInterval")); queryDeadlineFunc_ = QueryDeadlineFunc(funcLoader_.LoadSymbol("QueryDeadline")); requestAuthFunc_ = RequestAuthFunc(funcLoader_.LoadSymbol("RequestAuth")); diff --git a/services/src/concurrent_task_service.cpp b/services/src/concurrent_task_service.cpp index 6627ef2..a90c7c1 100644 --- a/services/src/concurrent_task_service.cpp +++ b/services/src/concurrent_task_service.cpp @@ -24,6 +24,11 @@ void ConcurrentTaskService::ReportData(uint32_t resType, int64_t value, const Js TaskControllerInterface::GetInstance().ReportData(resType, value, payload); } +void ConcurrentTaskService::ReportSceneInfo(uint32_t type, const Json::Value& payload) +{ + TaskControllerInterface::GetInstance().ReportSceneInfo(type, payload); +} + void ConcurrentTaskService::QueryInterval(int queryItem, IntervalReply& queryRs) { TaskControllerInterface::GetInstance().QueryInterval(queryItem, queryRs); diff --git a/services/src/concurrent_task_service_stub.cpp b/services/src/concurrent_task_service_stub.cpp index 6bcf9bd..dbdd533 100644 --- a/services/src/concurrent_task_service_stub.cpp +++ b/services/src/concurrent_task_service_stub.cpp @@ -60,6 +60,25 @@ int32_t ConcurrentTaskServiceStub::ReportDataInner(MessageParcel& data, [[maybe_ return ERR_OK; } +int32_t ConcurrentTaskServiceStub::ReportSceneInfoInner(MessageParcel& data, [[maybe_unused]] MessageParcel& reply) +{ + if (!IsValidToken(data)) { + return ERR_CONCURRENT_TASK_PARCEL_ERROR; + } + + uint32_t type = 0; + std::string payload; + if (!data.ReadUint32(type) || !data.ReadString(payload)) { + CONCUR_LOGE("Read info failed in ReportSceneInfoInner Stub"); + return IPC_STUB_ERR; + } + if (payload.empty()) { + return ERR_OK; + } + ReportSceneInfo(type, StringToJson(payload)); + return ERR_OK; +} + int32_t ConcurrentTaskServiceStub::QueryIntervalInner(MessageParcel& data, [[maybe_unused]] MessageParcel& reply) { if (!IsValidToken(data)) { @@ -168,6 +187,8 @@ void ConcurrentTaskServiceStub::Init() funcMap_ = { { static_cast(ConcurrentTaskInterfaceCode::REPORT_DATA), [this](auto& data, auto& reply) {return ReportDataInner(data, reply); } }, + { static_cast(ConcurrentTaskInterfaceCode::REPORT_SCENE_INFO), + [this](auto& data, auto& reply) {return ReportSceneInfoInner(data, reply); } }, { static_cast(ConcurrentTaskInterfaceCode::QUERY_INTERVAL), [this](auto& data, auto& reply) {return QueryIntervalInner(data, reply); } }, { static_cast(ConcurrentTaskInterfaceCode::QUERY_DEADLINE), diff --git a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp index 11504ac..d8178de 100644 --- a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp +++ b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp @@ -47,6 +47,8 @@ public: virtual ~ConcurrentTaskServiceStubFuzer() = default; void ReportData(uint32_t resType, int64_t value, const Json::Value& payload) override {} + void ReportSceneInfo(uint32_t type, const Json::Value& payload) override + {} void QueryInterval(int queryItem, IntervalReply& queryRs) override {} void QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload) override @@ -116,6 +118,30 @@ bool FuzzConcurrentTaskServiceReportData(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskServiceReportSceneInfo(const uint8_t* data, size_t size) +{ + g_baseFuzzData = data; + g_baseFuzzSize = size; + g_baseFuzzPos = 0; + if (size > sizeof(int) + sizeof(int)) { + MessageParcel data1; + Parcel parcel; + sptr iremoteobject = IRemoteObject::Unmarshalling(parcel); + int intdata = GetData(); + void *voiddata = &intdata; + size_t size1 = sizeof(int); + data1.WriteRemoteObject(iremoteobject); + data1.WriteRawData(voiddata, size1); + data1.ReadRawData(size1); + MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(ConcurrentTaskInterfaceCode::REPORT_SCENE_INFO); + ConcurrentTaskService s = ConcurrentTaskService(); + s.OnRemoteRequest(code, data1, reply, option); + } + return true; +} + bool FuzzConcurrentTaskServiceQueryInterval(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -383,6 +409,22 @@ bool FuzzConcurrentTaskServiceStubReportData(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskServiceStubReportSceneInfo(const uint8_t* data, size_t size) +{ + g_baseFuzzData = data; + g_baseFuzzSize = size; + g_baseFuzzPos = 0; + if (size > sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t)) { + ConcurrentTaskService s = ConcurrentTaskService(); + uint32_t type = GetData(); + Json::Value jsValue; + jsValue["1111"] = std::to_string(GetData()); + jsValue["2222"] = std::to_string(GetData()); + s.ReportSceneInfo(type, jsValue); + } + return true; +} + bool FuzzConcurrentTaskServiceStubQueryInterval(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -575,6 +617,24 @@ bool FuzzConcurrentTaskServiceProxyReportData(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskServiceProxyReportSceneInfo(const uint8_t* data, size_t size) +{ + g_baseFuzzData = data; + g_baseFuzzSize = size; + g_baseFuzzPos = 0; + if (size >= sizeof(uint32_t) + sizeof(int32_t)) { + uint32_t intdata1 = GetData(); + Json::Value payload; + payload["2123"] = std::to_string(GetData()); + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + sptr remoteObject = systemAbilityManager->GetSystemAbility(CONCURRENT_TASK_SERVICE_ID); + ConcurrentTaskServiceProxy s = ConcurrentTaskServiceProxy(remoteObject); + s.ReportSceneInfo(intdata1, payload); + } + return true; +} + bool FuzzConcurrentTaskServiceProxyQueryInterval(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -655,6 +715,21 @@ bool FuzzConcurrentTaskControllerInterfaceReportData(const uint8_t* data, size_t return true; } +bool FuzzConcurrentTaskControllerInterfaceReportSceneInfo(const uint8_t* data, size_t size) +{ + g_baseFuzzData = data; + g_baseFuzzSize = size; + g_baseFuzzPos = 0; + if (size > sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t)) { + uint32_t resType = GetData(); + Json::Value jsValue; + jsValue["1111"] = std::to_string(GetData()); + jsValue["2222"] = std::to_string(GetData()); + TaskControllerInterface::GetInstance().ReportSceneInfo(resType, jsValue); + } + return true; +} + bool FuzzConcurrentTaskControllerInterfaceQueryInterval(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -740,6 +815,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) /* Run your code on data */ OHOS::FuzzConcurrentTaskTryConnect(data, size); OHOS::FuzzConcurrentTaskServiceReportData(data, size); + OHOS::FuzzConcurrentTaskServiceReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskServiceRequestAuth(data, size); OHOS::FuzzConcurrentTaskServiceQueryInterval(data, size); OHOS::FuzzConcurrentTaskServiceStopRemoteObject(data, size); @@ -752,6 +828,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::FuzzQosInterfaceEnableRtg(data, size); OHOS::FuzzQosInterfaceQosLeave(data, size); OHOS::FuzzConcurrentTaskServiceStubReportData(data, size); + OHOS::FuzzConcurrentTaskServiceStubReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskServiceStubQueryInterval(data, size); OHOS::FuzzConcurrentTaskServiceStubQueryDeadline(data, size); OHOS::FuzzConcurrentTaskServiceStubRequestAuth(data, size); @@ -768,6 +845,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::FuzzConcurrentTaskClientTryConnect(data, size); OHOS::FuzzConcurrentTaskClientStopRemoteObject(data, size); OHOS::FuzzConcurrentTaskServiceProxyReportData(data, size); + OHOS::FuzzConcurrentTaskServiceProxyReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskServiceProxyQueryInterval(data, size); OHOS::FuzzConcurrentTaskServiceProxyQueryDeadline(data, size); OHOS::FuzzConcurrentTaskServiceProxyRequestAuth(data, size); diff --git a/test/unittest/phone/concurrent_task_client_test.cpp b/test/unittest/phone/concurrent_task_client_test.cpp index 69367b5..c92d6ca 100644 --- a/test/unittest/phone/concurrent_task_client_test.cpp +++ b/test/unittest/phone/concurrent_task_client_test.cpp @@ -63,6 +63,20 @@ HWTEST_F(ConcurrentTaskClientTest, ReportDataTest, TestSize.Level1) ConcurrentTaskClient::GetInstance().ReportData(resType, value, payload); } +/** + * @tc.name: PushTaskTest + * @tc.desc: Test whether the PushTask interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskClientTest, ReportSceneInfoTest, TestSize.Level1) +{ + uint32_t type = 0; + std::unordered_map payload; + payload["uid"] = "3587"; + payload["value"] = "12345"; + ConcurrentTaskClient::GetInstance().ReportSceneInfo(type, payload); +} + /** * @tc.name: PushTaskTest * @tc.desc: Test whether the PushTask interface are normal. diff --git a/test/unittest/phone/concurrent_task_controller_interface_test.cpp b/test/unittest/phone/concurrent_task_controller_interface_test.cpp index 3f2933e..0968828 100644 --- a/test/unittest/phone/concurrent_task_controller_interface_test.cpp +++ b/test/unittest/phone/concurrent_task_controller_interface_test.cpp @@ -75,6 +75,19 @@ HWTEST_F(ConcurrentTaskControllerInterfaceTest, ReportDataTest, TestSize.Level1) repData.ReportData(resType, value, payload); } +/** + * @tc.name: ReportSceneInfoTest + * @tc.desc: Test whether the ReportSceneInfoTest interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskControllerInterfaceTest, ReportSceneInfoTest, TestSize.Level1) +{ + uint32_t resType = 0; + const Json::Value payload; + TaskControllerInterface repData; + repData.ReportSceneInfo(resType, payload); +} + /** * @tc.name: QueryDeadlineTest * @tc.desc: Test whether the QueryDeadlineTest interface are normal. diff --git a/test/unittest/phone/func_loader_test.cpp b/test/unittest/phone/func_loader_test.cpp index 75a2cd4..0943205 100644 --- a/test/unittest/phone/func_loader_test.cpp +++ b/test/unittest/phone/func_loader_test.cpp @@ -72,6 +72,7 @@ HWTEST_F(FuncLoaderTest, LoadSymbolTest, TestSize.Level1) funcLoader.LoadSymbol("Init"); funcLoader.LoadSymbol("Release"); funcLoader.LoadSymbol("ReportData"); + funcLoader.LoadSymbol("ReportSceneInfo"); funcLoader.LoadSymbol("QueryInterval"); funcLoader.LoadSymbol("QueryDeadline"); funcLoader.LoadSymbol("RequestAuth"); -- Gitee