From eea48718741790ae4b6c66021250e968a55657e6 Mon Sep 17 00:00:00 2001 From: zhangzezhong Date: Thu, 4 Sep 2025 19:38:19 +0800 Subject: [PATCH] fix return errok Signed-off-by: zhangzezhong --- .../src/ets_ability_delegator.cpp | 116 +++--- .../src/ets_ability_manager.cpp | 67 ++-- .../ani/ani_common/include/ani_common_util.h | 3 + .../ani/ani_common/src/ani_common_util.cpp | 29 ++ .../src/ets_application_context_utils.cpp | 98 +++--- .../ani/ani_common/src/ets_context_utils.cpp | 17 +- .../src/ets_free_install_observer.cpp | 9 +- .../src/ets_mission_manager.cpp | 17 +- .../ani/app_manager/src/ets_app_manager.cpp | 329 +++++++++--------- .../ani/application/src/ets_application.cpp | 59 ++-- .../dialog_session/src/ets_dialog_session.cpp | 12 +- .../src/ets_insight_intent_driver.cpp | 16 +- .../ets_photo_editor_extension_context.cpp | 28 +- .../src/ets_service_extension_context.cpp | 73 ++-- .../ui_ability/src/ets_ability_context.cpp | 237 ++++++++----- .../src/ets_ui_extension_content_session.cpp | 42 ++- .../src/ets_ui_extension_context.cpp | 150 +++++--- .../src/ets_uri_perm_mgr.cpp | 19 +- .../ets/ani/wantagent/src/ani_want_agent.cpp | 21 +- .../ets/@ohos.app.ability.abilityManager.ets | 8 +- 20 files changed, 744 insertions(+), 606 deletions(-) diff --git a/frameworks/ets/ani/ability_delegator/src/ets_ability_delegator.cpp b/frameworks/ets/ani/ability_delegator/src/ets_ability_delegator.cpp index b5d00a6db2e..e22f667b718 100644 --- a/frameworks/ets/ani/ability_delegator/src/ets_ability_delegator.cpp +++ b/frameworks/ets/ani/ability_delegator/src/ets_ability_delegator.cpp @@ -220,11 +220,11 @@ void EtsAbilityDelegator::ExecuteShellCommand(ani_env *env, [[maybe_unused]]ani_ ani_object objValue = WrapShellCmdResult(env, std::move(result)); if (objValue == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "null objValue"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - COMMON_FAILED, "executeShellCommand failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + COMMON_FAILED, "executeShellCommand failed.")); return; } - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), objValue); + AppExecFwk::AsyncResolveWithNoError(env, callback, objValue); return; } @@ -247,14 +247,13 @@ void EtsAbilityDelegator::FinishTest(ani_env *env, [[maybe_unused]]ani_object ob auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (!delegator) { TAG_LOGE(AAFwkTag::DELEGATOR, "FinishTest delegator is null"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, - COMMON_FAILED, "Calling FinishTest failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, + COMMON_FAILED, "Calling FinishTest failed.")); return; } else { delegator->FinishUserTest(stdMsg, static_cast(code)); } - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -302,13 +301,12 @@ void EtsAbilityDelegator::AddAbilityMonitor(ani_env *env, [[maybe_unused]]ani_cl auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (delegator == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, - COMMON_FAILED, "Calling AddAbilityMonitor failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, + COMMON_FAILED, "Calling AddAbilityMonitor failed.")); return; } delegator->AddAbilityMonitor(monitorImpl); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -356,21 +354,18 @@ void EtsAbilityDelegator::StartAbility(ani_env *env, [[maybe_unused]]ani_object auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (delegator == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "startAbility failed."), - nullptr); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "startAbility failed.")); return; } int result = delegator->StartAbility(want); if (result != ERR_OK) { TAG_LOGE(AAFwkTag::DELEGATOR, "start ability failed: %{public}d", result); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, result, "startAbility failed."), - nullptr); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, result, "startAbility failed.")); return; } - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -412,8 +407,12 @@ ani_ref EtsAbilityDelegator::GetCurrentTopAbility(ani_env* env, [[maybe_unused]] AbilityRuntime::EtsErrorUtil::ThrowError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER); return objValue; } - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - AbilityRuntime::EtsErrorUtil::CreateError(env, resultCode, resultMsg), objValue); + if (resultCode == 0) { + AppExecFwk::AsyncResolveWithNoError(env, callback, objValue); + } else { + AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), + AbilityRuntime::EtsErrorUtil::CreateError(env, resultCode, resultMsg), objValue); + } return objValue; } @@ -436,16 +435,14 @@ void EtsAbilityDelegator::RemoveAbilityMonitor(ani_env *env, [[maybe_unused]]ani auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (delegator == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "Calling RemoveAbilityMonitor failed."), - nullptr); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "Calling RemoveAbilityMonitor failed.")); return; } else { delegator->RemoveAbilityMonitor(monitorImpl); CleanAndFindMonitorRecord(env, monitorObj); } - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -505,23 +502,20 @@ void EtsAbilityDelegator::WaitAbilityMonitor(ani_env *env, [[maybe_unused]]ani_c auto etsbaseProperty = std::static_pointer_cast(property); if (!etsbaseProperty || etsbaseProperty->object_.expired()) { TAG_LOGE(AAFwkTag::DELEGATOR, "invalid etsbaseProperty"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "Calling WaitAbilityMonitor failed."), - resultAniOj); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "Calling WaitAbilityMonitor failed.")); return; } std::unique_lock lck(g_mutexAbilityRecord); if (etsbaseProperty->object_.lock() == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "etsbaseProperty->object_ is null"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "Calling WaitAbilityMonitor failed."), - resultAniOj); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "Calling WaitAbilityMonitor failed.")); return; } g_abilityRecord.emplace(etsbaseProperty->object_, etsbaseProperty->token_); resultAniOj = etsbaseProperty->object_.lock()->aniObj; - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - resultAniOj); + AppExecFwk::AsyncResolveWithNoError(env, callback, resultAniOj); return; } @@ -545,18 +539,15 @@ void EtsAbilityDelegator::AddAbilityStageMonitor(ani_env *env, [[maybe_unused]]a auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (delegator == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "Calling AddAbilityStageMonitor failed."), - nullptr); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "Calling AddAbilityStageMonitor failed.")); return; } delegator->AddAbilityStageMonitor(stageMonitor); if (!isExisted) { AddStageMonitorRecord(env, stageMonitorObj, stageMonitor); } - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -610,14 +601,12 @@ void EtsAbilityDelegator::RemoveAbilityStageMonitor(ani_env *env, [[maybe_unused auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (delegator == nullptr) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "Calling RemoveAbilityStageMonitor failed."), - nullptr); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, "Calling RemoveAbilityStageMonitor failed.")); return; } delegator->RemoveAbilityStageMonitor(stageMonitor); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); if (isExisted) { RemoveStageMonitorRecord(env, stageMonitorObj); } @@ -687,13 +676,11 @@ void EtsAbilityDelegator::WaitAbilityStageMonitor(ani_env *env, [[maybe_unused]] if (CheckPropertyValue(env, resultCode, resultAniOj, etsbaseProperty)) { resultAniOj = etsbaseProperty->object_.lock()->aniObj; } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateError(env, resultCode, "Calling WaitAbilityStageMonitor failed."), - resultAniOj); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateError(env, resultCode, "Calling WaitAbilityStageMonitor failed.")); return; } - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - resultAniOj); + AppExecFwk::AsyncResolveWithNoError(env, callback, resultAniOj); return; } @@ -716,18 +703,17 @@ void EtsAbilityDelegator::DoAbilityForeground(ani_env *env, [[maybe_unused]]ani_ auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (!delegator) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "Calling DoAbilityForeground failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "Calling DoAbilityForeground failed.")); return; } else { if (!delegator->DoAbilityForeground(remoteObject)) { - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "Calling DoAbilityForeground failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "Calling DoAbilityForeground failed.")); return; } } - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -750,18 +736,17 @@ void EtsAbilityDelegator::DoAbilityBackground(ani_env *env, [[maybe_unused]]ani_ auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (!delegator) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "Calling DoAbilityBackground failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "Calling DoAbilityBackground failed.")); return; } else { if (!delegator->DoAbilityBackground(remoteObject)) { - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "Calling DoAbilityForeground failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "Calling DoAbilityForeground failed.")); return; } } - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } @@ -784,13 +769,12 @@ void EtsAbilityDelegator::Print(ani_env *env, [[maybe_unused]]ani_object object, auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(AbilityRuntime::Runtime::Language::ETS); if (!delegator) { TAG_LOGE(AAFwkTag::DELEGATOR, "null delegator"); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, - "print failed."), nullptr); + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, COMMON_FAILED, + "print failed.")); return; } delegator->Print(strMsg); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), - nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } diff --git a/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp b/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp index 71b07799c2d..1fee3f829a6 100644 --- a/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp +++ b/frameworks/ets/ani/ability_manager/src/ets_ability_manager.cpp @@ -70,21 +70,21 @@ sptr CreateShareDataCallbackStub( return; } if (resultCode != 0) { - AppExecFwk::AsyncCallback(env, static_cast(callbackRef), - EtsErrorUtil::CreateErrorByNativeErr(env, resultCode), nullptr); + AppExecFwk::AsyncReject(env, static_cast(callbackRef), + EtsErrorUtil::CreateErrorByNativeErr(env, resultCode)); env->GlobalReference_Delete(callbackRef); return; } ani_ref wantParamRef = AppExecFwk::WrapWantParams(env, wantParam); if (wantParamRef == nullptr) { TAG_LOGE(AAFwkTag::ABILITYMGR, "null wantParamRef"); - AppExecFwk::AsyncCallback(env, static_cast(callbackRef), - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER), nullptr); + AppExecFwk::AsyncReject(env, static_cast(callbackRef), + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER)); env->GlobalReference_Delete(callbackRef); return; } - AppExecFwk::AsyncCallback(env, static_cast(callbackRef), - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), static_cast(wantParamRef)); + AppExecFwk::AsyncResolveWithNoError( + env, static_cast(callbackRef), static_cast(wantParamRef)); env->GlobalReference_Delete(callbackRef); }; shareDataCallbackStub->SetShareRuntimeTask(task); @@ -178,8 +178,8 @@ void EtsAbilityManager::GetForegroundUIAbilitiesCallBack(ani_env *env, ani_objec sptr abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityManager is null"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)); return; } std::vector list; @@ -187,18 +187,18 @@ void EtsAbilityManager::GetForegroundUIAbilitiesCallBack(ani_env *env, ani_objec if (ret != ERR_OK) { TAG_LOGE(AAFwkTag::ABILITYMGR, "failed: ret=%{public}d", ret); AbilityRuntime::AbilityErrorCode code = AbilityRuntime::GetJsErrorCodeByNativeError(ret); - AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateError(env, code), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, EtsErrorUtil::CreateError(env, code)); return; } TAG_LOGD(AAFwkTag::ABILITYMGR, "GetForegroundUIAbilities succeeds, list.size=%{public}zu", list.size()); ani_object aniArray = AppExecFwk::CreateAniAbilityStateDataArray(env, list); if (aniArray == nullptr) { TAG_LOGE(AAFwkTag::ABILITYMGR, "null aniArray"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)); return; } - AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ERR_OK), aniArray); + AppExecFwk::AsyncResolveWithNoError(env, callbackObj, aniArray); } void EtsAbilityManager::GetTopAbility(ani_env *env, ani_object callback) @@ -221,8 +221,7 @@ void EtsAbilityManager::GetTopAbility(ani_env *env, ani_object callback) TAG_LOGE(AAFwkTag::ABILITYMGR, "null elementNameobj"); resultCode = ERR_FAILURE; } - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, resultCode), - elementNameobj); + AppExecFwk::AsyncResolveWithNoError(env, callback, elementNameobj); return; } @@ -237,7 +236,12 @@ void EtsAbilityManager::GetAbilityRunningInfos(ani_env *env, ani_object callback auto errcode = AAFwk::AbilityManagerClient::GetInstance()->GetAbilityRunningInfos(infos); ani_object retObject = nullptr; AbilityManagerEts::WrapAbilityRunningInfoArray(env, retObject, infos); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, errcode), retObject); + if (errcode == 0) { + AppExecFwk::AsyncResolveWithNoError(env, callback, retObject); + } else { + AppExecFwk::AsyncReject( + env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, errcode)); + } } void EtsAbilityManager::IsEmbeddedOpenAllowed(ani_env *env, ani_object contextObj, @@ -267,8 +271,7 @@ void EtsAbilityManager::IsEmbeddedOpenAllowed(ani_env *env, ani_object contextOb } auto token = uiAbilityContext->GetToken(); ani_boolean ret = AAFwk::AbilityManagerClient::GetInstance()->IsEmbeddedOpenAllowed(token, appId); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), AppExecFwk::CreateBoolean(env, ret)); + AppExecFwk::AsyncResolve(env, callbackObj, AppExecFwk::CreateBoolean(env, ret)); } void EtsAbilityManager::NativeOn(ani_env *env, ani_string aniType, ani_object aniObserver) @@ -419,15 +422,17 @@ void EtsAbilityManager::NativeNotifyDebugAssertResult(ani_env *env, ani_string a auto amsClient = AAFwk::AbilityManagerClient::GetInstance(); if (amsClient == nullptr) { TAG_LOGE(AAFwkTag::ABILITYMGR, "null amsClient"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR)); return; } auto ret = amsClient->NotifyDebugAssertResult(assertSessionId, static_cast(userStatus)); if (ret != ERR_OK) { TAG_LOGE(AAFwkTag::ABILITYMGR, "failed %{public}d", ret); + AppExecFwk::AsyncReject( + env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ret)); } - AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callbackObj, nullptr); } void EtsAbilityManager::NativeSetResidentProcessEnabledCheck(ani_env *env, ani_string aniBundleName) @@ -472,12 +477,11 @@ void EtsAbilityManager::NativeSetResidentProcessEnabled(ani_env *env, ani_string if (ret != ERR_OK) { TAG_LOGE(AAFwkTag::ABILITYMGR, "error: %{public}d", ret); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr); + AppExecFwk::AsyncReject( + env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ret)); return; } - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callbackObj, nullptr); } void EtsAbilityManager::NativeAcquireShareData(ani_env *env, ani_int aniMissionId, ani_object callbackObj) @@ -494,8 +498,8 @@ void EtsAbilityManager::NativeAcquireShareData(ani_env *env, ani_int aniMissionI auto shareDataCallbackStub = CreateShareDataCallbackStub(env, callbackRef); if (shareDataCallbackStub == nullptr) { TAG_LOGE(AAFwkTag::ABILITYMGR, "null shareDataCallbackStub"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, AAFwk::INNER_ERR)); env->GlobalReference_Delete(callbackRef); return; } @@ -510,8 +514,8 @@ void EtsAbilityManager::NativeAcquireShareData(ani_env *env, ani_int aniMissionI } if (err != ERR_OK) { TAG_LOGE(AAFwkTag::ABILITYMGR, "error: %{public}d", err); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, err), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, err)); env->GlobalReference_Delete(callbackRef); } } @@ -542,12 +546,11 @@ void EtsAbilityManager::NativeUpdateConfiguration(ani_env *env, ani_object confi if (errcode != ERR_OK) { TAG_LOGE(AAFwkTag::ABILITYMGR, "UpdateConfiguration failed: %{public}d", errcode); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, errcode), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, errcode)); return; } - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callbackObj, nullptr); } void EtsAbilityManagerRegistryInit(ani_env *env) diff --git a/frameworks/ets/ani/ani_common/include/ani_common_util.h b/frameworks/ets/ani/ani_common/include/ani_common_util.h index 4f4b5993f2c..fcfa85bc504 100644 --- a/frameworks/ets/ani/ani_common/include/ani_common_util.h +++ b/frameworks/ets/ani/ani_common/include/ani_common_util.h @@ -89,6 +89,9 @@ bool GetStaticFieldString(ani_env *env, ani_class classObj, const char *fieldNam bool IsValidProperty(ani_env *env, ani_ref param); bool CheckCallerIsSystemApp(); ani_object WrapLocale(ani_env *env, const std::string &locale); +void AsyncResolve(ani_env *env, ani_object call, ani_object result); +void AsyncResolveWithNoError(ani_env *env, ani_object call, ani_object result); +void AsyncReject(ani_env *env, ani_object call, ani_object error); } // namespace AppExecFwk } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_ANI_COMMON_UTIL_H diff --git a/frameworks/ets/ani/ani_common/src/ani_common_util.cpp b/frameworks/ets/ani/ani_common/src/ani_common_util.cpp index f13c0cbae4d..6d38e110659 100644 --- a/frameworks/ets/ani/ani_common/src/ani_common_util.cpp +++ b/frameworks/ets/ani/ani_common/src/ani_common_util.cpp @@ -17,6 +17,7 @@ #include "ani_common_util.h" #include "ani_enum_convert.h" +#include "ets_error_utils.h" #include "running_process_info.h" #include "hilog_tag_wrapper.h" #include "ipc_skeleton.h" @@ -1486,5 +1487,33 @@ ani_object WrapLocale(ani_env *env, const std::string &locale) } return localeObj; } + +void AsyncResolve(ani_env *env, ani_object call, ani_object result) +{ + if (env == nullptr) { + TAG_LOGE(AAFwkTag::JSNAPI, "env is nullptr"); + return; + } + AsyncCallback(env, call, AbilityRuntime::EtsErrorUtil::CreateError( + env, AbilityRuntime::AbilityErrorCode::ERROR_OK), result); +} + +void AsyncResolveWithNoError(ani_env *env, ani_object call, ani_object result) +{ + if (env == nullptr) { + TAG_LOGE(AAFwkTag::JSNAPI, "env is nullptr"); + return; + } + AsyncCallback(env, call, nullptr, result); +} + +void AsyncReject(ani_env *env, ani_object call, ani_object error) +{ + if (env == nullptr) { + TAG_LOGE(AAFwkTag::JSNAPI, "env is nullptr"); + return; + } + AsyncCallback(env, call, error, nullptr); +} } // namespace AppExecFwk } // namespace OHOS diff --git a/frameworks/ets/ani/ani_common/src/ets_application_context_utils.cpp b/frameworks/ets/ani/ani_common/src/ets_application_context_utils.cpp index b6cfd867fdb..7c76b8b1a16 100644 --- a/frameworks/ets/ani/ani_common/src/ets_application_context_utils.cpp +++ b/frameworks/ets/ani/ani_common/src/ets_application_context_utils.cpp @@ -101,26 +101,25 @@ void EtsApplicationContextUtils::OnNativeOffEnvironmentSync(ani_env *env, ani_ob auto applicationContext = applicationContext_.lock(); if (applicationContext == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "nativeContext is null"); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM), nullptr); + EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); return; } if (etsEnviromentCallback_ == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "etsEnviromentCallback is null"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "env_callback is nullptr"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "env_callback is nullptr")); return; } if (!etsEnviromentCallback_->UnRegister(callbackId)) { TAG_LOGE(AAFwkTag::APPKIT, "call UnRegister failed"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "call UnRegister failed!"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "call UnRegister failed!")); return; } - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); } void EtsApplicationContextUtils::OnNativeOnApplicationStateChangeSync(ani_env *env, ani_object aniObj, @@ -226,31 +225,30 @@ void EtsApplicationContextUtils::OnGetAllRunningInstanceKeys(ani_env *env, ani_o TAG_LOGE(AAFwkTag::APPKIT, "null env"); return; } - ani_object emptyArray = AppExecFwk::CreateEmptyArray(env); std::vector instanceKeys; auto applicationContext = applicationContext_.lock(); if (!applicationContext) { TAG_LOGE(AAFwkTag::APPKIT, "null context"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), emptyArray); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } if (applicationContext->GetCurrentAppMode() != static_cast(AppExecFwk::MultiAppModeType::MULTI_INSTANCE)) { TAG_LOGE(AAFwkTag::APPKIT, "not supported"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, - AAFwk::ERR_MULTI_INSTANCE_NOT_SUPPORTED), emptyArray); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, + AAFwk::ERR_MULTI_INSTANCE_NOT_SUPPORTED)); return; } ErrCode innerErrCode = applicationContext->GetAllRunningInstanceKeys(instanceKeys); if (innerErrCode != ERR_OK) { TAG_LOGE(AAFwkTag::APPKIT, "innerErrCode=%{public}d", innerErrCode); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateErrorByNativeErr(env, (int32_t)innerErrCode), emptyArray); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateErrorByNativeErr(env, (int32_t)innerErrCode)); return; } ani_object stringArray; AppExecFwk::WrapArrayString(env, stringArray, instanceKeys); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), stringArray); + AppExecFwk::AsyncResolveWithNoError(env, callback, stringArray); } void EtsApplicationContextUtils::OnRestartApp(ani_env *env, ani_object aniObj, ani_object wantObj) @@ -384,12 +382,12 @@ void EtsApplicationContextUtils::OnClearUpApplicationData(ani_env *env, ani_obje auto applicationContext = applicationContext_.lock(); if (applicationContext == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "nativeContext is null"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT, - "applicationContext if already released."), nullptr); + "applicationContext if already released.")); return; } - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); applicationContext->ClearUpApplicationData(); } @@ -399,13 +397,12 @@ void EtsApplicationContextUtils::OnGetRunningProcessInformation(ani_env *env, an TAG_LOGE(AAFwkTag::APPKIT, "null env"); return; } - ani_object emptyArray = AppExecFwk::CreateEmptyArray(env); auto applicationContext = applicationContext_.lock(); if (applicationContext == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "nativeContext is null"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT, - "applicationContext if already released."), emptyArray); + "applicationContext if already released.")); return; } std::vector infos; @@ -416,15 +413,14 @@ void EtsApplicationContextUtils::OnGetRunningProcessInformation(ani_env *env, an ani_object aniInfosRef = AppExecFwk::CreateRunningProcessInfoArray(env, infos); if (aniInfosRef == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null array"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INNER, "Initiate array failed."), emptyArray); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INNER, "Initiate array failed.")); } else { - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), aniInfosRef); + AppExecFwk::AsyncResolveWithNoError(env, callback, aniInfosRef); } } else { - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INNER, "Get process infos failed."), emptyArray); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INNER, "Get process infos failed.")); } } @@ -441,10 +437,10 @@ void EtsApplicationContextUtils::OnkillAllProcesses(ani_env *env, ani_object ani TAG_LOGE(AAFwkTag::APPKIT, "nativeContextLong is nullptr"); aniObject = EtsErrorUtil::CreateError(env, (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT, "applicationContext is already released."); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); context->KillProcessBySelf(clearPageStack); } @@ -459,25 +455,24 @@ void EtsApplicationContextUtils::OnPreloadUIExtensionAbility(ani_env *env, AAFwk::Want want; if (!OHOS::AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::APPKIT, "Parse want failed"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "Parse param want failed, want must be Want."), nullptr); + EtsErrorUtil::ThrowInvalidParamError(env, + "Parse param want failed, want must be Want."); return; } auto context = applicationContext_.lock(); if (!context) { - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, - (int32_t)AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, + (int32_t)AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } auto hostBundleName = context->GetBundleName(); TAG_LOGD(AAFwkTag::APPKIT, "HostBundleName is %{public}s", hostBundleName.c_str()); auto innerErrCode = AAFwk::AbilityManagerClient::GetInstance()->PreloadUIExtensionAbility(want, hostBundleName); if (innerErrCode == ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolve(env, callback, nullptr); } else { TAG_LOGE(AAFwkTag::APPKIT, "OnPreloadUIExtensionAbility failed %{public}d", innerErrCode); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode)); } } @@ -704,23 +699,22 @@ void EtsApplicationContextUtils::NativeOffLifecycleCallbackSync(ani_env *env, TAG_LOGD(AAFwkTag::APPKIT, "NativeOffLifecycleCallbackSync Call"); if (env == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "env is nullptr"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "env is nullptr"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "env is nullptr")); return; } auto etsContext = GeApplicationContext(env, aniObj); if (etsContext == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "etsContext is null"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "etsContext is null"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "etsContext is null")); return; } std::string stdType; if (!AppExecFwk::GetStdString(env, type, stdType)) { TAG_LOGE(AAFwkTag::APPKIT, "parse type failed"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "Failed to parse param type. Type must be a string."), - nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "Failed to parse param type. Type must be a string.")); return; } TAG_LOGD(AAFwkTag::APPKIT, "type=%{public}s", stdType.c_str()); @@ -728,8 +722,8 @@ void EtsApplicationContextUtils::NativeOffLifecycleCallbackSync(ani_env *env, etsContext->UnregisterAbilityLifecycleCallback(env, callbackId, callback); return; } - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "Unknown type."), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "Unknown type.")); } void EtsApplicationContextUtils::NativeOffInteropLifecycleCallbackSync(ani_env *env, @@ -766,26 +760,26 @@ void EtsApplicationContextUtils::UnregisterAbilityLifecycleCallback(ani_env *env auto applicationContext = applicationContext_.lock(); if (applicationContext == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "applicationContext is null"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "applicationContext is null"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "applicationContext is null")); return; } std::lock_guard lock(g_abilityLifecycleCallbackLock); if (abilityLifecycleCallback_ == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "abilityLifecycleCallback_ is null"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "callback_ is null"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "callback_ is null")); return; } if (abilityLifecycleCallback_->Unregister(callbackId)) { applicationContext->UnregisterAbilityLifecycleCallback(abilityLifecycleCallback_); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return; } TAG_LOGE(AAFwkTag::APPKIT, "failed to unregister"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "failed to unregister"), nullptr); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, + (ani_int)AbilityErrorCode::ERROR_CODE_INVALID_PARAM, "failed to unregister")); } void EtsApplicationContextUtils::UnregisterInteropAbilityLifecycleCallback(ani_env *env, ani_object callback) diff --git a/frameworks/ets/ani/ani_common/src/ets_context_utils.cpp b/frameworks/ets/ani/ani_common/src/ets_context_utils.cpp index 858c33c7c38..9930004628b 100644 --- a/frameworks/ets/ani/ani_common/src/ets_context_utils.cpp +++ b/frameworks/ets/ani/ani_common/src/ets_context_utils.cpp @@ -428,24 +428,27 @@ void NativeGetGroupDir([[maybe_unused]]ani_env *env, [[maybe_unused]]ani_object std::string dataGroupId = ""; if (!AppExecFwk::GetStdString(env, dataGroupIdObj, dataGroupId)) { TAG_LOGE(AAFwkTag::APPKIT, "Parse groupId failed"); - AppExecFwk::AsyncCallback(env, callBackObj, EtsErrorUtil::CreateError(env, - AbilityErrorCode::ERROR_CODE_INVALID_PARAM), nullptr); - EtsErrorUtil::ThrowInvalidParamError(env, "Parse param groupId failed, groupId must be string."); + AppExecFwk::AsyncReject(env, callBackObj, EtsErrorUtil::CreateError(env, + AbilityErrorCode::ERROR_CODE_INVALID_PARAM)); return; } auto context = GetBaseContext(env, aniObj); if (!context) { TAG_LOGE(AAFwkTag::APPKIT, "null context"); - AppExecFwk::AsyncCallback(env, callBackObj, EtsErrorUtil::CreateError(env, - AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); - EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); + AppExecFwk::AsyncReject(env, callBackObj, EtsErrorUtil::CreateError(env, + AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } ErrCode ret = ERR_OK; std::string path = context->GetGroupDir(dataGroupId); ani_object errorObject = EtsErrorUtil::CreateError(env, static_cast(ret)); ani_string aniPath = AppExecFwk::GetAniString(env, path); - AppExecFwk::AsyncCallback(env, callBackObj, errorObject, aniPath); + if (ret != ERR_OK) { + ani_object errorObject = EtsErrorUtil::CreateError( + env, static_cast(ret), "completeContext if already released."); + AppExecFwk::AsyncReject(env, callBackObj, errorObject); + } + AppExecFwk::AsyncResolveWithNoError(env, callBackObj, aniPath); } ani_object NativeCreateDisplayContext(ani_env *env, ani_object aniObj, ani_long displayId) diff --git a/frameworks/ets/ani/ani_common/src/ets_free_install_observer.cpp b/frameworks/ets/ani/ani_common/src/ets_free_install_observer.cpp index 5ab34be651e..2c4da7e295a 100644 --- a/frameworks/ets/ani/ani_common/src/ets_free_install_observer.cpp +++ b/frameworks/ets/ani/ani_common/src/ets_free_install_observer.cpp @@ -161,8 +161,10 @@ void EtsFreeInstallObserver::CallCallback(ani_object callback, int32_t resultCod ani_object aniObject = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); if (resultCode != ERR_OK) { aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, resultCode); + AppExecFwk::AsyncReject(env, callback, aniObject); + } else { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); } - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); env->GlobalReference_Delete(callback); if ((status = etsVm_->DetachCurrentThread()) != ANI_OK) { TAG_LOGE(AAFwkTag::FREE_INSTALL, "status: %{public}d", status); @@ -189,8 +191,7 @@ void EtsFreeInstallObserver::CallCallback(ani_object callback, ani_object abilit if ((status = etsVm_->GetEnv(ANI_VERSION_1, &env)) != ANI_OK || env == nullptr) { TAG_LOGE(AAFwkTag::FREE_INSTALL, "Failed to getEnv, status: %{public}d", status); } - ani_object aniObject = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); - AppExecFwk::AsyncCallback(env, callback, aniObject, abilityResult); + AppExecFwk::AsyncResolve(env, callback, abilityResult); env->GlobalReference_Delete(callback); } @@ -252,4 +253,4 @@ void EtsFreeInstallObserver::AddEtsObserverCommon( etsObserverObjectList_.emplace_back(object); } } // namespace AbilityRuntime -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/frameworks/ets/ani/ani_mission_manager/src/ets_mission_manager.cpp b/frameworks/ets/ani/ani_mission_manager/src/ets_mission_manager.cpp index 96cf5f6a820..35d5a3fc950 100644 --- a/frameworks/ets/ani/ani_mission_manager/src/ets_mission_manager.cpp +++ b/frameworks/ets/ani/ani_mission_manager/src/ets_mission_manager.cpp @@ -66,11 +66,11 @@ private: auto ret = AbilityManagerClient::GetInstance()->CleanAllMissions(); if (ret != 0) { TAG_LOGE(AAFwkTag::MISSION, "OnClearAllMissions is failed. ret = %{public}d.", ret); - AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, - ret, PermissionConstants::PERMISSION_MANAGE_MISSION), nullptr); + AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, + ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); return; } - AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AsyncResolveWithNoError(env, callback, nullptr); } void OnGetMissionInfo(ani_env* env, ani_string deviceId, ani_int missionId, ani_object callback) @@ -80,12 +80,11 @@ private: TAG_LOGE(AAFwkTag::MISSION, "null env"); return; } - auto emptyObject = GetEmptyMissionInfo(env); std::string stdDeviceId = ""; if (!GetStdString(env, deviceId, stdDeviceId)) { TAG_LOGE(AAFwkTag::MISSION, "GetStdString failed"); - AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "Parse param deviceId failed, must be a string."), emptyObject); + AsyncReject(env, callback, EtsErrorUtil::CreateInvalidParamError(env, + "Parse param deviceId failed, must be a string.")); return; } AAFwk::MissionInfo missionInfo; @@ -93,12 +92,12 @@ private: missionId, missionInfo); if (ret != 0) { TAG_LOGE(AAFwkTag::MISSION, "GetMissionInfo is failed. ret = %{public}d.", ret); - AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, - ret, PermissionConstants::PERMISSION_MANAGE_MISSION), emptyObject); + AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, + ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); return; } auto aniMissionInfo = CreateEtsMissionInfo(env, missionInfo); - AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), aniMissionInfo); + AsyncResolveWithNoError(env, callback, aniMissionInfo); } ani_object GetEmptyMissionInfo(ani_env* env) diff --git a/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp b/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp index b6436e2238d..be8271921f7 100644 --- a/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp +++ b/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp @@ -155,9 +155,8 @@ void EtsAppManager::PreloadApplication(ani_env *env, ani_object callback, ani_st std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "param bundlename err"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM)), nullptr); + AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param bundleName failed, must be a valid string."); return; } TAG_LOGD(AAFwkTag::APPMGR, "PreloadApplication userId:%{public}d, bundleName %{public}s", @@ -166,9 +165,8 @@ void EtsAppManager::PreloadApplication(ani_env *env, ani_object callback, ani_st ani_int mode = 0; if (!AAFwk::AniEnumConvertUtil::EnumConvert_EtsToNative(env, aniMode, mode)) { TAG_LOGE(AAFwkTag::APPMGR, "param mode err"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM)), nullptr); + AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError( + env, "Unsupported preloadMode, must be PreloadMode.PRESS_DOWN."); return; } @@ -191,16 +189,20 @@ void EtsAppManager::PreloadApplication(ani_env *env, ani_object callback, ani_st sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } auto ret = appMgr->PreloadApplication(bundleName, aniUserId, static_cast(mode), appIndex); TAG_LOGD(AAFwkTag::APPMGR, "PreloadApplication ret %{public}d", ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); + } TAG_LOGD(AAFwkTag::APPMGR, "PreloadApplication END"); } @@ -211,31 +213,29 @@ void EtsAppManager::GetRunningProcessInformation(ani_env *env, ani_object callba TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyArray = CreateEmptyAniArray(env); sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::vector infos; auto ret = appMgr->GetAllRunningProcesses(infos); TAG_LOGD(AAFwkTag::APPMGR, "GetAllRunningProcesses ret:%{public}d, size:%{public}zu", ret, infos.size()); if (ret != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), emptyArray); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return; } ani_object aniInfosRef = CreateRunningProcessInfoArray(env, infos); if (aniInfosRef == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), aniInfosRef); + AppExecFwk::AsyncResolveWithNoError(env, callback, aniInfosRef); } TAG_LOGD(AAFwkTag::APPMGR, "GetRunningProcessInformation finished"); } @@ -247,32 +247,29 @@ void EtsAppManager::GetForegroundApplications(ani_env *env, ani_object callback) TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyArray = CreateEmptyAniArray(env); auto appManager = GetAppManagerInstance(); if (appManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::vector appStateData; int32_t ret = appManager->GetForegroundApplications(appStateData); TAG_LOGD(AAFwkTag::APPMGR, "GetForegroundApplications ret:%{public}d, size:%{public}zu", ret, appStateData.size()); if (ret != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), emptyArray); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return; } ani_object appStateDataObj = CreateAppStateDataArray(env, appStateData); if (appStateDataObj == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), - appStateDataObj); + AppExecFwk::AsyncResolveWithNoError(env, callback, appStateDataObj); } TAG_LOGD(AAFwkTag::APPMGR, "GetForegroundApplications end"); } @@ -284,31 +281,30 @@ void EtsAppManager::GetRunningMultiAppInfo(ani_env *env, ani_string aniBundleNam TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyMultiAppInfo = CreateEmptyMultiAppInfo(env); #ifdef SUPPORT_SCREEN if (!AppExecFwk::CheckCallerIsSystemApp()) { TAG_LOGE(AAFwkTag::APPMGR, "Non-system app"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError( - env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP), emptyMultiAppInfo); + env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP)); return; } #endif std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM), - "Parse param bundleName failed, must be a string."), emptyMultiAppInfo); + "Parse param bundleName failed, must be a string.")); return; } auto appManager = GetAppManagerInstance(); if (appManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager nullptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyMultiAppInfo); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } AppExecFwk::RunningMultiAppInfo info; @@ -316,18 +312,17 @@ void EtsAppManager::GetRunningMultiAppInfo(ani_env *env, ani_string aniBundleNam innerErrorCode = appManager->GetRunningMultiAppInfoByBundleName(bundleName, info); TAG_LOGD(AAFwkTag::APPMGR, "GetRunningMultiAppInfoByBundleName ret: %{public}d", innerErrorCode); if (innerErrorCode != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrorCode), emptyMultiAppInfo); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrorCode)); return; } ani_object appinfoObj = WrapRunningMultiAppInfo(env, info); if (appinfoObj == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyMultiAppInfo); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback( - env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrorCode), appinfoObj); + AppExecFwk::AsyncResolveWithNoError(env, callback, appinfoObj); } TAG_LOGD(AAFwkTag::APPMGR, "GetRunningMultiAppInfo end"); } @@ -340,47 +335,44 @@ void EtsAppManager::GetRunningProcessInfoByBundleNameAndUserId( TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyArray = CreateEmptyAniArray(env); if (aniBundleName == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "aniBundleName null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM))); return; } std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM)), emptyArray); + AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param bundleName failed, must be a string."); return; } TAG_LOGD(AAFwkTag::APPMGR, "GetRunningProcessInfoByBundleNameAndUserId userid:%{public}d", aniUserId); auto appManager = GetAppManagerInstance(); if (appManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager nullptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::vector infos; int32_t ret = appManager->GetRunningProcessInformation(bundleName, aniUserId, infos); TAG_LOGD(AAFwkTag::APPMGR, "GetRunningProcessInformation ret: %{public}d, size:%{public}zu", ret, infos.size()); if (ret != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), emptyArray); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return; } ani_object aniInfos = CreateRunningProcessInfoArray(env, infos); if (aniInfos == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( - env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + env, static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), aniInfos); + AppExecFwk::AsyncResolveWithNoError(env, callback, aniInfos); } TAG_LOGD(AAFwkTag::APPMGR, "GetRunningProcessInfoByBundleNameAndUserId finished"); } @@ -515,9 +507,9 @@ void EtsAppManager::OnOff(ani_env *env, ani_string type, ani_int etsObserverId, std::string strType; if (!AppExecFwk::GetStdString(env, type, strType) || strType != ON_OFF_TYPE) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString failed"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param type failed, must be a string, value must be applicationState."), nullptr); + AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param type failed, must be a string," + "value must be applicationState, appForegroundState or abilityFirstFrameState."); return; } TAG_LOGD(AAFwkTag::APPMGR, "observerId:%{public}d", etsObserverId); @@ -525,34 +517,31 @@ void EtsAppManager::OnOff(ani_env *env, ani_string type, ani_int etsObserverId, sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - nullptr); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } if (appStateObserver_ == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "null observer"); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "observer is nullptr, please register first."), nullptr); + AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError( + env, "observer is nullptr, please register first."); return; } if (!appStateObserver_->FindObserverByObserverId(observerId)) { TAG_LOGE(AAFwkTag::APPMGR, "not find observer:%{public}d", static_cast(observerId)); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "not find observerId."), nullptr); + AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError(env, "not find observerId."); return; } int32_t ret = appMgr->UnregisterApplicationStateObserver(appStateObserver_); if (ret == 0 && appStateObserver_->RemoveEtsObserverObject(observerId)) { TAG_LOGD(AAFwkTag::APPMGR, "OnOff success"); + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); } else { TAG_LOGE(AAFwkTag::APPMGR, "OnOff err:%{public}d", ret); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); } - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); TAG_LOGD(AAFwkTag::APPMGR, "OnOff end"); } @@ -566,18 +555,16 @@ void EtsAppManager::GetAppMemorySize(ani_env *env, ani_object callback) auto abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "abilityManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - AppExecFwk::CreateInt(env, ERR_FAILURE)); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } int32_t memorySize = abilityManager->GetAppMemorySize(); TAG_LOGD(AAFwkTag::APPMGR, "memorySize:%{public}d", memorySize); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ERR_OK)), - AppExecFwk::CreateInt(env, memorySize)); + AppExecFwk::AsyncResolveWithNoError( + env, callback, AppExecFwk::CreateInt(env, memorySize)); TAG_LOGD(AAFwkTag::APPMGR, "GetAppMemorySize end"); } @@ -591,18 +578,16 @@ void EtsAppManager::IsRamConstrainedDevice(ani_env *env, ani_object callback) auto abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "abilityManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - AppExecFwk::CreateBoolean(env, false)); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } bool ret = abilityManager->IsRamConstrainedDevice(); TAG_LOGD(AAFwkTag::APPMGR, "IsRamConstrainedDevice:%{public}d", ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ERR_OK)), - AppExecFwk::CreateBoolean(env, static_cast(ret))); + AppExecFwk::AsyncResolveWithNoError( + env, callback, AppExecFwk::CreateBoolean(env, static_cast(ret))); TAG_LOGD(AAFwkTag::APPMGR, "IsRamConstrainedDevice end"); } @@ -616,18 +601,16 @@ void EtsAppManager::IsRunningInStabilityTest(ani_env *env, ani_object callback) auto abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "abilityManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - AppExecFwk::CreateBoolean(env, false)); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } bool ret = abilityManager->IsRunningInStabilityTest(); TAG_LOGD(AAFwkTag::APPMGR, "IsRunningInStabilityTest:%{public}d", ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ERR_OK)), - AppExecFwk::CreateBoolean(env, static_cast(ret))); + AppExecFwk::AsyncResolveWithNoError( + env, callback, AppExecFwk::CreateBoolean(env, static_cast(ret))); TAG_LOGD(AAFwkTag::APPMGR, "IsRunningInStabilityTest end"); } @@ -659,18 +642,18 @@ void EtsAppManager::KillProcessesByBundleNameInner(ani_env *env, ani_object call auto abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "abilityManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } ani_status status = ANI_OK; std::string bundleName; if (!AppExecFwk::GetStdString(env, etsBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleName failed, must be a string."), nullptr); + env, "Parse param bundleName failed, must be a string.")); return; } int32_t appIndex = 0; @@ -689,8 +672,13 @@ void EtsAppManager::KillProcessesByBundleNameInner(ani_env *env, ani_object call } auto ret = abilityManager->KillProcess(bundleName, clearPageStack, appIndex); TAG_LOGD(AAFwkTag::APPMGR, "KillProcess ret: %{public}d", ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + if (ret == 0) { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr( + env, static_cast(ret)), "kill process failed."); + } TAG_LOGD(AAFwkTag::APPMGR, "KillProcessesByBundleNameInner end"); } @@ -725,17 +713,17 @@ void EtsAppManager::KillProcessWithAccountInner(ani_env *env, ani_object callbac sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr || appMgr->GetAmsMgr() == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleName failed, must be a string."), nullptr); + env, "Parse param bundleName failed, must be a string.")); return; } TAG_LOGD(AAFwkTag::APPMGR, "KillProcessWithAccount accountId:%{public}d", aniAccountId); @@ -756,8 +744,13 @@ void EtsAppManager::KillProcessWithAccountInner(ani_env *env, ani_object callbac } auto ret = appMgr->GetAmsMgr()->KillProcessWithAccount(bundleName, aniAccountId, clearPageStack, appIndex); TAG_LOGD(AAFwkTag::APPMGR, "KillProcessWithAccount ret: %{public}d", ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + if (ret == 0) { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret), + "Kill processes failed.")); + } TAG_LOGD(AAFwkTag::APPMGR, "KillProcessWithAccount end"); } @@ -773,18 +766,20 @@ void EtsAppManager::NativeGetProcessMemoryByPid(ani_env *env, ani_int aniPid, an sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - AppExecFwk::CreateInt(env, ERR_FAILURE)); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } int32_t memSize = 0; int32_t ret = appMgr->GetProcessMemoryByPid(aniPid, memSize); TAG_LOGD(AAFwkTag::APPMGR, "NativeGetProcessMemoryByPid memSize: %{public}d, ret:%{public}d", memSize, ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), - AppExecFwk::CreateInt(env, memSize)); + if (ret == 0) { + AppExecFwk::AsyncResolveWithNoError(env, callback, CreateInt(env, memSize)); + } else { + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); + } TAG_LOGD(AAFwkTag::APPMGR, "NativeGetProcessMemoryByPid end"); } @@ -796,21 +791,20 @@ void EtsAppManager::GetRunningProcessInformationByBundleType( TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyArray = CreateEmptyAniArray(env); sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } ani_int bundleType; if (!AAFwk::AniEnumConvertUtil::EnumConvert_EtsToNative(env, aniBundleType, bundleType)) { TAG_LOGE(AAFwkTag::APPMGR, "param aniBundleType err"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleType failed, must be a BundleType."), emptyArray); + env, "Parse param bundleType failed, must be a BundleType.")); return; } std::vector infos; @@ -818,18 +812,17 @@ void EtsAppManager::GetRunningProcessInformationByBundleType( TAG_LOGD(AAFwkTag::APPMGR, "GetRunningProcessInformationByBundleType ret:%{public}d, size:%{public}zu", ret, infos.size()); if (ret != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), emptyArray); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return; } ani_object aniInfosRef = CreateRunningProcessInfoArray(env, infos); if (aniInfosRef == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), aniInfosRef); + AppExecFwk::AsyncResolveWithNoError(env, callback, aniInfosRef); } TAG_LOGD(AAFwkTag::APPMGR, "GetRunningProcessInformationByBundleType end"); } @@ -845,10 +838,9 @@ void EtsAppManager::NativeIsSharedBundleRunning(ani_env *env, ani_string aniBund sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - AppExecFwk::CreateBoolean(env, false)); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } TAG_LOGD(AAFwkTag::APPMGR, "NativeGetProcessMemoryByPid pid:%{public}lld", aniVersionCode); @@ -857,15 +849,14 @@ void EtsAppManager::NativeIsSharedBundleRunning(ani_env *env, ani_string aniBund std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleName failed, must be a string."), AppExecFwk::CreateBoolean(env, false)); + env, "Parse param bundleName failed, must be a string.")); return; } bool ret = appMgr->IsSharedBundleRunning(bundleName, versionCode); TAG_LOGD(AAFwkTag::APPMGR, "NativeIsSharedBundleRunning ret :%{public}d", ret); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ERR_OK)), + AppExecFwk::AsyncResolveWithNoError(env, callback, AppExecFwk::CreateBoolean(env, static_cast(ret))); TAG_LOGD(AAFwkTag::APPMGR, "NativeIsSharedBundleRunning end"); } @@ -877,39 +868,37 @@ void EtsAppManager::NativeGetSupportedProcessCachePids(ani_env *env, ani_string TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyArray = CreateEmptyAniArray(env); sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleName failed, must be a string."), emptyArray); + env, "Parse param bundleName failed, must be a string.")); return; } std::vector list; int32_t ret = appMgr->GetSupportedProcessCachePids(bundleName, list); TAG_LOGD(AAFwkTag::APPMGR, "GetSupportedProcessCachePids ret:%{public}d, size:%{public}zu", ret, list.size()); if (ret != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), emptyArray); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return; } ani_object arrayObj = CreateIntAniArray(env, list); if (arrayObj == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), arrayObj); + AppExecFwk::AsyncResolveWithNoError(env, callback, arrayObj); } TAG_LOGD(AAFwkTag::APPMGR, "NativeGetSupportedProcessCachePids end"); } @@ -924,23 +913,27 @@ void EtsAppManager::NativeKillProcessesInBatch(ani_env *env, ani_object pids, an sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr || appMgr->GetAmsMgr() == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::vector pidList; if (!UnWrapArrayInt(env, pids, pidList)) { TAG_LOGE(AAFwkTag::APPMGR, "Parse pids failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param pids failed, must be array of numbers."), nullptr); + env, "Parse param pids failed, must be array of numbers.")); return; } int32_t innerErrorCode = appMgr->GetAmsMgr()->KillProcessesInBatch(pidList); TAG_LOGD(AAFwkTag::APPMGR, "NativeKillProcessesInBatch ret:%{public}d", innerErrorCode); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrorCode)), nullptr); + if (innerErrorCode == ERR_OK) { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrorCode))); + } TAG_LOGD(AAFwkTag::APPMGR, "NativeKillProcessesInBatch end"); } @@ -955,18 +948,17 @@ void EtsAppManager::NativeIsAppRunning(ani_env *env, ani_object callback, ani_st sptr appMgr = GetAppManagerInstance(); if (appMgr == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), - AppExecFwk::CreateBoolean(env, false)); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return; } std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleName failed, must be a string."), AppExecFwk::CreateBoolean(env, false)); + env, "Parse param bundleName failed, must be a string.")); return; } ani_status status = ANI_OK; @@ -988,13 +980,10 @@ void EtsAppManager::NativeIsAppRunning(ani_env *env, ani_object callback, ani_st int32_t innerErrorCode = appMgr->IsAppRunning(bundleName, appCloneIndex, isRunnig); TAG_LOGD(AAFwkTag::APPMGR, "innerErrorCode:%{public}d, isRunning:%{public}d", innerErrorCode, isRunnig); if (innerErrorCode == ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrorCode)), - AppExecFwk::CreateBoolean(env, isRunnig)); + AppExecFwk::AsyncResolveWithNoError(env, callback, AppExecFwk::CreateBoolean(env, isRunnig)); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrorCode)), - AppExecFwk::CreateBoolean(env, false)); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrorCode))); } TAG_LOGD(AAFwkTag::APPMGR, "NativeIsAppRunning end"); } @@ -1010,24 +999,28 @@ void EtsAppManager::NativeSetKeepAliveForBundle(ani_env *env, ani_string aniBund auto abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "abilityManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError( - env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER), nullptr); + env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)); return; } std::string bundleName; if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) { TAG_LOGE(AAFwkTag::APPMGR, "GetStdString Failed"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param bundleName failed, must be a string."), nullptr); + env, "Parse param bundleName failed, must be a string.")); return; } TAG_LOGD(AAFwkTag::APPMGR, "KillProcessWithAccount aniUserId:%{public}d", aniUserId); int32_t innerErrCode = abilityManager->SetApplicationKeepAlive(bundleName, aniUserId, enable); TAG_LOGD(AAFwkTag::APPMGR, "innerErrCode:%{public}d", innerErrCode); - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode)), nullptr); + if (innerErrCode == ERR_OK) { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode))); + } TAG_LOGD(AAFwkTag::APPMGR, "NativeSetKeepAliveForBundle end"); } @@ -1039,21 +1032,20 @@ void EtsAppManager::NativeGetKeepAliveBundles(ani_env *env, ani_object callback, TAG_LOGE(AAFwkTag::APPMGR, "env null ptr"); return; } - ani_object emptyArray = CreateEmptyAniArray(env); auto abilityManager = GetAbilityManagerInstance(); if (abilityManager == nullptr) { TAG_LOGE(AAFwkTag::APPMGR, "abilityManager null ptr"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateError( - env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER), nullptr); + env, AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)); return; } ani_int appType = 0; if (!AAFwk::AniEnumConvertUtil::EnumConvert_EtsToNative(env, aniType, appType)) { TAG_LOGE(AAFwkTag::APPMGR, "param mode err"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateInvalidParamError( - env, "Parse param appType failed, must be a number."), nullptr); + env, "Parse param appType failed, must be a number.")); return; } ani_status status = ANI_OK; @@ -1076,18 +1068,17 @@ void EtsAppManager::NativeGetKeepAliveBundles(ani_env *env, ani_object callback, TAG_LOGD(AAFwkTag::APPMGR, "GetSupportedProcessCachePids innerErrCode:%{public}d, size:%{public}zu", innerErrCode, infoList.size()); if (innerErrCode != ERR_OK) { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode)), emptyArray); + AppExecFwk::AsyncReject(env, callback, + AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode))); return; } ani_object arrayObj = CreateKeepAliveInfoArray(env, infoList); if (arrayObj == nullptr) { - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); } else { - AppExecFwk::AsyncCallback(env, callback, - AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode)), arrayObj); + AppExecFwk::AsyncResolveWithNoError(env, callback, arrayObj); } TAG_LOGD(AAFwkTag::APPMGR, "NativeGetKeepAliveBundles end"); } diff --git a/frameworks/ets/ani/application/src/ets_application.cpp b/frameworks/ets/ani/application/src/ets_application.cpp index bdc89c3772d..b417939fe9a 100644 --- a/frameworks/ets/ani/application/src/ets_application.cpp +++ b/frameworks/ets/ani/application/src/ets_application.cpp @@ -58,18 +58,14 @@ ani_object CreateEmptyContextObject(ani_env *env) bool CheckIsSystemAppOrPermisson(ani_env *env, ani_object callback) { - auto emptyObject = CreateEmptyContextObject(env); if (!AAFwk::PermissionVerification::GetInstance()->IsSystemAppCall()) { TAG_LOGE(AAFwkTag::APPKIT, "no system app"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, - static_cast(AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP), - "The application is not system-app, can not use system-api."), emptyObject); + EtsErrorUtil::ThrowNotSystemAppError(env); return false; } if (!AAFwk::PermissionVerification::GetInstance()->VerifyGetBundleInfoPrivilegedPermission()) { TAG_LOGE(AAFwkTag::APPKIT, "no permission"); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateNoPermissionError(env, PERMISSION_GET_BUNDLE_INFO), emptyObject); + EtsErrorUtil::ThrowNoPermissionError(env, PERMISSION_GET_BUNDLE_INFO); return false; } return true; @@ -120,9 +116,8 @@ void SetCreateCompleteCallback(ani_env *env, std::shared_ptr GetContextByStageMode(ani_env *env, ani_object &contextObj, @@ -147,15 +142,15 @@ std::shared_ptr GetContextByStageMode(ani_env *env, ani_object &context ani_status status = IsStageContext(env, contextObj, stageMode); if (status != ANI_OK || !stageMode) { TAG_LOGE(AAFwkTag::APPKIT, "not stageMode"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "Parse param context failed, must be a context of stageMode."), emptyObject); + EtsErrorUtil::ThrowInvalidParamError(env, + "Parse param context failed, must be a context of stageMode."); return nullptr; } auto context = GetStageModeContext(env, contextObj); if (context == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null context"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "Parse param context failed, must not be nullptr."), emptyObject); + EtsErrorUtil::ThrowInvalidParamError(env, + "Parse param context failed, must not be nullptr."); return nullptr; } return context; @@ -181,16 +176,15 @@ void EtsApplication::CreateModuleContext(ani_env *env, auto inputContextPtr = Context::ConvertTo(context); if (inputContextPtr == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "Convert to context failed"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "Parse param context failed, must be a context."), emptyObject); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param context failed, must be a context."); return; } std::shared_ptr> moduleContext = std::make_shared>(); std::shared_ptr contextImpl = std::make_shared(); if (contextImpl == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null contextImpl"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "create context failed."), emptyObject); + EtsErrorUtil::ThrowInvalidParamError(env, "create context failed."); return; } contextImpl->SetProcessName(context->GetProcessName()); @@ -227,16 +221,15 @@ void EtsApplication::CreateBundleContext(ani_env *env, auto inputContextPtr = Context::ConvertTo(context); if (inputContextPtr == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "Convert to context failed"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "Parse param context failed, must be a context."), emptyObject); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param context failed, must be a context."); return; } auto bundleContext = std::make_shared>(); std::shared_ptr contextImpl = std::make_shared(); if (contextImpl == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null contextImpl"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateInvalidParamError(env, - "create context failed."), emptyObject); + EtsErrorUtil::ThrowInvalidParamError(env, "create context failed."); return; } contextImpl->SetProcessName(context->GetProcessName()); @@ -253,24 +246,22 @@ void EtsApplication::CreatePluginModuleContext(ani_env *env, return; } ani_boolean stageMode = false; - ani_object emptyArray = AppExecFwk::CreateEmptyArray(env); ani_status status = OHOS::AbilityRuntime::IsStageContext(env, contextObj, stageMode); if (status != ANI_OK || !stageMode) { - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateInvalidParamError(env, "Parse param context failed, must be a context of stageMode."), - emptyArray); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateInvalidParamError(env, "Parse param context failed, must be a context of stageMode.")); return; } auto context = OHOS::AbilityRuntime::GetStageModeContext(env, contextObj); if (context == nullptr) { - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateInvalidParamError(env, "Parse param context failed, must not be nullptr."), emptyArray); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateInvalidParamError(env, "Parse param context failed, must not be nullptr.")); return; } auto inputContextPtr = Context::ConvertTo(context); if (inputContextPtr == nullptr) { - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateInvalidParamError(env, "Parse param context failed, must be a context."), emptyArray); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateInvalidParamError(env, "Parse param context failed, must be a context.")); return; } std::string stdPluginBundleName = ""; @@ -281,15 +272,15 @@ void EtsApplication::CreatePluginModuleContext(ani_env *env, stdModuleName.c_str(), stdPluginBundleName.c_str()); if (stdPluginBundleName.empty() || stdModuleName.empty()) { TAG_LOGE(AAFwkTag::APPKIT, "Empty pluginBundleName or moduleName"); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateInvalidParamError(env, "Empty pluginBundleName or moduleName"), emptyArray); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateInvalidParamError(env, "Empty pluginBundleName or moduleName")); return; } auto moduleContext = std::make_shared>(); auto contextImpl = std::make_shared(); if (contextImpl == nullptr) { - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateInvalidParamError(env, "create context failed."), emptyArray); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateInvalidParamError(env, "create context failed.")); return; } contextImpl->SetProcessName(context->GetProcessName()); diff --git a/frameworks/ets/ani/dialog_session/src/ets_dialog_session.cpp b/frameworks/ets/ani/dialog_session/src/ets_dialog_session.cpp index ceb46031157..20215a4d790 100644 --- a/frameworks/ets/ani/dialog_session/src/ets_dialog_session.cpp +++ b/frameworks/ets/ani/dialog_session/src/ets_dialog_session.cpp @@ -41,27 +41,31 @@ static void SendDialogResult( if (!AppExecFwk::GetStdString(env, etsDialogSessionId, dialogSessionId)) { TAG_LOGE(AAFwkTag::DIALOG, "Failed unwrap dialogSessionId"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "Parameter error: dialogSessionId must be a string."); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::DIALOG, "Failed unwrap want"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "Parameter error: want must be a Want."); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } bool isAllow = false; if (etsIsAllow != 1 && etsIsAllow != 0) { TAG_LOGE(AAFwkTag::DIALOG, "Failed unwrap isAllow"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "Parameter error: isAllow must be a Boolean."); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } isAllow = static_cast(etsIsAllow); auto errorCode = AAFwk::AbilityManagerClient::GetInstance()->SendDialogResult(want, dialogSessionId, isAllow); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, errorCode), nullptr); + if (errorCode) { + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, errorCode)); + } else { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } } static ani_object GetDialogSessionInfo(ani_env *env, ani_string etsDialogSessionId) diff --git a/frameworks/ets/ani/insight_intent/insight_intent_driver/src/ets_insight_intent_driver.cpp b/frameworks/ets/ani/insight_intent/insight_intent_driver/src/ets_insight_intent_driver.cpp index c63917a5fa6..682fb5124ef 100644 --- a/frameworks/ets/ani/insight_intent/insight_intent_driver/src/ets_insight_intent_driver.cpp +++ b/frameworks/ets/ani/insight_intent/insight_intent_driver/src/ets_insight_intent_driver.cpp @@ -73,7 +73,7 @@ public: error = EtsErrorUtil::CreateErrorByNativeErr(env, resultCode); result = CreateNullExecuteResult(env); } else { - error = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); + error = nullptr; result = WrapExecuteResult(env, executeResult); } if (callbackRef_) { @@ -129,17 +129,15 @@ public: ani_object error; if (exparam == nullptr) { TAG_LOGE(AAFwkTag::INTENT, "invalid param"); - error = EtsErrorUtil::CreateInvalidParamError(env, "invalid param"); - AsyncCallback(env, callback, error, CreateNullExecuteResult(env)); + EtsErrorUtil::ThrowTooFewParametersError(env); return; } InsightIntentExecuteParam param; if (!UnwrapExecuteParam(env, exparam, param)) { TAG_LOGE(AAFwkTag::INTENT, "parse execute param failed"); - error = EtsErrorUtil::CreateInvalidParamError(env, - "Parameter error: Parse param failed, param must be a ExecuteParam."); - AsyncCallback(env, callback, error, CreateNullExecuteResult(env)); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parameter error: Parse param failed, param must be a ExecuteParam."); return; } @@ -148,7 +146,7 @@ public: TAG_LOGE(AAFwkTag::INTENT, "GlobalReference_Create failed"); error = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast( AbilityErrorCode::ERROR_CODE_INNER)); - AsyncCallback(env, callback, error, CreateNullExecuteResult(env)); + AsyncReject(env, callback, error); return; } @@ -157,7 +155,7 @@ public: TAG_LOGE(AAFwkTag::INTENT, "GetVM failed"); error = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast( AbilityErrorCode::ERROR_CODE_INNER)); - AsyncCallback(env, callback, error, CreateNullExecuteResult(env)); + AsyncReject(env, callback, error); return; } @@ -172,7 +170,7 @@ public: InsightIntentHostClient::GetInstance(), param); if (err != 0) { error = EtsErrorUtil::CreateErrorByNativeErr(env, err); - AsyncCallback(env, callback, error, CreateNullExecuteResult(env)); + AsyncReject(env, callback, error); InsightIntentHostClient::GetInstance()->RemoveInsightIntentExecute(key); } return; diff --git a/frameworks/ets/ani/photo_editor_extension_ability/src/ets_photo_editor_extension_context.cpp b/frameworks/ets/ani/photo_editor_extension_ability/src/ets_photo_editor_extension_context.cpp index de530cf9d14..25aa70c5bdb 100644 --- a/frameworks/ets/ani/photo_editor_extension_ability/src/ets_photo_editor_extension_context.cpp +++ b/frameworks/ets/ani/photo_editor_extension_ability/src/ets_photo_editor_extension_context.cpp @@ -212,7 +212,7 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithUri(ani_env* aniEnv, TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); aniObject = EtsErrorUtil::CreateError(aniEnv, (ani_int)PhotoEditorErrorCode::ERROR_CODE_INTERNAL_ERROR, ERR_MSG_INTERNAL_ERROR); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } @@ -221,7 +221,7 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithUri(ani_env* aniEnv, TAG_LOGE(AAFwkTag::UI_EXT, "get string error"); aniObject = EtsErrorUtil::CreateError(aniEnv, (ani_int)PhotoEditorErrorCode::ERROR_CODE_PARAM_ERROR, ERR_MSG_PARAMS_ERROR); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } TAG_LOGD(AAFwkTag::UI_EXT, "Uri:%{public}s", uriStr.c_str()); @@ -233,12 +233,17 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithUri(ani_env* aniEnv, TAG_LOGW(AAFwkTag::UI_EXT, "null abilityResult"); ret = static_cast(PhotoEditorErrorCode::ERROR_CODE_INTERNAL_ERROR); aniObject = EtsErrorUtil::CreateError(aniEnv, ret, "null abilityResult"); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } aniObject = EtsErrorUtil::CreateErrorByNativeErr(aniEnv, static_cast(errCode)); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, abilityResult); + if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::UI_EXT, "create error fail"); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); + return; + } + AppExecFwk::AsyncResolve(aniEnv, callback, abilityResult); } void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithImage(ani_env* aniEnv, ani_object obj, ani_object imageObj, @@ -253,7 +258,7 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithImage(ani_env* aniEn TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); ret = (ani_int)PhotoEditorErrorCode::ERROR_CODE_INTERNAL_ERROR; aniObject = EtsErrorUtil::CreateError(aniEnv, ret, ERR_MSG_INTERNAL_ERROR); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } @@ -262,7 +267,7 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithImage(ani_env* aniEn TAG_LOGE(AAFwkTag::UI_EXT, "Get edited image fail"); ret = (ani_int)PhotoEditorErrorCode::ERROR_CODE_PARAM_ERROR; aniObject = EtsErrorUtil::CreateError(aniEnv, ret, ERR_MSG_PARAMS_ERROR); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } @@ -270,7 +275,7 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithImage(ani_env* aniEn if (!UnwrapPackOption(aniEnv, optionObj, packOption)) { TAG_LOGE(AAFwkTag::UI_EXT, "unwrap packoption failed"); aniObject = EtsErrorUtil::CreateInvalidParamError(aniEnv, "unwrap packoption failed"); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } @@ -283,13 +288,18 @@ void EtsPhotoEditorExtensionContext::OnSaveEditedContentWithImage(ani_env* aniEn TAG_LOGW(AAFwkTag::UI_EXT, "null abilityResult"); ret = static_cast(PhotoEditorErrorCode::ERROR_CODE_INTERNAL_ERROR); aniObject = EtsErrorUtil::CreateError(aniEnv, ret, "null abilityResult"); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); return; } TAG_LOGD(AAFwkTag::UI_EXT, "SaveEditedContent end"); aniObject = EtsErrorUtil::CreateErrorByNativeErr(aniEnv, static_cast(errCode)); - AppExecFwk::AsyncCallback(aniEnv, callback, aniObject, abilityResult); + if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::UI_EXT, "create error fail"); + AppExecFwk::AsyncReject(aniEnv, callback, aniObject); + return; + } + AppExecFwk::AsyncResolve(aniEnv, callback, abilityResult); TAG_LOGD(AAFwkTag::UI_EXT, "OnSaveEditedContentWithImage called"); } diff --git a/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp b/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp index 35d22591030..dc315807fba 100644 --- a/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp +++ b/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp @@ -308,12 +308,16 @@ void EtsServiceExtensionContext::OnTerminateSelf(ani_env *env, ani_object obj, a TAG_LOGE(AAFwkTag::SERVICE_EXT, "context is nullptr"); ret = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } ret = context->TerminateAbility(); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + if (ret != ERR_OK) { + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); + return; + } else { + AppExecFwk::AsyncResolve(env, callback, nullptr); + } } void EtsServiceExtensionContext::OnStartServiceExtensionAbility( @@ -327,19 +331,25 @@ void EtsServiceExtensionContext::OnStartServiceExtensionAbility( TAG_LOGE(AAFwkTag::SERVICE_EXT, "context is nullptr"); ret = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callbackobj, aniObject); return; } AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::SERVICE_EXT, "UnwrapWant failed"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant failed"); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param want failed, must be a Want."); return; } ret = context->StartServiceExtensionAbility(want); aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + if (ret != ERR_OK) { + AppExecFwk::AsyncReject(env, callbackobj, aniObject); + return; + } else { + AppExecFwk::AsyncResolve(env, callbackobj, nullptr); + return; + } } void EtsServiceExtensionContext::OnStopServiceExtensionAbility( @@ -353,19 +363,25 @@ void EtsServiceExtensionContext::OnStopServiceExtensionAbility( TAG_LOGE(AAFwkTag::SERVICE_EXT, "context is nullptr"); ret = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callbackobj, aniObject); return; } AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::SERVICE_EXT, "UnwrapWant failed"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant failed"); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param want failed, must be a Want."); return; } ret = context->StopServiceExtensionAbility(want); aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + if (ret != ERR_OK) { + AppExecFwk::AsyncReject(env, callbackobj, aniObject); + return; + } else { + AppExecFwk::AsyncResolve(env, callbackobj, nullptr); + return; + } } void EtsServiceExtensionContext::OnStartAbility( @@ -375,8 +391,8 @@ void EtsServiceExtensionContext::OnStartAbility( AAFwk::Want want; ErrCode errCode = ERR_OK; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant filed"); - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param want failed, must be a Want."); return; } auto context = context_.lock(); @@ -384,7 +400,7 @@ void EtsServiceExtensionContext::OnStartAbility( TAG_LOGE(AAFwkTag::SERVICE_EXT, "context is nullptr"); errCode = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(errCode)); - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, aniObject); return; } if ((want.GetFlags() & AAFwk::Want::FLAG_INSTALL_ON_DEMAND) == AAFwk::Want::FLAG_INSTALL_ON_DEMAND) { @@ -398,8 +414,8 @@ void EtsServiceExtensionContext::OnStartAbility( AAFwk::StartOptions startOptions; if (!AppExecFwk::UnwrapStartOptions(env, opt, startOptions)) { TAG_LOGE(AAFwkTag::SERVICE_EXT, "UnwrapStartOptions filed"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant filed"); - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapStartOptions filed"); + AppExecFwk::AsyncReject(env, callbackObj, aniObject); return; } errCode = context->StartAbility(want, startOptions); @@ -415,7 +431,11 @@ void EtsServiceExtensionContext::OnStartAbility( freeInstallObserver_->OnInstallFinished(bundleName, abilityName, startTime, errCode); } } else { - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + if (errCode != 0) { + AppExecFwk::AsyncReject(env, callbackObj, aniObject); + return; + } + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); } } @@ -474,7 +494,7 @@ void EtsServiceExtensionContext::OnDisconnectServiceExtensionAbility(ani_env *en if (context == nullptr) { TAG_LOGE(AAFwkTag::SERVICE_EXT, "null context"); errorObject = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); - AppExecFwk::AsyncCallback(env, callback, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callback, errorObject); return; } sptr connection = nullptr; @@ -496,11 +516,16 @@ void EtsServiceExtensionContext::OnDisconnectServiceExtensionAbility(ani_env *en if (!connection) { errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); - AppExecFwk::AsyncCallback(env, callback, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callback, errorObject); + return; + } + auto errCode = context->DisconnectAbility(want, connection, accountId); + if (errCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callback, nullptr); return; } - context->DisconnectAbility(want, connection, accountId); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode)); + AppExecFwk::AsyncReject(env, callback, errorObject); } @@ -519,7 +544,7 @@ void EtsServiceExtensionContext::OnOpenAtomicService( if (!AppExecFwk::GetStdString(env, aniAppId, appId)) { TAG_LOGE(AAFwkTag::SERVICE_EXT, "parse appId failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param appId failed, appId must be string."); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); return; } AAFwk::Want want; @@ -527,7 +552,7 @@ void EtsServiceExtensionContext::OnOpenAtomicService( if (!isOptionsUndefined && !AppExecFwk::UnwrapAtomicServiceOptions(env, optionsObj, want, startOptions)) { TAG_LOGE(AAFwkTag::SERVICE_EXT, "UnwrapAtomicServiceOptions failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapAtomicServiceOptions failed."); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); return; } OpenAtomicServiceInner(env, aniObj, want, startOptions, appId, callbackObj); @@ -563,7 +588,7 @@ void EtsServiceExtensionContext::OpenAtomicServiceInner(ani_env *env, ani_object freeInstallObserver_->OnInstallFinished(bundleName, abilityName, startTime, ErrCode); } else { TAG_LOGI(AAFwkTag::SERVICE_EXT, "OpenAtomicService success"); - AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ErrCode), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ErrCode)); } } diff --git a/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp b/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp index 19aaa94e99f..81b5a07e351 100644 --- a/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp +++ b/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp @@ -716,7 +716,12 @@ void EtsAbilityContext::OnStartAbility( } return; } - AppExecFwk::AsyncCallback(env, call, aniObject, nullptr); + if (innerErrCode == ERR_OK) { + TAG_LOGD(AAFwkTag::CONTEXT, "startAbility success"); + AppExecFwk::AsyncResolve(env, call, nullptr); + return; + } + AppExecFwk::AsyncReject(env, call, aniObject); } void EtsAbilityContext::OnStartAbilityForResult( @@ -831,8 +836,12 @@ void EtsAbilityContext::StartAbilityForResultInner(ani_env *env, const AAFwk::St return; } auto errCode = isInner ? resultCode : 0; - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateErrorByNativeErr(env, errCode), abilityResult); + if (errCode == 0) { + AppExecFwk::AsyncResolve(env, reinterpret_cast(callbackRef), abilityResult); + } else { + AppExecFwk::AsyncReject(env, + reinterpret_cast(callbackRef),EtsErrorUtil::CreateErrorByNativeErr(env, errCode)); + } }; auto requestCode = GenerateRequestCode(); (startOptionsObj == nullptr) ? context->StartAbilityForResult(want, requestCode, std::move(task)) @@ -844,25 +853,24 @@ void EtsAbilityContext::OnTerminateSelf(ani_env *env, ani_object aniObj, ani_obj { if (env == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null env or aniObj"); - ani_object aniObject = EtsErrorUtil::CreateInvalidParamError(env, "env null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); return; } ani_object aniObject = nullptr; auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "context null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + aniObject = EtsErrorUtil::CreateError( + env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } ErrCode ret = context->TerminateSelf(); - if (ret == static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT) || ret == ERR_OK) { - aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); + if (ret == ANI_OK) { + AppExecFwk::AsyncResolve(env, callback, nullptr); } else { aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callback, aniObject); } - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); } void EtsAbilityContext::OnTerminateSelfWithResult( @@ -870,16 +878,15 @@ void EtsAbilityContext::OnTerminateSelfWithResult( { if (env == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null env"); - ani_object aniObject = EtsErrorUtil::CreateInvalidParamError(env, "env null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); return; } ani_object aniObject = nullptr; auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "GetAbilityContext is nullptr"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "context null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + aniObject = EtsErrorUtil::CreateError( + env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } AAFwk::Want want; @@ -887,37 +894,36 @@ void EtsAbilityContext::OnTerminateSelfWithResult( AppExecFwk::UnWrapAbilityResult(env, abilityResult, resultCode, want); context->SetTerminating(true); ErrCode ret = context->TerminateAbilityWithResult(want, resultCode); - if (ret == static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT) || ret == ERR_OK) { - aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolve(env, callback, nullptr); } else { - aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, ret); + AppExecFwk::AsyncReject(env, callback, aniObject); } - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); } void EtsAbilityContext::OnReportDrawnCompleted(ani_env *env, ani_object aniObj, ani_object callback) { if (env == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null env"); - ani_object aniObject = EtsErrorUtil::CreateInvalidParamError(env, "env null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); return; } ani_object aniObject = nullptr; auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "context null"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "context null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + aniObject = EtsErrorUtil::CreateErrorByNativeErr( + env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } ErrCode ret = context->ReportDrawnCompleted(); if (ret == ERR_OK) { - aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); + AppExecFwk::AsyncResolve(env, callback, nullptr); } else { aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callback, aniObject); } - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); } void EtsAbilityContext::OnStartServiceExtensionAbility(ani_env *env, ani_object aniObj, ani_object wantObj, @@ -930,14 +936,14 @@ void EtsAbilityContext::OnStartServiceExtensionAbility(ani_env *env, ani_object TAG_LOGE(AAFwkTag::CONTEXT, "context is nullptr"); ret = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); errorObject = EtsErrorUtil::CreateError(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackobj, errorObject); return; } AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::CONTEXT, "UnwrapWant filed"); - errorObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant filed"); - AppExecFwk::AsyncCallback(env, callbackobj, errorObject, nullptr); + errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param want failed, want must be Want."); + AppExecFwk::AsyncReject(env, callbackobj, errorObject); } if (extensionType == AppExecFwk::ExtensionAbilityType::SERVICE) { ret = context->StartServiceExtensionAbility(want); @@ -946,10 +952,11 @@ void EtsAbilityContext::OnStartServiceExtensionAbility(ani_env *env, ani_object } if (ret == ERR_OK) { errorObject = EtsErrorUtil::CreateError(env, static_cast(ret)); + AppExecFwk::AsyncResolve(env, callbackobj, nullptr); } else { errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callbackobj, errorObject); } - AppExecFwk::AsyncCallback(env, callbackobj, errorObject, nullptr); } void EtsAbilityContext::OnStopServiceExtensionAbility(ani_env *env, ani_object aniObj, ani_object wantObj, @@ -963,14 +970,14 @@ void EtsAbilityContext::OnStopServiceExtensionAbility(ani_env *env, ani_object a TAG_LOGE(AAFwkTag::CONTEXT, "context is nullptr"); ret = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callbackobj, aniObject); return; } AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::CONTEXT, "UnwrapWant failed"); - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant failed"); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + aniObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param want failed, want must be Want."); + AppExecFwk::AsyncReject(env, callbackobj, aniObject); return; } if (extensionType == AppExecFwk::ExtensionAbilityType::SERVICE) { @@ -978,8 +985,12 @@ void EtsAbilityContext::OnStopServiceExtensionAbility(ani_env *env, ani_object a } else if (extensionType == AppExecFwk::ExtensionAbilityType::APP_SERVICE) { ret = context->StopAppServiceExtensionAbility(want); } - aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackobj, aniObject, nullptr); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackobj, nullptr); + } else { + aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callbackobj, aniObject); + } } static bool CheckUrl(std::string &urlValue) @@ -1005,7 +1016,7 @@ void EtsAbilityContext::OnOpenLink(ani_env *env, ani_object aniObj, ani_string a if (!AppExecFwk::GetStdString(env, aniLink, link) || !CheckUrl(link)) { TAG_LOGE(AAFwkTag::CONTEXT, "parse link failed"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param link failed, link must be string."); - AppExecFwk::AsyncCallback(env, myCallbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, myCallbackobj, aniObject); return; } if (haveOptionsParm) { @@ -1023,7 +1034,7 @@ void EtsAbilityContext::OnOpenLink(ani_env *env, ani_object aniObj, ani_string a TAG_LOGE(AAFwkTag::CONTEXT, "GetAbilityContext is nullptr"); ret = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, myCallbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, myCallbackobj, aniObject); return; } AddFreeInstallObserver(env, want, myCallbackobj, false, true); @@ -1032,12 +1043,12 @@ void EtsAbilityContext::OnOpenLink(ani_env *env, ani_object aniObj, ani_string a CreateOpenLinkTask(env, callbackobj, context, want, requestCode); } ret = context->OpenLink(want, requestCode); - if (ret == AAFwk::ERR_OPEN_LINK_START_ABILITY_DEFAULT_OK) { - aniObject = EtsErrorUtil::CreateError(env, static_cast(ERR_OK)); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolve(env, myCallbackobj, nullptr); } else { aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, myCallbackobj, aniObject); } - AppExecFwk::AsyncCallback(env, myCallbackobj, aniObject, nullptr); } bool EtsAbilityContext::OnIsTerminating(ani_env *env, ani_object aniObj) @@ -1057,16 +1068,20 @@ void EtsAbilityContext::OnMoveAbilityToBackground(ani_env *env, ani_object aniOb auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)), nullptr); + static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT))); return; } ErrCode ret = ERR_OK; ani_object errorObject = nullptr; ret = context->MoveUIAbilityToBackground(); - errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callback, errorObject, nullptr); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callback, errorObject); + } } void EtsAbilityContext::OnRequestModalUIExtension(ani_env *env, ani_object aniObj, ani_object pickerWantObj, @@ -1084,14 +1099,18 @@ void EtsAbilityContext::OnRequestModalUIExtension(ani_env *env, ani_object aniOb TAG_LOGE(AAFwkTag::CONTEXT, "null context"); errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); return; } ErrCode ret = ERR_OK; ret = AAFwk::AbilityManagerClient::GetInstance()->RequestModalUIExtension(want); - errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + } else { + errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); + } } void EtsAbilityContext::OnBackToCallerAbilityWithResult(ani_env *env, ani_object aniObj, @@ -1108,30 +1127,34 @@ void EtsAbilityContext::OnBackToCallerAbilityWithResult(ani_env *env, ani_object if (!OHOS::AppExecFwk::UnWrapAbilityResult(env, abilityResultObj, resultCode, want)) { TAG_LOGE(AAFwkTag::CONTEXT, "UnWrapAbilityResult failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Failed to parse abilityResult."); - AppExecFwk::AsyncCallback(env, callBackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callBackObj, errorObject); return; } std::string requestCodeStr; if (!AppExecFwk::GetStdString(env, requestCodeObj, requestCodeStr)) { TAG_LOGE(AAFwkTag::CONTEXT, "Failed to parse label"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Failed to parse label."); - AppExecFwk::AsyncCallback(env, callBackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callBackObj, errorObject); return; } auto requestCode = RequestCodeFromStringToInt64(requestCodeStr); auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); - AppExecFwk::AsyncCallback(env, callBackObj, + AppExecFwk::AsyncReject(env, callBackObj, EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)), nullptr); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT))); return; } ErrCode ret = ERR_OK; ret = context->BackToCallerAbilityWithResult(want, resultCode, requestCode); - errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callBackObj, errorObject, nullptr); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolveWithNoError(env, callBackObj, nullptr); + } else { + errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callBackObj, errorObject); + } } void EtsAbilityContext::OnSetMissionLabel(ani_env *env, ani_object aniObj, ani_string labelObj, @@ -1147,20 +1170,24 @@ void EtsAbilityContext::OnSetMissionLabel(ani_env *env, ani_object aniObj, ani_s if (!AppExecFwk::GetStdString(env, labelObj, label)) { TAG_LOGE(AAFwkTag::CONTEXT, "Failed to parse label"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Failed to parse label."); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); return; } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); - AppExecFwk::AsyncCallback(env, callbackObj, + AppExecFwk::AsyncReject(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)), nullptr); + static_cast(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT))); return; } auto errCode = context->SetMissionLabel(label); - errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode)); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + if (errCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + } else { + errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode)); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); + } } ani_long EtsAbilityContext::OnConnectServiceExtensionAbility(ani_env *env, ani_object aniObj, ani_object wantObj, @@ -1223,7 +1250,7 @@ void EtsAbilityContext::OnDisconnectServiceExtensionAbility(ani_env *env, ani_ob if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); errorObject = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); - AppExecFwk::AsyncCallback(env, callback, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callback, errorObject); return; } sptr connection = nullptr; @@ -1245,11 +1272,11 @@ void EtsAbilityContext::OnDisconnectServiceExtensionAbility(ani_env *env, ani_ob if (!connection) { errorObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); - AppExecFwk::AsyncCallback(env, callback, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callback, errorObject); return; } context->DisconnectAbility(want, connection, accountId); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK), nullptr); + AppExecFwk::AsyncResolve(env, callback, nullptr); } void EtsAbilityContext::OnSetColorMode(ani_env *env, ani_object aniObj, ani_enum_item colorMode) @@ -1333,7 +1360,7 @@ void EtsAbilityContext::OnOpenAtomicService( if (!AppExecFwk::GetStdString(env, aniAppId, appId)) { TAG_LOGE(AAFwkTag::CONTEXT, "parse appId failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param appId failed, appId must be string."); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); return; } AAFwk::Want want; @@ -1342,7 +1369,7 @@ void EtsAbilityContext::OnOpenAtomicService( if (!AppExecFwk::UnwrapAtomicServiceOptions(env, optionsObj, want, startOptions)) { TAG_LOGE(AAFwkTag::CONTEXT, "UnwrapAtomicServiceOptions failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapAtomicServiceOptions failed."); - AppExecFwk::AsyncCallback(env, callbackObj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObject); return; } } @@ -1398,20 +1425,24 @@ void EtsAbilityContext::OnStopServiceExtensionAbilityWithAccount(ani_env *env, a AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::CONTEXT, "Failed to UnwrapWant"); - AppExecFwk::AsyncCallback(env, callbackObj, + AppExecFwk::AsyncReject(env, callbackObj, EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant"), nullptr); return; } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callbackObj, + AppExecFwk::AsyncReject(env, callbackObj, EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); return; } auto innerErrCode = context->StopServiceExtensionAbility(want, aniAccountId); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode)), nullptr); + if (innerErrCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + return; + } + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode))); } void EtsAbilityContext::OnStartServiceExtensionAbilityWithAccount(ani_env *env, ani_object aniObj, ani_object wantObj, @@ -1421,20 +1452,24 @@ void EtsAbilityContext::OnStartServiceExtensionAbilityWithAccount(ani_env *env, AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::CONTEXT, "Failed to UnwrapWant"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant"), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant")); return; } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } auto innerErrCode = context->StartServiceExtensionAbility(want, aniAccountId); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode)), nullptr); + if (innerErrCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + return; + } + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode))); } void EtsAbilityContext::OnRevokeDelegator(ani_env *env, ani_object aniObj, ani_object callback) @@ -1445,15 +1480,17 @@ void EtsAbilityContext::OnRevokeDelegator(ani_env *env, ani_object aniObj, ani_o if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "context null"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "context null"); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } ErrCode innerErrCode = ERR_OK; innerErrCode = context->RevokeDelegator(); if (innerErrCode != ERR_OK) { TAG_LOGE(AAFwkTag::CONTEXT, "RevokeDelegator failed, innerErrCode: %{public}d", innerErrCode); + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode)); + } else { + AppExecFwk::AsyncResolve(env, callback, nullptr); } - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode), nullptr); } @@ -1491,8 +1528,8 @@ void EtsAbilityContext::OnStartAbilityForResultWithAccountInner(ani_env *env, co auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } std::string startTime = std::to_string(std::chrono::duration_cast(std::chrono:: @@ -1533,8 +1570,12 @@ void EtsAbilityContext::OnStartAbilityForResultWithAccountInner(ani_env *env, co return; } auto errCode = isInner ? resultCode : 0; - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateErrorByNativeErr(env, errCode), abilityResult); + if (errCode == 0) { + AppExecFwk::AsyncResolve(env, reinterpret_cast(callbackRef), abilityResult); + } else { + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), + EtsErrorUtil::CreateErrorByNativeErr(env, errCode)); + } }; auto requestCode = GenerateRequestCode(); (startOptionsObj == nullptr) ? context->StartAbilityForResultWithAccount(want, accountId, requestCode, @@ -1646,8 +1687,12 @@ void EtsAbilityContext::CreateOpenLinkTask(ani_env *env, const ani_object callba resultCode = ERR_INVALID_VALUE; } auto errCode = isInner ? resultCode : 0; - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateErrorByNativeErr(env, errCode), abilityResult); + if (errCode == 0) { + AppExecFwk::AsyncResolveWithNoError(env, reinterpret_cast(callbackRef), abilityResult); + } else { + AppExecFwk::AsyncReject(env, + reinterpret_cast(callbackRef), EtsErrorUtil::CreateErrorByNativeErr(env, errCode)); + } }; requestCode = GenerateRequestCode(); context->InsertResultCallbackTask(requestCode, std::move(task)); @@ -1728,18 +1773,18 @@ void EtsAbilityContext::NativeChangeAbilityVisibility(ani_env *env, ani_object a auto context = etsContext->context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "null context"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } bool showFlag = static_cast(isShow); ErrCode errCode = context->ChangeAbilityVisibility(showFlag); if (errCode != ERR_OK) { TAG_LOGE(AAFwkTag::CONTEXT, "failed, errCode: %{public}d", errCode); - AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, errCode), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, errCode)); return; } - AppExecFwk::AsyncCallback(env, callbackObj, EtsErrorUtil::CreateErrorByNativeErr(env, ERR_OK), nullptr); + AppExecFwk::AsyncResolveWithNoError(env, callbackObj, nullptr); } void EtsAbilityContext::OpenAtomicServiceInner(ani_env *env, ani_object aniObj, AAFwk::Want &want, @@ -1829,11 +1874,11 @@ void EtsAbilityContext::OnSetAbilityInstanceInfo(ani_env *env, ani_object aniObj ErrCode ret = context->SetAbilityInstanceInfo(label, icon); ani_object errorObj = nullptr; if (ret == ERR_OK) { - errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); + AppExecFwk::AsyncResolve(env, callback, nullptr); } else { errorObj = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); + AppExecFwk::AsyncReject(env, callback, errorObj); } - AppExecFwk::AsyncCallback(env, callback, errorObj, nullptr); } void EtsAbilityContext::OnSetMissionIcon(ani_env *env, ani_object aniObj, ani_object pixelMapObj, @@ -1842,20 +1887,24 @@ void EtsAbilityContext::OnSetMissionIcon(ani_env *env, ani_object aniObj, ani_ob auto pixelMap = OHOS::Media::PixelMapTaiheAni::GetNativePixelMap(env, pixelMapObj); if (pixelMap == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "Unwrap pixelMap failed"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM)); return; } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::CONTEXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } auto innerErrCode = context->SetMissionIcon(pixelMap); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode)), nullptr); + if (innerErrCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + } else { + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(innerErrCode))); + } } #endif @@ -1946,7 +1995,11 @@ void EtsAbilityContext::OnStartAbilityWithAccount( } return; } - AppExecFwk::AsyncCallback(env, call, aniObject, nullptr); + if (innerErrCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, call, nullptr); + } else { + AppExecFwk::AsyncReject(env, call, aniObject); + } } namespace { diff --git a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp index 197078cfbd3..e33b04df1ac 100644 --- a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp +++ b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp @@ -116,8 +116,12 @@ void EtsUIExtensionContentSession::NativeTerminateSelf(ani_env *env, ani_object auto etsContentSession = EtsUIExtensionContentSession::GetEtsContentSession(env, obj); if (etsContentSession != nullptr) { int32_t resultCode = etsContentSession->TerminateSelfWithResult(); - OHOS::AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(resultCode)), nullptr); + if (resultCode == 0) { + OHOS::AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); + } else { + OHOS::AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(resultCode))); + } } } @@ -137,8 +141,8 @@ int EtsUIExtensionContentSession::NativeTerminateSelfWithResult(ani_env *env, an auto context = etsContentSession->GetContext(); if (context == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "null context"); - OHOS::AppExecFwk::AsyncCallback(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + OHOS::AppExecFwk::AsyncReject(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return ERR_FAILURE; } auto token = context->GetToken(); @@ -146,24 +150,25 @@ int EtsUIExtensionContentSession::NativeTerminateSelfWithResult(ani_env *env, an auto uiWindow = etsContentSession->GetUIWindow(); if (uiWindow == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "null uiWindow"); - OHOS::AppExecFwk::AsyncCallback(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + OHOS::AppExecFwk::AsyncReject(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return ERR_FAILURE; } auto result = uiWindow->TransferAbilityResult(resultCode, want); if (result != Rosen::WMError::WM_OK) { TAG_LOGE(AAFwkTag::UI_EXT, "TransferAbilityResult failed, errorCode is %{public}d", result); - OHOS::AppExecFwk::AsyncCallback(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr); + OHOS::AppExecFwk::AsyncReject(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER))); return ERR_FAILURE; } ret = etsContentSession->TerminateSelfWithResult(); if (ret != 0) { TAG_LOGE(AAFwkTag::UI_EXT, "TerminateSelfWithResult failed, errorCode is %{public}d", ret); + OHOS::AppExecFwk::AsyncReject(env, callback, + OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return ERR_FAILURE; } - OHOS::AppExecFwk::AsyncCallback(env, callback, - OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + OHOS::AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); return ret; } @@ -705,14 +710,14 @@ void EtsUIExtensionContentSession::SetWindowPrivacyMode( if (env == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "null env"); errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER); - AppExecFwk::AsyncCallback(env, callbackObj, errorObj, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObj); return; } auto selfToken = IPCSkeleton::GetSelfTokenID(); int ret = Security::AccessToken::AccessTokenKit::VerifyAccessToken(selfToken, PERMISSION_PRIVACY_WINDOW); if (ret != Security::AccessToken::PermissionState::PERMISSION_GRANTED) { errorObj = EtsErrorUtil::CreateNoPermissionError(env, PERMISSION_PRIVACY_WINDOW); - AppExecFwk::AsyncCallback(env, callbackObj, errorObj, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObj); return; } ani_ref callbackRef = nullptr; @@ -720,14 +725,14 @@ void EtsUIExtensionContentSession::SetWindowPrivacyMode( if ((status = env->GlobalReference_Create(callbackObj, &callbackRef)) != ANI_OK || callbackRef == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "status: %{public}d", status); errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER); - AppExecFwk::AsyncCallback(env, callbackObj, errorObj, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObj); return; } ani_vm *etsVm = nullptr; if ((status = env->GetVM(&etsVm)) != ANI_OK || etsVm == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "status: %{public}d", status); errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER); - AppExecFwk::AsyncCallback(env, callbackObj, errorObj, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObj); return; } SetWindowPrivacyModeInner(env, isPrivacyMode, callbackObj, etsVm, callbackRef); @@ -748,25 +753,24 @@ void EtsUIExtensionContentSession::SetWindowPrivacyModeInner(ani_env *env, ani_b if (uiWindow == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "null uiWindow"); errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER); - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), errorObj, nullptr); + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), errorObj); env->GlobalReference_Delete(callbackRef); return; } auto ret = uiWindow->SetPrivacyMode(isPrivacyMode); if (ret == Rosen::WMError::WM_OK) { - errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), errorObj, nullptr); + AppExecFwk::AsyncResolveWithNoError(env, reinterpret_cast(callbackRef), nullptr); env->GlobalReference_Delete(callbackRef); } else { errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER); - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), errorObj, nullptr); + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), errorObj); env->GlobalReference_Delete(callbackRef); } }; if (AniTask::AniSendEvent(task) != ANI_OK) { TAG_LOGE(AAFwkTag::UI_EXT, "Failed to sendEvent"); errorObj = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER); - AppExecFwk::AsyncCallback(env, callbackObj, errorObj, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, errorObj); env->GlobalReference_Delete(callbackRef); } } diff --git a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp index 8c5652f6988..5c3e57bf4e9 100644 --- a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp +++ b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp @@ -272,13 +272,17 @@ void EtsUIExtensionContext::OnTerminateSelf(ani_env *env, ani_object obj, ani_ob TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); auto errCode = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(errCode)); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } context->SetTerminating(true); auto ret = context->TerminateSelf(); - OHOS::AppExecFwk::AsyncCallback(env, callback, - OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + if (ret == ERR_OK) { + OHOS::AppExecFwk::AsyncResolve(env, callback, nullptr); + } else { + OHOS::AppExecFwk::AsyncReject(env, callback, + OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); + } } void EtsUIExtensionContext::OnTerminateSelfWithResult(ani_env *env, ani_object obj, @@ -290,7 +294,7 @@ void EtsUIExtensionContext::OnTerminateSelfWithResult(ani_env *env, ani_object o TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); auto errCode = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(errCode)); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } @@ -303,24 +307,25 @@ void EtsUIExtensionContext::OnTerminateSelfWithResult(ani_env *env, ani_object o OHOS::sptr uiWindow = context->GetWindow(); if (!uiWindow) { TAG_LOGE(AAFwkTag::UI_EXT, "null uiWindow"); - OHOS::AppExecFwk::AsyncCallback(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM)), nullptr); + OHOS::AppExecFwk::AsyncReject(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM))); return; } auto result = uiWindow->TransferAbilityResult(resultCode, want); if (result != OHOS::Rosen::WMError::WM_OK) { - OHOS::AppExecFwk::AsyncCallback(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM)), nullptr); + OHOS::AppExecFwk::AsyncReject(env, callback, OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(OHOS::AbilityRuntime::AbilityErrorCode::ERROR_CODE_INVALID_PARAM))); return; } #endif // SUPPORT_SCREEN auto ret = context->TerminateSelf(); if (ret != 0) { TAG_LOGE(AAFwkTag::UI_EXT, "TerminateSelf failed, errorCode is %{public}d", ret); + OHOS::AppExecFwk::AsyncReject(env, callback, + OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret))); return; } - OHOS::AppExecFwk::AsyncCallback(env, callback, - OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)), nullptr); + OHOS::AppExecFwk::AsyncResolveWithNoError(env, callback, nullptr); } void EtsUIExtensionContext::OnStartAbility( @@ -330,8 +335,8 @@ void EtsUIExtensionContext::OnStartAbility( AAFwk::Want want; ErrCode errCode = ERR_OK; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { - aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant filed"); - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + EtsErrorUtil::ThrowInvalidParamError( + env, "Parse param want failed, want must be Want"); return; } auto context = context_.lock(); @@ -339,7 +344,7 @@ void EtsUIExtensionContext::OnStartAbility( TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); errCode = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(errCode)); - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, aniObject); return; } if ((want.GetFlags() & AAFwk::Want::FLAG_INSTALL_ON_DEMAND) == AAFwk::Want::FLAG_INSTALL_ON_DEMAND) { @@ -354,7 +359,7 @@ void EtsUIExtensionContext::OnStartAbility( if (!AppExecFwk::UnwrapStartOptions(env, opt, startOptions)) { TAG_LOGE(AAFwkTag::UI_EXT, "UnwrapStartOptions filed"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "UnwrapWant filed"); - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callbackObj, aniObject); return; } errCode = context->StartAbility(want, startOptions); @@ -370,7 +375,11 @@ void EtsUIExtensionContext::OnStartAbility( freeInstallObserver_->OnInstallFinished(bundleName, abilityName, startTime, errCode); } } else { - AppExecFwk::AsyncCallback(env, callbackObj, aniObject, nullptr); + if (errCode != ERR_OK) { + AppExecFwk::AsyncReject(env, callbackObj, aniObject); + } else { + AppExecFwk::AsyncResolveWithNoError(env, callbackObj, nullptr); + } } } @@ -380,8 +389,8 @@ void EtsUIExtensionContext::OnStartAbilityForResult(ani_env *env, ani_object ani auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callback, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callback, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } @@ -416,14 +425,18 @@ void EtsUIExtensionContext::OnStartAbilityForResult(ani_env *env, ani_object ani ani_object abilityResult = AppExecFwk::WrapAbilityResult(env, resultCode, want); if (abilityResult == nullptr) { TAG_LOGW(AAFwkTag::UI_EXT, "null abilityResult"); - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER), nullptr); + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER)); env->GlobalReference_Delete(callbackRef); return; } auto errCode = isInner ? resultCode : 0; - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateErrorByNativeErr(env, errCode), abilityResult); + if (isInner) { + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), + EtsErrorUtil::CreateErrorByNativeErr(env, errCode)); + } else { + AppExecFwk::AsyncResolve(env, reinterpret_cast(callbackRef), abilityResult); + } env->GlobalReference_Delete(callbackRef); }; want.SetParam(AAFwk::Want::PARAM_RESV_FOR_RESULT, true); @@ -488,7 +501,7 @@ void EtsUIExtensionContext::OnDisconnectServiceExtensionAbility(ani_env *env, an TAG_LOGE(AAFwkTag::UI_EXT, "null context"); aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); return; } AAFwk::Want want; @@ -507,13 +520,17 @@ void EtsUIExtensionContext::OnDisconnectServiceExtensionAbility(ani_env *env, an } if (!connection) { aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(AbilityErrorCode::ERROR_CODE_INNER)); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + AppExecFwk::AsyncReject(env, callback, aniObject); TAG_LOGE(AAFwkTag::UI_EXT, "null connection"); return; } ErrCode ret = context->DisconnectAbility(want, connection); aniObject = EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(ret)); - AppExecFwk::AsyncCallback(env, callback, aniObject, nullptr); + if (ret == ERR_OK) { + AppExecFwk::AsyncResolve(env, callback, nullptr); + return; + } + AppExecFwk::AsyncReject(env, callback, aniObject); } void EtsUIExtensionContext::OnOpenLink(ani_env *env, ani_object aniObj, ani_string aniLink, ani_object myCallbackobj, @@ -547,7 +564,7 @@ void EtsUIExtensionContext::OnOpenAtomicService( if (!AppExecFwk::GetStdString(env, aniAppId, appId)) { TAG_LOGE(AAFwkTag::UI_EXT, "parse appId failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param label failed, lable must be string."); - AppExecFwk::AsyncCallback(env, callbackobj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackobj, errorObject); return; } AAFwk::Want want; @@ -556,7 +573,7 @@ void EtsUIExtensionContext::OnOpenAtomicService( if (!AppExecFwk::UnwrapAtomicServiceOptions(env, optionsObj, want, startOptions)) { TAG_LOGE(AAFwkTag::UI_EXT, "UnWrapAtomicServiceOptions failed"); errorObject = EtsErrorUtil::CreateInvalidParamError(env, "UnWrapAtomicServiceOptions failed."); - AppExecFwk::AsyncCallback(env, callbackobj, errorObject, nullptr); + AppExecFwk::AsyncReject(env, callbackobj, errorObject); return; } } @@ -646,21 +663,25 @@ void EtsUIExtensionContext::OnStartServiceExtensionAbilityWithAccount(ani_env *e AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::UI_EXT, "Failed to UnwrapWant"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant"), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant")); return; } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } auto errCode = context->StartServiceExtensionAbility(want, aniAccountId); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode)), nullptr); + if (errCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + return; + } + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode))); } RuntimeTask EtsUIExtensionContext::CreateRuntimeTask(ani_vm *etsVm, ani_ref callbackRef) @@ -675,15 +696,20 @@ RuntimeTask EtsUIExtensionContext::CreateRuntimeTask(ani_vm *etsVm, ani_ref call ani_object abilityResult = AppExecFwk::WrapAbilityResult(env, resultCode, want); if (abilityResult == nullptr) { TAG_LOGW(AAFwkTag::UI_EXT, "null abilityResult"); - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER), nullptr); + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INNER)); env->GlobalReference_Delete(callbackRef); return; } int errCode = isInner ? resultCode : 0; - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - EtsErrorUtil::CreateErrorByNativeErr(env, errCode), abilityResult); + if (isInner) { + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), + EtsErrorUtil::CreateErrorByNativeErr(env, errCode)); + env->GlobalReference_Delete(callbackRef); + return; + } + AppExecFwk::AsyncResolve(env, reinterpret_cast(callbackRef), abilityResult); env->GlobalReference_Delete(callbackRef); }; } @@ -694,8 +720,8 @@ void EtsUIExtensionContext::OnStartAbilityForResultAsCaller(ani_env *env, ani_ob AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::UI_EXT, "Failed to UnwrapWant"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant"), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant")); return; } if (!want.HasParameter(AAFwk::Want::PARAM_BACK_TO_OTHER_MISSION_STACK)) { @@ -711,16 +737,16 @@ void EtsUIExtensionContext::OnStartAbilityForResultAsCaller(ani_env *env, ani_ob if (!isUndefined) { if (!AppExecFwk::UnwrapStartOptions(env, optionsObj, startOptions)) { TAG_LOGE(AAFwkTag::UI_EXT, "UnwrapStartOptions filed"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateInvalidParamError(env, "startOptions filed"), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateInvalidParamError(env, "startOptions filed")); return; } } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } #ifdef SUPPORT_SCREEN @@ -747,21 +773,25 @@ void EtsUIExtensionContext::OnStartServiceExtensionAbility(ani_env *env, ani_obj AAFwk::Want want; if (!AppExecFwk::UnwrapWant(env, wantObj, want)) { TAG_LOGE(AAFwkTag::UI_EXT, "Failed to UnwrapWant"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant"), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateInvalidParamError(env, "Failed to UnwrapWant")); return; } auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "context is nullptr"); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT), nullptr); + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)); return; } auto errCode = context->StartServiceExtensionAbility(want); - AppExecFwk::AsyncCallback(env, callbackObj, - EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode)), nullptr); + if (errCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callbackObj, nullptr); + return; + } + AppExecFwk::AsyncReject(env, callbackObj, + EtsErrorUtil::CreateErrorByNativeErr(env, static_cast(errCode))); } void EtsUIExtensionContext::OnSetHostPageOverlayForbidden(ani_env *env, ani_object aniObj, ani_boolean aniIsForbidden) @@ -807,7 +837,7 @@ void EtsUIExtensionContext::OpenLinkInner(ani_env *env, ani_object aniObj, ani_s if (!AppExecFwk::GetStdString(env, aniLink, link) || !CheckUrl(link)) { TAG_LOGE(AAFwkTag::UI_EXT, "parse link failed"); aniObject = EtsErrorUtil::CreateInvalidParamError(env, "Parse param link failed, link must be string."); - AppExecFwk::AsyncCallback(env, myCallbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, myCallbackobj, aniObject); return; } if (haveOptionsParm) { @@ -825,7 +855,7 @@ void EtsUIExtensionContext::OpenLinkInner(ani_env *env, ani_object aniObj, ani_s TAG_LOGE(AAFwkTag::UI_EXT, "GetAbilityContext is nullptr"); ErrCode = static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT); aniObject = EtsErrorUtil::CreateError(env, static_cast(ErrCode)); - AppExecFwk::AsyncCallback(env, myCallbackobj, aniObject, nullptr); + AppExecFwk::AsyncReject(env, myCallbackobj, aniObject); return; } AddFreeInstallObserver(env, want, myCallbackobj, context, false, true); @@ -873,8 +903,12 @@ void EtsUIExtensionContext::CreateOpenLinkTask(ani_env *env, const ani_object ca resultCode = ERR_INVALID_VALUE; } auto errCode = isInner ? resultCode : 0; - AppExecFwk::AsyncCallback(env, reinterpret_cast(callbackRef), - OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, errCode), abilityResult); + if (isInner) { + AppExecFwk::AsyncReject(env, reinterpret_cast(callbackRef), + OHOS::AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, errCode), nullptr); + return; + } + AppExecFwk::AsyncResolveWithNoError(env, reinterpret_cast(callbackRef), abilityResult); }; requestCode = context->GenerateCurRequestCode(); context->InsertResultCallbackTask(requestCode, std::move(task)); @@ -1000,14 +1034,18 @@ void EtsUIExtensionContext::OnReportDrawnCompleted(ani_env* env, ani_object aniC auto context = context_.lock(); if (context == nullptr) { TAG_LOGE(AAFwkTag::UI_EXT, "null context"); - AppExecFwk::AsyncCallback(env, callback, + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT)), nullptr); + static_cast(AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT))); return; } int32_t innerErrorCode = context->ReportDrawnCompleted(); - AppExecFwk::AsyncCallback(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, - static_cast(innerErrorCode)), nullptr); + if (innerErrorCode == ERR_OK) { + AppExecFwk::AsyncResolve(env, callback, nullptr); + } else { + AppExecFwk::AsyncReject(env, callback, AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, + static_cast(innerErrorCode))); + } TAG_LOGD(AAFwkTag::UI_EXT, "NativeReportDrawnCompleted end"); } diff --git a/frameworks/ets/ani/uri_permission_manager/src/ets_uri_perm_mgr.cpp b/frameworks/ets/ani/uri_permission_manager/src/ets_uri_perm_mgr.cpp index 1931ee8a81f..3f528d20693 100644 --- a/frameworks/ets/ani/uri_permission_manager/src/ets_uri_perm_mgr.cpp +++ b/frameworks/ets/ani/uri_permission_manager/src/ets_uri_perm_mgr.cpp @@ -89,7 +89,7 @@ static void grantUriPermissionCallbackSync([[maybe_unused]]ani_env *env, } if (appCloneIndex < 0) { TAG_LOGE(AAFwkTag::URIPERMMGR, "appCloneIndex invalid"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_PARAM), "Param appCloneIndex is invalid, the value less than 0."), CreateDouble(env, ERR_FAILURE)); @@ -101,7 +101,7 @@ static void grantUriPermissionCallbackSync([[maybe_unused]]ani_env *env, TAG_LOGE(AAFwkTag::URIPERMMGR, "app not system-app"); etsErrCode = EtsErrorUtil::CreateError(env, static_cast(AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP), NOT_SYSTEM_APP); - AppExecFwk::AsyncCallback(env, callback, etsErrCode, CreateDouble(env, ERR_FAILURE)); + AppExecFwk::AsyncReject(env, callback, etsErrCode); return; } std::string uriStr = GetStdString(env, uri); @@ -116,9 +116,11 @@ static void grantUriPermissionCallbackSync([[maybe_unused]]ani_env *env, if (errCode != ERR_OK) { result = ERR_FAILURE; etsErrCode = EtsErrorUtil::CreateErrorByNativeErr(env, errCode); + AppExecFwk::AsyncReject(env, callback, etsErrCode); + return; } - AppExecFwk::AsyncCallback(env, callback, etsErrCode, CreateDouble(env, result)); + AppExecFwk::AsyncResolveWithNoError(env, callback, CreateDouble(env, result)); } static void revokeUriPermissionCallbackSync([[maybe_unused]]ani_env *env, @@ -131,10 +133,9 @@ static void revokeUriPermissionCallbackSync([[maybe_unused]]ani_env *env, } if (appCloneIndex < 0) { TAG_LOGE(AAFwkTag::URIPERMMGR, "appCloneIndex invalid"); - AppExecFwk::AsyncCallback(env, callback, EtsErrorUtil::CreateError(env, + AppExecFwk::AsyncReject(env, callback, EtsErrorUtil::CreateError(env, static_cast(AbilityErrorCode::ERROR_CODE_INVALID_PARAM), - "Param appCloneIndex is invalid, the value less than 0."), - CreateDouble(env, ERR_FAILURE)); + "Param appCloneIndex is invalid, the value less than 0.")); return; } auto selfToken = IPCSkeleton::GetSelfTokenID(); @@ -143,7 +144,7 @@ static void revokeUriPermissionCallbackSync([[maybe_unused]]ani_env *env, TAG_LOGE(AAFwkTag::URIPERMMGR, "app not system-app"); etsErrCode = EtsErrorUtil::CreateError(env, static_cast(AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP), NOT_SYSTEM_APP); - AppExecFwk::AsyncCallback(env, callback, etsErrCode, CreateDouble(env, ERR_FAILURE)); + AppExecFwk::AsyncReject(env, callback, etsErrCode); return; } std::string uriStr = GetStdString(env, uri); @@ -155,8 +156,10 @@ static void revokeUriPermissionCallbackSync([[maybe_unused]]ani_env *env, if (errCode != ERR_OK) { result = ERR_FAILURE; etsErrCode = EtsErrorUtil::CreateErrorByNativeErr(env, errCode); + AppExecFwk::AsyncReject(env, callback, etsErrCode); + return; } - AppExecFwk::AsyncCallback(env, callback, etsErrCode, CreateDouble(env, result)); + AppExecFwk::AsyncResolveWithNoError(env, callback, CreateDouble(env, result)); } void EtsUriPermissionManagerInit(ani_env *env) diff --git a/frameworks/ets/ani/wantagent/src/ani_want_agent.cpp b/frameworks/ets/ani/wantagent/src/ani_want_agent.cpp index 34dcc150e4a..5510a263206 100644 --- a/frameworks/ets/ani/wantagent/src/ani_want_agent.cpp +++ b/frameworks/ets/ani/wantagent/src/ani_want_agent.cpp @@ -238,9 +238,11 @@ void EtsWantAgent::OnGetBundleName(ani_env *env, ani_object agent, ani_object ca ani_object error = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); if (resultCode != ERR_OK) { error = EtsErrorUtil::CreateError(env, resultCode, AbilityRuntimeErrorUtil::GetErrMessage(resultCode)); + AsyncReject(env, call, error); + } else { + ani_string aniBundleName = GetAniString(env, bundleName); + AsyncResolveWithNoError(env, call, reinterpret_cast(aniBundleName)); } - ani_string aniBundleName = GetAniString(env, bundleName); - AsyncCallback(env, call, error, reinterpret_cast(aniBundleName)); } void EtsWantAgent::OnGetUid(ani_env *env, ani_object agent, ani_object call) @@ -262,8 +264,10 @@ void EtsWantAgent::OnGetUid(ani_env *env, ani_object agent, ani_object call) ani_object error = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); if (resultCode != ERR_OK) { error = EtsErrorUtil::CreateError(env, resultCode, AbilityRuntimeErrorUtil::GetErrMessage(resultCode)); + AsyncReject(env, call, error); + } else { + AsyncResolveWithNoError(env, call, CreateInt(env, uid)); } - AsyncCallback(env, call, error, CreateInt(env, uid)); } void EtsWantAgent::OnCancel(ani_env *env, ani_object agent, ani_object call) @@ -284,8 +288,10 @@ void EtsWantAgent::OnCancel(ani_env *env, ani_object agent, ani_object call) ani_object error = EtsErrorUtil::CreateError(env, AbilityErrorCode::ERROR_OK); if (resultCode != NO_ERROR) { error = EtsErrorUtil::CreateError(env, resultCode, AbilityRuntimeErrorUtil::GetErrMessage(resultCode)); + AsyncReject(env, call, error); + } else { + AsyncResolveWithNoError(env, call, nullptr); } - AsyncCallback(env, call, error, nullptr); } void EtsWantAgent::OnEqual(ani_env *env, ani_object agent, ani_object otherAgent, ani_object call) @@ -310,12 +316,14 @@ void EtsWantAgent::OnEqual(ani_env *env, ani_object agent, ani_object otherAgent bool ret = false; if (resultCode == ERR_NOT_OK) { ret = false; + AsyncResolveWithNoError(env, call, CreateBoolean(env, static_cast(ret))); } else if (resultCode == ERR_OK) { ret = true; + AsyncResolveWithNoError(env, call, CreateBoolean(env, static_cast(ret))); } else { error = EtsErrorUtil::CreateError(env, resultCode, AbilityRuntimeErrorUtil::GetErrMessage(resultCode)); + AsyncReject(env, call, error); } - AsyncCallback(env, call, error, CreateBoolean(env, static_cast(ret))); } void EtsWantAgent::OnGetWant(ani_env *env, ani_object agent, ani_object call) @@ -345,10 +353,11 @@ void EtsWantAgent::OnGetWant(ani_env *env, ani_object agent, ani_object call) if (retCode != NO_ERROR) { error = EtsErrorUtil::CreateError(env, retCode, AbilityRuntimeErrorUtil::GetErrMessage(retCode)); wantAniObj = WrapWant(env, AAFwk::Want()); + AsyncReject(env, call, error); } else { wantAniObj = WrapWant(env, *want); + AsyncResolve(env, call, wantAniObj); } - AsyncCallback(env, call, error, wantAniObj); } void EtsWantAgent::OnGetOperationType(ani_env *env, ani_object agent, ani_object call) diff --git a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets index de13d525636..c97d15f96a9 100644 --- a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets +++ b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets @@ -74,18 +74,14 @@ export default namespace abilityManager { reject(err); } }); - taskpool.execute((): void => { - abilityManager.nativeGetTopAbility(myCall); - }); + abilityManager.nativeGetTopAbility(myCall); }); return p; } export function getTopAbility(callback: AsyncCallback): void { let myCall = new AsyncCallbackWrapper(callback); - taskpool.execute( (): void => { - abilityManager.nativeGetTopAbility(myCall); - }); + abilityManager.nativeGetTopAbility(myCall); } function getAbilityRunningInfos(): Promise> { -- Gitee