diff --git a/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl b/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl index 44c58e9e11fce7facd58201acc5e6ffc4fb16f02..64e0a73d93b42708f1e561dcca694c1f5fefe7d6 100644 --- a/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl +++ b/frameworks/concurrent_task_client/idl/IConcurrentTaskService.idl @@ -20,5 +20,6 @@ [oneway] void ReportSceneInfo([in] unsigned int type, [in] Map payload); void QueryInterval([in] int queryItem, [inout] IpcIntervalReply queryRs); [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); } \ 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 fe5a6ca8f9cdcd8939c041a1d4ba372a5c987dfd..41963d6d69572ae600ca8f9455deaa37c6420708 100644 --- a/frameworks/concurrent_task_client/src/concurrent_task_client.cpp +++ b/frameworks/concurrent_task_client/src/concurrent_task_client.cpp @@ -108,6 +108,18 @@ void ConcurrentTaskClient::QueryDeadline(int queryItem, DeadlineReply& ddlReply, return; } +void ConcurrentTaskClient::SetAudioDeadline(int queryItem, int tid, int grpId, IntervalReply& queryRs) +{ + if (TryConnect() != ERR_OK) { + CONCUR_LOGE("SetAudioDeadline connnect fail"); + return; + } + IpcIntervalReply IpcQueryRs = QueryRsToIpc(queryRs); + clientService_->SetAudioDeadline(queryItem, tid, grpId, IpcQueryRs); + queryRs = IpcToQueryRs(IpcQueryRs); + 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 f56b85bbacad79fab825c4bbf4f5a4ac1135d668..0510394cb785c2e8144739435eef3c4255cadfca 100644 --- a/interfaces/inner_api/concurrent_task_client.h +++ b/interfaces/inner_api/concurrent_task_client.h @@ -82,6 +82,17 @@ public: void QueryDeadline(int queryItem, DeadlineReply& ddlReply, const std::unordered_map& mapPayload); + /** + * @brief audio rtg id and other info provided by concurrent task service. + * + * @param queryItem Information of the corresponding query module. + * @param tid Thread number of the audio thread. + * @param grpId The group which will be operate. + * @param queryRs Indicates the context info of the query message. + * + */ + void SetAudioDeadline(int queryItem, int tid, int grpId, IntervalReply& queryRs); + /** * @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 c494c42c5edb11e665e916c1bcb005174c07bcee..d2b718d0fbbf02c792efd6bc676e40fa68534d48 100644 --- a/interfaces/inner_api/concurrent_task_type.h +++ b/interfaces/inner_api/concurrent_task_type.h @@ -61,6 +61,13 @@ enum QueryIntervalItem { QURRY_TYPE_MAX, }; +enum AudioDeadlineType { + AUDIO_DDL_CREATE_GRP = 0, + AUDIO_DDL_DESTROY_GRP, + AUDIO_DDL_ADD_THREAD, + AUDIO_DDL_REMOVE_THREAD, +}; + enum DeadlineType { DDL_RATE = 0, MSG_GAME = 1, diff --git a/services/include/concurrent_task_controller_interface.h b/services/include/concurrent_task_controller_interface.h index 97ee36ea0d90d29b33f58cc5f61ef807cdc28cce..b62fb664b8f3ae3db48364d931023be6e7cd7fe9 100644 --- a/services/include/concurrent_task_controller_interface.h +++ b/services/include/concurrent_task_controller_interface.h @@ -32,6 +32,7 @@ using ReportDataFunc = void (*)(uint32_t resType, int64_t value, const Json::Val 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 SetAudioDeadlineFunc = void (*)(int queryItem, int tid, int grpId, IntervalReply& queryRs); using RequestAuthFunc = void (*)(const Json::Value& payload); using InitFunc = void (*)(); using ReleaseFunc = void (*)(); @@ -47,6 +48,7 @@ public: 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 SetAudioDeadline(int queryItem, int tid, int grpId, IntervalReply& queryRs); void Init(); void Release(); @@ -61,6 +63,7 @@ private: ReportSceneInfoFunc reportSceneInfoFunc_ = nullptr; QueryIntervalFunc queryIntervalFunc_ = nullptr; QueryDeadlineFunc queryDeadlineFunc_ = nullptr; + SetAudioDeadlineFunc setAudioDeadlineFunc_ = nullptr; RequestAuthFunc requestAuthFunc_ = nullptr; InitFunc initFunc_ = nullptr; ReleaseFunc releaseFunc_ = nullptr; diff --git a/services/include/concurrent_task_service.h b/services/include/concurrent_task_service.h index 3e776e6c8d4c9c779d7f1007610f56fd95b0101c..fe16574c692269e6ef39d8281a548ff4257b443f 100644 --- a/services/include/concurrent_task_service.h +++ b/services/include/concurrent_task_service.h @@ -35,6 +35,7 @@ public: ErrCode QueryInterval(int queryItem, IpcIntervalReply& IpcQueryRs) 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; ErrCode RequestAuth(const std::unordered_map& payload) override; Json::Value MapToJson(const std::unordered_map& dataMap); diff --git a/services/src/concurrent_task_controller_interface.cpp b/services/src/concurrent_task_controller_interface.cpp index 2161aed7baf5bb06f00e2a996f1c642c4735ad19..b9f955a8662e6f435059197dd7a7fcc5423384e4 100644 --- a/services/src/concurrent_task_controller_interface.cpp +++ b/services/src/concurrent_task_controller_interface.cpp @@ -89,6 +89,15 @@ void TaskControllerInterface::QueryDeadline(int queryItem, DeadlineReply& ddlRep queryDeadlineFunc_(queryItem, ddlReply, payload); } +void TaskControllerInterface::SetAudioDeadline(int queryItem, int tid, int grpId, IntervalReply& queryRs) +{ + if (!inited_) { + CONCUR_LOGE("[TaskControllerInterface] SetAudioDeadline failed, funcLoader_ load func failed"); + return; + } + setAudioDeadlineFunc_(queryItem, tid, grpId, queryRs); +} + void TaskControllerInterface::Init() { std::lock_guard autoLock(funcLoaderLock_); @@ -121,6 +130,7 @@ bool TaskControllerInterface::LoadFunc() reportSceneInfoFunc_ = ReportSceneInfoFunc(funcLoader_.LoadSymbol("ReportSceneInfo")); queryIntervalFunc_ = QueryIntervalFunc(funcLoader_.LoadSymbol("QueryInterval")); queryDeadlineFunc_ = QueryDeadlineFunc(funcLoader_.LoadSymbol("QueryDeadline")); + setAudioDeadlineFunc_ = SetAudioDeadlineFunc(funcLoader_.LoadSymbol("SetAudioDeadline")); requestAuthFunc_ = RequestAuthFunc(funcLoader_.LoadSymbol("RequestAuth")); initFunc_ = InitFunc(funcLoader_.LoadSymbol("Init")); releaseFunc_ = ReleaseFunc(funcLoader_.LoadSymbol("Release")); diff --git a/services/src/concurrent_task_service.cpp b/services/src/concurrent_task_service.cpp index ef9aa4ed3338493f85fc6ef7606570de4f9bc3cc..59ea934b793b53bb468533e45eecf9c9ac7a0c4c 100644 --- a/services/src/concurrent_task_service.cpp +++ b/services/src/concurrent_task_service.cpp @@ -44,6 +44,14 @@ ErrCode ConcurrentTaskService::QueryInterval(int queryItem, IpcIntervalReply& Ip return ERR_OK; } +ErrCode ConcurrentTaskService::SetAudioDeadline(int queryItem, int tid, int grpId, IpcIntervalReply& IpcQueryRs) +{ + IntervalReply queryRs = IpcToQueryRs(IpcQueryRs); + TaskControllerInterface::GetInstance().SetAudioDeadline(queryItem, tid, grpId, queryRs); + IpcQueryRs = QueryRsToIpc(queryRs); + return ERR_OK; +} + ErrCode ConcurrentTaskService::QueryDeadline( int queryItem, const IpcDeadlineReply& IpcDdlReply, const std::unordered_map& payload) { diff --git a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp index 34bed7e28fd6a9376d420c9737b79f57cdba687d..0f6ee7955b69ed84a48e1716444471c4d4548038 100644 --- a/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp +++ b/test/fuzztest/concurrent_fuzzer/concurrent_fuzzer.cpp @@ -159,6 +159,30 @@ bool FuzzConcurrentTaskServiceQueryDeadline(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskServiceSetAudioDeadline(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(IConcurrentTaskServiceIpcCode::COMMAND_SET_AUDIO_DEADLINE); + ConcurrentTaskService s = ConcurrentTaskService(); + s.OnRemoteRequest(code, data1, reply, option); + } + return true; +} + bool FuzzConcurrentTaskServiceRequestAuth(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -405,6 +429,20 @@ bool FuzzConcurrentTaskClientQueryDeadline(const uint8_t* data, size_t size) return true; } +bool FuzzConcurrentTaskClientSetAudioDeadline(const uint8_t* data, size_t size) +{ + g_baseFuzzData = data; + g_baseFuzzSize = size; + g_baseFuzzPos = 0; + if (size > sizeof(int) + sizeof(int)) { + int queryItem = GetData(); + queryItem = queryItem % (AUDIO_DDL_REMOVE_THREAD + 1); + IntervalReply queryRs; + ConcurrentTaskClient::GetInstance().SetAudioDeadline(queryItem, 20, 40, queryRs); + } + return true; +} + bool FuzzConcurrentTaskClinetRequestAuth(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -492,6 +530,21 @@ bool FuzzConcurrentTaskControllerInterfaceQueryDeadline(const uint8_t* data, siz return true; } +bool FuzzConcurrentTaskControllerInterfaceSetAudioDeadline(const uint8_t* data, size_t size) +{ + g_baseFuzzData = data; + g_baseFuzzSize = size; + g_baseFuzzPos = 0; + if (size > sizeof(int) + sizeof(int)) { + ConcurrentTaskService s = ConcurrentTaskService(); + int queryItem = GetData(); + queryItem = queryItem % (AUDIO_DDL_REMOVE_THREAD + 1); + IntervalReply queryRs; + TaskControllerInterface::GetInstance().SetAudioDeadline(queryItem, 20, 40, queryRs); + } + return true; +} + bool FuzzConcurrentTaskControllerInterfaceRequestAuth(const uint8_t* data, size_t size) { g_baseFuzzData = data; @@ -546,6 +599,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::FuzzConcurrentTaskServiceSetAudioDeadline(data, size); OHOS::FuzzConcurrentTaskServiceRequestAuth(data, size); OHOS::FuzzConcurrentTaskServiceStopRemoteObject(data, size); @@ -566,6 +620,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::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 1a7bcc905629b4d244c6f2e22342b3757d91621a..43f43aed3ce965f638127f1424f3179f2f2d79d4 100644 --- a/test/unittest/phone/concurrent_task_client_test.cpp +++ b/test/unittest/phone/concurrent_task_client_test.cpp @@ -122,6 +122,28 @@ HWTEST_F(ConcurrentTaskClientTest, QueryDeadlineTest, TestSize.Level1) EXPECT_FALSE(payload.empty()); } +/** + * @tc.name: PushTaskTest + * @tc.desc: Test whether the PushTask interface are normal. + * @tc.type: FUNC +*/ +HWTEST_F(ConcurrentTaskClientTest, SetAudioDeadlineTest, TestSize.Level1) +{ + int queryItem = AUDIO_DDL_CREATE_GRP; + IntervalReply queryRs = { 0 }; + ConcurrentTaskClient::GetInstance().SetAudioDeadline(queryItem, -1, -1, queryRs); + EXPECT_TRUE(queryRs.rtgId != -1); + queryItem = AUDIO_DDL_ADD_THREAD; + ConcurrentTaskClient::GetInstance().SetAudioDeadline(queryItem, gettid(), queryRs.rtgId, queryRs); + EXPECT_TRUE(queryRs.paramA == 0); + queryItem = AUDIO_DDL_REMOVE_THREAD; + ConcurrentTaskClient::GetInstance().SetAudioDeadline(queryItem, gettid(), queryRs.rtgId, queryRs); + EXPECT_TRUE(queryRs.paramA == 0); + queryItem = AUDIO_DDL_DESTROY_GRP; + ConcurrentTaskClient::GetInstance().SetAudioDeadline(queryItem, -1, queryRs.rtgId, queryRs); + EXPECT_TRUE(queryRs.paramA == 0); +} + /** * @tc.name: RequestAuthTest * @tc.desc: Test whether the RequestAuth 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 232f9526ca85f37bcb806e28c705de4e038d72ac..cb61ce398950a8eac8268ba5ca1ffcd85c0b1c25 100644 --- a/test/unittest/phone/concurrent_task_controller_interface_test.cpp +++ b/test/unittest/phone/concurrent_task_controller_interface_test.cpp @@ -135,6 +135,26 @@ HWTEST_F(ConcurrentTaskControllerInterfaceTest, QueryIntervalTest, TestSize.Leve EXPECT_FALSE(queInt.inited_); } +/** + * @tc.name: PushTaskTest + * @tc.desc: Test whether the PushTask interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskControllerInterfaceTest, SetAudioDeadlineTest, TestSize.Level1) +{ + TaskControllerInterface queInt; + int queryItem = AUDIO_DDL_CREATE_GRP; + IntervalReply queryRs = {0}; + queInt.SetAudioDeadline(queryItem, -1, -1, queryRs); + queryItem = AUDIO_DDL_ADD_THREAD; + queInt.SetAudioDeadline(queryItem, gettid(), queryRs.rtgId, queryRs); + queryItem = AUDIO_DDL_REMOVE_THREAD; + queInt.SetAudioDeadline(queryItem, gettid(), queryRs.rtgId, queryRs); + queryItem = AUDIO_DDL_DESTROY_GRP; + queInt.SetAudioDeadline(queryItem, -1, queryRs.rtgId, queryRs); + EXPECT_FALSE(queInt.inited_); +} + /** * @tc.name: PushTaskTest * @tc.desc: Test whether the PushTask interface are normal. diff --git a/test/unittest/phone/concurrent_task_service_test.cpp b/test/unittest/phone/concurrent_task_service_test.cpp index 3fd40bc18cd105435c01a505f5efee67aaffb3e3..62b320a6b6468d0bf33f5f12c409ea839ad5d3c4 100644 --- a/test/unittest/phone/concurrent_task_service_test.cpp +++ b/test/unittest/phone/concurrent_task_service_test.cpp @@ -175,5 +175,29 @@ HWTEST_F(ConcurrentTaskServiceTest, IpcToDdlReplyTest, TestSize.Level1) EXPECT_EQ(expectedDdlReply.setStatus, resultDdlReply.setStatus); } + +/** + * @tc.name: SetAudioDeadline + * @tc.desc: Test whether the SetAudioDeadline interface are normal. + * @tc.type: FUNC + */ +HWTEST_F(ConcurrentTaskServiceTest, SetAudioDeadlineTest, TestSize.Level1) +{ + int queryItem = AUDIO_DDL_CREATE_GRP; + IpcIntervalReply IpcQueryRs = { 0 }; + ConcurrentTaskService queInt; + queInt.SetAudioDeadline(queryItem, -1, -1, IpcQueryRs); + EXPECT_NE(IpcQueryRs.rtgId, -1); + queryItem = AUDIO_DDL_ADD_THREAD; + queInt.SetAudioDeadline(queryItem, gettid(), IpcQueryRs.rtgId, IpcQueryRs); + EXPECT_EQ(IpcQueryRs.paramA, 0); + queryItem = AUDIO_DDL_REMOVE_THREAD; + queInt.SetAudioDeadline(queryItem, gettid(), IpcQueryRs.rtgId, IpcQueryRs); + EXPECT_EQ(IpcQueryRs.paramA, 0); + queryItem = AUDIO_DDL_DESTROY_GRP; + queInt.SetAudioDeadline(queryItem, -1, IpcQueryRs.rtgId, IpcQueryRs); + EXPECT_EQ(IpcQueryRs.paramA, 0); +} + } // namespace FFRT_TEST -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/test/unittest/phone/func_loader_test.cpp b/test/unittest/phone/func_loader_test.cpp index e90ab8ae12cd9e50529bf9f1dc45c119a98ad783..463582b56e2cb5dc7d76e9ef8cd675db4a9bc19e 100644 --- a/test/unittest/phone/func_loader_test.cpp +++ b/test/unittest/phone/func_loader_test.cpp @@ -76,6 +76,7 @@ HWTEST_F(FuncLoaderTest, LoadSymbolTest, TestSize.Level1) funcLoader.LoadSymbol("ReportSceneInfo"); funcLoader.LoadSymbol("QueryInterval"); funcLoader.LoadSymbol("QueryDeadline"); + funcLoader.LoadSymbol("SetAudioDeadline"); void* funcSym = funcLoader.LoadSymbol("RequestAuth"); EXPECT_TRUE(funcSym == nullptr); }