From 23fcea662698ba9a723e6e1349de88979974d3bd Mon Sep 17 00:00:00 2001 From: wangkailong Date: Sun, 17 Sep 2023 16:17:02 +0800 Subject: [PATCH] napi2 Signed-off-by: wangkailong Change-Id: If17bb87d3975f66400b1209f5b3675bde2eb5e24 --- frameworks/js/napi/ability/ability_module.cpp | 29 +- .../ability_data_uri_utils_module.cpp | 13 +- .../ability_context_module.cpp | 13 +- .../action_extension_ability_module.cpp | 13 +- .../js_ability_delegator.cpp | 844 +++++++++--------- .../ability_delegator/js_ability_delegator.h | 180 ++-- .../js_ability_delegator_registry.cpp | 82 +- .../js_ability_delegator_registry.h | 4 +- .../js_ability_delegator_utils.cpp | 102 ++- .../js_ability_delegator_utils.h | 8 +- .../ability_delegator/js_ability_monitor.cpp | 24 +- .../ability_delegator/js_ability_monitor.h | 14 +- .../app/ability_delegator/native_module.cpp | 30 +- .../ability_stage/ability_stage_module.cpp | 24 +- .../ability_stage_context_module.cpp | 14 +- .../app/app_manager/js_app_state_observer.cpp | 2 +- .../application_context_module.cpp | 14 +- .../js/napi/app/context/context_module.cpp | 14 +- .../error_manager/error_manager_module.cpp | 35 +- .../app/error_manager/js_error_manager.cpp | 148 ++- .../napi/app/error_manager/js_error_manager.h | 2 +- .../app/error_manager/js_error_observer.cpp | 74 +- .../app/error_manager/js_error_observer.h | 10 +- .../js_app_manager/js_app_state_observer.cpp | 2 +- .../js/napi/app/recovery/app_recovery_api.cpp | 160 ++-- .../js/napi/app/recovery/app_recovery_api.h | 2 +- .../napi/app/recovery/app_recovery_module.cpp | 15 +- .../app/test_runner/test_runner_module.cpp | 14 +- frameworks/js/napi/callee/callee_module.cpp | 13 +- frameworks/js/napi/caller/caller_module.cpp | 13 +- .../dataUriUtils/data_uri_utils_module.cpp | 13 +- .../include/request_info.h | 8 +- .../napi/dialog_request_info/request_info.cpp | 63 +- .../extension_ability_module.cpp | 13 +- .../extension_context_module.cpp | 13 +- .../include/js_dialog_request.h | 2 +- .../include/js_dialog_request_callback.h | 2 +- .../js_dialog_request/js_dialog_request.cpp | 92 +- .../js_dialog_request_callback.cpp | 67 +- .../napi/js_dialog_request/native_module.cpp | 15 +- .../js_application_quick_fix_info.cpp | 44 +- .../quick_fix/js_application_quick_fix_info.h | 6 +- .../napi/quick_fix/js_quick_fix_manager.cpp | 127 ++- .../js/napi/quick_fix/js_quick_fix_manager.h | 2 +- .../js/napi/quick_fix/native_module.cpp | 18 +- .../service_extension_ability_module.cpp | 26 +- .../service_extension_context_module.cpp | 13 +- .../share_extension_ability_module.cpp | 13 +- .../ui_extension_ability_module.cpp | 13 +- .../ui_extension_context_module.cpp | 13 +- .../napi/uri_permission/js_uri_perm_mgr.cpp | 129 ++- .../js/napi/uri_permission/js_uri_perm_mgr.h | 2 +- .../js/napi/uri_permission/native_module.cpp | 15 +- .../simulator/common/include/request_info.h | 4 +- 54 files changed, 1269 insertions(+), 1356 deletions(-) diff --git a/frameworks/js/napi/ability/ability_module.cpp b/frameworks/js/napi/ability/ability_module.cpp index 3c7a4c1a6a1..6a1286a5077 100644 --- a/frameworks/js/napi/ability/ability_module.cpp +++ b/frameworks/js/napi/ability/ability_module.cpp @@ -21,16 +21,14 @@ extern const char _binary_ability_abc_start[]; extern const char _binary_ability_abc_end[]; #ifdef ENABLE_ERRCODE -extern "C" __attribute__((constructor)) -void NAPI_app_ability_UIAbility_AutoRegister() +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.UIAbility", + .nm_filename = "app/ability/libability.so/ability.js", +}; +extern "C" __attribute__((constructor)) void NAPI_app_ability_UIAbility_AutoRegister(void) { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.UIAbility", - .fileName = "app/ability/libability.so/ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) @@ -57,16 +55,15 @@ void NAPI_app_ability_UIAbility_GetABCCode(const char **buf, int *buflen) } } #else +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.Ability", + .nm_filename = "application/libability_napi.so/ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_Ability_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.Ability", - .fileName = "application/libability_napi.so/ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/abilityDataUriUtils/ability_data_uri_utils_module.cpp b/frameworks/js/napi/abilityDataUriUtils/ability_data_uri_utils_module.cpp index c4e1795a191..6b2f2031a15 100644 --- a/frameworks/js/napi/abilityDataUriUtils/ability_data_uri_utils_module.cpp +++ b/frameworks/js/napi/abilityDataUriUtils/ability_data_uri_utils_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_ability_data_uri_utils_js_end[]; extern const char _binary_ability_data_uri_utils_abc_start[]; extern const char _binary_ability_data_uri_utils_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.dataUriUtils", + .nm_filename = "app/ability/libdatauriutils.so/ability_data_uri_utils.js", +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_dataUriUtils_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.dataUriUtils", - .fileName = "app/ability/libdatauriutils.so/ability_data_uri_utils.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/ability_context/ability_context_module.cpp b/frameworks/js/napi/ability_context/ability_context_module.cpp index 0b273f5e87a..574cd31479d 100644 --- a/frameworks/js/napi/ability_context/ability_context_module.cpp +++ b/frameworks/js/napi/ability_context/ability_context_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_ability_context_js_end[]; extern const char _binary_ability_context_abc_start[]; extern const char _binary_ability_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.AbilityContext", + .nm_filename = "application/libabilitycontext_napi.so/ability_context.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_AbilityContext_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.AbilityContext", - .fileName = "application/libabilitycontext_napi.so/ability_context.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/action_extension_ability/action_extension_ability_module.cpp b/frameworks/js/napi/action_extension_ability/action_extension_ability_module.cpp index b569418158b..fde71d2c1c9 100644 --- a/frameworks/js/napi/action_extension_ability/action_extension_ability_module.cpp +++ b/frameworks/js/napi/action_extension_ability/action_extension_ability_module.cpp @@ -20,15 +20,14 @@ extern const char _binary_action_extension_ability_js_end[]; extern const char _binary_action_extension_ability_abc_start[]; extern const char _binary_action_extension_ability_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.ActionExtensionAbility", + .nm_filename = "app/ability/libactionextensionability_napi.so/action_extension_ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_ActionExtensionAbility_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.ActionExtensionAbility", - .fileName = "app/ability/libactionextensionability_napi.so/action_extension_ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) void NAPI_app_ability_ActionExtensionAbility_GetJSCode( diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_delegator.cpp b/frameworks/js/napi/app/ability_delegator/js_ability_delegator.cpp index c093a1c30ea..3d8da3aa476 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_delegator.cpp +++ b/frameworks/js/napi/app/ability_delegator/js_ability_delegator.cpp @@ -21,8 +21,9 @@ #include "hilog_wrapper.h" #include "js_ability_delegator_utils.h" #include "js_context_utils.h" -#include "js_runtime_utils.h" +#include "js_error_utils.h" #include "napi_common_want.h" +#include "napi_common_util.h" #include "napi_remote_object.h" #include "shell_cmd_result.h" @@ -66,33 +67,33 @@ constexpr int COMMON_FAILED = 16000100; constexpr int COMMON_FAILED = -1; #endif -NativeValue *ThrowJsError(NativeEngine& engine, int32_t errCode) +napi_value ThrowJsError(napi_env env, int32_t errCode) { #ifdef ENABLE_ERRCODE - NativeValue *error = CreateJsError(engine, errCode, errorMap[errCode]); - engine.Throw(error); + napi_value error = CreateJsError(env, errCode, errorMap[errCode]); + napi_throw(env, error); #endif - return engine.CreateUndefined(); + return CreateJsUndefined(env); } -void ResolveWithNoError(NativeEngine &engine, AsyncTask &task, NativeValue *value = nullptr) +void ResolveWithNoError(napi_env env, NapiAsyncTask &task, napi_value value = nullptr) { #ifdef ENABLE_ERRCODE if (value == nullptr) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.ResolveWithNoError(engine, value); + task.ResolveWithNoError(env, value); } #else if (value == nullptr) { - task.Resolve(engine, engine.CreateNull()); + task.Resolve(env, CreateJsNull(env)); } else { - task.Resolve(engine, value); + task.Resolve(env, value); } #endif } -NativeValue *AttachAppContext(NativeEngine *engine, void *value, void *) +napi_value AttachAppContext(napi_env env, void *value, void *) { HILOG_INFO("AttachAppContext"); if (value == nullptr) { @@ -105,17 +106,14 @@ NativeValue *AttachAppContext(NativeEngine *engine, void *value, void *) return nullptr; } - NativeValue *object = CreateJsBaseContext(*engine, ptr, true); - NativeObject *nObject = ConvertNativeValueTo(object); - nObject->ConvertToNativeBindingObject(engine, DetachCallbackFunc, AttachAppContext, value, nullptr); + napi_value object = CreateJsBaseContext(env, ptr, true); + napi_coerce_to_native_binding_object(env, object, DetachCallbackFunc, AttachAppContext, value, nullptr); auto workContext = new (std::nothrow) std::weak_ptr(ptr); - nObject->SetNativePointer( - workContext, - [](NativeEngine *, void *data, void *) { + napi_wrap(env, object, workContext, + [](napi_env, void *data, void *) { HILOG_INFO("Finalizer for weak_ptr app context is called"); delete static_cast *>(data); - }, - nullptr); + }, nullptr, nullptr); return object; } @@ -144,271 +142,252 @@ JSAbilityDelegator::JSAbilityDelegator() } } -void JSAbilityDelegator::Finalizer(NativeEngine *engine, void *data, void *hint) +void JSAbilityDelegator::Finalizer(napi_env env, void *data, void *hint) { HILOG_INFO("enter"); std::unique_ptr(static_cast(data)); } -NativeValue *JSAbilityDelegator::AddAbilityMonitor(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::AddAbilityMonitor(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnAddAbilityMonitor(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnAddAbilityMonitor); } -NativeValue *JSAbilityDelegator::AddAbilityMonitorSync(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::AddAbilityMonitorSync(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnAddAbilityMonitorSync(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnAddAbilityMonitorSync); } -NativeValue *JSAbilityDelegator::RemoveAbilityMonitor(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::RemoveAbilityMonitor(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRemoveAbilityMonitor(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnRemoveAbilityMonitor); } -NativeValue *JSAbilityDelegator::RemoveAbilityMonitorSync(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::RemoveAbilityMonitorSync(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRemoveAbilityMonitorSync(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnRemoveAbilityMonitorSync); } -NativeValue *JSAbilityDelegator::WaitAbilityMonitor(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::WaitAbilityMonitor(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnWaitAbilityMonitor(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnWaitAbilityMonitor); } -NativeValue *JSAbilityDelegator::AddAbilityStageMonitor(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::AddAbilityStageMonitor(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnAddAbilityStageMonitor(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnAddAbilityStageMonitor); } -NativeValue *JSAbilityDelegator::AddAbilityStageMonitorSync(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::AddAbilityStageMonitorSync(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnAddAbilityStageMonitorSync(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnAddAbilityStageMonitorSync); } -NativeValue *JSAbilityDelegator::RemoveAbilityStageMonitor(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::RemoveAbilityStageMonitor(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRemoveAbilityStageMonitor(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnRemoveAbilityStageMonitor); } -NativeValue *JSAbilityDelegator::RemoveAbilityStageMonitorSync(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::RemoveAbilityStageMonitorSync(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRemoveAbilityStageMonitorSync(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnRemoveAbilityStageMonitorSync); } -NativeValue *JSAbilityDelegator::WaitAbilityStageMonitor(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::WaitAbilityStageMonitor(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnWaitAbilityStageMonitor(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnWaitAbilityStageMonitor); } -NativeValue *JSAbilityDelegator::GetAppContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::GetAppContext(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetAppContext(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnGetAppContext); } -NativeValue *JSAbilityDelegator::GetAbilityState(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::GetAbilityState(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetAbilityState(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnGetAbilityState); } -NativeValue *JSAbilityDelegator::GetCurrentTopAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::GetCurrentTopAbility(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetCurrentTopAbility(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnGetCurrentTopAbility); } -NativeValue *JSAbilityDelegator::StartAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::StartAbility(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnStartAbility(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnStartAbility); } -NativeValue *JSAbilityDelegator::DoAbilityForeground(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::DoAbilityForeground(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnDoAbilityForeground(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnDoAbilityForeground); } -NativeValue *JSAbilityDelegator::DoAbilityBackground(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::DoAbilityBackground(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnDoAbilityBackground(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnDoAbilityBackground); } -NativeValue *JSAbilityDelegator::Print(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::Print(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnPrint(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnPrint); } -NativeValue *JSAbilityDelegator::PrintSync(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::PrintSync(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnPrintSync(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnPrintSync); } -NativeValue *JSAbilityDelegator::ExecuteShellCommand(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::ExecuteShellCommand(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnExecuteShellCommand(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnExecuteShellCommand); } -NativeValue *JSAbilityDelegator::FinishTest(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::FinishTest(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnFinishTest(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnFinishTest); } -NativeValue *JSAbilityDelegator::SetMockList(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JSAbilityDelegator::SetMockList(napi_env env, napi_callback_info info) { - JSAbilityDelegator *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnSetMockList(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JSAbilityDelegator, OnSetMockList); } -NativeValue *JSAbilityDelegator::OnAddAbilityMonitor(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnAddAbilityMonitor(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::shared_ptr monitor = nullptr; - if (!ParseAbilityMonitorPara(engine, info, monitor, false)) { + if (!ParseAbilityMonitorPara(env, info, monitor, false)) { HILOG_ERROR("Parse addAbilityMonitor parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [monitor](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnAddAbilityMonitor AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [monitor](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnAddAbilityMonitor NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "addAbilityMonitor failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "addAbilityMonitor failed.")); return; } delegator->AddAbilityMonitor(monitor); - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnAddAbilityMonitor", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnAddAbilityMonitor", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnAddAbilityMonitorSync(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnAddAbilityMonitorSync(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::shared_ptr monitor = nullptr; - if (!ParseAbilityMonitorPara(engine, info, monitor, true)) { + if (!ParseAbilityMonitorPara(env, info, monitor, true)) { HILOG_ERROR("Parse addAbilityMonitorSync parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (delegator) { delegator->AddAbilityMonitor(monitor); } else { - engine.Throw(CreateJsError(engine, COMMON_FAILED, "addAbilityMonitor failed.")); + ThrowError(env, COMMON_FAILED, "addAbilityMonitor failed."); } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } -NativeValue *JSAbilityDelegator::OnAddAbilityStageMonitor(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnAddAbilityStageMonitor(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); bool isExisted = false; std::shared_ptr monitor = nullptr; - if (!ParseAbilityStageMonitorPara(engine, info, monitor, isExisted, false)) { + if (!ParseAbilityStageMonitorPara(env, info, monitor, isExisted, false)) { HILOG_ERROR("Parse addAbilityStageMonitor parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [monitor](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnAddAbilityStageMonitor AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [monitor](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnAddAbilityStageMonitor NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "addAbilityStageMonitor failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "addAbilityStageMonitor failed.")); return; } delegator->AddAbilityStageMonitor(monitor); - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnAddAbilityStageMonitor", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnAddAbilityStageMonitor", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); if (!isExisted) { - AddStageMonitorRecord(engine, info.argv[INDEX_ZERO], monitor); + AddStageMonitorRecord(env, info.argv[INDEX_ZERO], monitor); } return result; } -NativeValue *JSAbilityDelegator::OnAddAbilityStageMonitorSync(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnAddAbilityStageMonitorSync(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); bool isExisted = false; std::shared_ptr monitor = nullptr; - if (!ParseAbilityStageMonitorPara(engine, info, monitor, isExisted, true)) { + if (!ParseAbilityStageMonitorPara(env, info, monitor, isExisted, true)) { HILOG_ERROR("Parse addAbilityStageMonitorSync parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - engine.Throw(CreateJsError(engine, COMMON_FAILED, "addAbilityStageMonitor failed.")); - return engine.CreateUndefined(); + ThrowError(env, COMMON_FAILED, "addAbilityStageMonitor failed."); + return CreateJsUndefined(env); } delegator->AddAbilityStageMonitor(monitor); if (!isExisted) { - AddStageMonitorRecord(engine, info.argv[INDEX_ZERO], monitor); + AddStageMonitorRecord(env, info.argv[INDEX_ZERO], monitor); } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } -NativeValue *JSAbilityDelegator::OnRemoveAbilityMonitor(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnRemoveAbilityMonitor(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::shared_ptr monitor = nullptr; - if (!ParseAbilityMonitorPara(engine, info, monitor, false)) { + if (!ParseAbilityMonitorPara(env, info, monitor, false)) { HILOG_ERROR("Parse removeAbilityMonitor parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = - [monitor](NativeEngine &engine, AsyncTask &task, int32_t status) mutable { - HILOG_INFO("OnRemoveAbilityMonitor AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = + [monitor](napi_env env, NapiAsyncTask &task, int32_t status) mutable { + HILOG_INFO("OnRemoveAbilityMonitor NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "removeAbilityMonitor failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "removeAbilityMonitor failed.")); return; } delegator->RemoveAbilityMonitor(monitor); - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnRemoveAbilityMonitor", - engine, CreateAsyncTaskWithLastParam(engine, + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnRemoveAbilityMonitor", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); if (AbilityDelegatorRegistry::GetAbilityDelegator()) { for (auto iter = g_monitorRecord.begin(); iter != g_monitorRecord.end(); ++iter) { std::shared_ptr jsMonitor = iter->first; - if ((info.argv[INDEX_ZERO])->StrictEquals(jsMonitor->Get())) { + bool isEquals = false; + napi_strict_equals(env, (info.argv[INDEX_ZERO]), jsMonitor->GetNapiValue(), &isEquals); + if (isEquals) { g_monitorRecord.erase(iter); break; } @@ -418,112 +397,114 @@ NativeValue *JSAbilityDelegator::OnRemoveAbilityMonitor(NativeEngine &engine, Na } -NativeValue *JSAbilityDelegator::OnRemoveAbilityMonitorSync(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnRemoveAbilityMonitorSync(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::shared_ptr monitor = nullptr; - if (!ParseAbilityMonitorPara(engine, info, monitor, true)) { + if (!ParseAbilityMonitorPara(env, info, monitor, true)) { HILOG_ERROR("Parse removeAbilityMonitorSync parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - engine.Throw(CreateJsError(engine, COMMON_FAILED, "removeAbilityMonitor failed.")); - return engine.CreateUndefined(); + ThrowError(env, COMMON_FAILED, "removeAbilityMonitor failed."); + return CreateJsUndefined(env); } delegator->RemoveAbilityMonitor(monitor); for (auto iter = g_monitorRecord.begin(); iter != g_monitorRecord.end(); ++iter) { std::shared_ptr jsMonitor = iter->first; - if ((info.argv[INDEX_ZERO])->StrictEquals(jsMonitor->Get())) { + bool isEquals = false; + napi_strict_equals(env, (info.argv[INDEX_ZERO]), jsMonitor->GetNapiValue(), &isEquals); + if (isEquals) { g_monitorRecord.erase(iter); break; } } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } -NativeValue *JSAbilityDelegator::OnRemoveAbilityStageMonitor(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnRemoveAbilityStageMonitor(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); bool isExisted = false; std::shared_ptr monitor = nullptr; - if (!ParseAbilityStageMonitorPara(engine, info, monitor, isExisted, false)) { + if (!ParseAbilityStageMonitorPara(env, info, monitor, isExisted, false)) { HILOG_ERROR("Parse removeAbilityStageMonitor parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = - [monitor](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnRemoveAbilityStageMonitor AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = + [monitor](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnRemoveAbilityStageMonitor NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "removeAbilityStageMonitor failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "removeAbilityStageMonitor failed.")); return; } delegator->RemoveAbilityStageMonitor(monitor); - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnRemoveAbilityStageMonitor", engine, - CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnRemoveAbilityStageMonitor", env, + CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); if (isExisted) { - RemoveStageMonitorRecord(info.argv[INDEX_ZERO]); + RemoveStageMonitorRecord(env, info.argv[INDEX_ZERO]); } return result; } -NativeValue *JSAbilityDelegator::OnRemoveAbilityStageMonitorSync(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnRemoveAbilityStageMonitorSync(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); bool isExisted = false; std::shared_ptr monitor = nullptr; - if (!ParseAbilityStageMonitorPara(engine, info, monitor, isExisted, true)) { + if (!ParseAbilityStageMonitorPara(env, info, monitor, isExisted, true)) { HILOG_ERROR("Parse removeAbilityStageMonitorSync parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - engine.Throw(CreateJsError(engine, COMMON_FAILED, "removeAbilityStageMonitor failed.")); - return engine.CreateUndefined(); + ThrowError(env, COMMON_FAILED, "removeAbilityStageMonitor failed."); + return CreateJsUndefined(env); } delegator->RemoveAbilityStageMonitor(monitor); if (isExisted) { - RemoveStageMonitorRecord(info.argv[INDEX_ZERO]); + RemoveStageMonitorRecord(env, info.argv[INDEX_ZERO]); } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } -NativeValue *JSAbilityDelegator::OnWaitAbilityMonitor(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnWaitAbilityMonitor(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::shared_ptr monitor = nullptr; TimeoutCallback opt {false, false}; int64_t timeout = 0; - if (!ParseWaitAbilityMonitorPara(engine, info, monitor, opt, timeout)) { + if (!ParseWaitAbilityMonitorPara(env, info, monitor, opt, timeout)) { HILOG_ERROR("Parse waitAbilityMonitor parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto abilityObjectBox = std::make_shared(); - AsyncTask::ExecuteCallback execute = [monitor, timeout, opt, abilityObjectBox]() { - HILOG_INFO("OnWaitAbilityMonitor AsyncTask ExecuteCallback is called"); + NapiAsyncTask::ExecuteCallback execute = [monitor, timeout, opt, abilityObjectBox]() { + HILOG_INFO("OnWaitAbilityMonitor NapiAsyncTask ExecuteCallback is called"); if (!abilityObjectBox) { - HILOG_ERROR("OnWaitAbilityMonitor AsyncTask ExecuteCallback, Invalid abilityObjectBox"); + HILOG_ERROR("OnWaitAbilityMonitor NapiAsyncTask ExecuteCallback, Invalid abilityObjectBox"); return; } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - HILOG_ERROR("OnWaitAbilityMonitor AsyncTask ExecuteCallback, Invalid delegator"); + HILOG_ERROR("OnWaitAbilityMonitor NapiAsyncTask ExecuteCallback, Invalid delegator"); return; } @@ -539,48 +520,48 @@ NativeValue *JSAbilityDelegator::OnWaitAbilityMonitor(NativeEngine &engine, Nati g_abilityRecord.emplace(property->object_, property->token_); }; - AsyncTask::CompleteCallback complete = [abilityObjectBox](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnWaitAbilityMonitor AsyncTask CompleteCallback is called"); + NapiAsyncTask::CompleteCallback complete = [abilityObjectBox](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnWaitAbilityMonitor NapiAsyncTask CompleteCallback is called"); if (abilityObjectBox && !abilityObjectBox->object_.expired()) { - ResolveWithNoError(engine, task, abilityObjectBox->object_.lock()->Get()); + ResolveWithNoError(env, task, abilityObjectBox->object_.lock()->GetNapiValue()); } else { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "waitAbilityMonitor failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "waitAbilityMonitor failed.")); } }; - NativeValue *lastParam = nullptr; + napi_value lastParam = nullptr; if (opt.hasCallbackPara) { lastParam = opt.hasTimeoutPara ? info.argv[INDEX_TWO] : info.argv[INDEX_ONE]; } - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnWaitAbilityMonitor", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, std::move(execute), std::move(complete), &result)); + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnWaitAbilityMonitor", + env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnWaitAbilityStageMonitor(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnWaitAbilityStageMonitor(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::shared_ptr monitor = nullptr; TimeoutCallback opt {false, false}; int64_t timeout = 0; - if (!ParseWaitAbilityStageMonitorPara(engine, info, monitor, opt, timeout)) { + if (!ParseWaitAbilityStageMonitorPara(env, info, monitor, opt, timeout)) { HILOG_ERROR("Parse waitAbilityStageMonitor parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto abilityStageObjBox = std::make_shared(); - AsyncTask::ExecuteCallback execute = [monitor, timeout, opt, abilityStageObjBox]() { - HILOG_INFO("OnWaitAbilityStageMonitor AsyncTask ExecuteCallback is called"); + NapiAsyncTask::ExecuteCallback execute = [monitor, timeout, opt, abilityStageObjBox]() { + HILOG_INFO("OnWaitAbilityStageMonitor NapiAsyncTask ExecuteCallback is called"); if (!abilityStageObjBox) { - HILOG_ERROR("OnWaitAbilityStageMonitor AsyncTask ExecuteCallback, Invalid abilityStageObjBox"); + HILOG_ERROR("OnWaitAbilityStageMonitor NapiAsyncTask ExecuteCallback, Invalid abilityStageObjBox"); return; } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - HILOG_ERROR("OnWaitAbilityMonitor AsyncTask ExecuteCallback, Invalid delegator"); + HILOG_ERROR("OnWaitAbilityMonitor NapiAsyncTask ExecuteCallback, Invalid delegator"); return; } std::shared_ptr result; @@ -593,394 +574,389 @@ NativeValue *JSAbilityDelegator::OnWaitAbilityStageMonitor(NativeEngine &engine, abilityStageObjBox->object_ = result->object_; }; - AsyncTask::CompleteCallback complete = [abilityStageObjBox](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnWaitAbilityMonitor AsyncTask CompleteCallback is called"); + NapiAsyncTask::CompleteCallback complete = [abilityStageObjBox](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnWaitAbilityMonitor NapiAsyncTask CompleteCallback is called"); if (abilityStageObjBox && !abilityStageObjBox->object_.expired()) { - ResolveWithNoError(engine, task, abilityStageObjBox->object_.lock()->Get()); + ResolveWithNoError(env, task, abilityStageObjBox->object_.lock()->GetNapiValue()); } else { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "waitAbilityStageMonitor failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "waitAbilityStageMonitor failed.")); } }; - NativeValue *lastParam = nullptr; + napi_value lastParam = nullptr; if (opt.hasCallbackPara) { lastParam = opt.hasTimeoutPara ? info.argv[INDEX_TWO] : info.argv[INDEX_ONE]; } - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnWaitAbilityStageMonitor", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, std::move(execute), std::move(complete), &result)); + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnWaitAbilityStageMonitor", + env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnPrint(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnPrint(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::string msg; - if (!ParsePrintPara(engine, info, msg)) { + if (!ParsePrintPara(env, info, msg)) { HILOG_ERROR("Parse print parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [msg](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnPrint AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [msg](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnPrint NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "print failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "print failed.")); return; } delegator->Print(msg); - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnPrint", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnPrint", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnPrintSync(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnPrintSync(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::string msg; - if (!ParsePrintPara(engine, info, msg)) { + if (!ParsePrintPara(env, info, msg)) { HILOG_ERROR("Parse print parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { HILOG_ERROR("Invalid delegator"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } delegator->Print(msg); - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::OnExecuteShellCommand(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnExecuteShellCommand(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::string cmd; TimeoutCallback opt {false, false}; int64_t timeoutSecs = 0; - if (!ParseExecuteShellCommandPara(engine, info, cmd, opt, timeoutSecs)) { + if (!ParseExecuteShellCommandPara(env, info, cmd, opt, timeoutSecs)) { HILOG_ERROR("Parse executeShellCommand parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } auto shellCmdResultBox = std::make_shared(); - AsyncTask::ExecuteCallback execute = [cmd, timeoutSecs, shellCmdResultBox]() { - HILOG_INFO("OnExecuteShellCommand AsyncTask ExecuteCallback is called"); + NapiAsyncTask::ExecuteCallback execute = [cmd, timeoutSecs, shellCmdResultBox]() { + HILOG_INFO("OnExecuteShellCommand NapiAsyncTask ExecuteCallback is called"); if (!shellCmdResultBox) { - HILOG_ERROR("OnExecuteShellCommand AsyncTask ExecuteCallback, Invalid shellCmdResultBox"); + HILOG_ERROR("OnExecuteShellCommand NapiAsyncTask ExecuteCallback, Invalid shellCmdResultBox"); return; } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - HILOG_ERROR("OnExecuteShellCommand AsyncTask ExecuteCallback, Invalid delegator"); + HILOG_ERROR("OnExecuteShellCommand NapiAsyncTask ExecuteCallback, Invalid delegator"); return; } shellCmdResultBox->shellCmdResult_ = delegator->ExecuteShellCommand(cmd, timeoutSecs); }; - AsyncTask::CompleteCallback complete = [shellCmdResultBox](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnExecuteShellCommand AsyncTask CompleteCallback is called"); + NapiAsyncTask::CompleteCallback complete = [shellCmdResultBox](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnExecuteShellCommand NapiAsyncTask CompleteCallback is called"); if (!shellCmdResultBox) { - HILOG_ERROR("OnExecuteShellCommand AsyncTask CompleteCallback, Invalid shellCmdResultBox"); - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "executeShellCommand failed.")); + HILOG_ERROR("OnExecuteShellCommand NapiAsyncTask CompleteCallback, Invalid shellCmdResultBox"); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "executeShellCommand failed.")); return; } - NativeValue *result = CreateJsShellCmdResult(engine, shellCmdResultBox->shellCmdResult_); + napi_value result = CreateJsShellCmdResult(env, shellCmdResultBox->shellCmdResult_); if (result) { - ResolveWithNoError(engine, task, result); + ResolveWithNoError(env, task, result); } else { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "executeShellCommand failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "executeShellCommand failed.")); } }; - NativeValue *lastParam = nullptr; + napi_value lastParam = nullptr; if (opt.hasCallbackPara) { lastParam = opt.hasTimeoutPara ? info.argv[INDEX_TWO] : info.argv[INDEX_ONE]; } - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnExecuteShellCommand:" + cmd, - engine, CreateAsyncTaskWithLastParam(engine, lastParam, std::move(execute), std::move(complete), &result)); + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnExecuteShellCommand:" + cmd, + env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnGetAppContext(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnGetAppContext(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { HILOG_ERROR("delegator is null"); - return engine.CreateNull(); + return CreateJsNull(env); } std::shared_ptr context = delegator->GetAppContext(); if (!context) { HILOG_ERROR("context is null"); - return engine.CreateNull(); - } - NativeValue *value = CreateJsBaseContext(engine, context, false); - NativeObject *nativeObj = ConvertNativeValueTo(value); - if (nativeObj == nullptr) { - HILOG_ERROR("Failed to get context native object"); - return engine.CreateNull(); + return CreateJsNull(env); } + napi_value value = CreateJsBaseContext(env, context, false); auto workContext = new (std::nothrow) std::weak_ptr(context); - nativeObj->ConvertToNativeBindingObject(&engine, DetachCallbackFunc, AttachAppContext, workContext, nullptr); - nativeObj->SetNativePointer( - workContext, - [](NativeEngine *, void *data, void *) { + if (workContext == nullptr) { + HILOG_ERROR("invalid workContext"); + return CreateJsNull(env); + } + napi_coerce_to_native_binding_object(env, value, DetachCallbackFunc, AttachAppContext, workContext, nullptr); + napi_wrap(env, value, workContext, + [](napi_env, void *data, void *) { HILOG_INFO("Finalizer for weak_ptr app context is called"); delete static_cast *>(data); - }, - nullptr); + }, nullptr, nullptr); return value; } -NativeValue *JSAbilityDelegator::OnGetAbilityState(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnGetAbilityState(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); if (info.argc < ARGC_ONE) { HILOG_ERROR("Incorrect number of parameters"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } sptr remoteObject = nullptr; - if (!ParseAbilityPara(engine, info.argv[INDEX_ZERO], remoteObject)) { + if (!ParseAbilityPara(env, info.argv[INDEX_ZERO], remoteObject)) { HILOG_ERROR("Parse ability parameter failed"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { HILOG_ERROR("delegator is null"); - return engine.CreateNull(); + return CreateJsNull(env); } AbilityDelegator::AbilityState lifeState = delegator->GetAbilityState(remoteObject); AbilityLifecycleState abilityLifeState = AbilityLifecycleState::UNINITIALIZED; AbilityLifecycleStateToJs(lifeState, abilityLifeState); - return engine.CreateNumber(static_cast(abilityLifeState)); + return CreateJsValue(env, static_cast(abilityLifeState)); } -NativeValue *JSAbilityDelegator::OnGetCurrentTopAbility(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnGetCurrentTopAbility(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); - if (info.argc >= ARGC_ONE && info.argv[INDEX_ZERO]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (info.argc >= ARGC_ONE && !AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ZERO], napi_function)) { HILOG_ERROR("Parse getCurrentTopAbility parameter failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [this](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnGetCurrentTopAbility AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [this](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnGetCurrentTopAbility NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { HILOG_ERROR("Invalid delegator"); - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "getCurrentTopAbility failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "getCurrentTopAbility failed.")); return; } auto property = delegator->GetCurrentTopAbility(); if (!property || property->object_.expired()) { HILOG_ERROR("Invalid property"); - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "getCurrentTopAbility failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "getCurrentTopAbility failed.")); } else { { std::unique_lock lck(g_mutexAbilityRecord); g_abilityRecord.emplace(property->object_, property->token_); } - ResolveWithNoError(engine, task, property->object_.lock()->Get()); + ResolveWithNoError(env, task, property->object_.lock()->GetNapiValue()); } }; - NativeValue *lastParam = (info.argc >= ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue *result = nullptr; - AsyncTask::ScheduleHighQos("JSAbilityDelegator::OnGetCurrentTopAbility", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc >= ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAbilityDelegator::OnGetCurrentTopAbility", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnStartAbility(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnStartAbility(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); AAFwk::Want want; - if (!ParseStartAbilityPara(engine, info, want)) { + if (!ParseStartAbilityPara(env, info, want)) { HILOG_ERROR("Parse startAbility parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [want](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnStartAbility AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [want](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnStartAbility NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "startAbility failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "startAbility failed.")); return; } int result = delegator->StartAbility(want); if (result) { - task.Reject(engine, CreateJsError(engine, result, "startAbility failed.")); + task.Reject(env, CreateJsError(env, result, "startAbility failed.")); } else { - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); } }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::ScheduleHighQos("JSAbilityDelegator::OnStartAbility", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAbilityDelegator::OnStartAbility", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnDoAbilityForeground(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnDoAbilityForeground(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); sptr remoteObject = nullptr; - if (!ParseAbilityCommonPara(engine, info, remoteObject)) { + if (!ParseAbilityCommonPara(env, info, remoteObject)) { HILOG_ERROR("Parse doAbilityForeground parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [remoteObject](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnDoAbilityForeground AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [remoteObject](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnDoAbilityForeground NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "doAbilityForeground failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "doAbilityForeground failed.")); return; } if (delegator->DoAbilityForeground(remoteObject)) { - ResolveWithNoError(engine, task, engine.CreateNull()); + ResolveWithNoError(env, task, CreateJsNull(env)); } else { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "doAbilityForeground failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "doAbilityForeground failed.")); } }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::ScheduleHighQos("JSAbilityDelegator::OnDoAbilityForeground", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAbilityDelegator::OnDoAbilityForeground", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnDoAbilityBackground(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnDoAbilityBackground(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); sptr remoteObject = nullptr; - if (!ParseAbilityCommonPara(engine, info, remoteObject)) { + if (!ParseAbilityCommonPara(env, info, remoteObject)) { HILOG_ERROR("Parse doAbilityBackground parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [remoteObject](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnDoAbilityBackground AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [remoteObject](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnDoAbilityBackground NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "doAbilityBackground failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "doAbilityBackground failed.")); return; } if (delegator->DoAbilityBackground(remoteObject)) { - ResolveWithNoError(engine, task, engine.CreateNull()); + ResolveWithNoError(env, task, CreateJsNull(env)); } else { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "doAbilityBackground failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "doAbilityBackground failed.")); } }; - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; - NativeValue *result = nullptr; - AsyncTask::ScheduleHighQos("JSAbilityDelegator::OnDoAbilityBackground", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAbilityDelegator::OnDoAbilityBackground", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnFinishTest(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnFinishTest(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::string msg; int64_t code = 0; - if (!ParseFinishTestPara(engine, info, msg, code)) { + if (!ParseFinishTestPara(env, info, msg, code)) { HILOG_ERROR("Parse finishTest parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - AsyncTask::CompleteCallback complete = [msg, code](NativeEngine &engine, AsyncTask &task, int32_t status) { - HILOG_INFO("OnFinishTest AsyncTask is called"); + NapiAsyncTask::CompleteCallback complete = [msg, code](napi_env env, NapiAsyncTask &task, int32_t status) { + HILOG_INFO("OnFinishTest NapiAsyncTask is called"); auto delegator = AbilityDelegatorRegistry::GetAbilityDelegator(); if (!delegator) { - task.Reject(engine, CreateJsError(engine, COMMON_FAILED, "finishTest failed.")); + task.Reject(env, CreateJsError(env, COMMON_FAILED, "finishTest failed.")); return; } delegator->FinishUserTest(msg, code); - ResolveWithNoError(engine, task); + ResolveWithNoError(env, task); }; - NativeValue *lastParam = (info.argc > ARGC_TWO) ? info.argv[INDEX_TWO] : nullptr; - NativeValue *result = nullptr; - AsyncTask::Schedule("JSAbilityDelegator::OnFinishTest", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc > ARGC_TWO) ? info.argv[INDEX_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAbilityDelegator::OnFinishTest", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } -NativeValue *JSAbilityDelegator::OnSetMockList(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JSAbilityDelegator::OnSetMockList(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("enter, argc = %{public}d", static_cast(info.argc)); std::map mockList; - if (!ParseMockListPara(engine, info, mockList)) { + if (!ParseMockListPara(env, info, mockList)) { HILOG_ERROR("Parse setMockList parameters failed"); - return ThrowJsError(engine, INCORRECT_PARAMETERS); + return ThrowJsError(env, INCORRECT_PARAMETERS); } - - engine.SetMockModuleList(mockList); - return engine.CreateNull(); + auto engine = reinterpret_cast(env); + engine->SetMockModuleList(mockList); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseMonitorPara( - NativeEngine &engine, NativeValue *value, std::shared_ptr &monitor) +napi_value JSAbilityDelegator::ParseMonitorPara( + napi_env env, napi_value value, std::shared_ptr &monitor) { HILOG_INFO("enter, monitorRecord size = %{public}zu", g_monitorRecord.size()); for (auto iter = g_monitorRecord.begin(); iter != g_monitorRecord.end(); ++iter) { std::shared_ptr jsMonitor = iter->first; - if (value->StrictEquals(jsMonitor->Get())) { + bool isEquals = false; + napi_strict_equals(env, value, jsMonitor->GetNapiValue(), &isEquals); + if (isEquals) { HILOG_ERROR("monitor existed"); monitor = iter->second; - return monitor ? engine.CreateNull() : nullptr; + return monitor ? CreateJsNull(env) : nullptr; } } - NativeObject *object = ConvertNativeValueTo(value); - if (object == nullptr) { - HILOG_ERROR("Failed to get object"); - return nullptr; - } - - auto abilityNameValue = object->GetProperty("abilityName"); + napi_value abilityNameValue = nullptr; + napi_get_named_property(env, value, "abilityName", &abilityNameValue); if (abilityNameValue == nullptr) { HILOG_ERROR("Failed to get property abilityName"); return nullptr; } std::string abilityName; - if (!ConvertFromJsValue(engine, abilityNameValue, abilityName)) { + if (!ConvertFromJsValue(env, abilityNameValue, abilityName)) { return nullptr; } std::string moduleName = ""; - auto moduleNameValue = object->GetProperty("moduleName"); - if (moduleNameValue != nullptr && !ConvertFromJsValue(engine, moduleNameValue, moduleName)) { + napi_value moduleNameValue = nullptr; + napi_get_named_property(env, value, "moduleName", &moduleNameValue); + if (moduleNameValue != nullptr && !ConvertFromJsValue(env, moduleNameValue, moduleName)) { HILOG_WARN("Failed to get property moduleName"); moduleName = ""; } @@ -988,70 +964,72 @@ NativeValue *JSAbilityDelegator::ParseMonitorPara( std::shared_ptr abilityMonitor = nullptr; if (moduleName.empty()) { abilityMonitor = std::make_shared(abilityName); - abilityMonitor->SetJsAbilityMonitorEnv(&engine); + abilityMonitor->SetJsAbilityMonitorEnv(env); abilityMonitor->SetJsAbilityMonitor(value); monitor = std::make_shared(abilityName, abilityMonitor); } else { abilityMonitor = std::make_shared(abilityName, moduleName); - abilityMonitor->SetJsAbilityMonitorEnv(&engine); + abilityMonitor->SetJsAbilityMonitorEnv(env); abilityMonitor->SetJsAbilityMonitor(value); monitor = std::make_shared(abilityName, moduleName, abilityMonitor); } std::shared_ptr reference = nullptr; - reference.reset(engine.CreateReference(value, 1)); + napi_ref ref = nullptr; + napi_create_reference(env, value, 1, &ref); + reference.reset(reinterpret_cast(ref)); g_monitorRecord.emplace(reference, monitor); - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseStageMonitorPara( - NativeEngine &engine, NativeValue *value, std::shared_ptr &monitor, bool &isExisted) +napi_value JSAbilityDelegator::ParseStageMonitorPara( + napi_env env, napi_value value, std::shared_ptr &monitor, bool &isExisted) { HILOG_INFO("enter, stageMonitorRecord size = %{public}zu", g_stageMonitorRecord.size()); isExisted = false; for (auto iter = g_stageMonitorRecord.begin(); iter != g_stageMonitorRecord.end(); ++iter) { std::shared_ptr jsMonitor = iter->first; - if (value->StrictEquals(jsMonitor->Get())) { + bool isEquals = false; + napi_strict_equals(env, value, jsMonitor->GetNapiValue(), &isEquals); + if (isEquals) { HILOG_WARN("AbilityStage monitor existed"); isExisted = true; monitor = iter->second; - return monitor ? engine.CreateNull() : nullptr; + return monitor ? CreateJsNull(env) : nullptr; } } - NativeObject *object = ConvertNativeValueTo(value); - if (object == nullptr) { - HILOG_ERROR("Failed to get object"); - return nullptr; - } - auto moduleNameValue = object->GetProperty("moduleName"); + + napi_value moduleNameValue = nullptr; + napi_get_named_property(env, value, "moduleName", &moduleNameValue); if (moduleNameValue == nullptr) { HILOG_ERROR("Failed to get property moduleName"); return nullptr; } std::string moduleName; - if (!ConvertFromJsValue(engine, moduleNameValue, moduleName)) { + if (!ConvertFromJsValue(env, moduleNameValue, moduleName)) { HILOG_ERROR("Failed to get moduleName from JsValue"); return nullptr; } - auto srcEntranceValue = object->GetProperty("srcEntrance"); + napi_value srcEntranceValue = nullptr; + napi_get_named_property(env, value, "srcEntrance", &srcEntranceValue); if (srcEntranceValue == nullptr) { HILOG_ERROR("Failed to get property srcEntrance"); return nullptr; } std::string srcEntrance; - if (!ConvertFromJsValue(engine, srcEntranceValue, srcEntrance)) { + if (!ConvertFromJsValue(env, srcEntranceValue, srcEntrance)) { HILOG_ERROR("Failed to get srcEntrance from JsValue"); return nullptr; } monitor = std::make_shared(moduleName, srcEntrance); - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseAbilityPara( - NativeEngine &engine, NativeValue *value, sptr &remoteObject) +napi_value JSAbilityDelegator::ParseAbilityPara( + napi_env env, napi_value value, sptr &remoteObject) { HILOG_INFO("enter"); @@ -1062,10 +1040,12 @@ NativeValue *JSAbilityDelegator::ParseAbilityPara( continue; } - if (value->StrictEquals(iter->first.lock()->Get())) { + bool isEquals = false; + napi_strict_equals(env, value, iter->first.lock()->GetNapiValue(), &isEquals); + if (isEquals) { remoteObject = iter->second; HILOG_INFO("Ability exist"); - return remoteObject ? engine.CreateNull() : nullptr; + return remoteObject ? CreateJsNull(env) : nullptr; } ++iter; @@ -1076,7 +1056,7 @@ NativeValue *JSAbilityDelegator::ParseAbilityPara( return nullptr; } -NativeValue *JSAbilityDelegator::CreateAbilityObject(NativeEngine &engine, const sptr &remoteObject) +napi_value JSAbilityDelegator::CreateAbilityObject(napi_env env, const sptr &remoteObject) { HILOG_INFO("enter"); @@ -1084,15 +1064,17 @@ NativeValue *JSAbilityDelegator::CreateAbilityObject(NativeEngine &engine, const return nullptr; } - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } std::shared_ptr reference = nullptr; - reference.reset(engine.CreateReference(objValue, 1)); + napi_ref ref = nullptr; + napi_create_reference(env, objValue, 1, &ref); + reference.reset(reinterpret_cast(ref)); std::unique_lock lck(g_mutexAbilityRecord); g_abilityRecord[reference] = remoteObject; @@ -1122,8 +1104,8 @@ void JSAbilityDelegator::AbilityLifecycleStateToJs( } } -NativeValue *JSAbilityDelegator::ParseAbilityMonitorPara( - NativeEngine &engine, NativeCallbackInfo &info, std::shared_ptr &monitor, bool isSync) +napi_value JSAbilityDelegator::ParseAbilityMonitorPara( + napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, bool isSync) { HILOG_INFO("enter"); if (info.argc < ARGC_ONE) { @@ -1131,25 +1113,25 @@ NativeValue *JSAbilityDelegator::ParseAbilityMonitorPara( return nullptr; } - if (!ParseMonitorPara(engine, info.argv[INDEX_ZERO], monitor)) { + if (!ParseMonitorPara(env, info.argv[INDEX_ZERO], monitor)) { HILOG_ERROR("Parse monitor parameters failed"); return nullptr; } if (isSync) { - return engine.CreateNull(); + return CreateJsNull(env); } if (info.argc > ARGC_ONE) { - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ONE], napi_function)) { HILOG_ERROR("ParseAbilityMonitorPara, Parse callback parameters failed"); return nullptr; } } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseAbilityStageMonitorPara(NativeEngine &engine, NativeCallbackInfo &info, +napi_value JSAbilityDelegator::ParseAbilityStageMonitorPara(napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, bool &isExisted, bool isSync) { HILOG_INFO("enter"); @@ -1158,25 +1140,25 @@ NativeValue *JSAbilityDelegator::ParseAbilityStageMonitorPara(NativeEngine &engi return nullptr; } - if (!ParseStageMonitorPara(engine, info.argv[INDEX_ZERO], monitor, isExisted)) { + if (!ParseStageMonitorPara(env, info.argv[INDEX_ZERO], monitor, isExisted)) { HILOG_ERROR("Parse stage monitor parameters failed"); return nullptr; } if (isSync) { - return engine.CreateNull(); + return CreateJsNull(env); } if (info.argc > ARGC_ONE) { - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ONE], napi_function)) { HILOG_ERROR("ParseAbilityStageMonitorPara, Parse callback parameters failed"); return nullptr; } } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseWaitAbilityMonitorPara(NativeEngine &engine, NativeCallbackInfo &info, +napi_value JSAbilityDelegator::ParseWaitAbilityMonitorPara(napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, TimeoutCallback &opt, int64_t &timeout) { HILOG_INFO("enter"); @@ -1185,19 +1167,19 @@ NativeValue *JSAbilityDelegator::ParseWaitAbilityMonitorPara(NativeEngine &engin return nullptr; } - if (!ParseMonitorPara(engine, info.argv[INDEX_ZERO], monitor)) { + if (!ParseMonitorPara(env, info.argv[INDEX_ZERO], monitor)) { HILOG_ERROR("Monitor parse parameters failed"); return nullptr; } - if (!ParseTimeoutCallbackPara(engine, info, opt, timeout)) { + if (!ParseTimeoutCallbackPara(env, info, opt, timeout)) { HILOG_ERROR("TimeoutCallback parse parameters failed"); return nullptr; } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseWaitAbilityStageMonitorPara(NativeEngine &engine, NativeCallbackInfo &info, +napi_value JSAbilityDelegator::ParseWaitAbilityStageMonitorPara(napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, TimeoutCallback &opt, int64_t &timeout) { HILOG_INFO("enter"); @@ -1207,22 +1189,22 @@ NativeValue *JSAbilityDelegator::ParseWaitAbilityStageMonitorPara(NativeEngine & } bool isExisted = false; - if (!ParseStageMonitorPara(engine, info.argv[INDEX_ZERO], monitor, isExisted)) { + if (!ParseStageMonitorPara(env, info.argv[INDEX_ZERO], monitor, isExisted)) { HILOG_ERROR("Stage monitor parse parameters failed"); return nullptr; } - if (!ParseTimeoutCallbackPara(engine, info, opt, timeout)) { + if (!ParseTimeoutCallbackPara(env, info, opt, timeout)) { HILOG_ERROR("TimeoutCallback parse parameters failed"); return nullptr; } if (!isExisted) { - AddStageMonitorRecord(engine, info.argv[INDEX_ZERO], monitor); + AddStageMonitorRecord(env, info.argv[INDEX_ZERO], monitor); } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseTimeoutCallbackPara( - NativeEngine &engine, NativeCallbackInfo &info, TimeoutCallback &opt, int64_t &timeout) +napi_value JSAbilityDelegator::ParseTimeoutCallbackPara( + napi_env env, NapiCallbackInfo& info, TimeoutCallback &opt, int64_t &timeout) { HILOG_INFO("enter"); @@ -1230,34 +1212,34 @@ NativeValue *JSAbilityDelegator::ParseTimeoutCallbackPara( opt.hasTimeoutPara = false; if (info.argc >= ARGC_TWO) { - if (ConvertFromJsValue(engine, info.argv[INDEX_ONE], timeout)) { + if (ConvertFromJsValue(env, info.argv[INDEX_ONE], timeout)) { opt.hasTimeoutPara = true; } else { if (info.argv[INDEX_ONE] == nullptr) { - HILOG_WARN("argv[1] is null"); - } else if (info.argv[INDEX_ONE]->TypeOf() == NativeValueType::NATIVE_FUNCTION) { + HILOG_WARN("info.argv[1] is null"); + } else if (AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ONE], napi_function)) { opt.hasCallbackPara = true; - return engine.CreateNull(); + return CreateJsNull(env); } else { return nullptr; } } if (info.argc > ARGC_TWO) { - if (info.argv[INDEX_TWO]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_TWO], napi_function)) { if (info.argv[INDEX_TWO] == nullptr) { - HILOG_WARN("argv[2] is null"); - return engine.CreateNull(); + HILOG_WARN("info.argv[2] is null"); + return CreateJsNull(env); } return nullptr; } opt.hasCallbackPara = true; } } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParsePrintPara(NativeEngine &engine, NativeCallbackInfo &info, std::string &msg) +napi_value JSAbilityDelegator::ParsePrintPara(napi_env env, NapiCallbackInfo& info, std::string &msg) { HILOG_INFO("enter"); if (info.argc < ARGC_ONE) { @@ -1265,22 +1247,22 @@ NativeValue *JSAbilityDelegator::ParsePrintPara(NativeEngine &engine, NativeCall return nullptr; } - if (!ConvertFromJsValue(engine, info.argv[INDEX_ZERO], msg)) { + if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], msg)) { HILOG_ERROR("Parse msg parameter failed"); return nullptr; } if (info.argc > ARGC_ONE) { - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ONE], napi_function)) { HILOG_ERROR("Parse callback parameter failed"); return nullptr; } } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseExecuteShellCommandPara( - NativeEngine &engine, NativeCallbackInfo &info, std::string &cmd, TimeoutCallback &opt, int64_t &timeout) +napi_value JSAbilityDelegator::ParseExecuteShellCommandPara( + napi_env env, NapiCallbackInfo& info, std::string &cmd, TimeoutCallback &opt, int64_t &timeout) { HILOG_INFO("enter"); if (info.argc < ARGC_ONE) { @@ -1288,19 +1270,19 @@ NativeValue *JSAbilityDelegator::ParseExecuteShellCommandPara( return nullptr; } - if (!ConvertFromJsValue(engine, info.argv[INDEX_ZERO], cmd)) { + if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], cmd)) { HILOG_ERROR("Parse cmd parameter failed"); return nullptr; } - if (!ParseTimeoutCallbackPara(engine, info, opt, timeout)) { + if (!ParseTimeoutCallbackPara(env, info, opt, timeout)) { HILOG_ERROR("Parse timeOut callback parameters failed"); return nullptr; } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseAbilityCommonPara( - NativeEngine &engine, NativeCallbackInfo &info, sptr &remoteObject) +napi_value JSAbilityDelegator::ParseAbilityCommonPara( + napi_env env, NapiCallbackInfo& info, sptr &remoteObject) { HILOG_INFO("enter"); if (info.argc < ARGC_ONE) { @@ -1308,22 +1290,22 @@ NativeValue *JSAbilityDelegator::ParseAbilityCommonPara( return nullptr; } - if (!ParseAbilityPara(engine, info.argv[INDEX_ZERO], remoteObject)) { + if (!ParseAbilityPara(env, info.argv[INDEX_ZERO], remoteObject)) { HILOG_ERROR("Parse ability parameter failed"); return nullptr; } if (info.argc > ARGC_ONE) { - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ONE], napi_function)) { HILOG_ERROR("Parse ability callback parameters failed"); return nullptr; } } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseStartAbilityPara( - NativeEngine &engine, NativeCallbackInfo &info, AAFwk::Want &want) +napi_value JSAbilityDelegator::ParseStartAbilityPara( + napi_env env, NapiCallbackInfo& info, AAFwk::Want &want) { HILOG_INFO("enter"); if (info.argc < ARGC_ONE) { @@ -1331,23 +1313,22 @@ NativeValue *JSAbilityDelegator::ParseStartAbilityPara( return nullptr; } - if (!OHOS::AppExecFwk::UnwrapWant( - reinterpret_cast(&engine), reinterpret_cast(info.argv[INDEX_ZERO]), want)) { + if (!OHOS::AppExecFwk::UnwrapWant(env, info.argv[INDEX_ZERO], want)) { HILOG_ERROR("Parse want parameter failed"); return nullptr; } if (info.argc > ARGC_ONE) { - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_ONE], napi_function)) { HILOG_ERROR("Parse StartAbility callback parameters failed"); return nullptr; } } - return engine.CreateNull(); + return CreateJsNull(env); } -NativeValue *JSAbilityDelegator::ParseFinishTestPara( - NativeEngine &engine, NativeCallbackInfo &info, std::string &msg, int64_t &code) +napi_value JSAbilityDelegator::ParseFinishTestPara( + napi_env env, NapiCallbackInfo& info, std::string &msg, int64_t &code) { HILOG_INFO("enter"); if (info.argc < ARGC_TWO) { @@ -1355,27 +1336,27 @@ NativeValue *JSAbilityDelegator::ParseFinishTestPara( return nullptr; } - if (!ConvertFromJsValue(engine, info.argv[INDEX_ZERO], msg)) { + if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], msg)) { HILOG_ERROR("Parse msg parameter failed"); return nullptr; } - if (!ConvertFromJsValue(engine, info.argv[INDEX_ONE], code)) { + if (!ConvertFromJsValue(env, info.argv[INDEX_ONE], code)) { HILOG_ERROR("Parse code para parameter failed"); return nullptr; } if (info.argc > ARGC_TWO) { - if ((info.argv[INDEX_TWO])->TypeOf() != NativeValueType::NATIVE_FUNCTION) { + if (!AppExecFwk::IsTypeForNapiValue(env, info.argv[INDEX_TWO], napi_function)) { HILOG_ERROR("Incorrect Callback Function type"); return nullptr; } } - return engine.CreateNull(); + return CreateJsNull(env); } bool JSAbilityDelegator::ParseMockListPara( - NativeEngine &engine, NativeCallbackInfo &info, std::map &mockList) + napi_env env, NapiCallbackInfo& info, std::map &mockList) { HILOG_DEBUG("enter"); if (info.argc != ARGC_ONE) { @@ -1383,42 +1364,38 @@ bool JSAbilityDelegator::ParseMockListPara( return false; } - NativeValue *value = info.argv[INDEX_ZERO]; + napi_value value = info.argv[INDEX_ZERO]; if (value == nullptr) { HILOG_ERROR("The arg[0] is nullptr."); return false; } - NativeValueType type = value->TypeOf(); - if (type != NativeValueType::NATIVE_OBJECT) { - HILOG_ERROR("The type of arg[0] is %{public}d.", static_cast(type)); - return false; - } - - NativeObject* obj = ConvertNativeValueTo(value); - if (obj == nullptr) { - HILOG_ERROR("Failed to get object"); + if (!CheckTypeForNapiValue(env, value, napi_object)) { + HILOG_ERROR("The type of arg[0] is not napi_object."); return false; } std::vector propNames; - if (!ParseArrayStringValue(engine, obj->GetPropertyNames(), propNames)) { + napi_value array = nullptr; + napi_get_property_names(env, value, &array); + if (!ParseArrayStringValue(env, array, propNames)) { HILOG_ERROR("Failed to property names."); return false; } for (const auto &propName : propNames) { - auto prop = obj->GetProperty(propName.c_str()); + napi_value prop = nullptr; + napi_get_named_property(env, value, propName.c_str(), &prop); if (prop == nullptr) { HILOG_WARN("Prop is null: %{public}s", propName.c_str()); continue; } - if (prop->TypeOf() != NativeValueType::NATIVE_STRING) { + if (!CheckTypeForNapiValue(env, prop, napi_string)) { HILOG_WARN("Prop is not string: %{public}s", propName.c_str()); continue; } std::string valName; - if (!ConvertFromJsValue(engine, prop, valName)) { + if (!ConvertFromJsValue(env, prop, valName)) { HILOG_WARN("Failed to ConvertFromJsValue: %{public}s", propName.c_str()); continue; } @@ -1429,28 +1406,29 @@ bool JSAbilityDelegator::ParseMockListPara( } bool JSAbilityDelegator::ParseArrayStringValue( - NativeEngine &engine, NativeValue* array, std::vector &vector) + napi_env env, napi_value array, std::vector &vector) { if (array == nullptr) { HILOG_ERROR("array is nullptr!"); return false; } - if (!array->IsArray()) { + bool isArray = false; + if (napi_is_array(env, array, &isArray) != napi_ok || isArray == false) { HILOG_ERROR("not array!"); return false; } - auto nativeArray = ConvertNativeValueTo(array); - auto arrayLen = nativeArray->GetLength(); + uint32_t arrayLen = 0; + napi_get_array_length(env, array, &arrayLen); if (arrayLen == 0) { return true; } - vector.reserve(arrayLen); for (uint32_t i = 0; i < arrayLen; i++) { std::string strItem; - NativeValue *value = nativeArray->GetElement(i); - if (!ConvertFromJsValue(engine, value, strItem)) { + napi_value jsValue = nullptr; + napi_get_element(env, array, i, &jsValue); + if (!ConvertFromJsValue(env, jsValue, strItem)) { HILOG_WARN("Failed to ConvertFromJsValue, index: %{public}u", i); continue; } @@ -1460,7 +1438,7 @@ bool JSAbilityDelegator::ParseArrayStringValue( } void JSAbilityDelegator::AddStageMonitorRecord( - NativeEngine &engine, NativeValue *value, const std::shared_ptr &monitor) + napi_env env, napi_value value, const std::shared_ptr &monitor) { if (!value) { HILOG_ERROR("UpdateStageMonitorRecord value is empty"); @@ -1471,7 +1449,9 @@ void JSAbilityDelegator::AddStageMonitorRecord( return; } std::shared_ptr reference = nullptr; - reference.reset(engine.CreateReference(value, 1)); + napi_ref ref = nullptr; + napi_create_reference(env, value, 1, &ref); + reference.reset(reinterpret_cast(ref)); { std::unique_lock lck(g_mtxStageMonitorRecord); g_stageMonitorRecord.emplace(reference, monitor); @@ -1479,7 +1459,7 @@ void JSAbilityDelegator::AddStageMonitorRecord( HILOG_INFO("g_stageMonitorRecord added, size = %{public}zu", g_stageMonitorRecord.size()); } -void JSAbilityDelegator::RemoveStageMonitorRecord(NativeValue *value) +void JSAbilityDelegator::RemoveStageMonitorRecord(napi_env env, napi_value value) { if (!value) { HILOG_ERROR("UpdateStageMonitorRecord value is empty"); @@ -1492,7 +1472,9 @@ void JSAbilityDelegator::RemoveStageMonitorRecord(NativeValue *value) std::unique_lock lck(g_mtxStageMonitorRecord); for (auto iter = g_stageMonitorRecord.begin(); iter != g_stageMonitorRecord.end(); ++iter) { std::shared_ptr jsMonitor = iter->first; - if (value->StrictEquals(jsMonitor->Get())) { + bool isEquals = false; + napi_strict_equals(env, value, jsMonitor->GetNapiValue(), &isEquals); + if (isEquals) { g_stageMonitorRecord.erase(iter); HILOG_INFO("g_stageMonitorRecord removed, size = %{public}zu", g_stageMonitorRecord.size()); break; diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_delegator.h b/frameworks/js/napi/app/ability_delegator/js_ability_delegator.h index e1116d7d7bf..b972359cfd2 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_delegator.h +++ b/frameworks/js/napi/app/ability_delegator/js_ability_delegator.h @@ -22,10 +22,12 @@ #include "ability_stage_monitor.h" #include "js_ability_delegator_registry.h" #include "js_ability_monitor.h" +#include "js_runtime_utils.h" #include "want.h" namespace OHOS { namespace AbilityDelegatorJs { +using namespace OHOS::AbilityRuntime; class JSAbilityDelegator { public: struct TimeoutCallback { @@ -46,256 +48,256 @@ public: /** * Destory object. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param data Indicates the object to be destroyed. * @param hint Indicates the hint. */ - static void Finalizer(NativeEngine *engine, void *data, void *hint); + static void Finalizer(napi_env env, void *data, void *hint); /** * Adds ability monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *AddAbilityMonitor(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value AddAbilityMonitor(napi_env env, napi_callback_info info); /** * Sync adds ability monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *AddAbilityMonitorSync(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value AddAbilityMonitorSync(napi_env env, napi_callback_info info); /** * Adds abilityStage monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *AddAbilityStageMonitor(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value AddAbilityStageMonitor(napi_env env, napi_callback_info info); /** * Sync adds abilityStage monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *AddAbilityStageMonitorSync(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value AddAbilityStageMonitorSync(napi_env env, napi_callback_info info); /** * Removes ability monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *RemoveAbilityMonitor(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value RemoveAbilityMonitor(napi_env env, napi_callback_info info); /** * Sync removes ability monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *RemoveAbilityMonitorSync(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value RemoveAbilityMonitorSync(napi_env env, napi_callback_info info); /** * Removes abilityStage monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *RemoveAbilityStageMonitor(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value RemoveAbilityStageMonitor(napi_env env, napi_callback_info info); /** * Sync removes abilityStage monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *RemoveAbilityStageMonitorSync(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value RemoveAbilityStageMonitorSync(napi_env env, napi_callback_info info); /** * Waits for the specified monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *WaitAbilityMonitor(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value WaitAbilityMonitor(napi_env env, napi_callback_info info); /** * Waits for the specified stage monitor. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *WaitAbilityStageMonitor(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value WaitAbilityStageMonitor(napi_env env, napi_callback_info info); /** * Prints log information to the console. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *Print(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value Print(napi_env env, napi_callback_info info); /** * Prints log information to the console. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *PrintSync(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value PrintSync(napi_env env, napi_callback_info info); /** * Execute the specified shell command. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *ExecuteShellCommand(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value ExecuteShellCommand(napi_env env, napi_callback_info info); /** * Obtains the application context. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *GetAppContext(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value GetAppContext(napi_env env, napi_callback_info info); /** * Obtains the lifecycle state of the specified ability. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *GetAbilityState(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value GetAbilityState(napi_env env, napi_callback_info info); /** * Obtains the ability that is currently being displayed. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *GetCurrentTopAbility(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value GetCurrentTopAbility(napi_env env, napi_callback_info info); /** * Starts an ability based on the given parameters. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *StartAbility(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value StartAbility(napi_env env, napi_callback_info info); /** * Transits the specified ability to foreground. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *DoAbilityForeground(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value DoAbilityForeground(napi_env env, napi_callback_info info); /** * Transits the specified ability to background. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *DoAbilityBackground(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value DoAbilityBackground(napi_env env, napi_callback_info info); /** * Finishes user test. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *FinishTest(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value FinishTest(napi_env env, napi_callback_info info); /** * Set mock list. * - * @param engine Indicates the native engine. + * @param env Indicates the native engine. * @param info Indicates the parameters from js. * @return exec result. */ - static NativeValue *SetMockList(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value SetMockList(napi_env env, napi_callback_info info); private: - NativeValue *OnAddAbilityMonitor(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnAddAbilityMonitorSync(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnAddAbilityStageMonitor(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnAddAbilityStageMonitorSync(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnRemoveAbilityMonitor(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnRemoveAbilityMonitorSync(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnRemoveAbilityStageMonitor(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnRemoveAbilityStageMonitorSync(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnWaitAbilityMonitor(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnWaitAbilityStageMonitor(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnPrint(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnPrintSync(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnExecuteShellCommand(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetAppContext(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetAbilityState(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetCurrentTopAbility(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnStartAbility(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnDoAbilityForeground(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnDoAbilityBackground(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnFinishTest(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnSetMockList(NativeEngine &engine, NativeCallbackInfo &info); + napi_value OnAddAbilityMonitor(napi_env env, NapiCallbackInfo& info); + napi_value OnAddAbilityMonitorSync(napi_env env, NapiCallbackInfo& info); + napi_value OnAddAbilityStageMonitor(napi_env env, NapiCallbackInfo& info); + napi_value OnAddAbilityStageMonitorSync(napi_env env, NapiCallbackInfo& info); + napi_value OnRemoveAbilityMonitor(napi_env env, NapiCallbackInfo& info); + napi_value OnRemoveAbilityMonitorSync(napi_env env, NapiCallbackInfo& info); + napi_value OnRemoveAbilityStageMonitor(napi_env env, NapiCallbackInfo& info); + napi_value OnRemoveAbilityStageMonitorSync(napi_env env, NapiCallbackInfo& info); + napi_value OnWaitAbilityMonitor(napi_env env, NapiCallbackInfo& info); + napi_value OnWaitAbilityStageMonitor(napi_env env, NapiCallbackInfo& info); + napi_value OnPrint(napi_env env, NapiCallbackInfo& info); + napi_value OnPrintSync(napi_env env, NapiCallbackInfo& info); + napi_value OnExecuteShellCommand(napi_env env, NapiCallbackInfo& info); + napi_value OnGetAppContext(napi_env env, NapiCallbackInfo& info); + napi_value OnGetAbilityState(napi_env env, NapiCallbackInfo& info); + napi_value OnGetCurrentTopAbility(napi_env env, NapiCallbackInfo& info); + napi_value OnStartAbility(napi_env env, NapiCallbackInfo& info); + napi_value OnDoAbilityForeground(napi_env env, NapiCallbackInfo& info); + napi_value OnDoAbilityBackground(napi_env env, NapiCallbackInfo& info); + napi_value OnFinishTest(napi_env env, NapiCallbackInfo& info); + napi_value OnSetMockList(napi_env env, NapiCallbackInfo& info); private: - NativeValue *CreateAbilityObject(NativeEngine &engine, const sptr &remoteObject); - NativeValue *ParseMonitorPara(NativeEngine &engine, NativeValue *value, std::shared_ptr &monitor); - NativeValue *ParseStageMonitorPara( - NativeEngine &engine, NativeValue *value, std::shared_ptr &monitor, bool &isExisted); - NativeValue *ParseAbilityPara(NativeEngine &engine, NativeValue *value, sptr &remoteObject); + napi_value CreateAbilityObject(napi_env env, const sptr &remoteObject); + napi_value ParseMonitorPara(napi_env env, napi_value value, std::shared_ptr &monitor); + napi_value ParseStageMonitorPara( + napi_env env, napi_value value, std::shared_ptr &monitor, bool &isExisted); + napi_value ParseAbilityPara(napi_env env, napi_value value, sptr &remoteObject); void AbilityLifecycleStateToJs( const AbilityDelegator::AbilityState &lifeState, AbilityLifecycleState &abilityLifeState); - NativeValue *ParseAbilityMonitorPara( - NativeEngine &engine, NativeCallbackInfo &info, std::shared_ptr &monitor, bool isSync); - NativeValue *ParseAbilityStageMonitorPara(NativeEngine &engine, NativeCallbackInfo &info, + napi_value ParseAbilityMonitorPara( + napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, bool isSync); + napi_value ParseAbilityStageMonitorPara(napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, bool &isExisted, bool isSync); - NativeValue *ParseWaitAbilityMonitorPara(NativeEngine &engine, NativeCallbackInfo &info, + napi_value ParseWaitAbilityMonitorPara(napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, TimeoutCallback &opt, int64_t &timeout); - NativeValue *ParseWaitAbilityStageMonitorPara(NativeEngine &engine, NativeCallbackInfo &info, + napi_value ParseWaitAbilityStageMonitorPara(napi_env env, NapiCallbackInfo& info, std::shared_ptr &monitor, TimeoutCallback &opt, int64_t &timeout); - NativeValue *ParseTimeoutCallbackPara( - NativeEngine &engine, NativeCallbackInfo &info, TimeoutCallback &opt, int64_t &timeout); - NativeValue *ParsePrintPara(NativeEngine &engine, NativeCallbackInfo &info, std::string &msg); - NativeValue *ParseExecuteShellCommandPara( - NativeEngine &engine, NativeCallbackInfo &info, std::string &cmd, TimeoutCallback &opt, int64_t &timeout); - NativeValue *ParseAbilityCommonPara( - NativeEngine &engine, NativeCallbackInfo &info, sptr &remoteObject); - NativeValue *ParseStartAbilityPara( - NativeEngine &engine, NativeCallbackInfo &info, AAFwk::Want &want); - NativeValue *ParseFinishTestPara(NativeEngine &engine, NativeCallbackInfo &info, std::string &msg, int64_t &code); + napi_value ParseTimeoutCallbackPara( + napi_env env, NapiCallbackInfo& info, TimeoutCallback &opt, int64_t &timeout); + napi_value ParsePrintPara(napi_env env, NapiCallbackInfo& info, std::string &msg); + napi_value ParseExecuteShellCommandPara( + napi_env env, NapiCallbackInfo& info, std::string &cmd, TimeoutCallback &opt, int64_t &timeout); + napi_value ParseAbilityCommonPara( + napi_env env, NapiCallbackInfo& info, sptr &remoteObject); + napi_value ParseStartAbilityPara( + napi_env env, NapiCallbackInfo& info, AAFwk::Want &want); + napi_value ParseFinishTestPara(napi_env env, NapiCallbackInfo& info, std::string &msg, int64_t &code); bool ParseMockListPara( - NativeEngine &engine, NativeCallbackInfo &info, std::map &mockList); - bool ParseArrayStringValue(NativeEngine &engine, NativeValue* param, std::vector &value); + napi_env env, NapiCallbackInfo& info, std::map &mockList); + bool ParseArrayStringValue(napi_env env, napi_value param, std::vector &value); void AddStageMonitorRecord( - NativeEngine &engine, NativeValue *value, const std::shared_ptr &monitor); - void RemoveStageMonitorRecord(NativeValue *value); + napi_env env, napi_value value, const std::shared_ptr &monitor); + void RemoveStageMonitorRecord(napi_env env, napi_value value); }; } // namespace AbilityDelegatorJs } // namespace OHOS diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.cpp b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.cpp index f8a38640f96..35d2bf9c403 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.cpp +++ b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.cpp @@ -34,43 +34,43 @@ public: JsAbilityDelegatorRegistry() = default; ~JsAbilityDelegatorRegistry() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint) + static void Finalizer(napi_env env, void *data, void *hint) { HILOG_INFO("enter"); reference.reset(); std::unique_ptr(static_cast(data)); } - static NativeValue *GetAbilityDelegator(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value GetAbilityDelegator(napi_env env, napi_callback_info info) { - JsAbilityDelegatorRegistry *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetAbilityDelegator(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAbilityDelegatorRegistry, OnGetAbilityDelegator); } - static NativeValue *GetArguments(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value GetArguments(napi_env env, napi_callback_info info) { - JsAbilityDelegatorRegistry *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetArguments(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAbilityDelegatorRegistry, OnGetArguments); } private: - NativeValue *OnGetAbilityDelegator(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnGetAbilityDelegator(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("enter"); if (!AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator()) { HILOG_ERROR("Failed to get delegator object"); - return engine.CreateNull(); + return CreateJsNull(env); } if (!reference) { - auto value = CreateJsAbilityDelegator(engine); - reference.reset(engine.CreateReference(value, 1)); + auto value = CreateJsAbilityDelegator(env); + napi_ref ref = nullptr; + napi_create_reference(env, value, 1, &ref); + reference.reset(reinterpret_cast(ref)); } - return reference->Get(); + return reference->GetNapiValue(); } - NativeValue *OnGetArguments(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnGetArguments(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("enter"); @@ -78,64 +78,60 @@ private: AppExecFwk::AbilityDelegatorRegistry::GetArguments(); if (!abilityDelegatorArgs) { HILOG_ERROR("Failed to get delegator args object"); - return engine.CreateNull(); + return CreateJsNull(env); } - return CreateJsAbilityDelegatorArguments(engine, abilityDelegatorArgs); + return CreateJsAbilityDelegatorArguments(env, abilityDelegatorArgs); } }; } // namespace -NativeValue *JsAbilityDelegatorRegistryInit(NativeEngine *engine, NativeValue *exportObj) +napi_value JsAbilityDelegatorRegistryInit(napi_env env, napi_value exportObj) { HILOG_INFO("enter"); - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_ERROR("Invalid input parameters"); return nullptr; } - NativeObject *object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_ERROR("Failed to get object"); - return nullptr; - } - - std::unique_ptr jsDelegatorManager = - std::make_unique(); - object->SetNativePointer(jsDelegatorManager.release(), JsAbilityDelegatorRegistry::Finalizer, nullptr); + std::unique_ptr jsDelegatorManager = std::make_unique(); + napi_wrap(env, exportObj, jsDelegatorManager.release(), JsAbilityDelegatorRegistry::Finalizer, nullptr, nullptr); const char *moduleName = "JsAbilityDelegatorRegistry"; - BindNativeFunction(*engine, *object, "getAbilityDelegator", moduleName, + BindNativeFunction(env, exportObj, "getAbilityDelegator", moduleName, JsAbilityDelegatorRegistry::GetAbilityDelegator); - BindNativeFunction(*engine, *object, "getArguments", moduleName, JsAbilityDelegatorRegistry::GetArguments); + BindNativeFunction(env, exportObj, "getArguments", moduleName, JsAbilityDelegatorRegistry::GetArguments); - object->SetProperty("AbilityLifecycleState", AbilityLifecycleStateInit(engine)); + napi_set_named_property(env, exportObj, "AbilityLifecycleState", + AbilityLifecycleStateInit(env)); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } -NativeValue *AbilityLifecycleStateInit(NativeEngine *engine) +napi_value AbilityLifecycleStateInit(napi_env env) { HILOG_INFO("enter"); - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("Invalid input parameters"); return nullptr; } - NativeValue *objValue = engine->CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } - - object->SetProperty("UNINITIALIZED", CreateJsValue(*engine, - static_cast(AbilityLifecycleState::UNINITIALIZED))); - object->SetProperty("CREATE", CreateJsValue(*engine, static_cast(AbilityLifecycleState::CREATE))); - object->SetProperty("FOREGROUND", CreateJsValue(*engine, static_cast(AbilityLifecycleState::FOREGROUND))); - object->SetProperty("BACKGROUND", CreateJsValue(*engine, static_cast(AbilityLifecycleState::BACKGROUND))); - object->SetProperty("DESTROY", CreateJsValue(*engine, static_cast(AbilityLifecycleState::DESTROY))); + napi_set_named_property(env, objValue, "UNINITIALIZED", + CreateJsValue(env, static_cast(AbilityLifecycleState::UNINITIALIZED))); + napi_set_named_property(env, objValue, "CREATE", + CreateJsValue(env, static_cast(AbilityLifecycleState::CREATE))); + napi_set_named_property(env, objValue, "FOREGROUND", + CreateJsValue(env, static_cast(AbilityLifecycleState::FOREGROUND))); + napi_set_named_property(env, objValue, "BACKGROUND", + CreateJsValue(env, static_cast(AbilityLifecycleState::BACKGROUND))); + napi_set_named_property(env, objValue, "DESTROY", + CreateJsValue(env, static_cast(AbilityLifecycleState::DESTROY))); return objValue; } diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.h b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.h index aee462b7ff1..bf75f8ba7c6 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.h +++ b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_registry.h @@ -43,8 +43,8 @@ enum class AbilityLifecycleState { DESTROY, }; -NativeValue *JsAbilityDelegatorRegistryInit(NativeEngine *engine, NativeValue *exportObj); -NativeValue *AbilityLifecycleStateInit(NativeEngine *engine); +napi_value JsAbilityDelegatorRegistryInit(napi_env env, napi_value exportObj); +napi_value AbilityLifecycleStateInit(napi_env env); } // namespace AbilityDelegatorJs } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_ABILITY_DELEGATOR_REGISTRY_H diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.cpp b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.cpp index bff94771a37..ff915418af9 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.cpp +++ b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.cpp @@ -24,90 +24,94 @@ namespace OHOS { namespace AbilityDelegatorJs { using namespace OHOS::AbilityRuntime; -NativeValue *CreateJsAbilityDelegator(NativeEngine &engine) +napi_value CreateJsAbilityDelegator(napi_env env) { HILOG_INFO("enter"); - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); - return engine.CreateNull(); + return nullptr; } std::unique_ptr jsAbilityDelegator = std::make_unique(); - object->SetNativePointer(jsAbilityDelegator.release(), JSAbilityDelegator::Finalizer, nullptr); + napi_wrap(env, objValue, jsAbilityDelegator.release(), JSAbilityDelegator::Finalizer, nullptr, nullptr); const char *moduleName = "JSAbilityDelegator"; - BindNativeFunction(engine, *object, "addAbilityMonitor", moduleName, JSAbilityDelegator::AddAbilityMonitor); - BindNativeFunction(engine, *object, "addAbilityStageMonitor", + BindNativeFunction(env, objValue, "addAbilityMonitor", moduleName, JSAbilityDelegator::AddAbilityMonitor); + BindNativeFunction(env, objValue, "addAbilityStageMonitor", moduleName, JSAbilityDelegator::AddAbilityStageMonitor); - BindNativeFunction(engine, *object, "removeAbilityMonitor", moduleName, JSAbilityDelegator::RemoveAbilityMonitor); - BindNativeFunction(engine, *object, "removeAbilityStageMonitor", + BindNativeFunction(env, objValue, "removeAbilityMonitor", moduleName, JSAbilityDelegator::RemoveAbilityMonitor); + BindNativeFunction(env, objValue, "removeAbilityStageMonitor", moduleName, JSAbilityDelegator::RemoveAbilityStageMonitor); - BindNativeFunction(engine, *object, "waitAbilityMonitor", moduleName, JSAbilityDelegator::WaitAbilityMonitor); - BindNativeFunction(engine, *object, "waitAbilityStageMonitor", + BindNativeFunction(env, objValue, "waitAbilityMonitor", moduleName, JSAbilityDelegator::WaitAbilityMonitor); + BindNativeFunction(env, objValue, "waitAbilityStageMonitor", moduleName, JSAbilityDelegator::WaitAbilityStageMonitor); - BindNativeFunction(engine, *object, "getAppContext", moduleName, JSAbilityDelegator::GetAppContext); - BindNativeFunction(engine, *object, "getAbilityState", moduleName, JSAbilityDelegator::GetAbilityState); - BindNativeFunction(engine, *object, "getCurrentTopAbility", moduleName, JSAbilityDelegator::GetCurrentTopAbility); - BindNativeFunction(engine, *object, "startAbility", moduleName, JSAbilityDelegator::StartAbility); - BindNativeFunction(engine, *object, "doAbilityForeground", moduleName, JSAbilityDelegator::DoAbilityForeground); - BindNativeFunction(engine, *object, "doAbilityBackground", moduleName, JSAbilityDelegator::DoAbilityBackground); - BindNativeFunction(engine, *object, "print", moduleName, JSAbilityDelegator::Print); - BindNativeFunction(engine, *object, "printSync", moduleName, JSAbilityDelegator::PrintSync); - BindNativeFunction(engine, *object, "executeShellCommand", moduleName, JSAbilityDelegator::ExecuteShellCommand); - BindNativeFunction(engine, *object, "finishTest", moduleName, JSAbilityDelegator::FinishTest); - BindNativeFunction(engine, *object, "addAbilityMonitorSync", moduleName, JSAbilityDelegator::AddAbilityMonitorSync); - BindNativeFunction(engine, *object, "addAbilityStageMonitorSync", + BindNativeFunction(env, objValue, "getAppContext", moduleName, JSAbilityDelegator::GetAppContext); + BindNativeFunction(env, objValue, "getAbilityState", moduleName, JSAbilityDelegator::GetAbilityState); + BindNativeFunction(env, objValue, "getCurrentTopAbility", moduleName, JSAbilityDelegator::GetCurrentTopAbility); + BindNativeFunction(env, objValue, "startAbility", moduleName, JSAbilityDelegator::StartAbility); + BindNativeFunction(env, objValue, "doAbilityForeground", moduleName, JSAbilityDelegator::DoAbilityForeground); + BindNativeFunction(env, objValue, "doAbilityBackground", moduleName, JSAbilityDelegator::DoAbilityBackground); + BindNativeFunction(env, objValue, "print", moduleName, JSAbilityDelegator::Print); + BindNativeFunction(env, objValue, "printSync", moduleName, JSAbilityDelegator::PrintSync); + BindNativeFunction(env, objValue, "executeShellCommand", moduleName, JSAbilityDelegator::ExecuteShellCommand); + BindNativeFunction(env, objValue, "finishTest", moduleName, JSAbilityDelegator::FinishTest); + BindNativeFunction(env, objValue, "addAbilityMonitorSync", moduleName, JSAbilityDelegator::AddAbilityMonitorSync); + BindNativeFunction(env, objValue, "addAbilityStageMonitorSync", moduleName, JSAbilityDelegator::AddAbilityStageMonitorSync); - BindNativeFunction(engine, *object, "removeAbilityMonitorSync", moduleName, + BindNativeFunction(env, objValue, "removeAbilityMonitorSync", moduleName, JSAbilityDelegator::RemoveAbilityMonitorSync); - BindNativeFunction(engine, *object, "removeAbilityStageMonitorSync", + BindNativeFunction(env, objValue, "removeAbilityStageMonitorSync", moduleName, JSAbilityDelegator::RemoveAbilityStageMonitorSync); - BindNativeFunction(engine, *object, "setMockList", moduleName, JSAbilityDelegator::SetMockList); + BindNativeFunction(env, objValue, "setMockList", moduleName, JSAbilityDelegator::SetMockList); return objValue; } -NativeValue *SetAbilityDelegatorArgumentsPara(NativeEngine &engine, const std::map ¶s) +napi_value SetAbilityDelegatorArgumentsPara(napi_env env, const std::map ¶s) { HILOG_INFO("enter"); - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } auto iter = paras.begin(); for (; iter != paras.end(); ++iter) { - object->SetProperty(iter->first.c_str(), CreateJsValue(engine, iter->second)); + napi_set_named_property(env, objValue, iter->first.c_str(), + CreateJsValue(env, iter->second)); } return objValue; } -NativeValue *CreateJsAbilityDelegatorArguments( - NativeEngine &engine, const std::shared_ptr &abilityDelegatorArgs) +napi_value CreateJsAbilityDelegatorArguments( + napi_env env, const std::shared_ptr &abilityDelegatorArgs) { HILOG_INFO("enter"); - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); - return engine.CreateNull(); + return CreateJsNull(env); } - object->SetProperty("bundleName", CreateJsValue(engine, abilityDelegatorArgs->GetTestBundleName())); - object->SetProperty("parameters", - SetAbilityDelegatorArgumentsPara(engine, abilityDelegatorArgs->GetTestParam())); - object->SetProperty("testCaseNames", CreateJsValue(engine, abilityDelegatorArgs->GetTestCaseName())); - object->SetProperty("testRunnerClassName", CreateJsValue(engine, abilityDelegatorArgs->GetTestRunnerClassName())); + napi_set_named_property(env, objValue, "bundleName", + CreateJsValue(env, abilityDelegatorArgs->GetTestBundleName())); + napi_set_named_property(env, objValue, "parameters", + SetAbilityDelegatorArgumentsPara(env, abilityDelegatorArgs->GetTestParam())); + napi_set_named_property(env, objValue, "testCaseNames", + CreateJsValue(env, abilityDelegatorArgs->GetTestCaseName())); + napi_set_named_property(env, objValue, "testRunnerClassName", + CreateJsValue(env, abilityDelegatorArgs->GetTestRunnerClassName())); return objValue; } -NativeValue *CreateJsShellCmdResult(NativeEngine &engine, std::unique_ptr &shellResult) +napi_value CreateJsShellCmdResult(napi_env env, std::unique_ptr &shellResult) { HILOG_INFO("enter"); @@ -116,15 +120,15 @@ NativeValue *CreateJsShellCmdResult(NativeEngine &engine, std::unique_ptr(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } - object->SetProperty("stdResult", CreateJsValue(engine, shellResult->GetStdResult())); - object->SetProperty("exitCode", CreateJsValue(engine, shellResult->GetExitCode())); + napi_set_named_property(env, objValue, "stdResult", CreateJsValue(env, shellResult->GetStdResult())); + napi_set_named_property(env, objValue, "exitCode", CreateJsValue(env, shellResult->GetExitCode())); return objValue; } diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.h b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.h index 049c6e80c5b..523316215dc 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.h +++ b/frameworks/js/napi/app/ability_delegator/js_ability_delegator_utils.h @@ -25,10 +25,10 @@ namespace OHOS { namespace AbilityDelegatorJs { -NativeValue *CreateJsAbilityDelegator(NativeEngine &engine); -NativeValue *CreateJsAbilityDelegatorArguments( - NativeEngine &engine, const std::shared_ptr &abilityDelegatorArgs); -NativeValue *CreateJsShellCmdResult(NativeEngine &engine, std::unique_ptr &shellResult); +napi_value CreateJsAbilityDelegator(napi_env env); +napi_value CreateJsAbilityDelegatorArguments( + napi_env env, const std::shared_ptr &abilityDelegatorArgs); +napi_value CreateJsShellCmdResult(napi_env env, std::unique_ptr &shellResult); } // namespace AbilityDelegatorJs } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_ABILITY_DELEGATOR_UTILS_H diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_monitor.cpp b/frameworks/js/napi/app/ability_delegator/js_ability_monitor.cpp index dac5c84e8ad..4961f2c2e73 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_monitor.cpp +++ b/frameworks/js/napi/app/ability_delegator/js_ability_monitor.cpp @@ -91,14 +91,16 @@ void JSAbilityMonitor::OnWindowStageDestroy(const std::weak_ptr HILOG_INFO("end"); } -void JSAbilityMonitor::SetJsAbilityMonitor(NativeValue *jsAbilityMonitor) +void JSAbilityMonitor::SetJsAbilityMonitor(napi_value jsAbilityMonitor) { HILOG_INFO("enter"); - jsAbilityMonitor_ = std::unique_ptr(engine_->CreateReference(jsAbilityMonitor, 1)); + napi_ref ref = nullptr; + napi_create_reference(env_, jsAbilityMonitor, 1, &ref); + jsAbilityMonitor_ = std::unique_ptr(reinterpret_cast(ref)); } -NativeValue *JSAbilityMonitor::CallLifecycleCBFunction(const std::string &functionName, +napi_value JSAbilityMonitor::CallLifecycleCBFunction(const std::string &functionName, const std::weak_ptr &abilityObj) { if (functionName.empty()) { @@ -111,26 +113,28 @@ NativeValue *JSAbilityMonitor::CallLifecycleCBFunction(const std::string &functi return nullptr; } - auto value = jsAbilityMonitor_->Get(); - auto obj = ConvertNativeValueTo(value); + napi_value obj = jsAbilityMonitor_->GetNapiValue(); if (obj == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } - auto method = obj->GetProperty(functionName.data()); + napi_value method = nullptr; + napi_get_named_property(env_, obj, functionName.data(), &method); if (method == nullptr) { HILOG_ERROR("Failed to get %{public}s from object", functionName.data()); return nullptr; } - auto nativeAbilityObj = engine_->CreateNull(); + auto nativeAbilityObj = CreateJsNull(env_); if (!abilityObj.expired()) { - nativeAbilityObj = abilityObj.lock()->Get(); + nativeAbilityObj = abilityObj.lock()->GetNapiValue(); } - NativeValue* argv[] = { nativeAbilityObj }; - return engine_->CallFunction(value, method, argv, ArraySize(argv)); + napi_value argv[] = { nativeAbilityObj }; + napi_value callResult = nullptr; + napi_call_function(env_, obj, method, ArraySize(argv), argv, &callResult); + return callResult; } } // namespace AbilityDelegatorJs } // namespace OHOS diff --git a/frameworks/js/napi/app/ability_delegator/js_ability_monitor.h b/frameworks/js/napi/app/ability_delegator/js_ability_monitor.h index c369ae38518..2ce1007e6fd 100644 --- a/frameworks/js/napi/app/ability_delegator/js_ability_monitor.h +++ b/frameworks/js/napi/app/ability_delegator/js_ability_monitor.h @@ -110,16 +110,16 @@ public: * * @param jsAbilityMonitor Indicates the js object. */ - void SetJsAbilityMonitor(NativeValue *jsAbilityMonitor); + void SetJsAbilityMonitor(napi_value jsAbilityMonitor); /** - * Sets the native engine. + * Sets the native env. * - * @param engine Indicates the native engine. + * @param env Indicates the native env. */ - void SetJsAbilityMonitorEnv(NativeEngine *engine) + void SetJsAbilityMonitorEnv(napi_env env) { - engine_ = engine; + env_ = env; } /** @@ -133,13 +133,13 @@ public: } private: - NativeValue *CallLifecycleCBFunction(const std::string &functionName, + napi_value CallLifecycleCBFunction(const std::string &functionName, const std::weak_ptr &abilityObj); private: std::string abilityName_ = ""; std::string moduleName_ = ""; - NativeEngine* engine_ = nullptr; + napi_env env_ = nullptr; std::unique_ptr jsAbilityMonitor_ = nullptr; }; } // namespace AbilityDelegatorJs diff --git a/frameworks/js/napi/app/ability_delegator/native_module.cpp b/frameworks/js/napi/app/ability_delegator/native_module.cpp index 58668222bb9..a70e66187c7 100644 --- a/frameworks/js/napi/app/ability_delegator/native_module.cpp +++ b/frameworks/js/napi/app/ability_delegator/native_module.cpp @@ -15,22 +15,22 @@ #include "native_engine/native_engine.h" #include "js_ability_delegator_registry.h" -extern "C" __attribute__((constructor)) void NAPI_application_AbilityDelegatorRegistry_AutoRegister() -{ #ifdef ENABLE_ERRCODE - NativeModule newModuleInfo = { - .name = "app.ability.abilityDelegatorRegistry", - .fileName = "app/ability/libabilitydelegator_napi.so/ability_delegator_registry.js", - .registerCallback = OHOS::AbilityDelegatorJs::JsAbilityDelegatorRegistryInit, - }; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.abilityDelegatorRegistry", + .nm_filename = "app/ability/libabilitydelegator_napi.so/ability_delegator_registry.js", + .nm_register_func = OHOS::AbilityDelegatorJs::JsAbilityDelegatorRegistryInit, +}; #else - NativeModule newModuleInfo = { - .name = "application.abilityDelegatorRegistry", - .fileName = "application/libabilitydelegator_napi.so/ability_delegator_registry.js", - .registerCallback = OHOS::AbilityDelegatorJs::JsAbilityDelegatorRegistryInit, - }; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.abilityDelegatorRegistry", + .nm_filename = "application/libabilitydelegator_napi.so/ability_delegator_registry.js", + .nm_register_func = OHOS::AbilityDelegatorJs::JsAbilityDelegatorRegistryInit, +}; #endif - - auto moduleManager = NativeModuleManager::GetInstance(); - moduleManager->Register(&newModuleInfo); +extern "C" __attribute__((constructor)) void NAPI_application_AbilityDelegatorRegistry_AutoRegister(void) +{ + napi_module_register(&_module); } diff --git a/frameworks/js/napi/app/ability_stage/ability_stage_module.cpp b/frameworks/js/napi/app/ability_stage/ability_stage_module.cpp index abcef9b26fc..b3afdcee96a 100644 --- a/frameworks/js/napi/app/ability_stage/ability_stage_module.cpp +++ b/frameworks/js/napi/app/ability_stage/ability_stage_module.cpp @@ -20,6 +20,17 @@ extern const char _binary_ability_stage_js_end[]; extern const char _binary_ability_stage_abc_start[]; extern const char _binary_ability_stage_abc_end[]; +static napi_module _module = { +#ifdef ENABLE_ERRCODE + .nm_version = 0, + .nm_modname = "app.ability.AbilityStage", + .nm_filename = "app/ability/libabilitystage.so/ability_stage.js", +#else + .nm_version = 0, + .nm_modname = "application.AbilityStage", + .nm_filename = "application/libabilitystage_napi.so/ability_stage.js", +#endif +}; extern "C" __attribute__((constructor)) #ifdef ENABLE_ERRCODE void NAPI_app_ability_AbilityStage_AutoRegister() @@ -27,18 +38,7 @@ void NAPI_app_ability_AbilityStage_AutoRegister() void NAPI_application_AbilityStage_AutoRegister() #endif { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { -#ifdef ENABLE_ERRCODE - .name = "app.ability.AbilityStage", - .fileName = "app/ability/libabilitystage.so/ability_stage.js", -#else - .name = "application.AbilityStage", - .fileName = "application/libabilitystage_napi.so/ability_stage.js", -#endif - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/app/ability_stage_context/ability_stage_context_module.cpp b/frameworks/js/napi/app/ability_stage_context/ability_stage_context_module.cpp index 13376a464ad..ec16a8ab447 100644 --- a/frameworks/js/napi/app/ability_stage_context/ability_stage_context_module.cpp +++ b/frameworks/js/napi/app/ability_stage_context/ability_stage_context_module.cpp @@ -20,16 +20,16 @@ extern const char _binary_ability_stage_context_js_end[]; extern const char _binary_ability_stage_context_abc_start[]; extern const char _binary_ability_stage_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.AbilityStageContext", + .nm_filename = "application/libabilitystagecontext_napi.so/ability_stage_context.js", +}; + extern "C" __attribute__((constructor)) void NAPI_application_AbilityStageContext_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.AbilityStageContext", - .fileName = "application/libabilitystagecontext_napi.so/ability_stage_context.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp b/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp index 5beead82acd..517abb8735a 100644 --- a/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp +++ b/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp @@ -225,7 +225,7 @@ void JSAppStateObserver::CallJsFunction( return; } napi_value callResult = nullptr; - napi_call_function(env_, nullptr, method, argc, argv, &callResult); + napi_call_function(env_, value, method, argc, argv, &callResult); HILOG_INFO("CallJsFunction end"); } diff --git a/frameworks/js/napi/app/application_context/application_context_module.cpp b/frameworks/js/napi/app/application_context/application_context_module.cpp index 810782ac357..3e1d2b8d1f0 100644 --- a/frameworks/js/napi/app/application_context/application_context_module.cpp +++ b/frameworks/js/napi/app/application_context/application_context_module.cpp @@ -20,16 +20,16 @@ extern const char _binary_application_context_js_end[]; extern const char _binary_application_context_abc_start[]; extern const char _binary_application_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.ApplicationContext", + .nm_filename = "application/libapplicationcontext_napi.so/application_context.js", +}; + extern "C" __attribute__((constructor)) void NAPI_application_ApplicationContext_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.ApplicationContext", - .fileName = "application/libapplicationcontext_napi.so/application_context.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/app/context/context_module.cpp b/frameworks/js/napi/app/context/context_module.cpp index 229d335977a..ba86d643132 100644 --- a/frameworks/js/napi/app/context/context_module.cpp +++ b/frameworks/js/napi/app/context/context_module.cpp @@ -20,16 +20,16 @@ extern const char _binary_context_js_end[]; extern const char _binary_context_abc_start[]; extern const char _binary_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.Context", + .nm_filename = "application/libcontext_napi.so/context.js", +}; + extern "C" __attribute__((constructor)) void NAPI_application_Context_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.Context", - .fileName = "application/libcontext_napi.so/context.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/app/error_manager/error_manager_module.cpp b/frameworks/js/napi/app/error_manager/error_manager_module.cpp index d68b42be64e..9bdd36739f8 100644 --- a/frameworks/js/napi/app/error_manager/error_manager_module.cpp +++ b/frameworks/js/napi/app/error_manager/error_manager_module.cpp @@ -16,29 +16,26 @@ #include "js_error_manager.h" #include "native_engine/native_engine.h" -extern "C" __attribute__((constructor)) #ifdef ENABLE_ERRCODE -void NAPI_app_ability_ErrorManager_AutoRegister() +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.errorManager", + .nm_filename = "app/ability/errormanager_napi.so/error_manager.js", + .nm_register_func = OHOS::AbilityRuntime::JsErrorManagerInit, +}; +extern "C" __attribute__((constructor)) void NAPI_app_ability_ErrorManager_AutoRegister() { - NativeModule newModuleInfo = { - .name = "app.ability.errorManager", - .fileName = "app/ability/errormanager_napi.so/error_manager.js", - .registerCallback = OHOS::AbilityRuntime::JsErrorManagerInit, - }; - - auto moduleManager = NativeModuleManager::GetInstance(); - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } #else -void NAPI_application_ErrorManager_AutoRegister() +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.errorManager", + .nm_filename = "application/errormanager_napi.so/error_manager.js", + .nm_register_func = OHOS::AbilityRuntime::JsErrorManagerInit, +}; +extern "C" __attribute__((constructor)) void NAPI_app_ability_ErrorManager_AutoRegister() { - NativeModule newModuleInfo = { - .name = "application.errorManager", - .fileName = "application/errormanager_napi.so/error_manager.js", - .registerCallback = OHOS::AbilityRuntime::JsErrorManagerInit, - }; - - auto moduleManager = NativeModuleManager::GetInstance(); - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } #endif diff --git a/frameworks/js/napi/app/error_manager/js_error_manager.cpp b/frameworks/js/napi/app/error_manager/js_error_manager.cpp index 666888af016..7980a9bf022 100644 --- a/frameworks/js/napi/app/error_manager/js_error_manager.cpp +++ b/frameworks/js/napi/app/error_manager/js_error_manager.cpp @@ -42,49 +42,47 @@ public: JsErrorManager() {} ~JsErrorManager() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsErrorManager Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* On(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value On(napi_env env, napi_callback_info info) { - JsErrorManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnOn(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsErrorManager, OnOn); } - static NativeValue* Off(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value Off(napi_env env, napi_callback_info info) { - JsErrorManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnOff(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsErrorManager, OnOff); } private: - NativeValue* OnOn(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnOn(napi_env env, const size_t argc, napi_value* argv) { HILOG_DEBUG("called."); - std::string type = ParseParamType(engine, info); + std::string type = ParseParamType(env, argc, argv); if (type == ON_OFF_TYPE_SYNC) { - return OnOnNew(engine, info); + return OnOnNew(env, argc, argv); } - return OnOnOld(engine, info); + return OnOnOld(env, argc, argv); } - NativeValue* OnOnOld(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnOnOld(napi_env env, const size_t argc, napi_value* argv) { HILOG_DEBUG("called."); - if (info.argc != ARGC_TWO) { + if (argc != ARGC_TWO) { HILOG_ERROR("The param is invalid, observers need."); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string type; - if (!ConvertFromJsValue(engine, info.argv[INDEX_ZERO], type) || type != ON_OFF_TYPE) { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + if (!ConvertFromJsValue(env, argv[INDEX_ZERO], type) || type != ON_OFF_TYPE) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); HILOG_ERROR("Parse type failed"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int32_t observerId = serialNumber_; if (serialNumber_ < INT32_MAX) { @@ -95,26 +93,26 @@ private: if (observer_ == nullptr) { // create observer - observer_ = std::make_shared(engine); + observer_ = std::make_shared(env); AppExecFwk::ApplicationDataManager::GetInstance().AddErrorObserver(observer_); } - observer_->AddJsObserverObject(observerId, info.argv[INDEX_ONE]); - return engine.CreateNumber(observerId); + observer_->AddJsObserverObject(observerId, argv[INDEX_ONE]); + return CreateJsValue(env, observerId); } - NativeValue* OnOnNew(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnOnNew(napi_env env, const size_t argc, napi_value* argv) { HILOG_DEBUG("called."); - if (info.argc < ARGC_TWO) { + if (argc < ARGC_TWO) { HILOG_ERROR("The param is invalid, observers need."); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_OBJECT) { + if (!CheckTypeForNapiValue(env, argv[INDEX_ONE], napi_object)) { HILOG_ERROR("Invalid param"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t observerId = serialNumber_; @@ -126,55 +124,54 @@ private: if (observer_ == nullptr) { // create observer - observer_ = std::make_shared(engine); + observer_ = std::make_shared(env); AppExecFwk::ApplicationDataManager::GetInstance().AddErrorObserver(observer_); } - observer_->AddJsObserverObject(observerId, info.argv[INDEX_ONE], true); - return engine.CreateNumber(observerId); + observer_->AddJsObserverObject(observerId, argv[INDEX_ONE], true); + return CreateJsValue(env, observerId); } - NativeValue* OnOff(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnOff(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called."); - std::string type = ParseParamType(engine, info); + std::string type = ParseParamType(env, argc, argv); if (type == ON_OFF_TYPE_SYNC) { - return OnOffNew(engine, info); + return OnOffNew(env, argc, argv); } - return OnOffOld(engine, info); + return OnOffOld(env, argc, argv); } - NativeValue* OnOffOld(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnOffOld(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called."); int32_t observerId = -1; - if (info.argc != ARGC_TWO && info.argc != ARGC_THREE) { - ThrowTooFewParametersError(engine); + if (argc != ARGC_TWO && argc != ARGC_THREE) { + ThrowTooFewParametersError(env); HILOG_ERROR("unregister errorObserver error, not enough params."); } else { - napi_get_value_int32(reinterpret_cast(&engine), - reinterpret_cast(info.argv[INDEX_ONE]), &observerId); + napi_get_value_int32(env, argv[INDEX_ONE], &observerId); HILOG_INFO("unregister errorObserver called, observer:%{public}d", observerId); } std::string type; - if (!ConvertFromJsValue(engine, info.argv[INDEX_ZERO], type) || type != ON_OFF_TYPE) { + if (!ConvertFromJsValue(env, argv[INDEX_ZERO], type) || type != ON_OFF_TYPE) { HILOG_ERROR("Parse type failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = + NapiAsyncTask::CompleteCallback complete = [&observer = observer_, observerId]( - NativeEngine& engine, AsyncTask& task, int32_t status) { + napi_env env, NapiAsyncTask& task, int32_t status) { HILOG_INFO("Unregister errorObserver called."); if (observerId == -1) { - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM)); return; } if (observer && observer->RemoveJsObserverObject(observerId)) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INVALID_ID)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INVALID_ID)); } if (observer && observer->IsEmpty()) { AppExecFwk::ApplicationDataManager::GetInstance().RemoveErrorObserver(); @@ -182,49 +179,49 @@ private: } }; - NativeValue* lastParam = (info.argc <= ARGC_TWO) ? nullptr : info.argv[INDEX_TWO]; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSErrorManager::OnUnregisterErrorObserver", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= ARGC_TWO) ? nullptr : argv[INDEX_TWO]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSErrorManager::OnUnregisterErrorObserver", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnOffNew(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnOffNew(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called."); - if (info.argc < ARGC_TWO) { - ThrowTooFewParametersError(engine); + if (argc < ARGC_TWO) { + ThrowTooFewParametersError(env); HILOG_ERROR("unregister errorObserver error, not enough params."); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int32_t observerId = -1; - if (!ConvertFromJsValue(engine, info.argv[INDEX_ONE], observerId)) { + if (!ConvertFromJsValue(env, argv[INDEX_ONE], observerId)) { HILOG_ERROR("Parse observerId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } if (observer_ == nullptr) { HILOG_ERROR("observer is nullptr"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } if (observer_->RemoveJsObserverObject(observerId, true)) { HILOG_DEBUG("RemoveJsObserverObject success"); } else { HILOG_ERROR("RemoveJsObserverObject failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_ID); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_ID); } if (observer_->IsEmpty()) { AppExecFwk::ApplicationDataManager::GetInstance().RemoveErrorObserver(); observer_ = nullptr; } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - std::string ParseParamType(NativeEngine& engine, const NativeCallbackInfo& info) + std::string ParseParamType(napi_env env, const size_t argc, napi_value* argv) { std::string type; - if (info.argc > INDEX_ZERO && ConvertFromJsValue(engine, info.argv[INDEX_ZERO], type)) { + if (argc > INDEX_ZERO && ConvertFromJsValue(env, argv[INDEX_ZERO], type)) { return type; } return ""; @@ -235,28 +232,21 @@ private: }; } // namespace -NativeValue* JsErrorManagerInit(NativeEngine* engine, NativeValue* exportObj) +napi_value JsErrorManagerInit(napi_env env, napi_value exportObj) { HILOG_INFO("Js error manager Init."); - if (engine == nullptr || exportObj == nullptr) { - HILOG_INFO("engine or exportObj null"); + if (env == nullptr || exportObj == nullptr) { + HILOG_INFO("env or exportObj null"); return nullptr; } - - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_INFO("object is nullptr"); - return nullptr; - } - std::unique_ptr jsErrorManager = std::make_unique(); - object->SetNativePointer(jsErrorManager.release(), JsErrorManager::Finalizer, nullptr); + napi_wrap(env, exportObj, jsErrorManager.release(), JsErrorManager::Finalizer, nullptr, nullptr); HILOG_INFO("JsErrorManager BindNativeFunction called"); const char *moduleName = "JsErrorManager"; - BindNativeFunction(*engine, *object, "on", moduleName, JsErrorManager::On); - BindNativeFunction(*engine, *object, "off", moduleName, JsErrorManager::Off); - return engine->CreateUndefined(); + BindNativeFunction(env, exportObj, "on", moduleName, JsErrorManager::On); + BindNativeFunction(env, exportObj, "off", moduleName, JsErrorManager::Off); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/app/error_manager/js_error_manager.h b/frameworks/js/napi/app/error_manager/js_error_manager.h index be76362c869..e4f1b85b2a5 100644 --- a/frameworks/js/napi/app/error_manager/js_error_manager.h +++ b/frameworks/js/napi/app/error_manager/js_error_manager.h @@ -21,7 +21,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* JsErrorManagerInit(NativeEngine* engine, NativeValue* exportObj); +napi_value JsErrorManagerInit(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_ERROR_MANAGER_H diff --git a/frameworks/js/napi/app/error_manager/js_error_observer.cpp b/frameworks/js/napi/app/error_manager/js_error_observer.cpp index 554969c7a09..b68722b0d5a 100644 --- a/frameworks/js/napi/app/error_manager/js_error_observer.cpp +++ b/frameworks/js/napi/app/error_manager/js_error_observer.cpp @@ -25,7 +25,7 @@ namespace OHOS { namespace AbilityRuntime { constexpr size_t ARGC_ONE = 1; -JsErrorObserver::JsErrorObserver(NativeEngine &engine) : engine_(engine) {} +JsErrorObserver::JsErrorObserver(napi_env env) : env_(env) {} JsErrorObserver::~JsErrorObserver() = default; @@ -33,17 +33,17 @@ void JsErrorObserver::OnUnhandledException(const std::string errMsg) { HILOG_DEBUG("OnUnhandledException come."); std::weak_ptr thisWeakPtr(shared_from_this()); - std::unique_ptr complete = std::make_unique - ([thisWeakPtr, errMsg](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([thisWeakPtr, errMsg](napi_env env, NapiAsyncTask &task, int32_t status) { std::shared_ptr jsObserver = thisWeakPtr.lock(); if (jsObserver) { jsObserver->HandleOnUnhandledException(errMsg); } }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JsErrorObserver::OnUnhandledException", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JsErrorObserver::OnUnhandledException", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JsErrorObserver::HandleOnUnhandledException(const std::string &errMsg) @@ -51,43 +51,46 @@ void JsErrorObserver::HandleOnUnhandledException(const std::string &errMsg) HILOG_DEBUG("HandleOnUnhandledException come."); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = { CreateJsValue(engine_, errMsg) }; + napi_value value = (item.second)->GetNapiValue(); + napi_value argv[] = { CreateJsValue(env_, errMsg) }; CallJsFunction(value, "onUnhandledException", argv, ARGC_ONE); } tmpMap = jsObserverObjectMapSync_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = { CreateJsValue(engine_, errMsg) }; + napi_value value = (item.second)->GetNapiValue(); + napi_value argv[] = { CreateJsValue(env_, errMsg) }; CallJsFunction(value, "onUnhandledException", argv, ARGC_ONE); } } -void JsErrorObserver::CallJsFunction(NativeValue* value, const char* methodName, NativeValue* const* argv, size_t argc) +void JsErrorObserver::CallJsFunction(napi_value obj, const char* methodName, napi_value const* argv, size_t argc) { HILOG_INFO("CallJsFunction begin, method:%{public}s", methodName); - NativeObject* obj = ConvertNativeValueTo(value); if (obj == nullptr) { HILOG_ERROR("Failed to get object"); return; } - NativeValue* method = obj->GetProperty(methodName); + napi_value method = nullptr; + napi_get_named_property(env_, obj, methodName, &method); if (method == nullptr) { HILOG_ERROR("Failed to get method"); return; } - engine_.CallFunction(value, method, argv, argc); + napi_value callResult = nullptr; + napi_call_function(env_, obj, method, argc, argv, &callResult); } -void JsErrorObserver::AddJsObserverObject(const int32_t observerId, NativeValue* jsObserverObject, bool isSync) +void JsErrorObserver::AddJsObserverObject(const int32_t observerId, napi_value jsObserverObject, bool isSync) { + napi_ref ref = nullptr; + napi_create_reference(env_, jsObserverObject, 1, &ref); if (isSync) { jsObserverObjectMapSync_.emplace( - observerId, std::shared_ptr(engine_.CreateReference(jsObserverObject, 1))); + observerId, std::shared_ptr(reinterpret_cast(ref))); } else { jsObserverObjectMap_.emplace( - observerId, std::shared_ptr(engine_.CreateReference(jsObserverObject, 1))); + observerId, std::shared_ptr(reinterpret_cast(ref))); } } @@ -112,17 +115,17 @@ void JsErrorObserver::OnExceptionObject(const AppExecFwk::ErrorObject &errorObj) { HILOG_DEBUG("OnExceptionObject come."); std::weak_ptr thisWeakPtr(shared_from_this()); - std::unique_ptr complete = std::make_unique - ([thisWeakPtr, errorObj](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([thisWeakPtr, errorObj](napi_env env, NapiAsyncTask &task, int32_t status) { std::shared_ptr jsObserver = thisWeakPtr.lock(); if (jsObserver) { jsObserver->HandleException(errorObj); } }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JsErrorObserver::OnExceptionObject", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JsErrorObserver::OnExceptionObject", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JsErrorObserver::HandleException(const AppExecFwk::ErrorObject &errorObj) @@ -130,31 +133,30 @@ void JsErrorObserver::HandleException(const AppExecFwk::ErrorObject &errorObj) HILOG_DEBUG("HandleException come."); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* jsObj = (item.second)->Get(); - NativeValue* jsValue[] = { CreateJsErrorObject(engine_, errorObj) }; + napi_value jsObj = (item.second)->GetNapiValue(); + napi_value jsValue[] = { CreateJsErrorObject(env_, errorObj) }; CallJsFunction(jsObj, "onException", jsValue, ARGC_ONE); } tmpMap = jsObserverObjectMapSync_; for (auto &item : tmpMap) { - NativeValue* jsObj = (item.second)->Get(); - NativeValue* jsValue[] = { CreateJsErrorObject(engine_, errorObj) }; + napi_value jsObj = (item.second)->GetNapiValue(); + napi_value jsValue[] = { CreateJsErrorObject(env_, errorObj) }; CallJsFunction(jsObj, "onException", jsValue, ARGC_ONE); } } -NativeValue* JsErrorObserver::CreateJsErrorObject(NativeEngine &engine, const AppExecFwk::ErrorObject &errorObj) +napi_value JsErrorObserver::CreateJsErrorObject(napi_env env, const AppExecFwk::ErrorObject &errorObj) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_WARN("invalid object."); return objValue; } - - object->SetProperty("name", CreateJsValue(engine, errorObj.name)); - object->SetProperty("message", CreateJsValue(engine, errorObj.message)); + napi_set_named_property(env, objValue, "name", CreateJsValue(env, errorObj.name)); + napi_set_named_property(env, objValue, "message", CreateJsValue(env, errorObj.message)); if (!errorObj.stack.empty()) { - object->SetProperty("stack", CreateJsValue(engine, errorObj.stack)); + napi_set_named_property(env, objValue, "stack", CreateJsValue(env, errorObj.stack)); } return objValue; diff --git a/frameworks/js/napi/app/error_manager/js_error_observer.h b/frameworks/js/napi/app/error_manager/js_error_observer.h index 9b3651e85fb..9cf06aa44aa 100644 --- a/frameworks/js/napi/app/error_manager/js_error_observer.h +++ b/frameworks/js/napi/app/error_manager/js_error_observer.h @@ -26,22 +26,22 @@ namespace AbilityRuntime { class JsErrorObserver : public AppExecFwk::IErrorObserver, public std::enable_shared_from_this { public: - explicit JsErrorObserver(NativeEngine &engine); + explicit JsErrorObserver(napi_env env); virtual ~JsErrorObserver(); void OnExceptionObject(const AppExecFwk::ErrorObject &errorObj) override; void OnUnhandledException(const std::string errMsg) override; - void AddJsObserverObject(const int32_t observerId, NativeValue* jsObserverObject, bool isSync = false); + void AddJsObserverObject(const int32_t observerId, napi_value jsObserverObject, bool isSync = false); bool RemoveJsObserverObject(const int32_t observerId, bool isSync = false); bool IsEmpty(); private: - void CallJsFunction(NativeValue* value, const char* methodName, NativeValue* const* argv, size_t argc); + void CallJsFunction(napi_value value, const char* methodName, napi_value const* argv, size_t argc); void HandleOnUnhandledException(const std::string &errMsg); void HandleException(const AppExecFwk::ErrorObject &errorObj); - NativeValue* CreateJsErrorObject(NativeEngine &engine, const AppExecFwk::ErrorObject &errorObj); + napi_value CreateJsErrorObject(napi_env env, const AppExecFwk::ErrorObject &errorObj); private: - NativeEngine &engine_; + napi_env env_; std::map> jsObserverObjectMap_; std::map> jsObserverObjectMapSync_; }; diff --git a/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp b/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp index 63bbaf839b0..27a557a3ea4 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp +++ b/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp @@ -248,7 +248,7 @@ void JSAppStateObserver::CallJsFunction( return; } napi_value callResult = nullptr; - napi_call_function(env_, nullptr, method, argc, argv, &callResult); + napi_call_function(env_, value, method, argc, argv, &callResult); HILOG_INFO("CallJsFunction end"); } diff --git a/frameworks/js/napi/app/recovery/app_recovery_api.cpp b/frameworks/js/napi/app/recovery/app_recovery_api.cpp index e858abfbe8e..e2879b24188 100644 --- a/frameworks/js/napi/app/recovery/app_recovery_api.cpp +++ b/frameworks/js/napi/app/recovery/app_recovery_api.cpp @@ -42,40 +42,36 @@ public: AppRecoveryApiRegistry() = default; ~AppRecoveryApiRegistry() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint) + static void Finalizer(napi_env env, void *data, void *hint) { std::unique_ptr(static_cast(data)); } - static NativeValue *EnableAppRecovery(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value EnableAppRecovery(napi_env env, napi_callback_info info) { - AppRecoveryApiRegistry *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnEnableAppRecovery(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, AppRecoveryApiRegistry, OnEnableAppRecovery); } - static NativeValue *RestartApp(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value RestartApp(napi_env env, napi_callback_info info) { - AppRecoveryApiRegistry *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRestartApp(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, AppRecoveryApiRegistry, OnRestartApp); } - static NativeValue *SaveAppState(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value SaveAppState(napi_env env, napi_callback_info info) { - AppRecoveryApiRegistry *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnSaveAppState(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, AppRecoveryApiRegistry, OnSaveAppState); } - static NativeValue *SetRestartWant(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value SetRestartWant(napi_env env, napi_callback_info info) { - AppRecoveryApiRegistry *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnSetRestartWant(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, AppRecoveryApiRegistry, OnSetRestartWant); } private: - NativeValue *OnEnableAppRecovery(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnEnableAppRecovery(napi_env env, const size_t argc, napi_value* argv) { - size_t parameterCount = info.argc; - NativeValue* result = engine.CreateUndefined(); + size_t parameterCount = argc; + napi_value result = CreateJsUndefined(env); constexpr int maxCount = 3; if (parameterCount > maxCount) { return result; @@ -89,14 +85,13 @@ private: for (size_t i = 0; i < parameterCount; ++i) { napi_valuetype paramType; - napi_typeof(reinterpret_cast(&engine), reinterpret_cast(info.argv[i]), ¶mType); + napi_typeof(env, argv[i], ¶mType); if (paramType != napi_number) { - HILOG_ERROR("AppRecoveryApi info.argv[%{public}s] type isn't number", std::to_string(i).c_str()); + HILOG_ERROR("AppRecoveryApi argv[%{public}s] type isn't number", std::to_string(i).c_str()); return result; } int32_t tmp = 0; - napi_get_value_int32(reinterpret_cast(&engine), - reinterpret_cast(info.argv[i]), &tmp); + napi_get_value_int32(env, argv[i], &tmp); flags[i] = static_cast(tmp); } @@ -132,144 +127,143 @@ private: return true; } - NativeValue *OnSaveAppState(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnSaveAppState(napi_env env, const size_t argc, napi_value* argv) { - if (info.argc > 1) { + if (argc > 1) { HILOG_ERROR("AppRecoveryApi SaveAppState Incorrect number of parameters"); - return engine.CreateBoolean(false); + return CreateJsValue(env, false); } uintptr_t ability = 0; - if (info.argc == 1) { - NativeValue* value = reinterpret_cast(info.argv[0]); - NativeObject *obj = ConvertNativeValueTo(value); - if (obj == nullptr) { + if (argc == 1) { + napi_value value = argv[0]; + if (value == nullptr) { HILOG_ERROR("AppRecoveryApi Invalid abilityContext."); - return engine.CreateBoolean(false); + return CreateJsValue(env, false); } - ability = reinterpret_cast(obj->GetNativePointer()); + void* result = nullptr; + napi_unwrap(env, value, &result); + ability = reinterpret_cast(result); } if (AppRecovery::GetInstance().ScheduleSaveAppState(StateReason::DEVELOPER_REQUEST, ability)) { - return engine.CreateBoolean(true); + return CreateJsValue(env, true); } - return engine.CreateBoolean(false); + return CreateJsValue(env, false); } - NativeValue *OnRestartApp(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnRestartApp(napi_env env, const size_t argc, napi_value* argv) { - if (info.argc != 0) { + if (argc != 0) { HILOG_ERROR("AppRecoveryApi OnRestartApp Incorrect number of parameters"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } AppRecovery::GetInstance().ScheduleRecoverApp(StateReason::DEVELOPER_REQUEST); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - NativeValue *OnSetRestartWant(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnSetRestartWant(napi_env env, const size_t argc, napi_value* argv) { - if (info.argc != 1) { + if (argc != 1) { HILOG_ERROR("AppRecoveryApi OnSetRestartWant Incorrect number of parameters"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::shared_ptr want = std::make_shared(); - OHOS::AppExecFwk::UnwrapWant(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), *(want.get())); + OHOS::AppExecFwk::UnwrapWant(env, argv[0], *(want.get())); AppRecovery::GetInstance().SetRestartWant(want); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } }; } // namespace -NativeValue *AppRecoveryRestartFlagInit(NativeEngine *engine) +napi_value AppRecoveryRestartFlagInit(napi_env env) { - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("AppRecoveryRestartFlagInit Invalid input parameters"); return nullptr; } - NativeValue *objValue = engine->CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); - if (object == nullptr) { + if (objValue == nullptr) { HILOG_ERROR("AppRecoveryRestartFlagInit Failed to get object"); return nullptr; } - object->SetProperty("ALWAYS_RESTART", CreateJsValue(*engine, RestartFlag::ALWAYS_RESTART)); - object->SetProperty("RESTART_WHEN_JS_CRASH", CreateJsValue(*engine, RestartFlag::RESTART_WHEN_JS_CRASH)); - object->SetProperty("RESTART_WHEN_APP_FREEZE", CreateJsValue(*engine, RestartFlag::RESTART_WHEN_APP_FREEZE)); - object->SetProperty("NO_RESTART", CreateJsValue(*engine, RestartFlag::NO_RESTART)); + napi_set_named_property(env, objValue, "ALWAYS_RESTART", CreateJsValue(env, RestartFlag::ALWAYS_RESTART)); + napi_set_named_property(env, objValue, "RESTART_WHEN_JS_CRASH", + CreateJsValue(env, RestartFlag::RESTART_WHEN_JS_CRASH)); + napi_set_named_property(env, objValue, "RESTART_WHEN_APP_FREEZE", + CreateJsValue(env, RestartFlag::RESTART_WHEN_APP_FREEZE)); + napi_set_named_property(env, objValue, "NO_RESTART", CreateJsValue(env, RestartFlag::NO_RESTART)); return objValue; } -NativeValue *AppRecoveryStateSaveFlagInit(NativeEngine *engine) +napi_value AppRecoveryStateSaveFlagInit(napi_env env) { - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("AppRecoveryStateSaveFlagInit Invalid input parameters"); return nullptr; } - NativeValue *objValue = engine->CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); - if (object == nullptr) { + if (objValue == nullptr) { HILOG_ERROR("AppRecoveryStateSaveFlagInit Failed to get object"); return nullptr; } - object->SetProperty("NONE", CreateJsValue(*engine, SaveOccasionFlag::NO_SAVE)); - object->SetProperty("SAVE_WHEN_ERROR", CreateJsValue(*engine, SaveOccasionFlag::SAVE_WHEN_ERROR)); - object->SetProperty("SAVE_WHEN_BACKGROUND", CreateJsValue(*engine, SaveOccasionFlag::SAVE_WHEN_BACKGROUND)); + napi_set_named_property(env, objValue, "NONE", CreateJsValue(env, SaveOccasionFlag::NO_SAVE)); + napi_set_named_property(env, objValue, "SAVE_WHEN_ERROR", + CreateJsValue(env, SaveOccasionFlag::SAVE_WHEN_ERROR)); + napi_set_named_property(env, objValue, "SAVE_WHEN_BACKGROUND", + CreateJsValue(env, SaveOccasionFlag::SAVE_WHEN_BACKGROUND)); return objValue; } -NativeValue *AppRecoverySaveModeFlagInit(NativeEngine *engine) +napi_value AppRecoverySaveModeFlagInit(napi_env env) { - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("AppRecoverySaveModeFlagInit Invalid input parameters"); return nullptr; } - NativeValue *objValue = engine->CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); - if (object == nullptr) { + if (objValue == nullptr) { HILOG_ERROR("AppRecoverySaveModeFlagInit Failed to get object"); return nullptr; } - - object->SetProperty("SAVE_WITH_FILE", CreateJsValue(*engine, SaveModeFlag::SAVE_WITH_FILE)); - object->SetProperty("SAVE_WITH_SHARED_MEMORY", CreateJsValue(*engine, SaveModeFlag::SAVE_WITH_SHARED_MEMORY)); + napi_set_named_property(env, objValue, "SAVE_WITH_FILE", + CreateJsValue(env, SaveModeFlag::SAVE_WITH_FILE)); + napi_set_named_property(env, objValue, "SAVE_WITH_SHARED_MEMORY", + CreateJsValue(env, SaveModeFlag::SAVE_WITH_SHARED_MEMORY)); return objValue; } -NativeValue *InitAppRecoveryApiModule(NativeEngine *engine, NativeValue *exportObj) +napi_value InitAppRecoveryApiModule(napi_env env, napi_value exportObj) { - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_ERROR("AppRecovery API Invalid input parameters"); return nullptr; } - NativeObject *object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_ERROR("AppRecovery API Failed to get object"); - return nullptr; - } - std::unique_ptr appRecoveryApi = std::make_unique(); - object->SetNativePointer(appRecoveryApi.release(), AppRecoveryApiRegistry::Finalizer, nullptr); + napi_wrap(env, exportObj, appRecoveryApi.release(), AppRecoveryApiRegistry::Finalizer, nullptr, nullptr); const char *moduleName = "AppRecovery"; - BindNativeFunction(*engine, *object, "enableAppRecovery", moduleName, AppRecoveryApiRegistry::EnableAppRecovery); - BindNativeFunction(*engine, *object, "restartApp", moduleName, AppRecoveryApiRegistry::RestartApp); - BindNativeFunction(*engine, *object, "saveAppState", moduleName, AppRecoveryApiRegistry::SaveAppState); - BindNativeFunction(*engine, *object, "setRestartWant", moduleName, AppRecoveryApiRegistry::SetRestartWant); + BindNativeFunction(env, exportObj, "enableAppRecovery", moduleName, AppRecoveryApiRegistry::EnableAppRecovery); + BindNativeFunction(env, exportObj, "restartApp", moduleName, AppRecoveryApiRegistry::RestartApp); + BindNativeFunction(env, exportObj, "saveAppState", moduleName, AppRecoveryApiRegistry::SaveAppState); + BindNativeFunction(env, exportObj, "setRestartWant", moduleName, AppRecoveryApiRegistry::SetRestartWant); - object->SetProperty("RestartFlag", AppRecoveryRestartFlagInit(engine)); - object->SetProperty("SaveOccasionFlag", AppRecoveryStateSaveFlagInit(engine)); - object->SetProperty("SaveModeFlag", AppRecoverySaveModeFlagInit(engine)); + napi_set_named_property(env, exportObj, "RestartFlag", AppRecoveryRestartFlagInit(env)); + napi_set_named_property(env, exportObj, "SaveOccasionFlag", AppRecoveryStateSaveFlagInit(env)); + napi_set_named_property(env, exportObj, "SaveModeFlag", AppRecoverySaveModeFlagInit(env)); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/app/recovery/app_recovery_api.h b/frameworks/js/napi/app/recovery/app_recovery_api.h index 6385c1c8142..2595750702a 100644 --- a/frameworks/js/napi/app/recovery/app_recovery_api.h +++ b/frameworks/js/napi/app/recovery/app_recovery_api.h @@ -25,7 +25,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* InitAppRecoveryApiModule(NativeEngine *engine, NativeValue *exportObj); +napi_value InitAppRecoveryApiModule(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_APP_RECOVERY_API_H \ No newline at end of file diff --git a/frameworks/js/napi/app/recovery/app_recovery_module.cpp b/frameworks/js/napi/app/recovery/app_recovery_module.cpp index 6a8943445a7..6782a6a66dc 100644 --- a/frameworks/js/napi/app/recovery/app_recovery_module.cpp +++ b/frameworks/js/napi/app/recovery/app_recovery_module.cpp @@ -16,14 +16,13 @@ #include "app_recovery_api.h" #include "native_engine/native_engine.h" +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.appRecovery", + .nm_filename = "app/ability/apprecovery_napi.so/app_recovery.js", + .nm_register_func = OHOS::AbilityRuntime::InitAppRecoveryApiModule, +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_AppRecovery_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.appRecovery", - .fileName = "app/ability/apprecovery_napi.so/app_recovery.js", - .registerCallback = OHOS::AbilityRuntime::InitAppRecoveryApiModule, - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } \ No newline at end of file diff --git a/frameworks/js/napi/app/test_runner/test_runner_module.cpp b/frameworks/js/napi/app/test_runner/test_runner_module.cpp index 311014cb0ce..09f96ab48fb 100644 --- a/frameworks/js/napi/app/test_runner/test_runner_module.cpp +++ b/frameworks/js/napi/app/test_runner/test_runner_module.cpp @@ -20,15 +20,15 @@ extern const char _binary_test_runner_js_end[]; extern const char _binary_test_runner_abc_start[]; extern const char _binary_test_runner_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.testRunner", + .nm_filename = "application/libtestrunner_napi.so/test_runner.js", +}; + extern "C" __attribute__((constructor)) void NAPI_application_testRunner_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.testRunner", - .fileName = "application/libtestrunner_napi.so/test_runner.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) void NAPI_application_testRunner_GetJSCode( diff --git a/frameworks/js/napi/callee/callee_module.cpp b/frameworks/js/napi/callee/callee_module.cpp index 9cd317f99da..82463d3cf78 100644 --- a/frameworks/js/napi/callee/callee_module.cpp +++ b/frameworks/js/napi/callee/callee_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_callee_js_end[]; extern const char _binary_callee_abc_start[]; extern const char _binary_callee_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.Callee", + .nm_filename = "application/libcallee_napi.so/callee.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_Callee_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.Callee", - .fileName = "application/libcallee_napi.so/callee.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/caller/caller_module.cpp b/frameworks/js/napi/caller/caller_module.cpp index 50d5af69a25..562bf83ff06 100644 --- a/frameworks/js/napi/caller/caller_module.cpp +++ b/frameworks/js/napi/caller/caller_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_caller_js_end[]; extern const char _binary_caller_abc_start[]; extern const char _binary_caller_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.Caller", + .nm_filename = "application/libcaller_napi.so/caller.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_Caller_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.Caller", - .fileName = "application/libcaller_napi.so/caller.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/dataUriUtils/data_uri_utils_module.cpp b/frameworks/js/napi/dataUriUtils/data_uri_utils_module.cpp index 14e79a42b71..2560a2d1860 100644 --- a/frameworks/js/napi/dataUriUtils/data_uri_utils_module.cpp +++ b/frameworks/js/napi/dataUriUtils/data_uri_utils_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_data_uri_utils_js_end[]; extern const char _binary_data_uri_utils_abc_start[]; extern const char _binary_data_uri_utils_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "ability.dataUriUtils", + .nm_filename = "ability/libdatauriutils_napi.so/data_uri_utils.js", +}; extern "C" __attribute__((constructor)) void NAPI_ability_dataUriUtils_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "ability.dataUriUtils", - .fileName = "ability/libdatauriutils_napi.so/data_uri_utils.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/dialog_request_info/include/request_info.h b/frameworks/js/napi/dialog_request_info/include/request_info.h index 31fa8c6803e..26bff04708d 100755 --- a/frameworks/js/napi/dialog_request_info/include/request_info.h +++ b/frameworks/js/napi/dialog_request_info/include/request_info.h @@ -33,7 +33,7 @@ public: * @param request Request information. * @return Native value wrapped from request. */ - static NativeValue* WrapRequestInfo(NativeEngine &engine, RequestInfo *request); + static napi_value WrapRequestInfo(napi_env env, RequestInfo *request); /** * @brief Unwrap native value to request information. @@ -42,7 +42,7 @@ public: * @param jsParam NativeValue. * @return Request information unwrapped from native value. */ - static std::shared_ptr UnwrapRequestInfo(NativeEngine &engine, NativeValue *jsParam); + static std::shared_ptr UnwrapRequestInfo(napi_env env, napi_value jsParam); /** * @brief Get caller token. @@ -61,8 +61,8 @@ public: * @param the height position of WindowRect. * @return Native value Created from left, top, width, height. */ - static NativeValue* CreateJsWindowRect( - NativeEngine& engine, int32_t left, int32_t top, int32_t width, int32_t height); + static napi_value CreateJsWindowRect( + napi_env env, int32_t left, int32_t top, int32_t width, int32_t height); private: sptr callerToken_; int32_t left_ = 0; diff --git a/frameworks/js/napi/dialog_request_info/request_info.cpp b/frameworks/js/napi/dialog_request_info/request_info.cpp index b3e40f36f87..67cfdc2307a 100755 --- a/frameworks/js/napi/dialog_request_info/request_info.cpp +++ b/frameworks/js/napi/dialog_request_info/request_info.cpp @@ -39,7 +39,7 @@ sptr RequestInfo::GetToken() return callerToken_; } -NativeValue* RequestInfo::WrapRequestInfo(NativeEngine &engine, RequestInfo *request) +napi_value RequestInfo::WrapRequestInfo(napi_env env, RequestInfo *request) { HILOG_DEBUG("WrapRequestInfo called."); if (request == nullptr) { @@ -47,24 +47,28 @@ NativeValue* RequestInfo::WrapRequestInfo(NativeEngine &engine, RequestInfo *req return nullptr; } - NativeCallback callback = [](NativeEngine* engine, NativeCallbackInfo* info) -> NativeValue* { - return info->thisVar; + auto callback = [](napi_env env, napi_callback_info info) -> napi_value { + napi_value thisVar = nullptr; + napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr); + return thisVar; }; - NativeValue* requestInfoClass = engine.DefineClass("RequestInfoClass", callback, nullptr, nullptr, 0); - NativeValue* result = engine.CreateInstance(requestInfoClass, nullptr, 0); + napi_value requestInfoClass = nullptr; + napi_define_class( + env, "RequestInfoClass", NAPI_AUTO_LENGTH, callback, nullptr, 0, nullptr, &requestInfoClass); + napi_value result = nullptr; + napi_new_instance(env, requestInfoClass, 0, nullptr, &result); if (result == nullptr) { HILOG_ERROR("create instance failed."); return nullptr; } - NativeObject* nativeObject = reinterpret_cast(result->GetInterface(NativeObject::INTERFACE_ID)); - if (nativeObject == nullptr) { - HILOG_ERROR("get nativeObject failed."); + if (!CheckTypeForNapiValue(env, result, napi_object)) { + HILOG_ERROR("UnwrapRequestInfo result type error!"); return nullptr; } - NativeFinalize nativeFinalize = [](NativeEngine* engine, void* data, void* hint) { + auto nativeFinalize = [](napi_env env, void* data, void* hint) { HILOG_INFO("Js RequestInfo finalizer is called"); auto requestInfo = static_cast(data); if (requestInfo) { @@ -72,32 +76,31 @@ NativeValue* RequestInfo::WrapRequestInfo(NativeEngine &engine, RequestInfo *req requestInfo = nullptr; } }; - - nativeObject->SetNativePointer(reinterpret_cast(request), nativeFinalize, nullptr); - nativeObject->SetProperty("windowRect", - CreateJsWindowRect(engine, request->left_, request->top_, request->width_, request->height_)); + napi_wrap(env, result, request, nativeFinalize, nullptr, nullptr); + napi_set_named_property(env, result, "windowRect", + CreateJsWindowRect(env, request->left_, request->top_, request->width_, request->height_)); return result; } -NativeValue* RequestInfo::CreateJsWindowRect( - NativeEngine& engine, int32_t left, int32_t top, int32_t width, int32_t height) +napi_value RequestInfo::CreateJsWindowRect( + napi_env env, int32_t left, int32_t top, int32_t width, int32_t height) { HILOG_DEBUG("left: %{public}d, top: %{public}d, width: %{public}d, height: %{public}d", left, top, width, height); - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Native object is nullptr."); return objValue; } - object->SetProperty("left", CreateJsValue(engine, left)); - object->SetProperty("top", CreateJsValue(engine, top)); - object->SetProperty("width", CreateJsValue(engine, width)); - object->SetProperty("height", CreateJsValue(engine, height)); + napi_set_named_property(env, objValue, "left", CreateJsValue(env, left)); + napi_set_named_property(env, objValue, "top", CreateJsValue(env, top)); + napi_set_named_property(env, objValue, "width", CreateJsValue(env, width)); + napi_set_named_property(env, objValue, "height", CreateJsValue(env, height)); return objValue; } -std::shared_ptr RequestInfo::UnwrapRequestInfo(NativeEngine &engine, NativeValue *jsParam) +std::shared_ptr RequestInfo::UnwrapRequestInfo(napi_env env, napi_value jsParam) { HILOG_INFO("UnwrapRequestInfo called."); if (jsParam == nullptr) { @@ -105,19 +108,13 @@ std::shared_ptr RequestInfo::UnwrapRequestInfo(NativeEngine &engine return nullptr; } - if (jsParam->TypeOf() != NATIVE_OBJECT) { + if (!CheckTypeForNapiValue(env, jsParam, napi_object)) { HILOG_ERROR("UnwrapRequestInfo jsParam type error!"); return nullptr; } - - NativeObject *nativeObject = reinterpret_cast(jsParam->GetInterface(NativeObject::INTERFACE_ID)); - if (nativeObject == nullptr) { - HILOG_ERROR("UnwrapRequestInfo reinterpret_cast failed!"); - return nullptr; - } - HILOG_INFO("UnwrapRequestInfo success."); - - RequestInfo *info = static_cast(nativeObject->GetNativePointer()); + void* result = nullptr; + napi_unwrap(env, jsParam, &result); + RequestInfo *info = static_cast(result); return std::make_shared(*info); } diff --git a/frameworks/js/napi/extension_ability/extension_ability_module.cpp b/frameworks/js/napi/extension_ability/extension_ability_module.cpp index ab642661d87..3acc8e01544 100644 --- a/frameworks/js/napi/extension_ability/extension_ability_module.cpp +++ b/frameworks/js/napi/extension_ability/extension_ability_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_extension_ability_js_end[]; extern const char _binary_extension_ability_abc_start[]; extern const char _binary_extension_ability_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.ExtensionAbility", + .nm_filename = "app/ability/libextensionability_napi.so/extension_ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_ExtensionAbility_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.ExtensionAbility", - .fileName = "app/ability/libextensionability_napi.so/extension_ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/extensioncontext/extension_context_module.cpp b/frameworks/js/napi/extensioncontext/extension_context_module.cpp index 8ab5d774708..bb9c5662dce 100644 --- a/frameworks/js/napi/extensioncontext/extension_context_module.cpp +++ b/frameworks/js/napi/extensioncontext/extension_context_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_extension_context_js_end[]; extern const char _binary_extension_context_abc_start[]; extern const char _binary_extension_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.ExtensionContext", + .nm_filename = "application/libextensioncontext_napi.so/ExtensionContext.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_ExtensionContext_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.ExtensionContext", - .fileName = "application/libextensioncontext_napi.so/ExtensionContext.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/js_dialog_request/include/js_dialog_request.h b/frameworks/js/napi/js_dialog_request/include/js_dialog_request.h index 2c927ce1dcc..2328e050eaf 100755 --- a/frameworks/js/napi/js_dialog_request/include/js_dialog_request.h +++ b/frameworks/js/napi/js_dialog_request/include/js_dialog_request.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* JsDialogRequestInit(NativeEngine* engine, NativeValue* exportObj); +napi_value JsDialogRequestInit(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_DIALOG_REQUEST_H diff --git a/frameworks/js/napi/js_dialog_request/include/js_dialog_request_callback.h b/frameworks/js/napi/js_dialog_request/include/js_dialog_request_callback.h index 97d83668448..977fe684d22 100755 --- a/frameworks/js/napi/js_dialog_request/include/js_dialog_request_callback.h +++ b/frameworks/js/napi/js_dialog_request/include/js_dialog_request_callback.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsDialogRequestCallback(NativeEngine &engine, const sptr &remoteObj); +napi_value CreateJsDialogRequestCallback(napi_env env, const sptr &remoteObj); } // AbilityRuntime } // OHOS #endif // OHOS_ABILITY_RUNTIME_DIALOG_REQUEST_CALLBACK_H diff --git a/frameworks/js/napi/js_dialog_request/js_dialog_request.cpp b/frameworks/js/napi/js_dialog_request/js_dialog_request.cpp index 38122f4b5da..6a69c41f25a 100755 --- a/frameworks/js/napi/js_dialog_request/js_dialog_request.cpp +++ b/frameworks/js/napi/js_dialog_request/js_dialog_request.cpp @@ -31,23 +31,23 @@ constexpr int32_t RESULT_OK = 0; constexpr int32_t RESULT_CANCEL = 1; } -NativeValue* ResultCodeInit(NativeEngine* engine) +napi_value ResultCodeInit(napi_env env) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("Invalid input parameters"); return nullptr; } - NativeValue* objValue = engine->CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } - object->SetProperty("RESULT_OK", CreateJsValue(*engine, RESULT_OK)); - object->SetProperty("RESULT_CANCEL", CreateJsValue(*engine, RESULT_CANCEL)); + napi_set_named_property(env, objValue, "RESULT_OK", CreateJsValue(env, RESULT_OK)); + napi_set_named_property(env, objValue, "RESULT_CANCEL", CreateJsValue(env, RESULT_CANCEL)); return objValue; } @@ -57,47 +57,44 @@ public: JsDialogRequest() = default; ~JsDialogRequest() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsDialogRequest::Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* GetRequestInfo(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetRequestInfo(napi_env env, napi_callback_info info) { - JsDialogRequest* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetRequestInfo(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsDialogRequest, OnGetRequestInfo); } - static NativeValue* GetRequestCallback(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetRequestCallback(napi_env env, napi_callback_info info) { - JsDialogRequest* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetRequestCallback(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsDialogRequest, OnGetRequestCallback); } private: - NativeValue* OnGetRequestInfo(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetRequestInfo(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("%{public}s is called", __FUNCTION__); if (info.argc < ARGC_ONE) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } OHOS::AAFwk::Want want; - if (!OHOS::AppExecFwk::UnwrapWant(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), want)) { + if (!OHOS::AppExecFwk::UnwrapWant(env, info.argv[0], want)) { HILOG_ERROR("The input want is invalid."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } sptr callerToken = want.GetRemoteObject(RequestConstants::REQUEST_TOKEN_KEY); if (!callerToken) { HILOG_ERROR("Can not get token from target want."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t left = want.GetIntParam(RequestConstants::WINDOW_RECTANGLE_LEFT_KEY, 0); int32_t top = want.GetIntParam(RequestConstants::WINDOW_RECTANGLE_TOP_KEY, 0); @@ -105,73 +102,66 @@ private: int32_t height = want.GetIntParam(RequestConstants::WINDOW_RECTANGLE_HEIGHT_KEY, 0); auto requestInfo = new RequestInfo(callerToken, left, top, width, height); - auto jsRequestInfo = RequestInfo::WrapRequestInfo(engine, requestInfo); + auto jsRequestInfo = RequestInfo::WrapRequestInfo(env, requestInfo); if (jsRequestInfo == nullptr) { HILOG_ERROR("Can not wrap requestinfo from target request."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } return jsRequestInfo; } - NativeValue* OnGetRequestCallback(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetRequestCallback(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("%{public}s is called", __FUNCTION__); if (info.argc < ARGC_ONE) { HILOG_ERROR("Params is not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } OHOS::AAFwk::Want want; - if (!OHOS::AppExecFwk::UnwrapWant(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), want)) { + if (!OHOS::AppExecFwk::UnwrapWant(env, info.argv[0], want)) { HILOG_ERROR("The input want is invalid."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } sptr remoteObj = want.GetRemoteObject(RequestConstants::REQUEST_CALLBACK_KEY); if (!remoteObj) { HILOG_ERROR("Can not get callback from target want."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } sptr callback = iface_cast(remoteObj); if (!callback) { HILOG_ERROR("Cast to IDialogRequestCallback failed."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } - return CreateJsDialogRequestCallback(engine, callback); + return CreateJsDialogRequestCallback(env, callback); } }; -NativeValue* JsDialogRequestInit(NativeEngine* engine, NativeValue* exportObj) +napi_value JsDialogRequestInit(napi_env env, napi_value exportObj) { HILOG_INFO("JsDialogRequestInit is called"); - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_INFO("Invalid input parameters"); return nullptr; } - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_INFO("object is nullptr"); - return nullptr; - } - std::unique_ptr jsDialogRequest = std::make_unique(); - object->SetNativePointer(jsDialogRequest.release(), JsDialogRequest::Finalizer, nullptr); - object->SetProperty("ResultCode", ResultCodeInit(engine)); + napi_wrap(env, exportObj, jsDialogRequest.release(), JsDialogRequest::Finalizer, nullptr, nullptr); + napi_set_named_property(env, exportObj, "ResultCode", ResultCodeInit(env)); const char *moduleName = "JsDialogRequest"; - BindNativeFunction(*engine, *object, "getRequestInfo", moduleName, JsDialogRequest::GetRequestInfo); - BindNativeFunction(*engine, *object, "getRequestCallback", moduleName, JsDialogRequest::GetRequestCallback); - return engine->CreateUndefined(); + BindNativeFunction(env, exportObj, "getRequestInfo", moduleName, JsDialogRequest::GetRequestInfo); + BindNativeFunction(env, exportObj, "getRequestCallback", moduleName, JsDialogRequest::GetRequestCallback); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/js_dialog_request/js_dialog_request_callback.cpp b/frameworks/js/napi/js_dialog_request/js_dialog_request_callback.cpp index 1ee6f201c58..5bddc9b352c 100755 --- a/frameworks/js/napi/js_dialog_request/js_dialog_request_callback.cpp +++ b/frameworks/js/napi/js_dialog_request/js_dialog_request_callback.cpp @@ -31,69 +31,64 @@ public: virtual ~JsDialogRequestCallback() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_DEBUG("JsDialogRequestCallback::Finalizer is called."); std::unique_ptr(static_cast(data)); } - static NativeValue* SetRequestResult(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value SetRequestResult(napi_env env, napi_callback_info info) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("input parameters %{public}s is nullptr", ((engine == nullptr) ? "engine" : "info")); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("input parameters %{public}s is nullptr", ((env == nullptr) ? "env" : "info")); return nullptr; } - auto object = CheckParamsAndGetThis(engine, info); - if (object == nullptr) { - HILOG_ERROR("CheckParamsAndGetThis return nullptr"); - return nullptr; - } - - return object->OnSetRequestResult(*engine, *info); + GET_NAPI_INFO_AND_CALL(env, info, JsDialogRequestCallback, OnSetRequestResult); } private: - NativeValue* OnSetRequestResult(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnSetRequestResult(napi_env env, NapiCallbackInfo& info) { HILOG_INFO("function called"); if (info.argc < 1) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (info.argv[0]->TypeOf() != NativeValueType::NATIVE_OBJECT) { + if (!CheckTypeForNapiValue(env, info.argv[0], napi_object)) { HILOG_ERROR("param type mismatch!"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - NativeObject* paramObject = ConvertNativeValueTo(info.argv[0]); - NativeValue* resultCode = paramObject->GetProperty("result"); + napi_value resultCode = nullptr; + napi_get_named_property(env, info.argv[0], "result", &resultCode); int32_t resultCodeValue = 0; - if (!ConvertFromJsValue(engine, resultCode, resultCodeValue)) { + if (!ConvertFromJsValue(env, resultCode, resultCodeValue)) { HILOG_ERROR("Convert result failed!"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } AAFwk::Want wantValue; - NativeValue* jWant = paramObject->GetProperty("want"); - if (jWant != nullptr && jWant->TypeOf() == NativeValueType::NATIVE_OBJECT) { - AppExecFwk::UnwrapWant(reinterpret_cast(&engine), reinterpret_cast(jWant), wantValue); + napi_value jWant = nullptr; + napi_get_named_property(env, info.argv[0], "want", &jWant); + if (jWant != nullptr && !CheckTypeForNapiValue(env, jWant, napi_object)) { + AppExecFwk::UnwrapWant(env, jWant, wantValue); } else { HILOG_WARN("jWant is invalid data!"); } if (callback_ == nullptr) { HILOG_ERROR("JsDialogRequestCallback::%{public}s, callback_ is nullptr", __func__); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } callback_->SendResult(resultCodeValue, wantValue); HILOG_INFO("function called end."); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } private: @@ -101,25 +96,25 @@ private: }; } // nameless -NativeValue* CreateJsDialogRequestCallback(NativeEngine &engine, const sptr &remoteObj) +napi_value CreateJsDialogRequestCallback(napi_env env, const sptr &remoteObj) { HILOG_INFO("CreateJsDialogRequestCallback"); if (!remoteObj) { HILOG_ERROR("remoteObj is invalid."); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - if (object == nullptr) { + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + if (objValue == nullptr) { HILOG_ERROR("object is invalid."); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } auto jsDialogRequestCallback = std::make_unique(remoteObj); - object->SetNativePointer(jsDialogRequestCallback.release(), JsDialogRequestCallback::Finalizer, nullptr); + napi_wrap(env, objValue, jsDialogRequestCallback.release(), JsDialogRequestCallback::Finalizer, nullptr, nullptr); const char *moduleName = "JsDialogRequestCallback"; - BindNativeFunction(engine, *object, "setRequestResult", moduleName, JsDialogRequestCallback::SetRequestResult); + BindNativeFunction(env, objValue, "setRequestResult", moduleName, JsDialogRequestCallback::SetRequestResult); HILOG_INFO("CreateJsDialogRequestCallback end"); return objValue; diff --git a/frameworks/js/napi/js_dialog_request/native_module.cpp b/frameworks/js/napi/js_dialog_request/native_module.cpp index faeaf69b9fc..5c1ae712393 100755 --- a/frameworks/js/napi/js_dialog_request/native_module.cpp +++ b/frameworks/js/napi/js_dialog_request/native_module.cpp @@ -16,15 +16,14 @@ #include "js_dialog_request.h" #include "native_engine/native_engine.h" +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.dialogRequest", + .nm_filename = "app/ability/libdialogrequest.so/dialogrequest.js", + .nm_register_func = OHOS::AbilityRuntime::JsDialogRequestInit, +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_dialogrequest_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.dialogRequest", - .fileName = "app/ability/libdialogrequest.so/dialogrequest.js", - .registerCallback = OHOS::AbilityRuntime::JsDialogRequestInit, - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } diff --git a/frameworks/js/napi/quick_fix/js_application_quick_fix_info.cpp b/frameworks/js/napi/quick_fix/js_application_quick_fix_info.cpp index 8f62322bfed..b92245b796d 100644 --- a/frameworks/js/napi/quick_fix/js_application_quick_fix_info.cpp +++ b/frameworks/js/napi/quick_fix/js_application_quick_fix_info.cpp @@ -19,33 +19,37 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsApplicationQuickFixInfo( - NativeEngine &engine, const AAFwk::ApplicationQuickFixInfo &appQuickFixInfo) +napi_value CreateJsApplicationQuickFixInfo( + napi_env env, const AAFwk::ApplicationQuickFixInfo &appQuickFixInfo) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - object->SetProperty("bundleName", CreateJsValue(engine, appQuickFixInfo.bundleName)); - object->SetProperty("bundleVersionCode", CreateJsValue(engine, appQuickFixInfo.bundleVersionCode)); - object->SetProperty("bundleVersionName", CreateJsValue(engine, appQuickFixInfo.bundleVersionName)); - object->SetProperty("quickFixVersionCode", CreateJsValue(engine, appQuickFixInfo.appqfInfo.versionCode)); - object->SetProperty("quickFixVersionName", CreateJsValue(engine, appQuickFixInfo.appqfInfo.versionName)); - object->SetProperty( - "hapModuleQuickFixInfo", CreateJsHapModuleQuickFixInfoArray(engine, appQuickFixInfo.appqfInfo.hqfInfos)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, appQuickFixInfo.bundleName)); + napi_set_named_property(env, objValue, "bundleVersionCode", + CreateJsValue(env, appQuickFixInfo.bundleVersionCode)); + napi_set_named_property(env, objValue, "bundleVersionName", + CreateJsValue(env, appQuickFixInfo.bundleVersionName)); + napi_set_named_property(env, objValue, "quickFixVersionCode", + CreateJsValue(env, appQuickFixInfo.appqfInfo.versionCode)); + napi_set_named_property(env, objValue, "quickFixVersionName", + CreateJsValue(env, appQuickFixInfo.appqfInfo.versionName)); + napi_set_named_property(env, objValue, "hapModuleQuickFixInfo", + CreateJsHapModuleQuickFixInfoArray(env, appQuickFixInfo.appqfInfo.hqfInfos)); return objValue; } -NativeValue *CreateJsHapModuleQuickFixInfoArray(NativeEngine &engine, const std::vector &hqfInfos) +napi_value CreateJsHapModuleQuickFixInfoArray(napi_env env, const std::vector &hqfInfos) { - NativeValue *arrayValue = engine.CreateArray(hqfInfos.size()); - NativeArray *array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, hqfInfos.size(), &arrayValue); uint32_t index = 0; for (const auto &hqfInfo : hqfInfos) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - object->SetProperty("moduleName", CreateJsValue(engine, hqfInfo.moduleName)); - object->SetProperty("originHapHash", CreateJsValue(engine, hqfInfo.hapSha256)); - object->SetProperty("quickFixFilePath", CreateJsValue(engine, hqfInfo.hqfFilePath)); - array->SetElement(index++, objValue); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, hqfInfo.moduleName)); + napi_set_named_property(env, objValue, "originHapHash", CreateJsValue(env, hqfInfo.hapSha256)); + napi_set_named_property(env, objValue, "quickFixFilePath", CreateJsValue(env, hqfInfo.hqfFilePath)); + napi_set_element(env, arrayValue, index++, objValue); } return arrayValue; } diff --git a/frameworks/js/napi/quick_fix/js_application_quick_fix_info.h b/frameworks/js/napi/quick_fix/js_application_quick_fix_info.h index e2e3cb0db2b..941257c2313 100644 --- a/frameworks/js/napi/quick_fix/js_application_quick_fix_info.h +++ b/frameworks/js/napi/quick_fix/js_application_quick_fix_info.h @@ -21,9 +21,9 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsApplicationQuickFixInfo( - NativeEngine &engine, const AAFwk::ApplicationQuickFixInfo &appQuickFixInfo); -NativeValue *CreateJsHapModuleQuickFixInfoArray(NativeEngine &engine, const std::vector &hqfInfos); +napi_value CreateJsApplicationQuickFixInfo( + napi_env env, const AAFwk::ApplicationQuickFixInfo &appQuickFixInfo); +napi_value CreateJsHapModuleQuickFixInfoArray(napi_env env, const std::vector &hqfInfos); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_APPLICATION_QUICK_FIX_INFO_H \ No newline at end of file diff --git a/frameworks/js/napi/quick_fix/js_quick_fix_manager.cpp b/frameworks/js/napi/quick_fix/js_quick_fix_manager.cpp index c2c33b55c6e..1a6b85b05b6 100644 --- a/frameworks/js/napi/quick_fix/js_quick_fix_manager.cpp +++ b/frameworks/js/napi/quick_fix/js_quick_fix_manager.cpp @@ -36,131 +36,126 @@ public: JsQuickFixManager() = default; ~JsQuickFixManager() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint) + static void Finalizer(napi_env env, void *data, void *hint) { HILOG_DEBUG("function called."); std::unique_ptr(static_cast(data)); } - static NativeValue *ApplyQuickFix(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value ApplyQuickFix(napi_env env, napi_callback_info info) { - JsQuickFixManager *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnApplyQuickFix(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsQuickFixManager, OnApplyQuickFix); } - static NativeValue *GetApplyedQuickFixInfo(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value GetApplyedQuickFixInfo(napi_env env, napi_callback_info info) { - JsQuickFixManager *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetApplyedQuickFixInfo(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsQuickFixManager, OnGetApplyedQuickFixInfo); } - static NativeValue *RevokeQuickFix(NativeEngine *engine, NativeCallbackInfo *info) + static napi_value RevokeQuickFix(napi_env env, napi_callback_info info) { - JsQuickFixManager *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRevokeQuickFix(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsQuickFixManager, OnRevokeQuickFix); } - static bool Throw(NativeEngine &engine, int32_t errCode) + static void Throw(napi_env env, int32_t errCode) { auto externalErrCode = AAFwk::QuickFixErrorUtil::GetErrorCode(errCode); auto errMsg = AAFwk::QuickFixErrorUtil::GetErrorMessage(errCode); - NativeValue *error = engine.CreateError(CreateJsValue(engine, externalErrCode), CreateJsValue(engine, errMsg)); - return engine.Throw(error); + napi_value error = CreateJsError(env, externalErrCode, errMsg); + napi_throw(env, error); } - static NativeValue *CreateJsErrorByErrorCode(NativeEngine &engine, int32_t errCode) + static napi_value CreateJsErrorByErrorCode(napi_env env, int32_t errCode) { auto externalErrCode = AAFwk::QuickFixErrorUtil::GetErrorCode(errCode); auto errMsg = AAFwk::QuickFixErrorUtil::GetErrorMessage(errCode); - return CreateJsError(engine, externalErrCode, errMsg); + return CreateJsError(env, externalErrCode, errMsg); } private: - NativeValue *OnGetApplyedQuickFixInfo(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetApplyedQuickFixInfo(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("function called."); if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) { HILOG_ERROR("The number of parameter is invalid."); - Throw(engine, AAFwk::ERR_QUICKFIX_PARAM_INVALID); - return engine.CreateUndefined(); + Throw(env, AAFwk::ERR_QUICKFIX_PARAM_INVALID); + return CreateJsUndefined(env); } std::string bundleName; - if (!OHOS::AppExecFwk::UnwrapStringFromJS2(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), bundleName)) { + if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[0], bundleName)) { HILOG_ERROR("The bundleName is invalid."); - Throw(engine, AAFwk::ERR_QUICKFIX_PARAM_INVALID); - return engine.CreateUndefined(); + Throw(env, AAFwk::ERR_QUICKFIX_PARAM_INVALID); + return CreateJsUndefined(env); } - auto complete = [bundleName](NativeEngine &engine, AsyncTask &task, int32_t status) { + auto complete = [bundleName](napi_env env, NapiAsyncTask &task, int32_t status) { AppExecFwk::ApplicationQuickFixInfo quickFixInfo; auto errCode = DelayedSingleton::GetInstance()->GetApplyedQuickFixInfo( bundleName, quickFixInfo); if (errCode == 0) { - task.ResolveWithNoError(engine, CreateJsApplicationQuickFixInfo(engine, quickFixInfo)); + task.ResolveWithNoError(env, CreateJsApplicationQuickFixInfo(env, quickFixInfo)); } else { - task.Reject(engine, CreateJsErrorByErrorCode(engine, errCode)); + task.Reject(env, CreateJsErrorByErrorCode(env, errCode)); } }; - NativeValue *lastParam = (info.argc == ARGC_ONE) ? nullptr : info.argv[1]; - NativeValue *result = nullptr; - AsyncTask::Schedule("JsQuickFixManager::OnGetApplyedQuickFixInfo", engine, - CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc == ARGC_ONE) ? nullptr : info.argv[1]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JsQuickFixManager::OnGetApplyedQuickFixInfo", env, + CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); HILOG_DEBUG("function finished."); return result; } - NativeValue *OnApplyQuickFix(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnApplyQuickFix(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("function called."); if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) { HILOG_ERROR("The number of parameter is invalid."); - Throw(engine, AAFwk::ERR_QUICKFIX_PARAM_INVALID); - return engine.CreateUndefined(); + Throw(env, AAFwk::ERR_QUICKFIX_PARAM_INVALID); + return CreateJsUndefined(env); } std::vector hapQuickFixFiles; - if (!OHOS::AppExecFwk::UnwrapArrayStringFromJS(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), hapQuickFixFiles)) { + if (!OHOS::AppExecFwk::UnwrapArrayStringFromJS(env, info.argv[0], hapQuickFixFiles)) { HILOG_ERROR("Hap quick fix files is invalid."); - Throw(engine, AAFwk::ERR_QUICKFIX_PARAM_INVALID); - return engine.CreateUndefined(); + Throw(env, AAFwk::ERR_QUICKFIX_PARAM_INVALID); + return CreateJsUndefined(env); } - auto complete = [hapQuickFixFiles](NativeEngine &engine, AsyncTask &task, int32_t status) { + auto complete = [hapQuickFixFiles](napi_env env, NapiAsyncTask &task, int32_t status) { auto errcode = DelayedSingleton::GetInstance()->ApplyQuickFix( hapQuickFixFiles); if (errcode == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, CreateJsErrorByErrorCode(engine, errcode)); + task.Reject(env, CreateJsErrorByErrorCode(env, errcode)); } }; - NativeValue *lastParam = (info.argc == 1) ? nullptr : info.argv[1]; - NativeValue *result = nullptr; - AsyncTask::Schedule("JsQuickFixManager::OnApplyQuickFix", engine, - CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc == 1) ? nullptr : info.argv[1]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JsQuickFixManager::OnApplyQuickFix", env, + CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); HILOG_DEBUG("function finished."); return result; } - NativeValue *OnRevokeQuickFix(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnRevokeQuickFix(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("called."); if (info.argc == ARGC_ZERO) { HILOG_ERROR("The number of parameter is invalid."); - Throw(engine, AAFwk::ERR_QUICKFIX_PARAM_INVALID); - return engine.CreateUndefined(); + Throw(env, AAFwk::ERR_QUICKFIX_PARAM_INVALID); + return CreateJsUndefined(env); } std::string bundleName; - if (!ConvertFromJsValue(engine, info.argv[ARGC_ZERO], bundleName)) { + if (!ConvertFromJsValue(env, info.argv[ARGC_ZERO], bundleName)) { HILOG_ERROR("The bundleName is invalid."); - Throw(engine, AAFwk::ERR_QUICKFIX_PARAM_INVALID); - return engine.CreateUndefined(); + Throw(env, AAFwk::ERR_QUICKFIX_PARAM_INVALID); + return CreateJsUndefined(env); } std::shared_ptr errCode = std::make_shared(AAFwk::ERR_OK); @@ -176,48 +171,42 @@ private: HILOG_DEBUG("Revoke quick fix execute retval is {%{public}d}.", *retval); }; - auto complete = [retval = errCode](NativeEngine &engine, AsyncTask &task, int32_t status) { + auto complete = [retval = errCode](napi_env env, NapiAsyncTask &task, int32_t status) { HILOG_DEBUG("Revoke quick fix complete called."); if (*retval != AAFwk::ERR_OK) { HILOG_ERROR("Revoke quick fix execution failed. retval is %{public}d", *retval); - task.Reject(engine, CreateJsErrorByErrorCode(engine, *retval)); + task.Reject(env, CreateJsErrorByErrorCode(env, *retval)); return; } HILOG_DEBUG("Revoke quick fix complete called ok."); - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); }; - NativeValue *lastParam = (info.argc == ARGC_ONE) ? nullptr : info.argv[ARGC_ONE]; - NativeValue *result = nullptr; - AsyncTask::Schedule("JsQuickFixManager::OnRevokeQuickFix", engine, - CreateAsyncTaskWithLastParam(engine, lastParam, std::move(execute), std::move(complete), &result)); + napi_value lastParam = (info.argc == ARGC_ONE) ? nullptr : info.argv[ARGC_ONE]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JsQuickFixManager::OnRevokeQuickFix", env, + CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); HILOG_DEBUG("Function finished."); return result; } }; -NativeValue *CreateJsQuickFixManager(NativeEngine *engine, NativeValue *exportObj) +napi_value CreateJsQuickFixManager(napi_env env, napi_value exportObj) { HILOG_DEBUG("function called."); - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_ERROR("Input parameter is invalid."); return nullptr; } - NativeObject *object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_ERROR("object is nullptr."); - return nullptr; - } - std::unique_ptr quickFixManager = std::make_unique(); - object->SetNativePointer(quickFixManager.release(), JsQuickFixManager::Finalizer, nullptr); + napi_wrap(env, exportObj, quickFixManager.release(), JsQuickFixManager::Finalizer, nullptr, nullptr); - BindNativeFunction(*engine, *object, "applyQuickFix", QUICK_FIX_MANAGER_NAME, JsQuickFixManager::ApplyQuickFix); - BindNativeFunction(*engine, *object, "getApplicationQuickFixInfo", QUICK_FIX_MANAGER_NAME, + BindNativeFunction(env, exportObj, "applyQuickFix", QUICK_FIX_MANAGER_NAME, JsQuickFixManager::ApplyQuickFix); + BindNativeFunction(env, exportObj, "getApplicationQuickFixInfo", QUICK_FIX_MANAGER_NAME, JsQuickFixManager::GetApplyedQuickFixInfo); - BindNativeFunction(*engine, *object, "revokeQuickFix", QUICK_FIX_MANAGER_NAME, JsQuickFixManager::RevokeQuickFix); - return engine->CreateUndefined(); + BindNativeFunction(env, exportObj, "revokeQuickFix", QUICK_FIX_MANAGER_NAME, JsQuickFixManager::RevokeQuickFix); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/quick_fix/js_quick_fix_manager.h b/frameworks/js/napi/quick_fix/js_quick_fix_manager.h index 74b2578775e..e78b24cbace 100644 --- a/frameworks/js/napi/quick_fix/js_quick_fix_manager.h +++ b/frameworks/js/napi/quick_fix/js_quick_fix_manager.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsQuickFixManager(NativeEngine *engine, NativeValue *exportObj); +napi_value CreateJsQuickFixManager(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_QUICK_FIX_MANAGER_H diff --git a/frameworks/js/napi/quick_fix/native_module.cpp b/frameworks/js/napi/quick_fix/native_module.cpp index 13d00d9679a..272ac983547 100644 --- a/frameworks/js/napi/quick_fix/native_module.cpp +++ b/frameworks/js/napi/quick_fix/native_module.cpp @@ -16,14 +16,14 @@ #include "js_quick_fix_manager.h" #include "native_engine/native_engine.h" -extern "C" __attribute__((constructor)) void NAPI_app_ability_quickfixmanager_AutoRegister() +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.quickFixManager", + .nm_filename = "app/ability/libquickfixmanager_napi.so/quickfixmanager.js", + .nm_register_func = OHOS::AbilityRuntime::CreateJsQuickFixManager, +}; +extern "C" __attribute__((constructor)) +void NAPI_app_ability_quickfixmanager_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.quickFixManager", - .fileName = "app/ability/libquickfixmanager_napi.so/quickfixmanager.js", - .registerCallback = OHOS::AbilityRuntime::CreateJsQuickFixManager, - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } diff --git a/frameworks/js/napi/service_extension_ability/service_extension_ability_module.cpp b/frameworks/js/napi/service_extension_ability/service_extension_ability_module.cpp index dbee756c5af..36f72000396 100644 --- a/frameworks/js/napi/service_extension_ability/service_extension_ability_module.cpp +++ b/frameworks/js/napi/service_extension_ability/service_extension_ability_module.cpp @@ -21,16 +21,15 @@ extern const char _binary_service_extension_ability_abc_start[]; extern const char _binary_service_extension_ability_abc_end[]; #ifdef ENABLE_ERRCODE +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.ServiceExtensionAbility", + .nm_filename = "app/ability/libserviceextensionability.so/service_extension_ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_ServiceExtensionAbility_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.ServiceExtensionAbility", - .fileName = "app/ability/libserviceextensionability.so/service_extension_ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) @@ -56,16 +55,15 @@ void NAPI_app_ability_ServiceExtensionAbility_GetABCCode(const char **buf, int * } } #else +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.ServiceExtensionAbility", + .nm_filename = "application/libserviceextensionability_napi.so/service_extension_ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_ServiceExtensionAbility_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.ServiceExtensionAbility", - .fileName = "application/libserviceextensionability_napi.so/service_extension_ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/service_extension_context/service_extension_context_module.cpp b/frameworks/js/napi/service_extension_context/service_extension_context_module.cpp index eeb24f590ee..a310f83c990 100644 --- a/frameworks/js/napi/service_extension_context/service_extension_context_module.cpp +++ b/frameworks/js/napi/service_extension_context/service_extension_context_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_service_extension_context_js_end[]; extern const char _binary_service_extension_context_abc_start[]; extern const char _binary_service_extension_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.ServiceExtensionContext", + .nm_filename = "application/libserviceextensioncontext_napi.so/ServiceExtensionContext.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_ServiceExtensionContext_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.ServiceExtensionContext", - .fileName = "application/libserviceextensioncontext_napi.so/ServiceExtensionContext.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/share_extension_ability/share_extension_ability_module.cpp b/frameworks/js/napi/share_extension_ability/share_extension_ability_module.cpp index ec024911141..9331b6ae59d 100644 --- a/frameworks/js/napi/share_extension_ability/share_extension_ability_module.cpp +++ b/frameworks/js/napi/share_extension_ability/share_extension_ability_module.cpp @@ -20,15 +20,14 @@ extern const char _binary_share_extension_ability_js_end[]; extern const char _binary_share_extension_ability_abc_start[]; extern const char _binary_share_extension_ability_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.ShareExtensionAbility", + .nm_filename = "app/ability/libshareextensionability_napi.so/share_extension_ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_ShareExtensionAbility_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.ShareExtensionAbility", - .fileName = "app/ability/libshareextensionability_napi.so/share_extension_ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) void NAPI_app_ability_ShareExtensionAbility_GetJSCode( diff --git a/frameworks/js/napi/ui_extension_ability/ui_extension_ability_module.cpp b/frameworks/js/napi/ui_extension_ability/ui_extension_ability_module.cpp index 5a22c453ed1..de545ed5a0a 100755 --- a/frameworks/js/napi/ui_extension_ability/ui_extension_ability_module.cpp +++ b/frameworks/js/napi/ui_extension_ability/ui_extension_ability_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_ui_extension_ability_js_end[]; extern const char _binary_ui_extension_ability_abc_start[]; extern const char _binary_ui_extension_ability_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.UIExtensionAbility", + .nm_filename = "app/ability/libuiextensionability_napi.so/ui_extension_ability.js", +}; extern "C" __attribute__((constructor)) void NAPI_app_ability_UIExtensionAbility_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.UIExtensionAbility", - .fileName = "app/ability/libuiextensionability_napi.so/ui_extension_ability.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/ui_extension_context/ui_extension_context_module.cpp b/frameworks/js/napi/ui_extension_context/ui_extension_context_module.cpp index 80cfbe5d10c..3fd56ece3f9 100755 --- a/frameworks/js/napi/ui_extension_context/ui_extension_context_module.cpp +++ b/frameworks/js/napi/ui_extension_context/ui_extension_context_module.cpp @@ -20,16 +20,15 @@ extern const char _binary_ui_extension_context_js_end[]; extern const char _binary_ui_extension_context_abc_start[]; extern const char _binary_ui_extension_context_abc_end[]; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.UIExtensionContext", + .nm_filename = "application/libuiextensioncontext_napi.so/ui_extension_context.js", +}; extern "C" __attribute__((constructor)) void NAPI_application_UIExtensionContext_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.UIExtensionContext", - .fileName = "application/libuiextensioncontext_napi.so/ui_extension_context.js", - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } extern "C" __attribute__((visibility("default"))) diff --git a/frameworks/js/napi/uri_permission/js_uri_perm_mgr.cpp b/frameworks/js/napi/uri_permission/js_uri_perm_mgr.cpp index 84b24bdf968..7c369e7db9b 100644 --- a/frameworks/js/napi/uri_permission/js_uri_perm_mgr.cpp +++ b/frameworks/js/napi/uri_permission/js_uri_perm_mgr.cpp @@ -40,165 +40,152 @@ public: JsUriPermMgr() = default; ~JsUriPermMgr() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsUriPermMgr::Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* GrantUriPermission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GrantUriPermission(napi_env env, napi_callback_info info) { - JsUriPermMgr* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGrantUriPermission(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsUriPermMgr, OnGrantUriPermission); } - static NativeValue* RevokeUriPermission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value RevokeUriPermission(napi_env env, napi_callback_info info) { - JsUriPermMgr* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRevokeUriPermission(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsUriPermMgr, OnRevokeUriPermission); } private: - NativeValue* OnGrantUriPermission(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnGrantUriPermission(napi_env env, NapiCallbackInfo& info) { HILOG_DEBUG("Grant Uri Permission start"); if (info.argc != argCountThree && info.argc != argCountFour) { HILOG_ERROR("The number of parameter is invalid."); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string uriStr; - if (!OHOS::AppExecFwk::UnwrapStringFromJS2(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), uriStr)) { + if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[0], uriStr)) { HILOG_ERROR("The uriStr is invalid."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int flag = 0; - if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(reinterpret_cast(&engine), - reinterpret_cast(info.argv[1]), flag)) { + if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[1], flag)) { HILOG_ERROR("The flag is invalid."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } std::string targetBundleName; - if (!OHOS::AppExecFwk::UnwrapStringFromJS2(reinterpret_cast(&engine), - reinterpret_cast(info.argv[argCountTwo]), targetBundleName)) { + if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[argCountTwo], targetBundleName)) { HILOG_ERROR("The targetBundleName is invalid."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } auto selfToken = IPCSkeleton::GetSelfTokenID(); if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) { HILOG_ERROR("This application is not system-app, can not use system-api."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [uriStr, flag, targetBundleName](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [uriStr, flag, targetBundleName](napi_env env, NapiAsyncTask& task, int32_t status) { Uri uri(uriStr); auto errCode = AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermission(uri, flag, targetBundleName, 0); if (errCode == ERR_OK) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else if (errCode == AAFwk::CHECK_PERMISSION_FAILED) { - task.Reject(engine, CreateNoPermissionError(engine, "ohos.permission.PROXY_AUTHORIZATION_URI")); + task.Reject(env, CreateNoPermissionError(env, "ohos.permission.PROXY_AUTHORIZATION_URI")); } else if (errCode == AAFwk::ERR_CODE_INVALID_URI_FLAG) { - task.Reject(engine, CreateJsError(engine, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_URI_FLAG, + task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_URI_FLAG, "Invalid URI flag.")); } else if (errCode == AAFwk::ERR_CODE_INVALID_URI_TYPE) { - task.Reject(engine, CreateJsError(engine, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_URI_TYPE, + task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_URI_TYPE, "Only support file URI.")); } else if (errCode == AAFwk::ERR_CODE_GRANT_URI_PERMISSION) { - task.Reject(engine, CreateJsError(engine, ERR_ABILITY_RUNTIME_EXTERNAL_GRANT_URI_PERMISSION, + task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_GRANT_URI_PERMISSION, "Sandbox application can not grant URI permission.")); } else { - task.Reject(engine, CreateJsError(engine, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR, + task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR, "Internal Error.")); } }; - NativeValue* lastParam = (info.argc == argCountFour) ? info.argv[argCountThree] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JsUriPermMgr::OnGrantUriPermission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc == argCountFour) ? info.argv[argCountThree] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JsUriPermMgr::OnGrantUriPermission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnRevokeUriPermission(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnRevokeUriPermission(napi_env env, NapiCallbackInfo& info) { // only support 2 or 3 params (2 parameter and 1 optional callback) if (info.argc != argCountThree && info.argc != argCountTwo) { HILOG_ERROR("Invalid arguments"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string uriStr; - if (!OHOS::AppExecFwk::UnwrapStringFromJS2(reinterpret_cast(&engine), - reinterpret_cast(info.argv[0]), uriStr)) { + if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[0], uriStr)) { HILOG_ERROR("invalid of the uriStr."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } std::string bundleName; - if (!OHOS::AppExecFwk::UnwrapStringFromJS2(reinterpret_cast(&engine), - reinterpret_cast(info.argv[1]), bundleName)) { + if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[1], bundleName)) { HILOG_ERROR("The bundleName is invalid."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } auto selfToken = IPCSkeleton::GetSelfTokenID(); if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) { HILOG_ERROR("can not use system-api, this application is not system-app."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [uriStr, bundleName](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [uriStr, bundleName](napi_env env, NapiAsyncTask& task, int32_t status) { Uri uri(uriStr); auto errCode = AAFwk::UriPermissionManagerClient::GetInstance().RevokeUriPermissionManually(uri, bundleName); if (errCode == ERR_OK) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else if (errCode == AAFwk::CHECK_PERMISSION_FAILED) { - task.Reject(engine, CreateNoPermissionError(engine, + task.Reject(env, CreateNoPermissionError(env, "Do not have permission ohos.permission.PROXY_AUTHORIZATION_URI")); } else if (errCode == AAFwk::ERR_CODE_INVALID_URI_TYPE) { - task.Reject(engine, CreateJsError(engine, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_URI_TYPE, + task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_URI_TYPE, "Only support file URI.")); } else { - task.Reject(engine, CreateJsError(engine, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR, + task.Reject(env, CreateJsError(env, ERR_ABILITY_RUNTIME_EXTERNAL_INTERNAL_ERROR, "Internal Error.")); } }; - NativeValue* lastParam = (info.argc == argCountThree) ? info.argv[argCountTwo] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JsUriPermMgr::OnRevokeUriPermission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (info.argc == argCountThree) ? info.argv[argCountTwo] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JsUriPermMgr::OnRevokeUriPermission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } }; -NativeValue* CreateJsUriPermMgr(NativeEngine* engine, NativeValue* exportObj) +napi_value CreateJsUriPermMgr(napi_env env, napi_value exportObj) { HILOG_INFO("CreateJsUriPermMgr is called"); - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_INFO("Invalid input parameters"); return nullptr; } - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_INFO("object is nullptr"); - return nullptr; - } - std::unique_ptr jsUriPermMgr = std::make_unique(); - object->SetNativePointer(jsUriPermMgr.release(), JsUriPermMgr::Finalizer, nullptr); + napi_wrap(env, exportObj, jsUriPermMgr.release(), JsUriPermMgr::Finalizer, nullptr, nullptr); const char *moduleName = "JsUriPermMgr"; - BindNativeFunction(*engine, *object, "grantUriPermission", moduleName, JsUriPermMgr::GrantUriPermission); - BindNativeFunction(*engine, *object, "revokeUriPermission", moduleName, JsUriPermMgr::RevokeUriPermission); - return engine->CreateUndefined(); + BindNativeFunction(env, exportObj, "grantUriPermission", moduleName, JsUriPermMgr::GrantUriPermission); + BindNativeFunction(env, exportObj, "revokeUriPermission", moduleName, JsUriPermMgr::RevokeUriPermission); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/uri_permission/js_uri_perm_mgr.h b/frameworks/js/napi/uri_permission/js_uri_perm_mgr.h index b8c70b1dd94..9773120d40d 100644 --- a/frameworks/js/napi/uri_permission/js_uri_perm_mgr.h +++ b/frameworks/js/napi/uri_permission/js_uri_perm_mgr.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsUriPermMgr(NativeEngine* engine, NativeValue* exportObj); +napi_value CreateJsUriPermMgr(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_URI_PERM_MGR_H diff --git a/frameworks/js/napi/uri_permission/native_module.cpp b/frameworks/js/napi/uri_permission/native_module.cpp index 65f4b5fdb65..f08bbdf2104 100644 --- a/frameworks/js/napi/uri_permission/native_module.cpp +++ b/frameworks/js/napi/uri_permission/native_module.cpp @@ -16,15 +16,14 @@ #include "js_uri_perm_mgr.h" #include "native_engine/native_engine.h" +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.uriPermissionManager", + .nm_filename = "application/liburipermissionmanager_napi.so/uripermissionmanager.js", + .nm_register_func = OHOS::AbilityRuntime::CreateJsUriPermMgr, +}; extern "C" __attribute__((constructor)) void NAPI_application_uripermissionmanager_AutoRegister() { - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.uriPermissionManager", - .fileName = "application/liburipermissionmanager_napi.so/uripermissionmanager.js", - .registerCallback = OHOS::AbilityRuntime::CreateJsUriPermMgr, - }; - - moduleManager->Register(&newModuleInfo); + napi_module_register(&_module); } diff --git a/frameworks/simulator/common/include/request_info.h b/frameworks/simulator/common/include/request_info.h index dc0680f0ad1..64424fefec0 100644 --- a/frameworks/simulator/common/include/request_info.h +++ b/frameworks/simulator/common/include/request_info.h @@ -20,11 +20,11 @@ namespace OHOS { namespace AbilityRuntime { class RequestInfo { public: - static NativeValue* WrapRequestInfo(NativeEngine &engine, RequestInfo *request) + static napi_value WrapRequestInfo(napi_env env, RequestInfo *request) { return nullptr; }; - static std::shared_ptr UnwrapRequestInfo(NativeEngine &engine, NativeValue *jsParam) + static std::shared_ptr UnwrapRequestInfo(napi_env env, napi_value jsParam) { return nullptr; }; -- Gitee