From 383dba9aff704760abc01103826ac8ef4c9889c9 Mon Sep 17 00:00:00 2001 From: wangkailong Date: Sun, 24 Sep 2023 12:53:07 +0800 Subject: [PATCH] napi3 Signed-off-by: wangkailong Change-Id: I97361e4ebe99d64739325dec05631acbb54da2a4 --- .../include/js_ability_context.h | 53 +-- .../include/js_ability_stage_context.h | 4 +- .../include/js_application_context_utils.h | 67 ++-- .../include/js_console_log.h | 2 +- .../include/js_context_utils.h | 2 +- .../include/js_data_converter.h | 9 +- .../include/js_resource_manager_utils.h | 3 +- .../ability_simulator/include/js_timer.h | 2 +- .../src/js_ability_context.cpp | 162 ++++----- .../src/js_ability_stage_context.cpp | 28 +- .../src/js_application_context_utils.cpp | 241 ++++++------- .../ability_simulator/src/js_console_log.cpp | 57 +-- .../src/js_context_utils.cpp | 248 ++++++------- .../src/js_data_converter.cpp | 61 ++-- .../src/js_resource_manager_utils.cpp | 5 +- .../src/js_runtime_utils.cpp | 337 ++++++++++++++++++ .../ability_simulator/src/js_timer.cpp | 92 +++-- .../ability_simulator/src/simulator.cpp | 263 ++++++++------ 18 files changed, 993 insertions(+), 643 deletions(-) diff --git a/frameworks/simulator/ability_simulator/include/js_ability_context.h b/frameworks/simulator/ability_simulator/include/js_ability_context.h index 372658679da..13d3d95bc37 100644 --- a/frameworks/simulator/ability_simulator/include/js_ability_context.h +++ b/frameworks/simulator/ability_simulator/include/js_ability_context.h @@ -21,6 +21,7 @@ #include #include "ability_context.h" #include "configuration.h" +#include "js_runtime_utils.h" class NativeObject; class NativeReference; @@ -33,40 +34,40 @@ public: explicit JsAbilityContext(const std::shared_ptr &context) : context_(context) {} ~JsAbilityContext() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint); + static void Finalizer(napi_env env, void *data, void *hint); - static NativeValue *StartAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityAsCaller(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartRecentAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityByCall(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityForResult(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityForResultWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StopServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StopServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *ConnectAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *ConnectAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *DisconnectAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *TerminateSelf(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *TerminateSelfWithResult(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *RestoreWindowStage(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *RequestDialogService(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *IsTerminating(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value StartAbility(napi_env env, napi_callback_info info); + static napi_value StartAbilityAsCaller(napi_env env, napi_callback_info info); + static napi_value StartRecentAbility(napi_env env, napi_callback_info info); + static napi_value StartAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value StartAbilityByCall(napi_env env, napi_callback_info info); + static napi_value StartAbilityForResult(napi_env env, napi_callback_info info); + static napi_value StartAbilityForResultWithAccount(napi_env env, napi_callback_info info); + static napi_value StartServiceExtensionAbility(napi_env env, napi_callback_info info); + static napi_value StartServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value StopServiceExtensionAbility(napi_env env, napi_callback_info info); + static napi_value StopServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value ConnectAbility(napi_env env, napi_callback_info info); + static napi_value ConnectAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value DisconnectAbility(napi_env env, napi_callback_info info); + static napi_value TerminateSelf(napi_env env, napi_callback_info info); + static napi_value TerminateSelfWithResult(napi_env env, napi_callback_info info); + static napi_value RestoreWindowStage(napi_env env, napi_callback_info info); + static napi_value RequestDialogService(napi_env env, napi_callback_info info); + static napi_value IsTerminating(napi_env env, napi_callback_info info); - static void ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, + static void ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config); private: - NativeValue *OnTerminateSelf(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnIsTerminating(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnTerminateSelfWithResult(NativeEngine &engine, NativeCallbackInfo &info); + napi_value OnTerminateSelf(napi_env env, NapiCallbackInfo &info); + napi_value OnIsTerminating(napi_env env, NapiCallbackInfo &info); + napi_value OnTerminateSelfWithResult(napi_env env, NapiCallbackInfo &info); std::weak_ptr context_; }; -NativeValue *CreateJsAbilityContext(NativeEngine &engine, const std::shared_ptr &context); -NativeValue *CreateJsErrorByNativeErr(NativeEngine &engine, int32_t err, const std::string &permission = ""); +napi_value CreateJsAbilityContext(napi_env env, const std::shared_ptr &context); +napi_value CreateJsErrorByNativeErr(napi_env env, int32_t err, const std::string &permission = ""); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_ABILITY_CONTEXT_H diff --git a/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h b/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h index dc22628c1e1..11352ca4254 100644 --- a/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h +++ b/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h @@ -27,7 +27,7 @@ public: explicit JsAbilityStageContext(const std::shared_ptr &context) : context_(context) {} ~JsAbilityStageContext() = default; - static void ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, + static void ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config); std::shared_ptr GetContext() @@ -39,7 +39,7 @@ private: std::weak_ptr context_; }; -NativeValue *CreateJsAbilityStageContext(NativeEngine &engine, const std::shared_ptr &context); +napi_value CreateJsAbilityStageContext(napi_env env, const std::shared_ptr &context); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_ABILITY_STAGE_CONTEXT_H diff --git a/frameworks/simulator/ability_simulator/include/js_application_context_utils.h b/frameworks/simulator/ability_simulator/include/js_application_context_utils.h index dd66a823451..f66301c7408 100644 --- a/frameworks/simulator/ability_simulator/include/js_application_context_utils.h +++ b/frameworks/simulator/ability_simulator/include/js_application_context_utils.h @@ -20,6 +20,7 @@ #include "native_engine/native_engine.h" #include "context.h" +#include "js_runtime_utils.h" namespace OHOS { namespace AbilityRuntime { @@ -27,42 +28,42 @@ class JsApplicationContextUtils { public: JsApplicationContextUtils(std::weak_ptr &&context) : context_(std::move(context)) {} virtual ~JsApplicationContextUtils() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint); - static NativeValue *RegisterAbilityLifecycleCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *UnregisterAbilityLifecycleCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *RegisterEnvironmentCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *UnregisterEnvironmentCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *On(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *Off(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *SwitchArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetTempDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *KillProcessBySelf(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetRunningProcessInformation(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateJsApplicationContext(NativeEngine &engine, const std::shared_ptr &context); + static void Finalizer(napi_env env, void *data, void *hint); + static napi_value RegisterAbilityLifecycleCallback(napi_env env, napi_callback_info info); + static napi_value UnregisterAbilityLifecycleCallback(napi_env env, napi_callback_info info); + static napi_value RegisterEnvironmentCallback(napi_env env, napi_callback_info info); + static napi_value UnregisterEnvironmentCallback(napi_env env, napi_callback_info info); + static napi_value On(napi_env env, napi_callback_info info); + static napi_value Off(napi_env env, napi_callback_info info); + static napi_value CreateBundleContext(napi_env env, napi_callback_info info); + static napi_value SwitchArea(napi_env env, napi_callback_info info); + static napi_value GetArea(napi_env env, napi_callback_info info); + static napi_value CreateModuleContext(napi_env env, napi_callback_info info); + static napi_value GetCacheDir(napi_env env, napi_callback_info info); + static napi_value GetTempDir(napi_env env, napi_callback_info info); + static napi_value GetFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDistributedFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDatabaseDir(napi_env env, napi_callback_info info); + static napi_value GetPreferencesDir(napi_env env, napi_callback_info info); + static napi_value GetBundleCodeDir(napi_env env, napi_callback_info info); + static napi_value GetApplicationContext(napi_env env, napi_callback_info info); + static napi_value KillProcessBySelf(napi_env env, napi_callback_info info); + static napi_value GetRunningProcessInformation(napi_env env, napi_callback_info info); + static napi_value CreateJsApplicationContext(napi_env env, const std::shared_ptr &context); - NativeValue *OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetArea(NativeEngine &engine, NativeCallbackInfo &info); + napi_value OnGetCacheDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetTempDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetFilesDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetDatabaseDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetPreferencesDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetBundleCodeDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetArea(napi_env env, NapiCallbackInfo& info); private: - NativeValue *OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info); - static void BindNativeApplicationContext(NativeEngine &engine, NativeObject *object); + napi_value OnSwitchArea(napi_env env, NapiCallbackInfo& info); + napi_value OnGetApplicationContext(napi_env env, NapiCallbackInfo& info); + static void BindNativeApplicationContext(napi_env env, napi_value object); private: std::weak_ptr context_; diff --git a/frameworks/simulator/ability_simulator/include/js_console_log.h b/frameworks/simulator/ability_simulator/include/js_console_log.h index f975aca14e5..693629abeaa 100644 --- a/frameworks/simulator/ability_simulator/include/js_console_log.h +++ b/frameworks/simulator/ability_simulator/include/js_console_log.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -void InitConsoleLogModule(NativeEngine &engine, NativeObject &globalObject); +void InitConsoleLogModule(napi_env env, napi_value globalObject); } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/include/js_context_utils.h b/frameworks/simulator/ability_simulator/include/js_context_utils.h index 91cf407528f..c2173881388 100644 --- a/frameworks/simulator/ability_simulator/include/js_context_utils.h +++ b/frameworks/simulator/ability_simulator/include/js_context_utils.h @@ -23,7 +23,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsBaseContext(NativeEngine &engine, std::shared_ptr context, bool keepContext = false); +napi_value CreateJsBaseContext(napi_env env, std::shared_ptr context, bool keepContext = false); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_CONTEXT_UTILS_H diff --git a/frameworks/simulator/ability_simulator/include/js_data_converter.h b/frameworks/simulator/ability_simulator/include/js_data_converter.h index cf23c948331..f871c22afff 100644 --- a/frameworks/simulator/ability_simulator/include/js_data_converter.h +++ b/frameworks/simulator/ability_simulator/include/js_data_converter.h @@ -20,6 +20,7 @@ #include "application_info.h" #include "hap_module_info.h" #include "configuration.h" +#include "native_engine/native_engine.h" #include "res_common.h" class NativeEngine; @@ -31,10 +32,10 @@ Global::Resource::Direction ConvertDirection(const std::string &direction); Global::Resource::ScreenDensity ConvertDensity(const std::string &density); int32_t ConvertDisplayId(const std::string &displayId); std::string GetDensityStr(float density); -NativeValue *CreateJsConfiguration(NativeEngine &engine, const AppExecFwk::Configuration &configuration); -NativeValue *CreateJsApplicationInfo(NativeEngine &engine, const AppExecFwk::ApplicationInfo &applicationInfo); -NativeValue *CreateJsHapModuleInfo(NativeEngine &engine, const AppExecFwk::HapModuleInfo &hapModuleInfo); -NativeValue *CreateJsAbilityInfo(NativeEngine &engine, const AppExecFwk::AbilityInfo &abilityInfo); +napi_value CreateJsConfiguration(napi_env env, const AppExecFwk::Configuration &configuration); +napi_value CreateJsApplicationInfo(napi_env env, const AppExecFwk::ApplicationInfo &applicationInfo); +napi_value CreateJsHapModuleInfo(napi_env env, const AppExecFwk::HapModuleInfo &hapModuleInfo); +napi_value CreateJsAbilityInfo(napi_env env, const AppExecFwk::AbilityInfo &abilityInfo); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_DATA_CONVERTER_H diff --git a/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h b/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h index 298106fdd76..c2869477922 100644 --- a/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h +++ b/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h @@ -17,6 +17,7 @@ #define OHOS_ABILITY_RUNTIME_JS_RESOURCE_MANAGER_UTILS_H #include "context.h" +#include "native_engine/native_engine.h" #include "resource_manager.h" class NativeEngine; @@ -24,7 +25,7 @@ class NativeValue; namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsResourceManager(NativeEngine &engine, +napi_value CreateJsResourceManager(napi_env env, std::shared_ptr resourceManager, std::shared_ptr context); } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/include/js_timer.h b/frameworks/simulator/ability_simulator/include/js_timer.h index ac380aa482a..98649be115f 100644 --- a/frameworks/simulator/ability_simulator/include/js_timer.h +++ b/frameworks/simulator/ability_simulator/include/js_timer.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -void InitTimer(NativeEngine &engine, NativeObject &globalObject); +void InitTimer(napi_env env, napi_value globalObject); } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_ability_context.cpp b/frameworks/simulator/ability_simulator/src/js_ability_context.cpp index 2f5f05d0dcb..5af64ab82e7 100644 --- a/frameworks/simulator/ability_simulator/src/js_ability_context.cpp +++ b/frameworks/simulator/ability_simulator/src/js_ability_context.cpp @@ -28,89 +28,88 @@ namespace { constexpr size_t ARGC_ZERO = 0; constexpr size_t ARGC_ONE = 1; } -void JsAbilityContext::Finalizer(NativeEngine *engine, void *data, void *hint) +void JsAbilityContext::Finalizer(napi_env env, void *data, void *hint) { HILOG_DEBUG("called"); std::unique_ptr(static_cast(data)); } -NativeValue *JsAbilityContext::StartAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityAsCaller(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityAsCaller(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartRecentAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartRecentAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityByCall(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityByCall(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityForResult(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityForResult(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityForResultWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityForResultWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartServiceExtensionAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StopServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StopServiceExtensionAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StopServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StopServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::ConnectAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::ConnectAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::ConnectAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::ConnectAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::DisconnectAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::DisconnectAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::TerminateSelf(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::TerminateSelf(napi_env env, napi_callback_info info) { - JsAbilityContext *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnTerminateSelf(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityContext, OnTerminateSelf); } -NativeValue *JsAbilityContext::OnTerminateSelf(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsAbilityContext::OnTerminateSelf(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("TerminateSelf"); auto abilityContext = context_.lock(); @@ -119,30 +118,29 @@ NativeValue *JsAbilityContext::OnTerminateSelf(NativeEngine &engine, NativeCallb } abilityContext->SetTerminating(true); - NativeValue *lastParam = (info.argc > ARGC_ZERO) ? info.argv[ARGC_ZERO] : nullptr; - NativeValue *result = nullptr; - auto task = CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, nullptr, &result); + napi_value lastParam = (info.argc > ARGC_ZERO) ? info.argv[ARGC_ZERO] : nullptr; + napi_value result = nullptr; + auto task = CreateAsyncTaskWithLastParam(env, lastParam, nullptr, nullptr, &result); if (task == nullptr) { return nullptr; } auto errcode = abilityContext->TerminateSelf(); if (errcode == 0) { - task->Resolve(engine, engine.CreateUndefined()); + task->Resolve(env, CreateJsUndefined(env)); } else { - task->Reject(engine, CreateJsErrorByNativeErr(engine, errcode)); + task->Reject(env, CreateJsErrorByNativeErr(env, errcode)); } return result; } -NativeValue *JsAbilityContext::TerminateSelfWithResult(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::TerminateSelfWithResult(napi_env env, napi_callback_info info) { - JsAbilityContext *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnTerminateSelfWithResult(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityContext, OnTerminateSelfWithResult); } -NativeValue *JsAbilityContext::OnTerminateSelfWithResult(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsAbilityContext::OnTerminateSelfWithResult(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("called."); auto abilityContext = context_.lock(); @@ -151,59 +149,58 @@ NativeValue *JsAbilityContext::OnTerminateSelfWithResult(NativeEngine &engine, N } abilityContext->SetTerminating(true); - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[ARGC_ONE] : nullptr; - NativeValue *result = nullptr; - auto task = CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, nullptr, &result); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[ARGC_ONE] : nullptr; + napi_value result = nullptr; + auto task = CreateAsyncTaskWithLastParam(env, lastParam, nullptr, nullptr, &result); if (task == nullptr) { return nullptr; } auto errcode = abilityContext->TerminateSelf(); if (errcode == 0) { - task->Resolve(engine, engine.CreateUndefined()); + task->Resolve(env, CreateJsUndefined(env)); } else { - task->Reject(engine, CreateJsErrorByNativeErr(engine, errcode)); + task->Reject(env, CreateJsErrorByNativeErr(env, errcode)); } return result; } -NativeValue *JsAbilityContext::RestoreWindowStage(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::RestoreWindowStage(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::RequestDialogService(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::RequestDialogService(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::IsTerminating(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::IsTerminating(napi_env env, napi_callback_info info) { - JsAbilityContext *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsTerminating(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityContext, OnIsTerminating); } -NativeValue *JsAbilityContext::OnIsTerminating(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsAbilityContext::OnIsTerminating(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("IsTerminating"); auto context = context_.lock(); if (context == nullptr) { HILOG_ERROR("OnIsTerminating context is nullptr"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - return engine.CreateBoolean(context->IsTerminating()); + return CreateJsValue(env, context->IsTerminating()); } -NativeValue *CreateJsErrorByNativeErr(NativeEngine &engine, int32_t err, const std::string &permission) +napi_value CreateJsErrorByNativeErr(napi_env env, int32_t err, const std::string &permission) { auto errCode = GetJsErrorCodeByNativeError(err); auto errMsg = (errCode == AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED && !permission.empty()) ? GetNoPermissionErrorMsg(permission) : GetErrorMsg(errCode); - return CreateJsError(engine, static_cast(errCode), errMsg); + return CreateJsError(env, static_cast(errCode), errMsg); } -void JsAbilityContext::ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, +void JsAbilityContext::ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config) { HILOG_DEBUG("called."); @@ -212,83 +209,86 @@ void JsAbilityContext::ConfigurationUpdated(NativeEngine *engine, std::shared_pt return; } - NativeValue *value = jsContext->Get(); - NativeObject *object = ConvertNativeValueTo(value); - if (object == nullptr) { - HILOG_ERROR("object is nullptr."); + napi_value value = jsContext->GetNapiValue(); + if (value == nullptr) { + HILOG_ERROR("value is nullptr."); return; } - NativeValue *method = object->GetProperty("onUpdateConfiguration"); + napi_value method = nullptr; + napi_get_named_property(env, value, "onUpdateConfiguration", &method); if (method == nullptr) { HILOG_ERROR("Failed to get onUpdateConfiguration from object"); return; } - NativeValue *argv[] = { CreateJsConfiguration(*engine, *config) }; - engine->CallFunction(value, method, argv, 1); + napi_value argv[] = { CreateJsConfiguration(env, *config) }; + napi_value callResult = nullptr; + napi_call_function(env, nullptr, method, 1, argv, &callResult); } -NativeValue *CreateJsAbilityContext(NativeEngine &engine, const std::shared_ptr &context) +napi_value CreateJsAbilityContext(napi_env env, const std::shared_ptr &context) { - NativeValue *objValue = CreateJsBaseContext(engine, context); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = CreateJsBaseContext(env, context); std::unique_ptr jsContext = std::make_unique(context); - object->SetNativePointer(jsContext.release(), JsAbilityContext::Finalizer, nullptr); + napi_wrap(env, object, jsContext.release(), JsAbilityContext::Finalizer, nullptr, nullptr); auto resourceManager = context->GetResourceManager(); if (resourceManager != nullptr) { - object->SetProperty("resourceManager", CreateJsResourceManager(engine, resourceManager, context)); + napi_set_named_property(env, object, "resourceManager", + CreateJsResourceManager(env, resourceManager, context)); } auto abilityInfo = context->GetAbilityInfo(); if (abilityInfo != nullptr) { - object->SetProperty("abilityInfo", CreateJsAbilityInfo(engine, *abilityInfo)); + napi_set_named_property( + env, object, "abilityInfo", CreateJsAbilityInfo(env, *abilityInfo)); } auto configuration = context->GetConfiguration(); if (configuration != nullptr) { - object->SetProperty("config", CreateJsConfiguration(engine, *configuration)); + napi_set_named_property( + env, object, "config", CreateJsConfiguration(env, *configuration)); } const char *moduleName = "JsAbilityContext"; - BindNativeFunction(engine, *object, "startAbility", moduleName, JsAbilityContext::StartAbility); - BindNativeFunction(engine, *object, "startAbilityAsCaller", moduleName, JsAbilityContext::StartAbilityAsCaller); - BindNativeFunction(engine, *object, "startAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "startAbility", moduleName, JsAbilityContext::StartAbility); + BindNativeFunction(env, object, "startAbilityAsCaller", moduleName, JsAbilityContext::StartAbilityAsCaller); + BindNativeFunction(env, object, "startAbilityWithAccount", moduleName, JsAbilityContext::StartAbilityWithAccount); - BindNativeFunction(engine, *object, "startAbilityByCall", moduleName, JsAbilityContext::StartAbilityByCall); - BindNativeFunction(engine, *object, "startAbilityForResult", moduleName, JsAbilityContext::StartAbilityForResult); - BindNativeFunction(engine, *object, "startAbilityForResultWithAccount", moduleName, + BindNativeFunction(env, object, "startAbilityByCall", moduleName, JsAbilityContext::StartAbilityByCall); + BindNativeFunction(env, object, "startAbilityForResult", moduleName, JsAbilityContext::StartAbilityForResult); + BindNativeFunction(env, object, "startAbilityForResultWithAccount", moduleName, JsAbilityContext::StartAbilityForResultWithAccount); - BindNativeFunction(engine, *object, "startServiceExtensionAbility", moduleName, + BindNativeFunction(env, object, "startServiceExtensionAbility", moduleName, JsAbilityContext::StartServiceExtensionAbility); - BindNativeFunction(engine, *object, "startServiceExtensionAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "startServiceExtensionAbilityWithAccount", moduleName, JsAbilityContext::StartServiceExtensionAbilityWithAccount); - BindNativeFunction(engine, *object, "stopServiceExtensionAbility", moduleName, + BindNativeFunction(env, object, "stopServiceExtensionAbility", moduleName, JsAbilityContext::StopServiceExtensionAbility); - BindNativeFunction(engine, *object, "stopServiceExtensionAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "stopServiceExtensionAbilityWithAccount", moduleName, JsAbilityContext::StopServiceExtensionAbilityWithAccount); - BindNativeFunction(engine, *object, "connectAbility", moduleName, JsAbilityContext::ConnectAbility); - BindNativeFunction(engine, *object, "connectServiceExtensionAbility", moduleName, JsAbilityContext::ConnectAbility); - BindNativeFunction(engine, *object, "connectAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "connectAbility", moduleName, JsAbilityContext::ConnectAbility); + BindNativeFunction(env, object, "connectServiceExtensionAbility", moduleName, JsAbilityContext::ConnectAbility); + BindNativeFunction(env, object, "connectAbilityWithAccount", moduleName, JsAbilityContext::ConnectAbilityWithAccount); - BindNativeFunction(engine, *object, "connectServiceExtensionAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "connectServiceExtensionAbilityWithAccount", moduleName, JsAbilityContext::ConnectAbilityWithAccount); - BindNativeFunction(engine, *object, "disconnectAbility", moduleName, JsAbilityContext::DisconnectAbility); + BindNativeFunction(env, object, "disconnectAbility", moduleName, JsAbilityContext::DisconnectAbility); BindNativeFunction( - engine, *object, "disconnectServiceExtensionAbility", moduleName, JsAbilityContext::DisconnectAbility); - BindNativeFunction(engine, *object, "terminateSelf", moduleName, JsAbilityContext::TerminateSelf); - BindNativeFunction(engine, *object, "terminateSelfWithResult", moduleName, + env, object, "disconnectServiceExtensionAbility", moduleName, JsAbilityContext::DisconnectAbility); + BindNativeFunction(env, object, "terminateSelf", moduleName, JsAbilityContext::TerminateSelf); + BindNativeFunction(env, object, "terminateSelfWithResult", moduleName, JsAbilityContext::TerminateSelfWithResult); - BindNativeFunction(engine, *object, "restoreWindowStage", moduleName, JsAbilityContext::RestoreWindowStage); - BindNativeFunction(engine, *object, "isTerminating", moduleName, JsAbilityContext::IsTerminating); - BindNativeFunction(engine, *object, "startRecentAbility", moduleName, + BindNativeFunction(env, object, "restoreWindowStage", moduleName, JsAbilityContext::RestoreWindowStage); + BindNativeFunction(env, object, "isTerminating", moduleName, JsAbilityContext::IsTerminating); + BindNativeFunction(env, object, "startRecentAbility", moduleName, JsAbilityContext::StartRecentAbility); - BindNativeFunction(engine, *object, "requestDialogService", moduleName, + BindNativeFunction(env, object, "requestDialogService", moduleName, JsAbilityContext::RequestDialogService); - return objValue; + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp b/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp index 9dfb49ac0d7..3219325fe91 100644 --- a/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp +++ b/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp @@ -22,23 +22,22 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsAbilityStageContext(NativeEngine &engine, const std::shared_ptr &context) +napi_value CreateJsAbilityStageContext(napi_env env, const std::shared_ptr &context) { HILOG_DEBUG("called."); - NativeValue *objValue = CreateJsBaseContext(engine, context); + napi_value objValue = CreateJsBaseContext(env, context); if (context == nullptr) { return objValue; } - - NativeObject *object = ConvertNativeValueTo(objValue); auto configuration = context->GetConfiguration(); - if (configuration != nullptr && object != nullptr) { - object->SetProperty("config", CreateJsConfiguration(engine, *configuration)); + if (configuration != nullptr && objValue != nullptr) { + napi_set_named_property(env, objValue, "config", + CreateJsConfiguration(env, *configuration)); } return objValue; } -void JsAbilityStageContext::ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, +void JsAbilityStageContext::ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config) { HILOG_DEBUG("called."); @@ -47,22 +46,23 @@ void JsAbilityStageContext::ConfigurationUpdated(NativeEngine *engine, std::shar return; } - NativeValue *value = jsContext->Get(); - NativeObject *object = ConvertNativeValueTo(value); - if (!object) { - HILOG_ERROR("object is nullptr."); + napi_value value = jsContext->GetNapiValue(); + if (value == nullptr) { + HILOG_ERROR("value is nullptr."); return; } - NativeValue *method = object->GetProperty("onUpdateConfiguration"); + napi_value method = nullptr; + napi_get_named_property(env, value, "onUpdateConfiguration", &method); if (!method) { HILOG_ERROR("Failed to get onUpdateConfiguration from object"); return; } HILOG_DEBUG("JsAbilityStageContext call onUpdateConfiguration."); - NativeValue *argv[] = { CreateJsConfiguration(*engine, *config) }; - engine->CallFunction(value, method, argv, 1); + napi_value argv[] = { CreateJsConfiguration(env, *config) }; + napi_value callResult = nullptr; + napi_call_function(env, value, method, 1, argv, &callResult); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp b/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp index fd7c66317ed..ca320f20b92 100644 --- a/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp @@ -29,312 +29,287 @@ constexpr char APPLICATION_CONTEXT_NAME[] = "__application_context_ptr__"; const char *MD_NAME = "JsApplicationContextUtils"; } // namespace -NativeValue *JsApplicationContextUtils::CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::CreateBundleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::SwitchArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::SwitchArea(napi_env env, napi_callback_info info) { - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnSwitchArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnSwitchArea, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnSwitchArea(napi_env env, NapiCallbackInfo &info) { - NativeValue *thisVar = info.thisVar; - NativeObject *object = ConvertNativeValueTo(thisVar); + napi_value object = info.thisVar; if (object == nullptr) { HILOG_ERROR("object is null"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - BindNativeProperty(*object, "cacheDir", GetCacheDir); - BindNativeProperty(*object, "tempDir", GetTempDir); - BindNativeProperty(*object, "filesDir", GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", GetBundleCodeDir); - return engine.CreateUndefined(); + BindNativeProperty(env, object, "cacheDir", GetCacheDir); + BindNativeProperty(env, object, "tempDir", GetTempDir); + BindNativeProperty(env, object, "filesDir", GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", GetBundleCodeDir); + return CreateJsUndefined(env); } -NativeValue *JsApplicationContextUtils::CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::CreateModuleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::GetTempDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetTempDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetTempDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetTempDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetTempDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetTempDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetArea(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetArea, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetArea(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int area = context->GetArea(); - return engine.CreateNumber(area); + return CreateJsValue(env, area); } -NativeValue *JsApplicationContextUtils::GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetCacheDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetCacheDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetCacheDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetCacheDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetCacheDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetFilesDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetDistributedFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetDistributedFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, + OnGetDistributedFilesDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDistributedFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetDatabaseDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetDatabaseDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetDatabaseDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetDatabaseDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDatabaseDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetPreferencesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetPreferencesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, + info, JsApplicationContextUtils, OnGetPreferencesDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetPreferencesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetPreferencesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetBundleCodeDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetBundleCodeDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, + info, JsApplicationContextUtils, OnGetBundleCodeDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetBundleCodeDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetBundleCodeDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::KillProcessBySelf(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::KillProcessBySelf(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::GetRunningProcessInformation(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetRunningProcessInformation(napi_env env, napi_callback_info info) { return nullptr; } -void JsApplicationContextUtils::Finalizer(NativeEngine *engine, void *data, void *hint) +void JsApplicationContextUtils::Finalizer(napi_env env, void *data, void *hint) { std::unique_ptr(static_cast(data)); } -NativeValue *JsApplicationContextUtils::RegisterAbilityLifecycleCallback(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::RegisterAbilityLifecycleCallback(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::UnregisterAbilityLifecycleCallback( - NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::UnregisterAbilityLifecycleCallback( + napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::RegisterEnvironmentCallback(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::RegisterEnvironmentCallback(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::UnregisterEnvironmentCallback( - NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::UnregisterEnvironmentCallback( + napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::On(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::On(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::Off(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::Off(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetApplicationContext(napi_env env, napi_callback_info info) { - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetApplicationContext(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, + OnGetApplicationContext, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetApplicationContext(napi_env env, NapiCallbackInfo &info) { - NativeValue *value = CreateJsApplicationContext(engine, context_.lock()); - auto systemModule = JsRuntime::LoadSystemModuleByEngine(&engine, "application.ApplicationContext", &value, 1); + napi_value value = CreateJsApplicationContext(env, context_.lock()); + auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.ApplicationContext", &value, 1); if (systemModule == nullptr) { HILOG_WARN("OnGetApplicationContext, invalid systemModule."); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - return systemModule->Get(); + return systemModule->GetNapiValue(); } -NativeValue *JsApplicationContextUtils::CreateJsApplicationContext( - NativeEngine &engine, const std::shared_ptr &context) +napi_value JsApplicationContextUtils::CreateJsApplicationContext( + napi_env env, const std::shared_ptr &context) { HILOG_DEBUG("called"); - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - return objValue; + return object; } auto jsApplicationContextUtils = std::make_unique(context); - SetNamedNativePointer(engine, *object, APPLICATION_CONTEXT_NAME, jsApplicationContextUtils.release(), + SetNamedNativePointer(env, object, APPLICATION_CONTEXT_NAME, jsApplicationContextUtils.release(), JsApplicationContextUtils::Finalizer); auto appInfo = context->GetApplicationInfo(); if (appInfo != nullptr) { - object->SetProperty("applicationInfo", CreateJsApplicationInfo(engine, *appInfo)); + napi_set_named_property(env, object, "applicationInfo", CreateJsApplicationInfo(env, *appInfo)); } - BindNativeApplicationContext(engine, object); + BindNativeApplicationContext(env, object); - return objValue; + return object; } -void JsApplicationContextUtils::BindNativeApplicationContext(NativeEngine &engine, NativeObject *object) +void JsApplicationContextUtils::BindNativeApplicationContext(napi_env env, napi_value object) { - BindNativeProperty(*object, "cacheDir", JsApplicationContextUtils::GetCacheDir); - BindNativeProperty(*object, "tempDir", JsApplicationContextUtils::GetTempDir); - BindNativeProperty(*object, "filesDir", JsApplicationContextUtils::GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", JsApplicationContextUtils::GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", JsApplicationContextUtils::GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", JsApplicationContextUtils::GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", JsApplicationContextUtils::GetBundleCodeDir); - BindNativeFunction(engine, *object, "registerAbilityLifecycleCallback", MD_NAME, + BindNativeProperty(env, object, "cacheDir", JsApplicationContextUtils::GetCacheDir); + BindNativeProperty(env, object, "tempDir", JsApplicationContextUtils::GetTempDir); + BindNativeProperty(env, object, "filesDir", JsApplicationContextUtils::GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", JsApplicationContextUtils::GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", JsApplicationContextUtils::GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", JsApplicationContextUtils::GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", JsApplicationContextUtils::GetBundleCodeDir); + BindNativeFunction(env, object, "registerAbilityLifecycleCallback", MD_NAME, JsApplicationContextUtils::RegisterAbilityLifecycleCallback); - BindNativeFunction(engine, *object, "unregisterAbilityLifecycleCallback", MD_NAME, + BindNativeFunction(env, object, "unregisterAbilityLifecycleCallback", MD_NAME, JsApplicationContextUtils::UnregisterAbilityLifecycleCallback); - BindNativeFunction(engine, *object, "registerEnvironmentCallback", MD_NAME, + BindNativeFunction(env, object, "registerEnvironmentCallback", MD_NAME, JsApplicationContextUtils::RegisterEnvironmentCallback); - BindNativeFunction(engine, *object, "unregisterEnvironmentCallback", MD_NAME, + BindNativeFunction(env, object, "unregisterEnvironmentCallback", MD_NAME, JsApplicationContextUtils::UnregisterEnvironmentCallback); - BindNativeFunction(engine, *object, "createBundleContext", MD_NAME, JsApplicationContextUtils::CreateBundleContext); - BindNativeFunction(engine, *object, "switchArea", MD_NAME, JsApplicationContextUtils::SwitchArea); - BindNativeFunction(engine, *object, "getArea", MD_NAME, JsApplicationContextUtils::GetArea); - BindNativeFunction(engine, *object, "createModuleContext", MD_NAME, JsApplicationContextUtils::CreateModuleContext); - BindNativeFunction(engine, *object, "on", MD_NAME, JsApplicationContextUtils::On); - BindNativeFunction(engine, *object, "off", MD_NAME, JsApplicationContextUtils::Off); - BindNativeFunction(engine, *object, "getApplicationContext", MD_NAME, + BindNativeFunction(env, object, "createBundleContext", MD_NAME, JsApplicationContextUtils::CreateBundleContext); + BindNativeFunction(env, object, "switchArea", MD_NAME, JsApplicationContextUtils::SwitchArea); + BindNativeFunction(env, object, "getArea", MD_NAME, JsApplicationContextUtils::GetArea); + BindNativeFunction(env, object, "createModuleContext", MD_NAME, JsApplicationContextUtils::CreateModuleContext); + BindNativeFunction(env, object, "on", MD_NAME, JsApplicationContextUtils::On); + BindNativeFunction(env, object, "off", MD_NAME, JsApplicationContextUtils::Off); + BindNativeFunction(env, object, "getApplicationContext", MD_NAME, JsApplicationContextUtils::GetApplicationContext); - BindNativeFunction(engine, *object, "killAllProcesses", MD_NAME, JsApplicationContextUtils::KillProcessBySelf); - BindNativeFunction(engine, *object, "getProcessRunningInformation", MD_NAME, + BindNativeFunction(env, object, "killAllProcesses", MD_NAME, JsApplicationContextUtils::KillProcessBySelf); + BindNativeFunction(env, object, "getProcessRunningInformation", MD_NAME, JsApplicationContextUtils::GetRunningProcessInformation); - BindNativeFunction(engine, *object, "getRunningProcessInformation", MD_NAME, + BindNativeFunction(env, object, "getRunningProcessInformation", MD_NAME, JsApplicationContextUtils::GetRunningProcessInformation); } } // namespace AbilityRuntime diff --git a/frameworks/simulator/ability_simulator/src/js_console_log.cpp b/frameworks/simulator/ability_simulator/src/js_console_log.cpp index f5ff91f0131..37e637a0e39 100644 --- a/frameworks/simulator/ability_simulator/src/js_console_log.cpp +++ b/frameworks/simulator/ability_simulator/src/js_console_log.cpp @@ -27,24 +27,29 @@ constexpr uint32_t JS_CONSOLE_LOG_MAX_LOG_LEN = 1024; constexpr uint32_t JS_CONSOLE_LOG_DOMAIN = 0xFEFE; constexpr char JS_CONSOLE_LOG_TAG[] = "JsApp"; -std::string MakeLogContent(NativeCallbackInfo &info) +std::string MakeLogContent(napi_env env, napi_callback_info info) { std::string content; - for (size_t i = 0; i < info.argc; i++) { - NativeValue *value = info.argv[i]; - if (value->TypeOf() != NATIVE_STRING) { - value = value->ToString(); + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + for (size_t i = 0; i < argc; i++) { + napi_value value = argv[i]; + if (!CheckTypeForNapiValue(env, value, napi_string)) { + napi_value resultStr = nullptr; + napi_coerce_to_string(env, value, &resultStr); + value = resultStr; } - NativeString *str = ConvertNativeValueTo(value); - if (str == nullptr) { + if (value == nullptr) { HILOG_ERROR("Failed to convert to string object"); continue; } - size_t bufferLen = str->GetLength(); - if (bufferLen >= JS_CONSOLE_LOG_MAX_LOG_LEN) { + size_t bufferLen = 0; + napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &bufferLen); + if (status != napi_ok || bufferLen == 0 || bufferLen >= JS_CONSOLE_LOG_MAX_LOG_LEN) { HILOG_DEBUG("Log length exceeds maximum"); return content; } @@ -56,7 +61,7 @@ std::string MakeLogContent(NativeCallbackInfo &info) } size_t strLen = 0; - str->GetCString(buff, bufferLen + 1, &strLen); + napi_get_value_string_utf8(env, value, buff, bufferLen + 1, &strLen); if (!content.empty()) { content.append(" "); } @@ -68,37 +73,37 @@ std::string MakeLogContent(NativeCallbackInfo &info) } template -NativeValue *ConsoleLog(NativeEngine *engine, NativeCallbackInfo *info) +napi_value ConsoleLog(napi_env env, napi_callback_info info) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("engine or callback info is nullptr"); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("env or callback info is nullptr"); return nullptr; } - std::string content = MakeLogContent(*info); + std::string content = MakeLogContent(env, info); HiLogPrint(LOG_APP, LEVEL, JS_CONSOLE_LOG_DOMAIN, JS_CONSOLE_LOG_TAG, "%{public}s", content.c_str()); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } -void InitConsoleLogModule(NativeEngine &engine, NativeObject &globalObject) +void InitConsoleLogModule(napi_env env, napi_value globalObject) { - NativeValue *consoleValue = engine.CreateObject(); - NativeObject *consoleObj = ConvertNativeValueTo(consoleValue); + napi_value consoleObj = nullptr; + napi_create_object(env, &consoleObj); if (consoleObj == nullptr) { HILOG_ERROR("Failed to create console object"); return; } const char *moduleName = "console"; - BindNativeFunction(engine, *consoleObj, "log", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "debug", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "info", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "warn", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "error", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "fatal", moduleName, ConsoleLog); - - globalObject.SetProperty("console", consoleValue); + BindNativeFunction(env, consoleObj, "log", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "debug", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "info", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "warn", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "error", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "fatal", moduleName, ConsoleLog); + + napi_set_named_property(env, globalObject, "console", consoleObj); } } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/simulator/ability_simulator/src/js_context_utils.cpp b/frameworks/simulator/ability_simulator/src/js_context_utils.cpp index a6852e4f851..94e3e3ab7a3 100644 --- a/frameworks/simulator/ability_simulator/src/js_context_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_context_utils.cpp @@ -31,296 +31,276 @@ public: explicit JsBaseContext(std::weak_ptr &&context) : context_(std::move(context)) {} virtual ~JsBaseContext() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint); - static NativeValue *CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *SwitchArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info); - - static NativeValue *GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetTempDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info); - - NativeValue *OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetArea(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info); + static void Finalizer(napi_env env, void *data, void *hint); + static napi_value CreateBundleContext(napi_env env, napi_callback_info info); + static napi_value GetApplicationContext(napi_env env, napi_callback_info info); + static napi_value SwitchArea(napi_env env, napi_callback_info info); + static napi_value GetArea(napi_env env, napi_callback_info info); + static napi_value CreateModuleContext(napi_env env, napi_callback_info info); + + static napi_value GetCacheDir(napi_env env, napi_callback_info info); + static napi_value GetTempDir(napi_env env, napi_callback_info info); + static napi_value GetFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDistributedFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDatabaseDir(napi_env env, napi_callback_info info); + static napi_value GetPreferencesDir(napi_env env, napi_callback_info info); + static napi_value GetBundleCodeDir(napi_env env, napi_callback_info info); + + napi_value OnGetCacheDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetTempDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetFilesDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetDatabaseDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetPreferencesDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetBundleCodeDir(napi_env env, NapiCallbackInfo &info); + napi_value OnSwitchArea(napi_env env, NapiCallbackInfo &info); + napi_value OnGetArea(napi_env env, NapiCallbackInfo &info); + napi_value OnGetApplicationContext(napi_env env, NapiCallbackInfo &info); protected: std::weak_ptr context_; }; -void JsBaseContext::Finalizer(NativeEngine *engine, void *data, void *hint) +void JsBaseContext::Finalizer(napi_env env, void *data, void *hint) { HILOG_DEBUG("called"); std::unique_ptr(static_cast(data)); } -NativeValue *JsBaseContext::CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::CreateBundleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsBaseContext::GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetApplicationContext(napi_env env, napi_callback_info info) { - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetApplicationContext(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetApplicationContext, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::SwitchArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::SwitchArea(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnSwitchArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnSwitchArea, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnSwitchArea(napi_env env, NapiCallbackInfo &info) { if (info.argc == 0) { HILOG_ERROR("Not enough params"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int mode = 0; - if (!ConvertFromJsValue(engine, info.argv[0], mode)) { + if (!ConvertFromJsValue(env, info.argv[0], mode)) { HILOG_ERROR("Parse mode failed"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } context->SwitchArea(mode); - NativeValue *thisVar = info.thisVar; - NativeObject *object = ConvertNativeValueTo(thisVar); + napi_value object = info.thisVar; if (object == nullptr) { HILOG_ERROR("object is nullptr"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - BindNativeProperty(*object, "cacheDir", GetCacheDir); - BindNativeProperty(*object, "tempDir", GetTempDir); - BindNativeProperty(*object, "filesDir", GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", GetBundleCodeDir); - return engine.CreateUndefined(); + BindNativeProperty(env, object, "cacheDir", GetCacheDir); + BindNativeProperty(env, object, "tempDir", GetTempDir); + BindNativeProperty(env, object, "filesDir", GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", GetBundleCodeDir); + return CreateJsUndefined(env); } -NativeValue *JsBaseContext::CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::CreateModuleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsBaseContext::GetArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetArea(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetArea, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetArea(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int area = context->GetArea(); - return engine.CreateNumber(area); + return CreateJsValue(env, area); } -NativeValue *JsBaseContext::GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetCacheDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetCacheDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetCacheDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetCacheDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetCacheDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetTempDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetTempDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetTempDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetTempDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetTempDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetTempDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetFilesDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetDistributedFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetDistributedFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetDistributedFilesDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDistributedFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetDatabaseDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetDatabaseDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetDatabaseDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetDatabaseDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDatabaseDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetPreferencesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetPreferencesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetPreferencesDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetPreferencesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetPreferencesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetBundleCodeDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetBundleCodeDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetBundleCodeDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetBundleCodeDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetBundleCodeDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetApplicationContext(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("called"); - NativeValue *value = JsApplicationContextUtils::CreateJsApplicationContext(engine, context_.lock()); - auto systemModule = JsRuntime::LoadSystemModuleByEngine(&engine, "application.ApplicationContext", &value, 1); + napi_value value = JsApplicationContextUtils::CreateJsApplicationContext(env, context_.lock()); + auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.ApplicationContext", &value, 1); if (systemModule == nullptr) { - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - auto contextObj = systemModule->Get(); + auto contextObj = systemModule->GetNapiValue(); return contextObj; } } // namespace -NativeValue *CreateJsBaseContext(NativeEngine &engine, std::shared_ptr context, bool keepContext) +napi_value CreateJsBaseContext(napi_env env, std::shared_ptr context, bool keepContext) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { HILOG_WARN("invalid object."); - return objValue; + return object; } auto appInfo = context->GetApplicationInfo(); if (appInfo != nullptr) { - object->SetProperty("applicationInfo", CreateJsApplicationInfo(engine, *appInfo)); + napi_set_named_property(env, object, "applicationInfo", CreateJsApplicationInfo(env, *appInfo)); } auto hapModuleInfo = context->GetHapModuleInfo(); if (hapModuleInfo != nullptr) { - object->SetProperty("currentHapModuleInfo", CreateJsHapModuleInfo(engine, *hapModuleInfo)); + napi_set_named_property(env, object, "currentHapModuleInfo", CreateJsHapModuleInfo(env, *hapModuleInfo)); } auto jsContext = std::make_unique(context); - SetNamedNativePointer(engine, *object, BASE_CONTEXT_NAME, jsContext.release(), JsBaseContext::Finalizer); - - BindNativeProperty(*object, "cacheDir", JsBaseContext::GetCacheDir); - BindNativeProperty(*object, "tempDir", JsBaseContext::GetTempDir); - BindNativeProperty(*object, "filesDir", JsBaseContext::GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", JsBaseContext::GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", JsBaseContext::GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", JsBaseContext::GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", JsBaseContext::GetBundleCodeDir); - BindNativeProperty(*object, "area", JsBaseContext::GetArea); + SetNamedNativePointer(env, object, BASE_CONTEXT_NAME, jsContext.release(), JsBaseContext::Finalizer); + + BindNativeProperty(env, object, "cacheDir", JsBaseContext::GetCacheDir); + BindNativeProperty(env, object, "tempDir", JsBaseContext::GetTempDir); + BindNativeProperty(env, object, "filesDir", JsBaseContext::GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", JsBaseContext::GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", JsBaseContext::GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", JsBaseContext::GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", JsBaseContext::GetBundleCodeDir); + BindNativeProperty(env, object, "area", JsBaseContext::GetArea); const char *moduleName = "JsBaseContext"; - BindNativeFunction(engine, *object, "createBundleContext", moduleName, JsBaseContext::CreateBundleContext); - BindNativeFunction(engine, *object, "getApplicationContext", moduleName, JsBaseContext::GetApplicationContext); - BindNativeFunction(engine, *object, "switchArea", moduleName, JsBaseContext::SwitchArea); - BindNativeFunction(engine, *object, "getArea", moduleName, JsBaseContext::GetArea); - BindNativeFunction(engine, *object, "createModuleContext", moduleName, JsBaseContext::CreateModuleContext); + BindNativeFunction(env, object, "createBundleContext", moduleName, JsBaseContext::CreateBundleContext); + BindNativeFunction(env, object, "getApplicationContext", moduleName, JsBaseContext::GetApplicationContext); + BindNativeFunction(env, object, "switchArea", moduleName, JsBaseContext::SwitchArea); + BindNativeFunction(env, object, "getArea", moduleName, JsBaseContext::GetArea); + BindNativeFunction(env, object, "createModuleContext", moduleName, JsBaseContext::CreateModuleContext); - return objValue; + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_data_converter.cpp b/frameworks/simulator/ability_simulator/src/js_data_converter.cpp index a36bcdccd95..2fdfc59c536 100644 --- a/frameworks/simulator/ability_simulator/src/js_data_converter.cpp +++ b/frameworks/simulator/ability_simulator/src/js_data_converter.cpp @@ -92,73 +92,74 @@ Global::Resource::Direction ConvertDirection(const std::string &direction) return resolution; } -NativeValue *CreateJsConfiguration(NativeEngine &engine, const AppExecFwk::Configuration &configuration) +napi_value CreateJsConfiguration(napi_env env, const AppExecFwk::Configuration &configuration) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { HILOG_ERROR("Native object is nullptr."); - return objValue; + return object; } - object->SetProperty("language", CreateJsValue(engine, + napi_set_named_property(env, object, "language", CreateJsValue(env, configuration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE))); - - object->SetProperty("colorMode", CreateJsValue(engine, + + napi_set_named_property(env, object, "colorMode", CreateJsValue(env, ConvertColorMode(configuration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE)))); std::string direction = configuration.GetItem(AppExecFwk::ConfigurationInner::APPLICATION_DIRECTION); - object->SetProperty("direction", CreateJsValue(engine, ConvertDirection(direction))); + napi_set_named_property(env, object, "direction", CreateJsValue(env, ConvertDirection(direction))); std::string density = configuration.GetItem(AppExecFwk::ConfigurationInner::APPLICATION_DENSITYDPI); - object->SetProperty("screenDensity", CreateJsValue(engine, ConvertDensity(density))); + napi_set_named_property(env, object, "screenDensity", CreateJsValue(env, ConvertDensity(density))); int32_t displayId = ConvertDisplayId(configuration.GetItem(AppExecFwk::ConfigurationInner::APPLICATION_DISPLAYID)); - object->SetProperty("displayId", CreateJsValue(engine, displayId)); + napi_set_named_property(env, object, "displayId", CreateJsValue(env, displayId)); std::string hasPointerDevice = configuration.GetItem(AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE); - object->SetProperty("hasPointerDevice", CreateJsValue(engine, hasPointerDevice == "true" ? true : false)); + napi_set_named_property( + env, object, "hasPointerDevice", CreateJsValue(env, hasPointerDevice == "true" ? true : false)); - return objValue; + return object; } -NativeValue *CreateJsApplicationInfo(NativeEngine &engine, const AppExecFwk::ApplicationInfo &applicationInfo) +napi_value CreateJsApplicationInfo(napi_env env, const AppExecFwk::ApplicationInfo &applicationInfo) { - NativeValue *objValue = engine.CreateObject(); - if (objValue == nullptr) { + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { HILOG_ERROR("Create object failed."); return nullptr; } - AppExecFwk::CommonFunc::ConvertApplicationInfo(reinterpret_cast(&engine), - reinterpret_cast(objValue), applicationInfo); - return objValue; + AppExecFwk::CommonFunc::ConvertApplicationInfo(env, object, applicationInfo); + return object; } -NativeValue *CreateJsHapModuleInfo(NativeEngine &engine, const AppExecFwk::HapModuleInfo &hapModuleInfo) +napi_value CreateJsHapModuleInfo(napi_env env, const AppExecFwk::HapModuleInfo &hapModuleInfo) { - NativeValue *objValue = engine.CreateObject(); - if (objValue == nullptr) { + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { HILOG_ERROR("Create object failed."); return nullptr; } - AppExecFwk::CommonFunc::ConvertHapModuleInfo(reinterpret_cast(&engine), hapModuleInfo, - reinterpret_cast(objValue)); - return objValue; + AppExecFwk::CommonFunc::ConvertHapModuleInfo(env, hapModuleInfo, object); + return object; } -NativeValue *CreateJsAbilityInfo(NativeEngine &engine, const AppExecFwk::AbilityInfo &abilityInfo) +napi_value CreateJsAbilityInfo(napi_env env, const AppExecFwk::AbilityInfo &abilityInfo) { - NativeValue *objValue = engine.CreateObject(); - if (objValue == nullptr) { + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { HILOG_ERROR("Create object failed."); return nullptr; } - AppExecFwk::CommonFunc::ConvertAbilityInfo(reinterpret_cast(&engine), abilityInfo, - reinterpret_cast(objValue)); - return objValue; + AppExecFwk::CommonFunc::ConvertAbilityInfo(env, abilityInfo, object); + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp b/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp index 8c12ed1f4dd..9eee7737b82 100644 --- a/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp @@ -20,12 +20,11 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsResourceManager(NativeEngine &engine, +napi_value CreateJsResourceManager(napi_env env, std::shared_ptr resourceManager, std::shared_ptr context) { - napi_env env = reinterpret_cast(&engine); napi_value result = Global::Resource::ResourceManagerAddon::Create(env, "", resourceManager, context); - return reinterpret_cast(result); + return result; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_runtime_utils.cpp b/frameworks/simulator/ability_simulator/src/js_runtime_utils.cpp index 73a3739e440..4f8d73ccf17 100644 --- a/frameworks/simulator/ability_simulator/src/js_runtime_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_runtime_utils.cpp @@ -19,6 +19,7 @@ #include "js_runtime.h" namespace OHOS { namespace AbilityRuntime { +#define ARGS_MAX_COUNT 10 namespace { std::unique_ptr CreateAsyncTaskWithLastParam(NativeEngine &engine, NativeValue *lastParam, std::unique_ptr &&execute, std::unique_ptr &&complete, @@ -287,5 +288,341 @@ std::unique_ptr JsRuntime::LoadSystemModuleByEngine(NativeEngin return std::unique_ptr(engine->CreateReference(instanceValue, 1)); } + +namespace { +// ----------above going to delete---------- +std::unique_ptr CreateAsyncTaskWithLastParam(napi_env env, napi_value lastParam, + std::unique_ptr &&execute, + std::unique_ptr &&complete, napi_value* result) +{ + napi_valuetype type = napi_undefined; + napi_typeof(env, lastParam, &type); + if (lastParam == nullptr || type != napi_function) { + napi_deferred nativeDeferred = nullptr; + napi_create_promise(env, &nativeDeferred, result); + return std::make_unique(nativeDeferred, std::move(execute), std::move(complete)); + } else { + napi_get_undefined(env, result); + napi_ref callbackRef = nullptr; + napi_create_reference(env, lastParam, 1, &callbackRef); + return std::make_unique(callbackRef, std::move(execute), std::move(complete)); + } +} +} // namespace + +// Help Functions +napi_value CreateJsError(napi_env env, int32_t errCode, const std::string &message) +{ + napi_value result = nullptr; + napi_create_error(env, CreateJsValue(env, errCode), CreateJsValue(env, message), &result); + return result; +} + +void BindNativeFunction(napi_env env, napi_value object, const char *name, + const char *moduleName, napi_callback func) +{ + std::string fullName(moduleName); + fullName += "."; + fullName += name; + napi_value result = nullptr; + napi_create_function(env, fullName.c_str(), fullName.length(), func, nullptr, &result); + napi_set_named_property(env, object, name, result); +} + +void BindNativeProperty(napi_env env, napi_value object, const char *name, napi_callback getter) +{ + napi_property_descriptor properties[1]; + properties[0].utf8name = name; + properties[0].name = nullptr; + properties[0].method = nullptr; + properties[0].getter = getter; + properties[0].setter = nullptr; + properties[0].value = nullptr; + properties[0].attributes = napi_default; + properties[0].data = nullptr; + napi_define_properties(env, object, 1, properties); +} + +void *GetNativePointerFromCallbackInfo(const napi_env env, napi_callback_info info, const char *name) +{ + size_t argcAsync = ARGS_MAX_COUNT; + napi_value args[ARGS_MAX_COUNT] = {nullptr}; + napi_value thisVar = nullptr; + NAPI_CALL_NO_THROW(napi_get_cb_info(env, info, &argcAsync, args, &thisVar, nullptr), nullptr); + if (name != nullptr) { + napi_get_named_property(env, thisVar, name, &thisVar); + } + void* result = nullptr; + NAPI_CALL_NO_THROW(napi_unwrap(env, thisVar, &result), nullptr); + return result; +} + +void* GetNapiCallbackInfoAndThis(napi_env env, napi_callback_info info, NapiCallbackInfo& napiInfo, const char* name) +{ + NAPI_CALL_NO_THROW(napi_get_cb_info( + env, info, &napiInfo.argc, napiInfo.argv, &napiInfo.thisVar, nullptr), nullptr); + napi_value value = napiInfo.thisVar; + if (name != nullptr) { + napi_get_named_property(env, value, name, &value); + } + void* result = nullptr; + NAPI_CALL_NO_THROW(napi_unwrap(env, value, &result), nullptr); + return result; +} + +void SetNamedNativePointer(napi_env env, napi_value object, const char *name, void *ptr, napi_finalize func) +{ + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_wrap(env, objValue, ptr, func, nullptr, nullptr); + napi_set_named_property(env, object, name, objValue); +} + +void *GetNamedNativePointer(napi_env env, napi_value object, const char *name) +{ + napi_value proValue = nullptr; + napi_get_named_property(env, object, name, &proValue); + void* result = nullptr; + napi_unwrap(env, proValue, &result); + return result; +} + +bool CheckTypeForNapiValue(napi_env env, napi_value param, napi_valuetype expectType) +{ + napi_valuetype valueType = napi_undefined; + if (napi_typeof(env, param, &valueType) != napi_ok) { + return false; + } + return valueType == expectType; +} + +// Async Task +NapiAsyncTask::NapiAsyncTask(napi_deferred deferred, std::unique_ptr &&execute, + std::unique_ptr &&complete) + : deferred_(deferred), execute_(std::move(execute)), complete_(std::move(complete)) +{} + +NapiAsyncTask::NapiAsyncTask(napi_ref callbackRef, std::unique_ptr &&execute, + std::unique_ptr &&complete) + : callbackRef_(callbackRef), execute_(std::move(execute)), complete_(std::move(complete)) +{} + +NapiAsyncTask::~NapiAsyncTask() = default; + +void NapiAsyncTask::Schedule(const std::string &name, napi_env env, std::unique_ptr &&task) +{ + if (task && task->Start(name, env)) { + task.release(); + } +} + +void NapiAsyncTask::Resolve(napi_env env, napi_value value) +{ + HILOG_DEBUG("NapiAsyncTask::Resolve is called"); + if (deferred_) { + napi_resolve_deferred(env, deferred_, value); + deferred_ = nullptr; + } + if (callbackRef_) { + napi_value argv[] = { + CreateJsError(env, 0), + value, + }; + napi_value func = nullptr; + napi_get_reference_value(env, callbackRef_, &func); + napi_call_function(env, CreateJsUndefined(env), func, ArraySize(argv), argv, nullptr); + napi_delete_reference(env, callbackRef_); + callbackRef_ = nullptr; + } + HILOG_DEBUG("NapiAsyncTask::Resolve is called end."); +} + +void NapiAsyncTask::ResolveWithNoError(napi_env env, napi_value value) +{ + HILOG_DEBUG("NapiAsyncTask::Resolve is called"); + if (deferred_) { + napi_resolve_deferred(env, deferred_, value); + deferred_ = nullptr; + } + if (callbackRef_) { + napi_value argv[] = { + CreateJsNull(env), + value, + }; + napi_value func = nullptr; + napi_get_reference_value(env, callbackRef_, &func); + napi_call_function(env, CreateJsUndefined(env), func, ArraySize(argv), argv, nullptr); + napi_delete_reference(env, callbackRef_); + callbackRef_ = nullptr; + } + HILOG_DEBUG("NapiAsyncTask::Resolve is called end."); +} + +void NapiAsyncTask::Reject(napi_env env, napi_value error) +{ + if (deferred_) { + napi_reject_deferred(env, deferred_, error); + deferred_ = nullptr; + } + if (callbackRef_) { + napi_value argv[] = { + error, + CreateJsUndefined(env), + }; + napi_value func = nullptr; + napi_get_reference_value(env, callbackRef_, &func); + napi_call_function(env, CreateJsUndefined(env), func, ArraySize(argv), argv, nullptr); + napi_delete_reference(env, callbackRef_); + callbackRef_ = nullptr; + } +} + +void NapiAsyncTask::ResolveWithCustomize(napi_env env, napi_value error, napi_value value) +{ + HILOG_DEBUG("NapiAsyncTask::ResolveWithCustomize is called"); + if (deferred_) { + napi_resolve_deferred(env, deferred_, value); + deferred_ = nullptr; + } + if (callbackRef_) { + napi_value argv[] = { + error, + value, + }; + napi_value func = nullptr; + napi_get_reference_value(env, callbackRef_, &func); + napi_call_function(env, CreateJsUndefined(env), func, ArraySize(argv), argv, nullptr); + napi_delete_reference(env, callbackRef_); + callbackRef_ = nullptr; + } + HILOG_DEBUG("NapiAsyncTask::ResolveWithCustomize is called end."); +} + +void NapiAsyncTask::RejectWithCustomize(napi_env env, napi_value error, napi_value value) +{ + HILOG_DEBUG("NapiAsyncTask::RejectWithCustomize is called"); + if (deferred_) { + napi_reject_deferred(env, deferred_, error); + deferred_ = nullptr; + } + if (callbackRef_) { + napi_value argv[] = { + error, + value, + }; + napi_value func = nullptr; + napi_get_reference_value(env, callbackRef_, &func); + napi_call_function(env, CreateJsUndefined(env), func, ArraySize(argv), argv, nullptr); + napi_delete_reference(env, callbackRef_); + callbackRef_ = nullptr; + } + HILOG_DEBUG("NapiAsyncTask::RejectWithCustomize is called end."); +} + +void NapiAsyncTask::Execute(napi_env env, void *data) +{ + if (env == nullptr || data == nullptr) { + return; + } + auto me = static_cast(data); + if (me->execute_ && *(me->execute_)) { + (*me->execute_)(); + } +} + +void NapiAsyncTask::Complete(napi_env env, napi_status status, void *data) +{ + if (data == nullptr) { + return; + } + std::unique_ptr me(static_cast(data)); + if (me->complete_ && *(me->complete_)) { + (*me->complete_)(env, *me, static_cast(status)); + } +} + +bool NapiAsyncTask::Start(const std::string &name, napi_env env) +{ + if (work_) { + napi_delete_async_work(env, work_); + work_ = nullptr; + } + if (env == nullptr) { + return false; + } + NativeEngine* engine = reinterpret_cast(env); + work_ = reinterpret_cast(engine->CreateAsyncWork(name, + reinterpret_cast(Execute), + reinterpret_cast(Complete), this)); + napi_queue_async_work(env, work_); + return true; +} + +std::unique_ptr CreateAsyncTaskWithLastParam(napi_env env, napi_value lastParam, + NapiAsyncTask::ExecuteCallback &&execute, NapiAsyncTask::CompleteCallback &&complete, napi_value *result) +{ + return CreateAsyncTaskWithLastParam(env, lastParam, + std::make_unique(std::move(execute)), + std::make_unique(std::move(complete)), result); +} + +std::unique_ptr CreateAsyncTaskWithLastParam(napi_env env, napi_value lastParam, + NapiAsyncTask::ExecuteCallback &&execute, nullptr_t, napi_value *result) +{ + return CreateAsyncTaskWithLastParam( + env, lastParam, std::make_unique(std::move(execute)), nullptr, result); +} + +std::unique_ptr CreateAsyncTaskWithLastParam(napi_env env, napi_value lastParam, + nullptr_t, NapiAsyncTask::CompleteCallback &&complete, napi_value *result) +{ + return CreateAsyncTaskWithLastParam( + env, lastParam, nullptr, std::make_unique(std::move(complete)), result); +} + +std::unique_ptr CreateAsyncTaskWithLastParam(napi_env env, napi_value lastParam, + nullptr_t, nullptr_t, napi_value *result) +{ + return CreateAsyncTaskWithLastParam(env, lastParam, std::unique_ptr(), + std::unique_ptr(), result); +} + +std::unique_ptr JsRuntime::LoadSystemModuleByEngine(napi_env env, + const std::string &moduleName, napi_value const *argv, size_t argc) +{ + HILOG_DEBUG("JsRuntime::LoadSystemModule(%{public}s)", moduleName.c_str()); + if (env == nullptr) { + HILOG_DEBUG("JsRuntime::LoadSystemModule: invalid env."); + return std::unique_ptr(); + } + + napi_value globalObj = nullptr; + napi_get_global(env, &globalObj); + std::unique_ptr methodRequireNapiRef_; + napi_value ref = nullptr; + napi_get_named_property(env, globalObj, "requireNapi", &ref); + napi_ref methodRequireNapiRef = nullptr; + napi_create_reference(env, ref, 1, &methodRequireNapiRef); + methodRequireNapiRef_.reset(reinterpret_cast(methodRequireNapiRef)); + if (!methodRequireNapiRef_) { + HILOG_ERROR("Failed to create reference for global.requireNapi"); + return nullptr; + } + napi_value className = nullptr; + napi_create_string_utf8(env, moduleName.c_str(), moduleName.length(), &className); + napi_value classValue = nullptr; + napi_call_function(env, + globalObj, methodRequireNapiRef_->GetNapiValue(), 1, &className, &classValue); + napi_value instanceValue = nullptr; + napi_new_instance(env, classValue, argc, argv, &instanceValue); + if (instanceValue == nullptr) { + HILOG_ERROR("Failed to create object instance"); + return std::unique_ptr(); + } + + napi_ref result = nullptr; + napi_create_reference(env, instanceValue, 1, &result); + return std::unique_ptr(reinterpret_cast(result)); +} } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/simulator/ability_simulator/src/js_timer.cpp b/frameworks/simulator/ability_simulator/src/js_timer.cpp index b459a86ef64..9d1dcff273b 100644 --- a/frameworks/simulator/ability_simulator/src/js_timer.cpp +++ b/frameworks/simulator/ability_simulator/src/js_timer.cpp @@ -37,10 +37,16 @@ std::unordered_map> g_timerTable; class JsTimer final { public: - JsTimer(NativeEngine &nativeEngine, const std::shared_ptr &jsFunction, uint32_t id) - : nativeEngine_(nativeEngine), jsFunction_(jsFunction), id_(id) + JsTimer(napi_env env, const std::shared_ptr &jsFunction, uint32_t id) + : env_(env), jsFunction_(jsFunction), id_(id) { - uv_timer_init(nativeEngine.GetUVLoop(), &timerReq_); + uv_loop_s* loop = nullptr; + napi_get_uv_event_loop(env_, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop == nullptr."); + return; + } + uv_timer_init(loop, &timerReq_); timerReq_.data = this; } @@ -59,12 +65,14 @@ public: void OnTimeout() { - std::vector args; + std::vector args; args.reserve(jsArgs_.size()); for (auto arg : jsArgs_) { - args.emplace_back(arg->Get()); + args.emplace_back(arg->GetNapiValue()); } - nativeEngine_.CallFunction(nativeEngine_.CreateUndefined(), jsFunction_->Get(), args.data(), args.size()); + napi_value res = nullptr; + napi_call_function(env_, CreateJsUndefined(env_), + jsFunction_->GetNapiValue(), args.size(), args.data(), &res); if (uv_timer_get_repeat(&timerReq_) == 0) { std::lock_guard lock(g_mutex); @@ -78,34 +86,44 @@ public: } private: - NativeEngine& nativeEngine_; + napi_env env_; std::shared_ptr jsFunction_; std::vector> jsArgs_; uv_timer_t timerReq_; uint32_t id_ = 0; }; -NativeValue *StartTimeoutOrInterval(NativeEngine *engine, NativeCallbackInfo *info, bool isInterval) +napi_value StartTimeoutOrInterval(napi_env env, napi_callback_info info, bool isInterval) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("Start timeout or interval failed with engine or callback info is nullptr."); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("Start timeout or interval failed with env or callback info is nullptr."); return nullptr; } + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); // parameter check, must have at least 2 params - if (info->argc < 2 || info->argv[0]->TypeOf() != NATIVE_FUNCTION || info->argv[1]->TypeOf() != NATIVE_NUMBER) { + if (argc < 2 ||!CheckTypeForNapiValue(env, argv[0], napi_function) + || !CheckTypeForNapiValue(env, argv[1], napi_number)) { HILOG_ERROR("Set callback timer failed with invalid parameter."); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } // parse parameter - std::shared_ptr jsFunction(engine->CreateReference(info->argv[0], 1)); - int64_t delayTime = *ConvertNativeValueTo(info->argv[1]); + napi_ref ref = nullptr; + napi_create_reference(env, argv[0], 1, &ref); + std::shared_ptr jsFunction(reinterpret_cast(ref)); + int64_t delayTime = 0; + napi_get_value_int64(env, argv[1], &delayTime); uint32_t callbackId = g_callbackId.fetch_add(1, std::memory_order_relaxed); - auto task = std::make_shared(*engine, jsFunction, callbackId); - for (size_t index = 2; index < info->argc; ++index) { - task->PushArgs(std::shared_ptr(engine->CreateReference(info->argv[index], 1))); + auto task = std::make_shared(env, jsFunction, callbackId); + for (size_t index = 2; index < argc; ++index) { + napi_ref taskRef = nullptr; + napi_create_reference(env, argv[index], 1, &taskRef); + task->PushArgs(std::shared_ptr(reinterpret_cast(taskRef))); } // if setInterval is called, interval must not be zero for repeat, so set to 1ms @@ -120,48 +138,52 @@ NativeValue *StartTimeoutOrInterval(NativeEngine *engine, NativeCallbackInfo *in g_timerTable.emplace(callbackId, task); } - return engine->CreateNumber(callbackId); + return CreateJsValue(env, callbackId); } -NativeValue *StartTimeout(NativeEngine *engine, NativeCallbackInfo *info) +napi_value StartTimeout(napi_env env, napi_callback_info info) { - return StartTimeoutOrInterval(engine, info, false); + return StartTimeoutOrInterval(env, info, false); } -NativeValue *StartInterval(NativeEngine *engine, NativeCallbackInfo *info) +napi_value StartInterval(napi_env env, napi_callback_info info) { - return StartTimeoutOrInterval(engine, info, true); + return StartTimeoutOrInterval(env, info, true); } -NativeValue *StopTimeoutOrInterval(NativeEngine *engine, NativeCallbackInfo *info) +napi_value StopTimeoutOrInterval(napi_env env, napi_callback_info info) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("Stop timeout or interval failed with engine or callback info is nullptr."); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("Stop timeout or interval failed with env or callback info is nullptr."); return nullptr; } + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); // parameter check, must have at least 1 param - if (info->argc < 1 || info->argv[0]->TypeOf() != NATIVE_NUMBER) { + if (argc < 1 || !CheckTypeForNapiValue(env, argv[0], napi_number)) { HILOG_ERROR("Clear callback timer failed with invalid parameter."); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } - - uint32_t callbackId = *ConvertNativeValueTo(info->argv[0]); + uint32_t callbackId = 0; + napi_get_value_uint32(env, argv[0], &callbackId); { std::lock_guard lock(g_mutex); g_timerTable.erase(callbackId); } - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } -void InitTimer(NativeEngine &engine, NativeObject &globalObject) +void InitTimer(napi_env env, napi_value globalObject) { const char *moduleName = "AsJsTimer"; - BindNativeFunction(engine, globalObject, "setTimeout", moduleName, StartTimeout); - BindNativeFunction(engine, globalObject, "setInterval", moduleName, StartInterval); - BindNativeFunction(engine, globalObject, "clearTimeout", moduleName, StopTimeoutOrInterval); - BindNativeFunction(engine, globalObject, "clearInterval", moduleName, StopTimeoutOrInterval); + BindNativeFunction(env, globalObject, "setTimeout", moduleName, StartTimeout); + BindNativeFunction(env, globalObject, "setInterval", moduleName, StartInterval); + BindNativeFunction(env, globalObject, "clearTimeout", moduleName, StopTimeoutOrInterval); + BindNativeFunction(env, globalObject, "clearInterval", moduleName, StopTimeoutOrInterval); } } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/simulator/ability_simulator/src/simulator.cpp b/frameworks/simulator/ability_simulator/src/simulator.cpp index ee41549cdb6..05c579a2490 100644 --- a/frameworks/simulator/ability_simulator/src/simulator.cpp +++ b/frameworks/simulator/ability_simulator/src/simulator.cpp @@ -101,25 +101,26 @@ public: private: bool OnInit(); void Run(); - NativeValue *LoadScript(const std::string &srcPath); + napi_value LoadScript(const std::string &srcPath); void InitResourceMgr(); - void InitJsAbilityContext(NativeValue *instanceValue); - void DispatchStartLifecycle(NativeValue *instanceValue); + void InitJsAbilityContext(napi_env env, napi_value instanceValue); + void DispatchStartLifecycle(napi_value instanceValue); std::unique_ptr CreateJsWindowStage(const std::shared_ptr &windowScene); - NativeValue *CreateJsWant(NativeEngine &engine); + napi_value CreateJsWant(napi_env env); bool LoadAbilityStage(uint8_t *buffer, size_t len); - void InitJsAbilityStageContext(NativeValue *instanceValue); - NativeValue *CreateJsLaunchParam(NativeEngine &engine); + void InitJsAbilityStageContext(napi_value instanceValue); + napi_value CreateJsLaunchParam(napi_env env); bool ParseBundleAndModuleInfo(); bool ParseAbilityInfo(const std::string &abilitySrcPath); - bool LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &globalObject); + bool LoadRuntimeEnv(napi_env env, napi_value globalObject); + static napi_value RequireNapi(napi_env env, napi_callback_info info); panda::ecmascript::EcmaVM *CreateJSVM(); Options options_; std::string abilityPath_; panda::ecmascript::EcmaVM *vm_ = nullptr; DebuggerTask debuggerTask_; - std::unique_ptr nativeEngine_; + napi_env nativeEngine_ = nullptr; int64_t currentId_ = 0; std::unordered_map> abilities_; @@ -159,11 +160,12 @@ SimulatorImpl::~SimulatorImpl() { if (nativeEngine_) { uv_close(reinterpret_cast(&debuggerTask_.onPostTaskSignal), nullptr); - uv_loop_t *uvLoop = nativeEngine_->GetUVLoop(); + uv_loop_t* uvLoop = nullptr; + napi_get_uv_event_loop(nativeEngine_, &uvLoop); if (uvLoop != nullptr) { uv_work_t work; uv_queue_work(uvLoop, &work, [](uv_work_t*) {}, [](uv_work_t *work, int32_t status) { - HILOG_DEBUG("Simulator stop uv loop"); + HILOG_ERROR("Simulator stop uv loop"); uv_stop(work->loop); }); } @@ -172,7 +174,7 @@ SimulatorImpl::~SimulatorImpl() panda::JSNApi::StopDebugger(vm_); abilities_.clear(); - nativeEngine_.reset(); + nativeEngine_ = nullptr; panda::JSNApi::DestroyJSVM(vm_); vm_ = nullptr; } @@ -180,7 +182,7 @@ SimulatorImpl::~SimulatorImpl() bool SimulatorImpl::Initialize(const Options &options) { if (nativeEngine_) { - HILOG_DEBUG("Simulator is already initialized"); + HILOG_ERROR("Simulator is already initialized"); return true; } @@ -189,7 +191,8 @@ bool SimulatorImpl::Initialize(const Options &options) return false; } - uv_loop_t *uvLoop = nativeEngine_->GetUVLoop(); + uv_loop_t* uvLoop = nullptr; + napi_get_uv_event_loop(nativeEngine_, &uvLoop); if (uvLoop == nullptr) { return false; } @@ -201,23 +204,25 @@ bool SimulatorImpl::Initialize(const Options &options) return true; } -void CallObjectMethod(NativeEngine &engine, NativeValue *value, const char *name, NativeValue *const *argv, size_t argc) +void CallObjectMethod(napi_env env, napi_value obj, const char *name, napi_value const *argv, size_t argc) { - NativeObject *obj = ConvertNativeValueTo(value); if (obj == nullptr) { HILOG_ERROR("%{public}s, Failed to get Ability object", __func__); return; } - - NativeValue *methodOnCreate = obj->GetProperty(name); + napi_value methodOnCreate = nullptr; + napi_get_named_property(env, obj, name, &methodOnCreate); if (methodOnCreate == nullptr) { HILOG_ERROR("Failed to get '%{public}s' from Ability object", name); return; } - engine.CallFunction(value, methodOnCreate, argv, argc); + napi_status status = napi_call_function(env, obj, methodOnCreate, argc, argv, nullptr); + if (status != napi_ok) { + HILOG_ERROR("Failed to napi call function"); + } } -NativeValue *SimulatorImpl::LoadScript(const std::string &srcPath) +napi_value SimulatorImpl::LoadScript(const std::string &srcPath) { panda::Local objRef = panda::JSNApi::GetExportObject(vm_, srcPath, "default"); if (objRef->IsNull()) { @@ -225,8 +230,10 @@ NativeValue *SimulatorImpl::LoadScript(const std::string &srcPath) return nullptr; } - auto obj = ArkNativeEngine::ArkValueToNativeValue(static_cast(nativeEngine_.get()), objRef); - return nativeEngine_->CreateInstance(obj, nullptr, 0); + auto obj = ArkNativeEngine::ArkValueToNapiValue(nativeEngine_, objRef); + napi_value instanceValue = nullptr; + napi_new_instance(nativeEngine_, obj, 0, nullptr, &instanceValue); + return instanceValue; } bool SimulatorImpl::ParseBundleAndModuleInfo() @@ -326,12 +333,12 @@ int64_t SimulatorImpl::StartAbility(const std::string &abilitySrcPath, Terminate } abilityPath_ = BUNDLE_INSTALL_PATH + options_.moduleName + "/" + abilitySrcPath; - if (!nativeEngine_->RunScriptBuffer(abilityPath_, buf, len, false)) { + if (!reinterpret_cast(nativeEngine_)->RunScriptBuffer(abilityPath_, buf, len, false)) { HILOG_ERROR("Failed to run script: %{public}s", abilityPath_.c_str()); return -1; } - NativeValue *instanceValue = LoadScript(abilityPath_); + napi_value instanceValue = LoadScript(abilityPath_); if (instanceValue == nullptr) { HILOG_ERROR("Failed to create object instance"); return -1; @@ -339,9 +346,11 @@ int64_t SimulatorImpl::StartAbility(const std::string &abilitySrcPath, Terminate ++currentId_; InitResourceMgr(); - InitJsAbilityContext(instanceValue); + InitJsAbilityContext(nativeEngine_, instanceValue); DispatchStartLifecycle(instanceValue); - abilities_.emplace(currentId_, nativeEngine_->CreateReference(instanceValue, 1)); + napi_ref ref = nullptr; + napi_create_reference(nativeEngine_, instanceValue, 1, &ref); + abilities_.emplace(currentId_, std::shared_ptr(reinterpret_cast(ref))); return currentId_; } @@ -368,56 +377,56 @@ bool SimulatorImpl::LoadAbilityStage(uint8_t *buffer, size_t len) auto moduleSrcPath = BUNDLE_INSTALL_PATH + options_.moduleName + "/" + srcEntrance; HILOG_DEBUG("moduleSrcPath is %{public}s", moduleSrcPath.c_str()); - if (!nativeEngine_->RunScriptBuffer(moduleSrcPath, buffer, len, false)) { + if (!reinterpret_cast(nativeEngine_)->RunScriptBuffer(moduleSrcPath, buffer, len, false)) { HILOG_ERROR("Failed to run ability stage script: %{public}s", moduleSrcPath.c_str()); return false; } - NativeValue *instanceValue = LoadScript(moduleSrcPath); + napi_value instanceValue = LoadScript(moduleSrcPath); if (instanceValue == nullptr) { HILOG_ERROR("Failed to create ability stage instance"); return false; } InitJsAbilityStageContext(instanceValue); + CallObjectMethod(nativeEngine_, instanceValue, "onCreate", nullptr, 0); - CallObjectMethod(*nativeEngine_, instanceValue, "onCreate", nullptr, 0); - NativeValue *wantArgv[] = { - CreateJsWant(*nativeEngine_) + napi_value wantArgv[] = { + CreateJsWant(nativeEngine_) }; - CallObjectMethod(*nativeEngine_, instanceValue, "onAcceptWant", wantArgv, ArraySize(wantArgv)); - - abilityStage_ = std::shared_ptr(nativeEngine_->CreateReference(instanceValue, 1)); + CallObjectMethod(nativeEngine_, instanceValue, "onAcceptWant", wantArgv, ArraySize(wantArgv)); + napi_ref ref = nullptr; + napi_create_reference(nativeEngine_, instanceValue, 1, &ref); + abilityStage_ = std::shared_ptr(reinterpret_cast(ref)); return true; } -void SimulatorImpl::InitJsAbilityStageContext(NativeValue *instanceValue) +void SimulatorImpl::InitJsAbilityStageContext(napi_value obj) { - NativeValue *contextObj = CreateJsAbilityStageContext(*nativeEngine_, stageContext_); + napi_value contextObj = CreateJsAbilityStageContext(nativeEngine_, stageContext_); if (contextObj == nullptr) { HILOG_ERROR("contextObj is nullptr"); return; } jsStageContext_ = std::shared_ptr( - JsRuntime::LoadSystemModuleByEngine(nativeEngine_.get(), "application.AbilityStageContext", &contextObj, 1)); + JsRuntime::LoadSystemModuleByEngine(nativeEngine_, "application.AbilityStageContext", &contextObj, 1)); if (jsStageContext_ == nullptr) { HILOG_ERROR("Failed to get LoadSystemModuleByEngine"); return; } - contextObj = jsStageContext_->Get(); + contextObj = jsStageContext_->GetNapiValue(); if (contextObj == nullptr) { HILOG_ERROR("contextObj is nullptr."); return; } - NativeObject *obj = ConvertNativeValueTo(instanceValue); if (obj == nullptr) { HILOG_ERROR("obj is nullptr"); return; } - obj->SetProperty("context", contextObj); + napi_set_named_property(nativeEngine_, obj, "context", contextObj); } void SimulatorImpl::TerminateAbility(int64_t abilityId) @@ -435,14 +444,14 @@ void SimulatorImpl::TerminateAbility(int64_t abilityId) std::shared_ptr ref = it->second; abilities_.erase(it); - auto instanceValue = ref->Get(); + auto instanceValue = ref->GetNapiValue(); if (instanceValue == nullptr) { return; } - CallObjectMethod(*nativeEngine_, instanceValue, "onBackground", nullptr, 0); - CallObjectMethod(*nativeEngine_, instanceValue, "onWindowStageDestroy", nullptr, 0); - CallObjectMethod(*nativeEngine_, instanceValue, "onDestroy", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onBackground", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onWindowStageDestroy", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onDestroy", nullptr, 0); auto windowSceneIter = windowScenes_.find(abilityId); if (windowSceneIter != windowScenes_.end()) { @@ -477,29 +486,29 @@ void SimulatorImpl::UpdateConfiguration(const AppExecFwk::Configuration &config) stageContext_->SetConfiguration(configuration); } - NativeValue *configArgv[] = { - CreateJsConfiguration(*nativeEngine_, config) + napi_value configArgv[] = { + CreateJsConfiguration(nativeEngine_, config) }; - auto abilityStage = abilityStage_->Get(); + auto abilityStage = abilityStage_->GetNapiValue(); if (abilityStage == nullptr) { HILOG_ERROR("abilityStage is nullptr"); return; } - CallObjectMethod(*nativeEngine_, abilityStage, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); - CallObjectMethod(*nativeEngine_, abilityStage, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); - JsAbilityStageContext::ConfigurationUpdated(nativeEngine_.get(), jsStageContext_, configuration); + CallObjectMethod(nativeEngine_, abilityStage, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); + CallObjectMethod(nativeEngine_, abilityStage, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); + JsAbilityStageContext::ConfigurationUpdated(nativeEngine_, jsStageContext_, configuration); for (auto iter = abilities_.begin(); iter != abilities_.end(); iter++) { - auto ability = iter->second->Get(); + auto ability = iter->second->GetNapiValue(); if (ability == nullptr) { HILOG_ERROR("ability is nullptr"); continue; } - CallObjectMethod(*nativeEngine_, ability, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); - CallObjectMethod(*nativeEngine_, ability, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); - JsAbilityContext::ConfigurationUpdated(nativeEngine_.get(), iter->second, configuration); + CallObjectMethod(nativeEngine_, ability, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); + CallObjectMethod(nativeEngine_, ability, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); + JsAbilityContext::ConfigurationUpdated(nativeEngine_, iter->second, configuration); } } @@ -524,7 +533,7 @@ void SimulatorImpl::InitResourceMgr() HILOG_DEBUG("Add resource success."); } -void SimulatorImpl::InitJsAbilityContext(NativeValue *instanceValue) +void SimulatorImpl::InitJsAbilityContext(napi_env env, napi_value obj) { if (context_ == nullptr) { context_ = std::make_shared(); @@ -534,66 +543,67 @@ void SimulatorImpl::InitJsAbilityContext(NativeValue *instanceValue) context_->SetResourceManager(resourceMgr_); context_->SetAbilityInfo(abilityInfo_); } - NativeValue *contextObj = CreateJsAbilityContext(*nativeEngine_, context_); + napi_value contextObj = CreateJsAbilityContext(nativeEngine_, context_); auto systemModule = std::shared_ptr( - JsRuntime::LoadSystemModuleByEngine(nativeEngine_.get(), "application.AbilityContext", &contextObj, 1)); + JsRuntime::LoadSystemModuleByEngine(nativeEngine_, "application.AbilityContext", &contextObj, 1)); if (systemModule == nullptr) { HILOG_ERROR("systemModule is nullptr."); return; } - - contextObj = systemModule->Get(); + contextObj = systemModule->GetNapiValue(); if (contextObj == nullptr) { HILOG_ERROR("contextObj is nullptr."); return; } - NativeObject *obj = ConvertNativeValueTo(instanceValue); if (obj == nullptr) { HILOG_ERROR("obj is nullptr"); return; } - obj->SetProperty("context", contextObj); + napi_set_named_property(env, obj, "context", contextObj); jsContexts_.emplace(currentId_, systemModule); } -NativeValue *SimulatorImpl::CreateJsWant(NativeEngine &engine) +napi_value SimulatorImpl::CreateJsWant(napi_env env) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - - object->SetProperty("deviceId", CreateJsValue(engine, "")); - object->SetProperty("bundleName", CreateJsValue(engine, options_.bundleName)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_set_named_property(env, objValue, "deviceId", CreateJsValue(env, std::string(""))); + napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, options_.bundleName)); if (abilityInfo_) { - object->SetProperty("abilityName", CreateJsValue(engine, abilityInfo_->name)); - } - object->SetProperty("moduleName", CreateJsValue(engine, options_.moduleName)); - object->SetProperty("uri", CreateJsValue(engine, "")); - object->SetProperty("type", CreateJsValue(engine, "")); - object->SetProperty("flags", CreateJsValue(engine, 0)); - object->SetProperty("action", CreateJsValue(engine, "")); - object->SetProperty("parameters", engine.CreateObject()); - object->SetProperty("entities", engine.CreateArray(0)); + napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, abilityInfo_->name)); + } + napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, options_.moduleName)); + + napi_set_named_property(env, objValue, "uri", CreateJsValue(env, std::string(""))); + napi_set_named_property(env, objValue, "type", CreateJsValue(env, std::string(""))); + napi_set_named_property(env, objValue, "flags", CreateJsValue(env, 0)); + napi_set_named_property(env, objValue, "type", CreateJsValue(env, std::string(""))); + napi_value object = nullptr; + napi_create_object(env, &object); + napi_set_named_property(env, objValue, "parameters", object); + napi_value array = nullptr; + napi_create_array_with_length(env, 0, &array); + napi_set_named_property(env, objValue, "entities", array); return objValue; } -NativeValue *SimulatorImpl::CreateJsLaunchParam(NativeEngine &engine) +napi_value SimulatorImpl::CreateJsLaunchParam(napi_env env) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - object->SetProperty("launchReason", CreateJsValue(engine, AAFwk::LAUNCHREASON_UNKNOWN)); - object->SetProperty("lastExitReason", CreateJsValue(engine, AAFwk::LASTEXITREASON_UNKNOWN)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_set_named_property(env, objValue, "launchReason", CreateJsValue(env, AAFwk::LAUNCHREASON_UNKNOWN)); + napi_set_named_property(env, objValue, "lastExitReason", CreateJsValue(env, AAFwk::LASTEXITREASON_UNKNOWN)); return objValue; } -void SimulatorImpl::DispatchStartLifecycle(NativeValue *instanceValue) +void SimulatorImpl::DispatchStartLifecycle(napi_value instanceValue) { - NativeValue *wantArgv[] = { - CreateJsWant(*nativeEngine_), - CreateJsLaunchParam(*nativeEngine_) + napi_value wantArgv[] = { + CreateJsWant(nativeEngine_), + CreateJsLaunchParam(nativeEngine_) }; - CallObjectMethod(*nativeEngine_, instanceValue, "onCreate", wantArgv, ArraySize(wantArgv)); - + CallObjectMethod(nativeEngine_, instanceValue, "onCreate", wantArgv, ArraySize(wantArgv)); auto windowScene = std::make_shared(); if (windowScene == nullptr) { return; @@ -604,10 +614,10 @@ void SimulatorImpl::DispatchStartLifecycle(NativeValue *instanceValue) if (jsWindowStage == nullptr) { return; } - NativeValue *argv[] = { jsWindowStage->Get() }; - CallObjectMethod(*nativeEngine_, instanceValue, "onWindowStageCreate", argv, ArraySize(argv)); + napi_value argv[] = { jsWindowStage->GetNapiValue() }; + CallObjectMethod(nativeEngine_, instanceValue, "onWindowStageCreate", argv, ArraySize(argv)); - CallObjectMethod(*nativeEngine_, instanceValue, "onForeground", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onForeground", nullptr, 0); windowScenes_.emplace(currentId_, windowScene); jsWindowStages_.emplace(currentId_, std::shared_ptr(jsWindowStage.release())); @@ -616,12 +626,13 @@ void SimulatorImpl::DispatchStartLifecycle(NativeValue *instanceValue) std::unique_ptr SimulatorImpl::CreateJsWindowStage( const std::shared_ptr &windowScene) { - NativeValue *jsWindowStage = Rosen::CreateJsWindowStage(*nativeEngine_, windowScene); + auto engine = reinterpret_cast(nativeEngine_); + napi_value jsWindowStage = reinterpret_cast(Rosen::CreateJsWindowStage(*engine, windowScene)); if (jsWindowStage == nullptr) { HILOG_ERROR("Failed to create jsWindowSatge object"); return nullptr; } - return JsRuntime::LoadSystemModuleByEngine(nativeEngine_.get(), "application.WindowStage", &jsWindowStage, 1); + return JsRuntime::LoadSystemModuleByEngine(nativeEngine_, "application.WindowStage", &jsWindowStage, 1); } panda::ecmascript::EcmaVM *SimulatorImpl::CreateJSVM() @@ -673,18 +684,23 @@ bool SimulatorImpl::OnInit() panda::JSNApi::StartDebugger(vm_, debugOption, 0, std::bind(&DebuggerTask::OnPostTask, &debuggerTask_, std::placeholders::_1)); - auto nativeEngine = std::make_unique(vm_, nullptr); + auto nativeEngine = new (std::nothrow) ArkNativeEngine(vm_, nullptr); if (nativeEngine == nullptr) { HILOG_ERROR("nativeEngine is nullptr"); return false; } - NativeObject *globalObj = ConvertNativeValueTo(nativeEngine->GetGlobal()); + napi_env env = reinterpret_cast(nativeEngine); + + napi_value globalObj; + napi_get_global(env, &globalObj); if (globalObj == nullptr) { + delete nativeEngine; HILOG_ERROR("Failed to get global object"); return false; } - if (!LoadRuntimeEnv(*nativeEngine, *globalObj)) { + if (!LoadRuntimeEnv(env, globalObj)) { + delete nativeEngine; HILOG_ERROR("Load runtime env failed."); return false; } @@ -694,18 +710,40 @@ bool SimulatorImpl::OnInit() panda::JSNApi::SetModuleName(vm_, options_.moduleName); panda::JSNApi::SetAssetPath(vm_, options_.modulePath); - nativeEngine_ = std::move(nativeEngine); + nativeEngine_ = env; return true; } -bool SimulatorImpl::LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &globalObj) +napi_value SimulatorImpl::RequireNapi(napi_env env, napi_callback_info info) { - JsSysModule::Console::InitConsoleModule(reinterpret_cast(&nativeEngine)); - auto ret = JsSysModule::Timer::RegisterTime(reinterpret_cast(&nativeEngine)); + napi_value globalObj; + napi_get_global(env, &globalObj); + napi_value requireNapi = nullptr; + napi_get_named_property(env, globalObj, "requireNapiPreview", &requireNapi); + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + napi_value result = nullptr; + napi_call_function(env, CreateJsUndefined(env), requireNapi, argc, argv, &result); + if (!CheckTypeForNapiValue(env, result, napi_undefined)) { + return result; + } + napi_value mockRequireNapi = nullptr; + napi_get_named_property(env, globalObj, "mockRequireNapi", &mockRequireNapi); + napi_call_function(env, CreateJsUndefined(env), mockRequireNapi, argc, argv, &result); + return result; +} + +bool SimulatorImpl::LoadRuntimeEnv(napi_env env, napi_value globalObj) +{ + JsSysModule::Console::InitConsoleModule(env); + auto ret = JsSysModule::Timer::RegisterTime(env); if (!ret) { HILOG_ERROR("Register timer failed"); } - globalObj.SetProperty("group", nativeEngine.CreateObject()); + napi_value object = nullptr; + napi_create_object(env, &object); + napi_set_named_property(env, globalObj, "group", object); uintptr_t bufferStart = reinterpret_cast(_binary_jsMockSystemPlugin_abc_start); uintptr_t bufferEnd = reinterpret_cast(_binary_jsMockSystemPlugin_abc_end); @@ -713,12 +751,12 @@ bool SimulatorImpl::LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &glo size_t size = bufferEnd - bufferStart; panda::JSNApi::Execute(vm_, buffer, size, "_GLOBAL::func_main_0"); - NativeValue *mockRequireNapi = globalObj.GetProperty("requireNapi"); - globalObj.SetProperty("mockRequireNapi", mockRequireNapi); - - auto* moduleManager = nativeEngine.GetModuleManager(); + napi_value mockRequireNapi = nullptr; + napi_get_named_property(env, globalObj, "requireNapi", &mockRequireNapi); + napi_set_named_property(env, globalObj, "mockRequireNapi", mockRequireNapi); + auto* moduleManager = reinterpret_cast(env)->GetModuleManager(); if (moduleManager != nullptr) { - HILOG_DEBUG("moduleManager SetPreviewSearchPath: %{public}s", options_.containerSdkPath.c_str()); + HILOG_ERROR("moduleManager SetPreviewSearchPath: %{public}s", options_.containerSdkPath.c_str()); moduleManager->SetPreviewSearchPath(options_.containerSdkPath); } @@ -735,25 +773,14 @@ bool SimulatorImpl::LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &glo } const char *moduleName = "SimulatorImpl"; - BindNativeFunction(nativeEngine, globalObj, "requireNapi", moduleName, - [](NativeEngine *engine, NativeCallbackInfo *info) { - NativeObject *globalObj = ConvertNativeValueTo(engine->GetGlobal()); - NativeValue *requireNapi = globalObj->GetProperty("requireNapiPreview"); - - NativeValue *result = engine->CallFunction(engine->CreateUndefined(), requireNapi, info->argv, info->argc); - if (result->TypeOf() != NATIVE_UNDEFINED) { - return result; - } - - NativeValue *mockRequireNapi = globalObj->GetProperty("mockRequireNapi"); - return engine->CallFunction(engine->CreateUndefined(), mockRequireNapi, info->argv, info->argc); - }); + BindNativeFunction(env, globalObj, "requireNapi", moduleName, SimulatorImpl::RequireNapi); return true; } void SimulatorImpl::Run() { - uv_loop_t *uvLoop = nativeEngine_->GetUVLoop(); + uv_loop_t* uvLoop = nullptr; + napi_get_uv_event_loop(nativeEngine_, &uvLoop); if (uvLoop != nullptr) { uv_run(uvLoop, UV_RUN_NOWAIT); } -- Gitee