From 8b32ac8416d5f7fe6014c7babf4a350249d4ff28 Mon Sep 17 00:00:00 2001 From: YouZijun97 Date: Mon, 16 Jun 2025 02:53:24 +0000 Subject: [PATCH 1/2] add async ipc Signed-off-by: YouZijun97 --- .../idl/IConcurrentTaskService.idl | 1 + .../src/concurrent_task_client.cpp | 11 ++++ interfaces/inner_api/concurrent_task_client.h | 8 +++ interfaces/inner_api/concurrent_task_type.h | 6 +++ .../concurrent_task_controller_interface.h | 3 ++ services/include/concurrent_task_service.h | 1 + .../concurrent_task_controller_interface.cpp | 11 ++++ services/src/concurrent_task_service.cpp | 7 +++ .../concurrent_fuzzer/concurrent_fuzzer.cpp | 53 ++++++++++++++++++- .../phone/concurrent_task_client_test.cpp | 15 ++++++ ...current_task_controller_interface_test.cpp | 15 ++++++ .../phone/concurrent_task_service_test.cpp | 17 ++++++ 12 files changed, 147 insertions(+), 1 deletion(-) diff --git a/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl b/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl index 64e0a73..ed8141d 100644 --- a/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl +++ b/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl @@ -22,4 +22,5 @@ [oneway] void QueryDeadline([in] int queryItem, [in] IpcDeadlineReply IpcDdlReply, [in] Map payload); void SetAudioDeadline([in] int queryItem, [in] int tid, [in] int grpId, [inout] IpcIntervalReply queryRs); void RequestAuth([in] Map payload); + [oneway] void QueryIntervalAsync([in] int queryItem, [in] Map payload); } \ No newline at end of file diff --git a/frameworks/concurrent_task_client/src/concurrent_task_client.cpp b/frameworks/concurrent_task_client/src/concurrent_task_client.cpp index 41963d6..249815d 100644 --- a/frameworks/concurrent_task_client/src/concurrent_task_client.cpp +++ b/frameworks/concurrent_task_client/src/concurrent_task_client.cpp @@ -120,6 +120,17 @@ void ConcurrentTaskClient::SetAudioDeadline(int queryItem, int tid, int grpId, I return; } +void ConcurrentTaskClient::QueryIntervalAsync( + int queryItem, const std::unordered_map& mapPayload) +{ + if (TryConnect() != ERR_OK) { + CONCUR_LOGE("QueryIntervalAsync connnect fail"); + return; + } + clientService_->QueryIntervalAsync(queryItem, mapPayload); + return; +} + void ConcurrentTaskClient::RequestAuth(const std::unordered_map& mapPayload) { if (TryConnect() != ERR_OK) { diff --git a/interfaces/inner_api/concurrent_task_client.h b/interfaces/inner_api/concurrent_task_client.h index 0510394..de736a2 100644 --- a/interfaces/inner_api/concurrent_task_client.h +++ b/interfaces/inner_api/concurrent_task_client.h @@ -93,6 +93,14 @@ public: */ void SetAudioDeadline(int queryItem, int tid, int grpId, IntervalReply& queryRs); + /** + * @brief Query rtg id and other info provided by concurrent task service async. + * + * @param queryItem Information of the corresponding query module. + * @param mapPayload Indicates the context info of the query message. + */ + void QueryIntervalAsync(int queryItem, const std::unordered_map& mapPayload); + /** * @brief Report auth request data to the concurrent task service. * diff --git a/interfaces/inner_api/concurrent_task_type.h b/interfaces/inner_api/concurrent_task_type.h index d2b718d..5576c9e 100644 --- a/interfaces/inner_api/concurrent_task_type.h +++ b/interfaces/inner_api/concurrent_task_type.h @@ -85,6 +85,12 @@ struct DeadlineReply { bool setStatus; }; +enum QueryAsyncItem { + QUERY_ASYNC_SELF_RENDER_FRAME_END = 1, + QUERY_ASYNC_SELF_RENDER_FRAME_START = 2, + QUERY_ASYNC_TYPE_MAX, +}; + enum GameStatus { GAME_ENTRY_MSG = 0, GAME_EXIT_MSG, diff --git a/services/include/concurrent_task_controller_interface.h b/services/include/concurrent_task_controller_interface.h index a015c75..12370d4 100644 --- a/services/include/concurrent_task_controller_interface.h +++ b/services/include/concurrent_task_controller_interface.h @@ -32,6 +32,7 @@ using QueryIntervalFunc = void (*)(int queryItem, IntervalReply& queryRs); using QueryDeadlineFunc = void (*)( int queryItem, DeadlineReply& ddlReply, const std::unordered_map& payload); using SetAudioDeadlineFunc = void (*)(int queryItem, int tid, int grpId, IntervalReply& queryRs); +using QueryIntervalAsyncFunc = void (*)(int queryItem, const std::unordered_map& mapPayload); using RequestAuthFunc = void (*)(const std::unordered_map& payload); using InitFunc = void (*)(); using ReleaseFunc = void (*)(); @@ -46,6 +47,7 @@ public: void ReportData(uint32_t resType, int64_t value, const std::unordered_map& payload); void ReportSceneInfo(uint32_t type, const std::unordered_map& payload); void QueryInterval(int queryItem, IntervalReply& queryRs); + void QueryIntervalAsync(int queryItem, const std::unordered_map& mapPayload); void QueryDeadline( int queryItem, DeadlineReply& ddlReply, const std::unordered_map& payload); void SetAudioDeadline(int queryItem, int tid, int grpId, IntervalReply& queryRs); @@ -62,6 +64,7 @@ private: ReportDataFunc reportDataFunc_ = nullptr; ReportSceneInfoFunc reportSceneInfoFunc_ = nullptr; QueryIntervalFunc queryIntervalFunc_ = nullptr; + QueryIntervalAsyncFunc queryIntervalAsyncFunc_ = nullptr; QueryDeadlineFunc queryDeadlineFunc_ = nullptr; SetAudioDeadlineFunc setAudioDeadlineFunc_ = nullptr; RequestAuthFunc requestAuthFunc_ = nullptr; diff --git a/services/include/concurrent_task_service.h b/services/include/concurrent_task_service.h index a18d8c4..010d6ed 100644 --- a/services/include/concurrent_task_service.h +++ b/services/include/concurrent_task_service.h @@ -32,6 +32,7 @@ public: const std::unordered_map& payload) override; ErrCode ReportSceneInfo(uint32_t type, const std::unordered_map& payload) override; ErrCode QueryInterval(int queryItem, IpcIntervalReply& IpcQueryRs) override; + ErrCode QueryIntervalAsync(int queryItem, const std::unordered_map& mapPayload) override; ErrCode QueryDeadline(int queryItem, const IpcDeadlineReply& IpcDdlReply, const std::unordered_map& payload) override; ErrCode SetAudioDeadline(int queryItem, int tid, int grpId, IpcIntervalReply& IpcQueryRs) override; diff --git a/services/src/concurrent_task_controller_interface.cpp b/services/src/concurrent_task_controller_interface.cpp index 1032669..91afa92 100644 --- a/services/src/concurrent_task_controller_interface.cpp +++ b/services/src/concurrent_task_controller_interface.cpp @@ -101,6 +101,16 @@ void TaskControllerInterface::SetAudioDeadline(int queryItem, int tid, int grpId setAudioDeadlineFunc_(queryItem, tid, grpId, queryRs); } +void TaskControllerInterface::QueryIntervalAsync( + int queryItem, const std::unordered_map& mapPayload) +{ + if (!inited_) { + CONCUR_LOGE("[TaskControllerInterface] QueryIntervalAsync failed, funcLoader_ load func failed"); + return; + } + queryIntervalAsyncFunc_(queryItem, mapPayload); +} + void TaskControllerInterface::Init() { std::lock_guard autoLock(funcLoaderLock_); @@ -132,6 +142,7 @@ bool TaskControllerInterface::LoadFunc() reportDataFunc_ = ReportDataFunc(funcLoader_.LoadSymbol("ReportData")); reportSceneInfoFunc_ = ReportSceneInfoFunc(funcLoader_.LoadSymbol("ReportSceneInfo")); queryIntervalFunc_ = QueryIntervalFunc(funcLoader_.LoadSymbol("QueryInterval")); + queryIntervalAsyncFunc_ = QueryIntervalAsyncFunc(funcLoader_.LoadSymbol("QueryIntervalAsync")); queryDeadlineFunc_ = QueryDeadlineFunc(funcLoader_.LoadSymbol("QueryDeadline")); setAudioDeadlineFunc_ = SetAudioDeadlineFunc(funcLoader_.LoadSymbol("SetAudioDeadline")); requestAuthFunc_ = RequestAuthFunc(funcLoader_.LoadSymbol("RequestAuth")); diff --git a/services/src/concurrent_task_service.cpp b/services/src/concurrent_task_service.cpp index 5c5d784..ff7dcca 100644 --- a/services/src/concurrent_task_service.cpp +++ b/services/src/concurrent_task_service.cpp @@ -58,6 +58,13 @@ ErrCode ConcurrentTaskService::QueryDeadline( return ERR_OK; } +ErrCode ConcurrentTaskService::QueryIntervalAsync( + int queryItem, const std::unordered_map& payload) +{ + TaskControllerInterface::GetInstance().QueryIntervalAsync(queryItem, payload); + return ERR_OK; +} + ErrCode ConcurrentTaskService::RequestAuth(const std::unordered_map& payload) { TaskControllerInterface::GetInstance().RequestAuth(payload); diff --git a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp index 8e3a5f9..3cd5e07 100644 --- a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp +++ b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp @@ -114,6 +114,28 @@ bool FuzzConcurrentTaskServiceQueryInterval(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskServiceQueryIntervalAsync(const uint8_t* data, size_t size) +{ + FuzzedDataProvider fdp(data, size); + if (size > sizeof(int) + sizeof(int)) { + MessageParcel data1; + Parcel parcel; + sptr iremoteobject = IRemoteObject::Unmarshalling(parcel); + int intdata = fdp.ConsumeIntegral(); + 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(IConcurrentTaskServiceIpcCode::COMMAND_QUERY_INTERVAL_ASYNC); + ConcurrentTaskService s = ConcurrentTaskService(); + s.OnRemoteRequest(code, data1, reply, option); + } + return true; +} + bool FuzzConcurrentTaskServiceQueryDeadline(const uint8_t* data, size_t size) { FuzzedDataProvider fdp(data, size); @@ -352,6 +374,19 @@ bool FuzzConcurrentTaskClientQueryInterval(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskClientQueryIntervalAsync(const uint8_t* data, size_t size) +{ + FuzzedDataProvider fdp(data, size); + if (size > sizeof(int) + sizeof(int)) { + int queryItem = fdp.ConsumeIntegral(); + queryItem = queryItem % (QUERY_ASYNC_TYPE_MAX + 1); + std::unordered_map mapPayload; + mapPayload["218266"] = std::to_string(fdp.ConsumeIntegral()); + ConcurrentTaskClient::GetInstance().QueryIntervalAsync(queryItem, mapPayload); + } + return true; +} + bool FuzzConcurrentTaskClientQueryDeadline(const uint8_t* data, size_t size) { FuzzedDataProvider fdp(data, size); @@ -438,6 +473,20 @@ bool FuzzConcurrentTaskControllerInterfaceQueryInterval(const uint8_t* data, siz return true; } +bool FuzzConcurrentTaskControllerInterfaceQueryIntervalAsync(const uint8_t* data, size_t size) +{ + FuzzedDataProvider fdp(data, size); + if (size > sizeof(int) + sizeof(int)) { + ConcurrentTaskService s = ConcurrentTaskService(); + int queryItem = fdp.ConsumeIntegral(); + queryItem = queryItem % (QUERY_ASYNC_TYPE_MAX + 1); + std::unordered_map mapPayload; + mapPayload["218266"] = std::to_string(fdp.ConsumeIntegral()); + TaskControllerInterface::GetInstance().QueryIntervalAsync(queryItem, mapPayload); + } + return true; +} + bool FuzzConcurrentTaskControllerInterfaceQueryDeadline(const uint8_t* data, size_t size) { FuzzedDataProvider fdp(data, size); @@ -516,7 +565,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::FuzzConcurrentTaskServiceReportData(data, size); OHOS::FuzzConcurrentTaskServiceReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskServiceQueryDeadline(data, size); - OHOS::FuzzConcurrentTaskServiceQueryInterval(data, size); + OHOS::FuzzConcurrentTaskServiceQueryInterval(data, size);、 + OHOS::FuzzConcurrentTaskServiceQueryIntervalAsync(data, size); OHOS::FuzzConcurrentTaskServiceSetAudioDeadline(data, size); OHOS::FuzzConcurrentTaskServiceRequestAuth(data, size); @@ -538,6 +588,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::FuzzConcurrentTaskClientReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskClientQueryDeadline(data, size); OHOS::FuzzConcurrentTaskClientQueryInterval(data, size); + OHOS::FuzzConcurrentTaskClientQueryIntervalAsync(data, size); OHOS::FuzzConcurrentTaskClientSetAudioDeadline(data, size); OHOS::FuzzConcurrentTaskClinetRequestAuth(data, size); OHOS::FuzzConcurrentTaskClientStopRemoteObject(data, size); diff --git a/test/unittest/phone/concurrent_task_client_test.cpp b/test/unittest/phone/concurrent_task_client_test.cpp index 43f43ae..6a48495 100644 --- a/test/unittest/phone/concurrent_task_client_test.cpp +++ b/test/unittest/phone/concurrent_task_client_test.cpp @@ -93,6 +93,21 @@ HWTEST_F(ConcurrentTaskClientTest, QueryIntervalTest, TestSize.Level1) EXPECT_TRUE(queryRs.tid != -1); } +/** + * @tc.name: PushTaskTest + * @tc.desc: Test whether the PushTask interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskClientTest, QueryIntervalAsyncTest, TestSize.Level1) +{ + std::unordered_map payload; + payload["uid"] = "3587"; + payload["value"] = "12345"; + int queryItem = 3; + ConcurrentTaskClient::GetInstance().QueryIntervalAsync(queryItem, payload); + EXPECT_FALSE(payload.empty()); +} + /** * @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 82ed853..35a8b6d 100644 --- a/test/unittest/phone/concurrent_task_controller_interface_test.cpp +++ b/test/unittest/phone/concurrent_task_controller_interface_test.cpp @@ -134,6 +134,21 @@ HWTEST_F(ConcurrentTaskControllerInterfaceTest, QueryIntervalTest, TestSize.Leve queInt.QueryInterval(queryItem, queryRs); EXPECT_FALSE(queInt.inited_); } + +/** + * @tc.name: QueryIntervalAsyncTest + * @tc.desc: Test whether the QueryIntervalAsync interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskControllerInterfaceTest, QueryIntervalAsyncTest, TestSize.Level1) +{ + TaskControllerInterface queInt; + int queryItem = QUERY_ASYNC_SELF_RENDER_FRAME_END; + std::unordered_map payload; + payload["tid"] = "12345678"; + queInt.QueryIntervalAsync(queryItem, payload); + EXPECT_FALSE(payload.empty()); +} /** * @tc.name: PushTaskTest diff --git a/test/unittest/phone/concurrent_task_service_test.cpp b/test/unittest/phone/concurrent_task_service_test.cpp index 484d557..c92d110 100644 --- a/test/unittest/phone/concurrent_task_service_test.cpp +++ b/test/unittest/phone/concurrent_task_service_test.cpp @@ -60,6 +60,23 @@ HWTEST_F(ConcurrentTaskServiceTest, QueryIntervalTest, TestSize.Level1) queInt.QueryInterval(queryItem, IpcQueryRs); EXPECT_NE(IpcQueryRs.tid, -1); } + +/** + * @tc.name: QueryIntervalAsyncTest + * @tc.desc: Test whether the QueryIntervalAsyn interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskServiceTest, QueryIntervalAsynTest, TestSize.Level1) +{ + int queryItem = 0; + std::unordered_map mapPayload; + std::string keyWord = "tid"; + std::string tid = "12345678"; + mapPayload[keyWord] = tid; + ConcurrentTaskService queInt; + queInt.QueryIntervalAsync(queryItem, mapPayload); + EXPECT_EQ(mapPayload[keyWord], tid); +} /** * @tc.name: QueryDeadlineTest -- Gitee From f345d733d263bd0ee9029fd51eec8cbd093df934 Mon Sep 17 00:00:00 2001 From: YouZijun97 Date: Mon, 16 Jun 2025 03:28:48 +0000 Subject: [PATCH 2/2] fix bug Signed-off-by: YouZijun97 --- test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp index 3cd5e07..a5ebb04 100644 --- a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp +++ b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp @@ -565,7 +565,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::FuzzConcurrentTaskServiceReportData(data, size); OHOS::FuzzConcurrentTaskServiceReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskServiceQueryDeadline(data, size); - OHOS::FuzzConcurrentTaskServiceQueryInterval(data, size);、 + OHOS::FuzzConcurrentTaskServiceQueryInterval(data, size); OHOS::FuzzConcurrentTaskServiceQueryIntervalAsync(data, size); OHOS::FuzzConcurrentTaskServiceSetAudioDeadline(data, size); OHOS::FuzzConcurrentTaskServiceRequestAuth(data, size); -- Gitee