From 4f9398b51592d386769a3dfc36c91be585fcffaf Mon Sep 17 00:00:00 2001 From: zhangzezhong Date: Thu, 14 Aug 2025 14:58:40 +0800 Subject: [PATCH] =?UTF-8?q?=E6=94=AF=E6=8C=81=E5=BA=94=E7=94=A8=E8=8E=B7?= =?UTF-8?q?=E5=8F=96=E8=87=AA=E8=BA=AB=E5=BC=80=E6=9C=BA=E5=90=AF=E5=8A=A8?= =?UTF-8?q?=E7=8A=B6=E6=80=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhangzezhong --- .../js_ability_auto_startup_manager.cpp | 42 +++++++++++++++++- .../js_ability_auto_startup_manager.h | 4 +- .../include/ability_manager_client.h | 7 +++ .../include/ability_manager_interface.h | 10 +++++ .../ability_manager_ipc_interface_code.h | 4 +- .../ability_auto_startup_data_manager.h | 2 + .../include/ability_auto_startup_service.h | 8 ++++ .../include/ability_manager_proxy.h | 7 +++ .../include/ability_manager_service.h | 7 +++ .../abilitymgr/include/ability_manager_stub.h | 1 + .../src/ability_auto_startup_data_manager.cpp | 40 +++++++++++++++++ .../src/ability_auto_startup_service.cpp | 11 +++++ .../abilitymgr/src/ability_manager_client.cpp | 8 ++++ .../abilitymgr/src/ability_manager_proxy.cpp | 18 ++++++++ .../src/ability_manager_service.cpp | 10 +++++ .../abilitymgr/src/ability_manager_stub.cpp | 16 +++++++ .../abilityautostartupdatamanager_fuzzer.cpp | 4 +- .../abilityautostartupservicea_fuzzer.cpp | 2 + .../abilitymanagerservicethird_fuzzer.cpp | 4 +- .../jsabilityautostartupmanager_fuzzer.cpp | 3 +- ...ability_auto_startup_data_manager_test.cpp | 44 +++++++++++++++++++ ...ility_auto_startup_service_second_test.cpp | 20 +++++++++ .../ability_auto_startup_service_test.cpp | 18 ++++++++ .../ability_manager_client_branch_test.cpp | 12 +++++ .../ability_manager_proxy_fifth_test.cpp | 17 +++++++ .../ability_manager_proxy_test.cpp | 12 +++++ .../ability_manager_service_first_test.cpp | 29 ++++++++++++ .../ability_manager_stub_second_test.cpp | 3 +- .../ability_manager_stub_impl_mock.h | 1 + .../ability_manager_stub_test.cpp | 27 ++++++++++++ 30 files changed, 384 insertions(+), 7 deletions(-) diff --git a/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp index 6436adb8e38..2368f3f2641 100644 --- a/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp +++ b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 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 @@ -69,6 +69,11 @@ napi_value JsAbilityAutoStartupManager::QueryAllAutoStartupApplications(napi_env GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnQueryAllAutoStartupApplications); } +napi_value JsAbilityAutoStartupManager::GetAutoStartupStatusForSelf(napi_env env, napi_callback_info info) +{ + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnGetAutoStartupStatusForSelf); +} + bool JsAbilityAutoStartupManager::CheckCallerIsSystemApp() { auto selfToken = IPCSkeleton::GetSelfTokenID(); @@ -313,6 +318,39 @@ napi_value JsAbilityAutoStartupManager::OnQueryAllAutoStartupApplications(napi_e return result; } +napi_value JsAbilityAutoStartupManager::OnGetAutoStartupStatusForSelf(napi_env env, const NapiCallbackInfo &info) +{ + auto retVal = std::make_shared(ERR_OK); + auto isAutoStartEnabled = std::make_shared(false); + NapiAsyncTask::ExecuteCallback execute = [ret = retVal, isAutoStartEnabled]() { + if (ret == nullptr || isAutoStartEnabled == nullptr) { + TAG_LOGE(AAFwkTag::AUTO_STARTUP, "null ret or isAutoStartEnabled"); + return; + } + *ret = AbilityManagerClient::GetInstance()->GetAutoStartupStatusForSelf(*isAutoStartEnabled); + }; + + NapiAsyncTask::CompleteCallback complete = [ret = retVal, isAutoStartEnabled]( + napi_env env, NapiAsyncTask &task, int32_t status) { + if (ret == nullptr || isAutoStartEnabled == nullptr) { + TAG_LOGE(AAFwkTag::AUTO_STARTUP, "null ret or isAutoStartEnabled"); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(INNER_ERR))); + return; + } + if (*ret != ERR_OK) { + TAG_LOGE(AAFwkTag::AUTO_STARTUP, "error:%{public}d", *ret); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(*ret))); + return; + } + task.ResolveWithNoError(env, CreateJsValue(env, *isAutoStartEnabled)); + }; + + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JsAbilityAutoStartupManager::OnGetAutoStartupStatusForSelf", env, + CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result)); + return result; +} + napi_value JsAbilityAutoStartupManagerInit(napi_env env, napi_value exportObj) { TAG_LOGD(AAFwkTag::AUTO_STARTUP, "called"); @@ -334,6 +372,8 @@ napi_value JsAbilityAutoStartupManagerInit(napi_env env, napi_value exportObj) JsAbilityAutoStartupManager::CancelApplicationAutoStartup); BindNativeFunction(env, exportObj, "queryAllAutoStartupApplications", moduleName, JsAbilityAutoStartupManager::QueryAllAutoStartupApplications); + BindNativeFunction(env, exportObj, "getAutoStartupStatusForSelf", moduleName, + JsAbilityAutoStartupManager::GetAutoStartupStatusForSelf); TAG_LOGD(AAFwkTag::AUTO_STARTUP, "end"); return CreateJsUndefined(env); } diff --git a/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h index 03cd80d17e0..c2591398824 100644 --- a/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h +++ b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 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 @@ -34,6 +34,7 @@ public: static napi_value SetApplicationAutoStartup(napi_env env, napi_callback_info info); static napi_value CancelApplicationAutoStartup(napi_env env, napi_callback_info info); static napi_value QueryAllAutoStartupApplications(napi_env env, napi_callback_info info); + static napi_value GetAutoStartupStatusForSelf(napi_env env, napi_callback_info info); private: napi_value OnRegisterAutoStartupCallback(napi_env env, NapiCallbackInfo &info); @@ -41,6 +42,7 @@ private: napi_value OnSetApplicationAutoStartup(napi_env env, NapiCallbackInfo &info); napi_value OnCancelApplicationAutoStartup(napi_env env, NapiCallbackInfo &info); napi_value OnQueryAllAutoStartupApplications(napi_env env, const NapiCallbackInfo &info); + napi_value OnGetAutoStartupStatusForSelf(napi_env env, const NapiCallbackInfo &info); static bool CheckCallerIsSystemApp(); sptr jsAutoStartupCallback_; diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_client.h b/interfaces/inner_api/ability_manager/include/ability_manager_client.h index 60e6e80a814..6247a06f3d8 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_client.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_client.h @@ -1099,6 +1099,13 @@ public: */ ErrCode QueryAllAutoStartupApplications(std::vector &infoList); + /** + * @brief Retrieves the auto startup status of the current application. + * @param isAutoStartEnabled Indicates whether auto startup is enabled for the current application. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode GetAutoStartupStatusForSelf(bool &isAutoStartEnabled); + /** * PrepareTerminateAbilityBySCB, prepare to terminate ability by scb. * diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h index c04c88ea43a..1ac272270bb 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h @@ -1683,6 +1683,16 @@ public: return 0; } + /** + * @brief Retrieves the auto startup status of the current application. + * @param isAutoStartEnabled Indicates whether auto startup is enabled for the current application. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t GetAutoStartupStatusForSelf(bool &isAutoStartEnabled) + { + return 0; + } + /** * PrepareTerminateAbilityBySCB, prepare to terminate ability by scb. * diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_ipc_interface_code.h b/interfaces/inner_api/ability_manager/include/ability_manager_ipc_interface_code.h index 38921bbefa8..850a70d2b09 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_ipc_interface_code.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_ipc_interface_code.h @@ -551,8 +551,10 @@ enum class AbilityManagerInterfaceCode { SET_APPLICATION_AUTO_STARTUP = 6103, // ipc id for cancel application auto startup CANCEL_APPLICATION_AUTO_STARTUP = 6104, - // ipc id for auery all auto startup application + // ipc id for query all auto startup application QUERY_ALL_AUTO_STARTUP_APPLICATION = 6105, + // ipc id for retrieves the auto startup status of the current application. + GET_AUTO_STARTUP_STATUS_FOR_SELF = 6106, // ipc id for on auto starup on ON_AUTO_STARTUP_ON = 6111, diff --git a/services/abilitymgr/include/ability_auto_startup_data_manager.h b/services/abilitymgr/include/ability_auto_startup_data_manager.h index 9abee27b744..e956d6d45a6 100644 --- a/services/abilitymgr/include/ability_auto_startup_data_manager.h +++ b/services/abilitymgr/include/ability_auto_startup_data_manager.h @@ -47,6 +47,8 @@ public: int32_t GetCurrentAppAutoStartupData(const std::string &bundleName, std::vector &infoList, const std::string &accessTokenId); + int32_t GetAutoStartupStatusForSelf(uint32_t callerTokenId, bool &isAutoStartEnabled); + private: DistributedKv::Status RestoreKvStore(DistributedKv::Status status); DistributedKv::Status GetKvStore(); diff --git a/services/abilitymgr/include/ability_auto_startup_service.h b/services/abilitymgr/include/ability_auto_startup_service.h index a9ea45b1101..c4a8b495b19 100644 --- a/services/abilitymgr/include/ability_auto_startup_service.h +++ b/services/abilitymgr/include/ability_auto_startup_service.h @@ -74,6 +74,14 @@ public: */ int32_t QueryAllAutoStartupApplications(std::vector &infoList, int32_t userId); + /** + * @brief Retrieves the auto startup status of the current application. + * @param callerTokenId the tokenId of caller application. + * @param isAutoStartEnabled Indicates whether auto startup is enabled for the current application. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t GetAutoStartupStatusForSelf(uint32_t callerTokenId, bool &isAutoStartEnabled); + /** * @brief Query auto startup state all application without permission. * @param infoList Output parameters, return auto startup info list. diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h index 90aa5002ea4..a20cd90920a 100644 --- a/services/abilitymgr/include/ability_manager_proxy.h +++ b/services/abilitymgr/include/ability_manager_proxy.h @@ -1282,6 +1282,13 @@ public: */ virtual int32_t QueryAllAutoStartupApplications(std::vector &infoList) override; + /** + * @brief Retrieves the auto startup status of the current application. + * @param isAutoStartEnabled Indicates whether auto startup is enabled for the current application. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t GetAutoStartupStatusForSelf(bool &isAutoStartEnabled) override; + /** * PrepareTerminateAbilityBySCB, prepare to terminate ability by scb. * diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h index 01a1152b878..d0afa34d5fe 100644 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -1634,6 +1634,13 @@ public: */ virtual int32_t QueryAllAutoStartupApplications(std::vector &infoList) override; + /** + * @brief Retrieves the auto startup status of the current application. + * @param isAutoStartEnabled Indicates whether auto startup is enabled for the current application. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t GetAutoStartupStatusForSelf(bool &isAutoStartEnabled) override; + /** * PrepareTerminateAbilityBySCB, prepare to terminate ability by scb. * diff --git a/services/abilitymgr/include/ability_manager_stub.h b/services/abilitymgr/include/ability_manager_stub.h index d98997a8075..e98c0f59db1 100644 --- a/services/abilitymgr/include/ability_manager_stub.h +++ b/services/abilitymgr/include/ability_manager_stub.h @@ -274,6 +274,7 @@ private: int32_t SetApplicationAutoStartupInner(MessageParcel &data, MessageParcel &reply); int32_t CancelApplicationAutoStartupInner(MessageParcel &data, MessageParcel &reply); int32_t QueryAllAutoStartupApplicationsInner(MessageParcel &data, MessageParcel &reply); + int32_t GetAutoStartupStatusForSelfInner(MessageParcel &data, MessageParcel &reply); int PrepareTerminateAbilityBySCBInner(MessageParcel &data, MessageParcel &reply); int RegisterSessionHandlerInner(MessageParcel &data, MessageParcel &reply); diff --git a/services/abilitymgr/src/ability_auto_startup_data_manager.cpp b/services/abilitymgr/src/ability_auto_startup_data_manager.cpp index 91e31782c06..97b78d4cd83 100644 --- a/services/abilitymgr/src/ability_auto_startup_data_manager.cpp +++ b/services/abilitymgr/src/ability_auto_startup_data_manager.cpp @@ -427,6 +427,46 @@ int32_t AbilityAutoStartupDataManager::GetCurrentAppAutoStartupData( return ERR_OK; } +int32_t AbilityAutoStartupDataManager::GetAutoStartupStatusForSelf(uint32_t callerTokenId, bool &isAutoStartEnabled) +{ + auto callerTokenIdStr = std::to_string(callerTokenId); + TAG_LOGI(AAFwkTag::AUTO_STARTUP, "callerTokenIdStr: %{public}s", callerTokenIdStr.c_str()); + { + std::lock_guard lock(kvStorePtrMutex_); + if (!CheckKvStore()) { + TAG_LOGE(AAFwkTag::AUTO_STARTUP, "null kvStore"); + return ERR_NO_INIT; + } + } + + std::vector allEntries; + DistributedKv::Status status = DistributedKv::Status::SUCCESS; + { + std::lock_guard lock(kvStorePtrMutex_); + status = kvStorePtr_->GetEntries(nullptr, allEntries); + } + if (status != DistributedKv::Status::SUCCESS) { + TAG_LOGE(AAFwkTag::AUTO_STARTUP, "GetEntries error: %{public}d", status); + { + std::lock_guard lock(kvStorePtrMutex_); + status = RestoreKvStore(status); + } + return ERR_INVALID_OPERATION; + } + + for (const auto &item : allEntries) { + if (IsEqual(item.key, callerTokenIdStr)) { + AutoStartupStatus startupStatus; + ConvertAutoStartupStatusFromValue(item.value, startupStatus); + if (startupStatus.isAutoStartup) { + isAutoStartEnabled = true; + break; + } + } + } + return ERR_OK; +} + DistributedKv::Value AbilityAutoStartupDataManager::ConvertAutoStartupStatusToValue( const AutoStartupInfo &info, bool isAutoStartup, bool isEdmForce) { diff --git a/services/abilitymgr/src/ability_auto_startup_service.cpp b/services/abilitymgr/src/ability_auto_startup_service.cpp index 6c6d2a2218c..05f97c3a1e4 100644 --- a/services/abilitymgr/src/ability_auto_startup_service.cpp +++ b/services/abilitymgr/src/ability_auto_startup_service.cpp @@ -229,6 +229,17 @@ int32_t AbilityAutoStartupService::QueryAllAutoStartupApplications(std::vector::GetInstance()->GetAutoStartupStatusForSelf(callerTokenId, + isAutoStartEnabled); +} + int32_t AbilityAutoStartupService::QueryAllAutoStartupApplicationsWithoutPermission( std::vector &infoList, int32_t userId) { diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp index e4149b294d1..670b7b64d82 100644 --- a/services/abilitymgr/src/ability_manager_client.cpp +++ b/services/abilitymgr/src/ability_manager_client.cpp @@ -1867,6 +1867,14 @@ ErrCode AbilityManagerClient::QueryAllAutoStartupApplications(std::vectorQueryAllAutoStartupApplications(infoList); } +ErrCode AbilityManagerClient::GetAutoStartupStatusForSelf(bool &isAutoStartEnabled) +{ + TAG_LOGD(AAFwkTag::ABILITYMGR, "GetAutoStartupStatusForSelf called"); + auto abms = GetAbilityManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->GetAutoStartupStatusForSelf(isAutoStartEnabled); +} + ErrCode AbilityManagerClient::PrepareTerminateAbilityBySCB(sptr sessionInfo, bool &isPrepareTerminate) { diff --git a/services/abilitymgr/src/ability_manager_proxy.cpp b/services/abilitymgr/src/ability_manager_proxy.cpp index 8ab7a0ec36f..b42e528417e 100644 --- a/services/abilitymgr/src/ability_manager_proxy.cpp +++ b/services/abilitymgr/src/ability_manager_proxy.cpp @@ -5139,6 +5139,24 @@ int32_t AbilityManagerProxy::QueryAllAutoStartupApplications(std::vector &sessionInfo, bool &isPrepareTerminate) { MessageParcel data; diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index b69764e9456..0e260d686cc 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -12033,6 +12033,16 @@ int32_t AbilityManagerService::QueryAllAutoStartupApplications(std::vectorQueryAllAutoStartupApplications(infoList, GetUserId()); } +int32_t AbilityManagerService::GetAutoStartupStatusForSelf(bool &isAutoStartEnabled) +{ + if (abilityAutoStartupService_ == nullptr) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityAutoStartupService_ null"); + return ERR_NO_INIT; + } + auto callerTokenId = IPCSkeleton::GetCallingTokenID(); + return abilityAutoStartupService_->GetAutoStartupStatusForSelf(callerTokenId, isAutoStartEnabled); +} + int AbilityManagerService::PrepareTerminateAbilityBySCB(const sptr &sessionInfo, bool &isTerminate) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp index e5d8a75a12e..aaadfb05f69 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -722,6 +722,9 @@ int AbilityManagerStub::OnRemoteRequestInnerSeventeenth(uint32_t code, MessagePa if (interfaceCode == AbilityManagerInterfaceCode::QUERY_ALL_AUTO_STARTUP_APPLICATION) { return QueryAllAutoStartupApplicationsInner(data, reply); } + if (interfaceCode == AbilityManagerInterfaceCode::GET_AUTO_STARTUP_STATUS_FOR_SELF) { + return GetAutoStartupStatusForSelfInner(data, reply); + } return ERR_CODE_NOT_EXIST; } @@ -3749,6 +3752,19 @@ int32_t AbilityManagerStub::QueryAllAutoStartupApplicationsInner(MessageParcel & return NO_ERROR; } +int32_t AbilityManagerStub::GetAutoStartupStatusForSelfInner(MessageParcel &data, MessageParcel &reply) +{ + bool isAutoStartEnabled = false; + int32_t result = GetAutoStartupStatusForSelf(isAutoStartEnabled); + if (result == ERR_OK) { + if (!reply.WriteBool(isAutoStartEnabled)) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "reply write fail"); + return ERR_INVALID_VALUE; + } + } + return result; +} + int AbilityManagerStub::RegisterSessionHandlerInner(MessageParcel &data, MessageParcel &reply) { sptr handler = data.ReadRemoteObject(); diff --git a/test/fuzztest/abilityautostartupdatamanager_fuzzer/abilityautostartupdatamanager_fuzzer.cpp b/test/fuzztest/abilityautostartupdatamanager_fuzzer/abilityautostartupdatamanager_fuzzer.cpp index acc0038b5fd..ed8537b9209 100644 --- a/test/fuzztest/abilityautostartupdatamanager_fuzzer/abilityautostartupdatamanager_fuzzer.cpp +++ b/test/fuzztest/abilityautostartupdatamanager_fuzzer/abilityautostartupdatamanager_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 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 @@ -77,11 +77,13 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) std::string keys(data, size); std::string values(data, size); bool checkEmpty = *data % ENABLE; + bool isAutoStartEnabled = false; abilityAutoStartupDataManager->IsEqual(key, info); abilityAutoStartupDataManager->IsEqual(key, strParam); abilityAutoStartupDataManager->IsEqual(key, in32Param); abilityAutoStartupDataManager->DeleteAutoStartupData(info); abilityAutoStartupDataManager->DeleteAutoStartupData(strParam, in32Param); + abilityAutoStartupDataManager->GetAutoStartupStatusForSelf(in32Param, isAutoStartEnabled); return true; } diff --git a/test/fuzztest/abilityautostartupservicea_fuzzer/abilityautostartupservicea_fuzzer.cpp b/test/fuzztest/abilityautostartupservicea_fuzzer/abilityautostartupservicea_fuzzer.cpp index ee0c33519a0..5be488ff446 100755 --- a/test/fuzztest/abilityautostartupservicea_fuzzer/abilityautostartupservicea_fuzzer.cpp +++ b/test/fuzztest/abilityautostartupservicea_fuzzer/abilityautostartupservicea_fuzzer.cpp @@ -87,11 +87,13 @@ void AbilityStartupServiceFuzztest(bool boolParam, std::string &stringParam, int std::vector vecs; vecs.emplace_back(info); + bool isAutoStartEnabled = false; service->QueryAllAutoStartupApplications(vecs, int32Param); service->QueryAllAutoStartupApplicationsWithoutPermission(vecs, int32Param); service->DeleteAutoStartupData(stringParam, int32Param); service->CheckAutoStartupData(stringParam, int32Param); service->ExecuteCallbacks(boolParam, info); + service->GetAutoStartupStatusForSelf(int32Param, isAutoStartEnabled); } bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) diff --git a/test/fuzztest/abilitymanagerservicethird_fuzzer/abilitymanagerservicethird_fuzzer.cpp b/test/fuzztest/abilitymanagerservicethird_fuzzer/abilitymanagerservicethird_fuzzer.cpp index b01b9e9f9e1..13b12354870 100755 --- a/test/fuzztest/abilitymanagerservicethird_fuzzer/abilitymanagerservicethird_fuzzer.cpp +++ b/test/fuzztest/abilitymanagerservicethird_fuzzer/abilitymanagerservicethird_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 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 @@ -68,6 +68,7 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) int32_t int32Param = static_cast(GetU32Data(data)); int64_t int64Param = static_cast(GetU32Data(data)); sptr token = GetFuzzAbilityToken(); + bool isAutoStartEnabled = false; // fuzz for AbilityManagerService auto abilityms = std::make_shared(); @@ -83,6 +84,7 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) abilityms->GetConnectManagerByUserId(int32Param); abilityms->GetDataAbilityManagerByUserId(int32Param); abilityms->GetConnectManagerByToken(token); + abilityms->GetAutoStartupStatusForSelf(isAutoStartEnabled); return true; } diff --git a/test/fuzztest/jsabilityautostartupmanager_fuzzer/jsabilityautostartupmanager_fuzzer.cpp b/test/fuzztest/jsabilityautostartupmanager_fuzzer/jsabilityautostartupmanager_fuzzer.cpp index 2bada8f6624..e4a8035d656 100755 --- a/test/fuzztest/jsabilityautostartupmanager_fuzzer/jsabilityautostartupmanager_fuzzer.cpp +++ b/test/fuzztest/jsabilityautostartupmanager_fuzzer/jsabilityautostartupmanager_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 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 @@ -74,6 +74,7 @@ void JsAbilityAutostartupManagerFuzztest1(bool boolParam, std::string &stringPar mgr->SetApplicationAutoStartup(env, info); // branch mgr->CancelApplicationAutoStartup(env, info); // branch mgr->QueryAllAutoStartupApplications(env, info); // branch + mgr->GetAutoStartupStatusForSelf(env, info); } bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) diff --git a/test/unittest/ability_auto_startup_data_manager_test/ability_auto_startup_data_manager_test.cpp b/test/unittest/ability_auto_startup_data_manager_test/ability_auto_startup_data_manager_test.cpp index 0fcbd9c15db..a33eeec1a29 100644 --- a/test/unittest/ability_auto_startup_data_manager_test/ability_auto_startup_data_manager_test.cpp +++ b/test/unittest/ability_auto_startup_data_manager_test/ability_auto_startup_data_manager_test.cpp @@ -1485,5 +1485,49 @@ HWTEST_F(AbilityAutoStartupDataManagerTest, ConvertAutoStartupInfoFromValue_200, EXPECT_EQ(info1.canUserModify, false); GTEST_LOG_(INFO) << "ConvertAutoStartupInfoFromValue_200 end"; } + +/** + * Feature: AbilityAutoStartupDataManager + * Function: GetAutoStartupStatusForSelf + * SubFunction: NA + * FunctionPoints: AbilityAutoStartupDataManager GetAutoStartupStatusForSelf + */ +HWTEST_F(AbilityAutoStartupDataManagerTest, GetAutoStartupStatusForSelf_100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetAutoStartupStatusForSelf_100 start"; + AbilityAutoStartupDataManager abilityAutoStartupDataManager; + std::shared_ptr kvStorePtr = std::make_shared(); + abilityAutoStartupDataManager.kvStorePtr_ = kvStorePtr; + EXPECT_EQ(true, abilityAutoStartupDataManager.CheckKvStore()); + + uint32_t callerTokenId = 1; + bool isAutoStartEnabled = false; + auto result = abilityAutoStartupDataManager.GetAutoStartupStatusForSelf(callerTokenId, isAutoStartEnabled); + EXPECT_EQ(result, ERR_OK); + GTEST_LOG_(INFO) << "GetAutoStartupStatusForSelf_100 end"; +} + +/** + * Feature: AbilityAutoStartupDataManager + * Function: GetAutoStartupStatusForSelf + * SubFunction: NA + * FunctionPoints: AbilityAutoStartupDataManager GetAutoStartupStatusForSelf + */ +HWTEST_F(AbilityAutoStartupDataManagerTest, GetAutoStartupStatusForSelf_200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetAutoStartupStatusForSelf_200 start"; + AbilityAutoStartupDataManager abilityAutoStartupDataManager; + std::shared_ptr kvStorePtr = std::make_shared(); + abilityAutoStartupDataManager.kvStorePtr_ = kvStorePtr; + EXPECT_EQ(true, abilityAutoStartupDataManager.CheckKvStore()); + kvStorePtr->GetEntries_ = DistributedKv::Status::INVALID_FORMAT; + + uint32_t callerTokenId = 1; + bool isAutoStartEnabled = false; + auto result = abilityAutoStartupDataManager.GetAutoStartupStatusForSelf(callerTokenId, isAutoStartEnabled); + EXPECT_EQ(result, ERR_INVALID_OPERATION); + kvStorePtr->GetEntries_ = DistributedKv::Status::SUCCESS; + GTEST_LOG_(INFO) << "GetAutoStartupStatusForSelf_200 end"; +} } // namespace AbilityRuntime } // namespace OHOS diff --git a/test/unittest/ability_auto_startup_service_second_test/ability_auto_startup_service_second_test.cpp b/test/unittest/ability_auto_startup_service_second_test/ability_auto_startup_service_second_test.cpp index 429c6be9b23..59fb8994fe0 100644 --- a/test/unittest/ability_auto_startup_service_second_test/ability_auto_startup_service_second_test.cpp +++ b/test/unittest/ability_auto_startup_service_second_test/ability_auto_startup_service_second_test.cpp @@ -1269,5 +1269,25 @@ HWTEST_F(AbilityAutoStartupServiceSecondTest, QueryAllAutoStartupApplications_00 system::SetBoolParameter("", false); GTEST_LOG_(INFO) << "AbilityAutoStartupServiceSecondTest QueryAllAutoStartupApplications_003 end"; } + +/* + * Feature: AbilityAutoStartupService + * Function: GetAutoStartupStatusForSelfTest + * SubFunction: NA + * FunctionPoints: AbilityAutoStartupService CheckPermissionForSystem + */ +HWTEST_F(AbilityAutoStartupServiceSecondTest, GetAutoStartupStatusForSelf_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetAutoStartupStatusForSelf_001 start"; + auto abilityAutoStartupService = std::make_shared(); + EXPECT_NE(abilityAutoStartupService, nullptr); + MyFlag::flag_ = 0; + system::SetBoolParameter("", true); + uint32_t callerTokenId = 1; + bool isAutoStartEnabled = false; + auto result = abilityAutoStartupService->GetAutoStartupStatusForSelf(callerTokenId, isAutoStartEnabled); + EXPECT_EQ(result, ERR_OK); + GTEST_LOG_(INFO) << "GetAutoStartupStatusForSelf_001 end"; +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_auto_startup_service_test/ability_auto_startup_service_test.cpp b/test/unittest/ability_auto_startup_service_test/ability_auto_startup_service_test.cpp index 1af25cf1916..756d754f2f6 100644 --- a/test/unittest/ability_auto_startup_service_test/ability_auto_startup_service_test.cpp +++ b/test/unittest/ability_auto_startup_service_test/ability_auto_startup_service_test.cpp @@ -1093,5 +1093,23 @@ HWTEST_F(AbilityAutoStartupServiceTest, GetValidUserId_004, TestSize.Level1) abilityAutoStartupService->GetValidUserId(userId); GTEST_LOG_(INFO) << "AbilityAutoStartupServiceTest GetValidUserId_004 end"; } + +/* + * Feature: AbilityAutoStartupService + * Function: GetAutoStartupStatusForSelf + * SubFunction: NA + * FunctionPoints: AbilityAutoStartupService GetAutoStartupStatusForSelf + */ +HWTEST_F(AbilityAutoStartupServiceTest, GetAutoStartupStatusForSelf_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "AbilityAutoStartupServiceTest GetAutoStartupStatusForSelf_001 start"; + auto abilityAutoStartupService = std::make_shared(); + EXPECT_NE(abilityAutoStartupService, nullptr); + uint32_t callerTokenId = 1; + bool isAutoStartEnabled = false; + auto result = abilityAutoStartupService->GetAutoStartupStatusForSelf(callerTokenId, isAutoStartEnabled); + EXPECT_EQ(result, ERR_CAPABILITY_NOT_SUPPORT); + GTEST_LOG_(INFO) << "AbilityAutoStartupServiceTest GetAutoStartupStatusForSelf_001 end"; +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_manager_client_branch_test/ability_manager_client_branch_test.cpp b/test/unittest/ability_manager_client_branch_test/ability_manager_client_branch_test.cpp index aace3c78645..aa2d607ef08 100644 --- a/test/unittest/ability_manager_client_branch_test/ability_manager_client_branch_test.cpp +++ b/test/unittest/ability_manager_client_branch_test/ability_manager_client_branch_test.cpp @@ -1872,6 +1872,18 @@ HWTEST_F(AbilityManagerClientBranchTest, QueryAllAutoStartupApplications_0100, T EXPECT_EQ(result, ERR_OK); } +/** + * @tc.name: AbilityManagerClient_GetAutoStartupStatusForSelf_0100 + * @tc.desc: GetAutoStartupStatusForSelf + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerClientBranchTest, GetAutoStartupStatusForSelf_0100, TestSize.Level1) +{ + bool isAutoStartEnabled = false; + auto result = client_->GetAutoStartupStatusForSelf(isAutoStartEnabled); + EXPECT_EQ(result, ERR_OK); +} + /** * @tc.name: AbilityManagerClient_RegisterIAbilityManagerCollaborator_0100 * @tc.desc: RegisterIAbilityManagerCollaborator diff --git a/test/unittest/ability_manager_proxy_fifth_test/ability_manager_proxy_fifth_test.cpp b/test/unittest/ability_manager_proxy_fifth_test/ability_manager_proxy_fifth_test.cpp index d6f4095c3d8..fe08a03a9f0 100644 --- a/test/unittest/ability_manager_proxy_fifth_test/ability_manager_proxy_fifth_test.cpp +++ b/test/unittest/ability_manager_proxy_fifth_test/ability_manager_proxy_fifth_test.cpp @@ -692,6 +692,23 @@ HWTEST_F(AbilityManagerProxyFifthTest, QueryAllAutoStartupApplications_0100, Tes EXPECT_EQ(res2, ZERO); } +/** + * @tc.name: GetAutoStartupStatusForSelf_0100 + * @tc.desc: Test the GetAutoStartupStatusForSelf + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerProxyFifthTest, GetAutoStartupStatusForSelf_0100, TestSize.Level1) +{ + bool isAutoStartEnabled = false; + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(INVALID_PARAMETERS_ERR)); + auto res1 = proxy_->GetAutoStartupStatusForSelf(isAutoStartEnabled); + EXPECT_EQ(res1, INVALID_PARAMETERS_ERR); + + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + auto res2 = proxy_->GetAutoStartupStatusForSelf(isAutoStartEnabled); + EXPECT_EQ(res2, ZERO); +} + /** * @tc.name: RegisterSessionHandler_0100 * @tc.desc: Test the RegisterSessionHandler diff --git a/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp b/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp index 49af01d529d..0cc4758e4fa 100644 --- a/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp +++ b/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp @@ -2798,6 +2798,18 @@ HWTEST_F(AbilityManagerProxyTest, QueryAllAutoStartupApplications_0100, TestSize EXPECT_EQ(res, ERR_OK); } +/** + * @tc.name: AbilityManagerProxyTest_GetAutoStartupStatusForSelf_0100 + * @tc.desc: Test the state of GetAutoStartupStatusForSelf + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerProxyTest, GetAutoStartupStatusForSelf_0100, TestSize.Level1) +{ + bool isAutoStartEnabled = false; + auto res = proxy_->GetAutoStartupStatusForSelf(isAutoStartEnabled); + EXPECT_EQ(res, ERR_OK); +} + /** * @tc.name: AbilityManagerProxy_SetResidentProcessEnable_0100 * @tc.desc: RestartApp diff --git a/test/unittest/ability_manager_service_first_test/ability_manager_service_first_test.cpp b/test/unittest/ability_manager_service_first_test/ability_manager_service_first_test.cpp index 1a34bb1a92d..b315b043017 100644 --- a/test/unittest/ability_manager_service_first_test/ability_manager_service_first_test.cpp +++ b/test/unittest/ability_manager_service_first_test/ability_manager_service_first_test.cpp @@ -1687,6 +1687,35 @@ HWTEST_F(AbilityManagerServiceFirstTest, QueryAllAutoStartupApplications_0200, T EXPECT_NE(result, ERR_NO_INIT); } +/** + * @tc.name: AbilityManagerServiceFirstTest_GetAutoStartupStatusForSelf_0100 + * @tc.desc: Test the state of GetAutoStartupStatusForSelf + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerServiceFirstTest, GetAutoStartupStatusForSelf_0100, TestSize.Level1) +{ + auto abilityMs_ = std::make_shared(); + abilityMs_->abilityAutoStartupService_ = nullptr; + bool isAutoStartEnabled = false; + auto result = abilityMs_->GetAutoStartupStatusForSelf(isAutoStartEnabled); + EXPECT_EQ(result, ERR_NO_INIT); +} + +/** + * @tc.name: AbilityManagerServiceFirstTest_GetAutoStartupStatusForSelf_0200 + * @tc.desc: Test the state of GetAutoStartupStatusForSelf + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerServiceFirstTest, GetAutoStartupStatusForSelf_0200, TestSize.Level1) +{ + auto abilityMs_ = std::make_shared(); + abilityMs_->abilityAutoStartupService_ = std::make_shared(); + EXPECT_NE(abilityMs_->abilityAutoStartupService_, nullptr); + bool isAutoStartEnabled = false; + auto result = abilityMs_->GetAutoStartupStatusForSelf(isAutoStartEnabled); + EXPECT_NE(result, ERR_NO_INIT); +} + /* * Feature: AbilityManagerService * Function: GenerateEmbeddableUIAbilityRequest diff --git a/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp b/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp index 9cc9813d935..67128a37ac7 100644 --- a/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp +++ b/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp @@ -674,7 +674,8 @@ HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerSeventeenth_0100, Tes static_cast(AbilityManagerInterfaceCode::UNREGISTER_AUTO_STARTUP_SYSTEM_CALLBACK), static_cast(AbilityManagerInterfaceCode::SET_APPLICATION_AUTO_STARTUP), static_cast(AbilityManagerInterfaceCode::CANCEL_APPLICATION_AUTO_STARTUP), - static_cast(AbilityManagerInterfaceCode::QUERY_ALL_AUTO_STARTUP_APPLICATION) + static_cast(AbilityManagerInterfaceCode::QUERY_ALL_AUTO_STARTUP_APPLICATION), + static_cast(AbilityManagerInterfaceCode::GET_AUTO_STARTUP_STATUS_FOR_SELF) }; int i = 0; diff --git a/test/unittest/ability_manager_stub_test/ability_manager_stub_impl_mock.h b/test/unittest/ability_manager_stub_test/ability_manager_stub_impl_mock.h index cc1dac2376a..ae31bf8bd8e 100644 --- a/test/unittest/ability_manager_stub_test/ability_manager_stub_impl_mock.h +++ b/test/unittest/ability_manager_stub_test/ability_manager_stub_impl_mock.h @@ -472,6 +472,7 @@ public: const InsightIntentExecuteResult &result)); MOCK_METHOD3(GetUIExtensionRootHostInfo, int32_t(const sptr token, UIExtensionHostInfo &hostInfo, int32_t userId)); + MOCK_METHOD1(GetAutoStartupStatusForSelf, int32_t(bool &isAutoStartEnabled)); }; } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp b/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp index 9dacee755f4..f9a2f77ec09 100644 --- a/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp +++ b/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp @@ -3635,6 +3635,33 @@ HWTEST_F(AbilityManagerStubTest, QueryAllAutoStartupApplicationsInner_0100, Test EXPECT_EQ(result, NO_ERROR); } +/** + * @tc.name: AbilityManagerStubTest_GetAutoStartupStatusForSelfInner_0100 + * @tc.desc: Test the state of GetAutoStartupStatusForSelfInner + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerStubTest, GetAutoStartupStatusForSelfInner_0100, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + auto result = stub_->GetAutoStartupStatusForSelfInner(data, reply); + EXPECT_EQ(result, NO_ERROR); +} + +/** + * @tc.name: AbilityManagerStubTest_GetAutoStartupStatusForSelfInner_0200 + * @tc.desc: Test the state of GetAutoStartupStatusForSelfInner + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerStubTest, GetAutoStartupStatusForSelfInner_0200, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + EXPECT_CALL(*stub_, GetAutoStartupStatusForSelf(_)).WillOnce(Return(ERR_INVALID_VALUE)); + auto result = stub_->GetAutoStartupStatusForSelfInner(data, reply); + EXPECT_EQ(result, ERR_INVALID_VALUE); +} + /** * @tc.name: GetUIExtensionRootHostInfo_0100 * @tc.desc: GetUIExtensionRootHostInfo -- Gitee