diff --git a/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl b/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl index 64e0a73d93b42708f1e561dcca694c1f5fefe7d6..ed8141db568de2cc59836d75108dd83bb6704437 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 41963d6d69572ae600ca8f9455deaa37c6420708..249815de489dc4a9fd3b731dd7f891fbee601b50 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 0510394cb785c2e8144739435eef3c4255cadfca..de736a2e17028d7e09e8b218ecd77acf58d5dad0 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 d2b718d0fbbf02c792efd6bc676e40fa68534d48..5576c9eb74897bda466ba5f67dc1304bc5a1c422 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 a015c75703fa95b1b0a984be3438d52e7ed9120c..12370d44da1db1f4c09c373687ab8fb43d710fb5 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 a18d8c44891984b013fcb8c0994be0929f46e5f0..010d6ed9b3144efa91a66d9d820d379623c0531d 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 1032669acf8f940c4314e80e94a6c378a48019ca..91afa923690ad12c4cf6ee85b30da46399f309bc 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 5c5d78492cab1d0b9eefceb4693229637bbd8d17..ff7dcca38559149c5d03ecb696a4638865c6c1c6 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 8e3a5f9b27a0faf6c679fce61b1d99d9c491218c..a5ebb04be0e505eb5b24364ee7816d210481c43a 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); @@ -517,6 +566,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) OHOS::FuzzConcurrentTaskServiceReportSceneInfo(data, size); OHOS::FuzzConcurrentTaskServiceQueryDeadline(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 43f43aed3ce965f638127f1424f3179f2f2d79d4..6a484953dee6a83ccbbc83272c91f418d14e2647 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 82ed853e4b4a9543e51e93020f50e04677d06604..35a8b6d061d4ffb1466c2af56f374748f3971c11 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 484d557ab0165a54fb0338f55f7187e63ec53156..c92d110323a1c2315f8c144e5b0f3b56798934dd 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