diff --git a/frameworks/js/napi/app/app_manager/app_manager_module.cpp b/frameworks/js/napi/app/app_manager/app_manager_module.cpp index 285e20f5e8031cd00111bb7ba4f9cf558fcd64ea..0399155cd9a4c1004b2dcf7c6bd3941020814eeb 100644 --- a/frameworks/js/napi/app/app_manager/app_manager_module.cpp +++ b/frameworks/js/napi/app/app_manager/app_manager_module.cpp @@ -16,15 +16,14 @@ #include "native_engine/native_engine.h" #include "js_app_manager.h" -extern "C" __attribute__((constructor)) -void NAPI_application_AppManager_AutoRegister() -{ - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.appManager", - .fileName = "application/appmanager_napi.so/app_manager.js", - .registerCallback = OHOS::AbilityRuntime::JsAppManagerInit, - }; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.appManager", + .nm_filename = "application/appmanager_napi.so/app_manager.js", + .nm_register_func = OHOS::AbilityRuntime::JsAppManagerInit, +}; - moduleManager->Register(&newModuleInfo); +extern "C" __attribute__((constructor)) void NAPI_application_AppManager_AutoRegister(void) +{ + napi_module_register(&_module); } diff --git a/frameworks/js/napi/app/app_manager/js_app_manager.cpp b/frameworks/js/napi/app/app_manager/js_app_manager.cpp index c6ed242e5a9733512618e1d1118d1fd7e466c443..5132e785760aff171829e626674648bc78eb85fb 100644 --- a/frameworks/js/napi/app/app_manager/js_app_manager.cpp +++ b/frameworks/js/napi/app/app_manager/js_app_manager.cpp @@ -52,129 +52,117 @@ public: abilityManager_(abilityManager) {} ~JsAppManager() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsAbilityContext::Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* RegisterApplicationStateObserver(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value RegisterApplicationStateObserver(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRegisterApplicationStateObserver(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnRegisterApplicationStateObserver); } - static NativeValue* UnregisterApplicationStateObserver(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value UnregisterApplicationStateObserver(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnUnregisterApplicationStateObserver(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnUnregisterApplicationStateObserver); } - static NativeValue* GetForegroundApplications(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetForegroundApplications(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetForegroundApplications(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetForegroundApplications); } - static NativeValue* GetProcessRunningInfos(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetProcessRunningInfos(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetProcessRunningInfos(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetProcessRunningInfos); } - static NativeValue* IsRunningInStabilityTest(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value IsRunningInStabilityTest(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsRunningInStabilityTest(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnIsRunningInStabilityTest); } - static NativeValue* KillProcessWithAccount(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value KillProcessWithAccount(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnKillProcessWithAccount(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnKillProcessWithAccount); } - static NativeValue* KillProcessesByBundleName(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value KillProcessesByBundleName(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnkillProcessByBundleName(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnkillProcessByBundleName); } - static NativeValue* ClearUpApplicationData(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value ClearUpApplicationData(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnClearUpApplicationData(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnClearUpApplicationData); } - static NativeValue* GetAppMemorySize(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetAppMemorySize(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetAppMemorySize(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetAppMemorySize); } - static NativeValue* IsRamConstrainedDevice(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value IsRamConstrainedDevice(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsRamConstrainedDevice(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnIsRamConstrainedDevice); } private: sptr appManager_ = nullptr; sptr abilityManager_ = nullptr; sptr observer_ = nullptr; - NativeValue* OnRegisterApplicationStateObserver(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnRegisterApplicationStateObserver(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); // only support 1 or 2 params - if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) { + if (argc != ARGC_ONE && argc != ARGC_TWO) { HILOG_ERROR("Not enough params"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } if (appManager_ == nullptr) { HILOG_ERROR("appManager nullptr"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } static int64_t serialNumber = 0; std::vector bundleNameList; // unwarp observer if (observer_ == nullptr) { - observer_ = new JSAppStateObserver(engine); + observer_ = new JSAppStateObserver(env); } - if (info.argc == ARGC_TWO) { - AppExecFwk::UnwrapArrayStringFromJS(reinterpret_cast(&engine), - reinterpret_cast(info.argv[INDEX_ONE]), bundleNameList); + if (argc == ARGC_TWO) { + AppExecFwk::UnwrapArrayStringFromJS(env, argv[INDEX_ONE], bundleNameList); } int32_t ret = appManager_->RegisterApplicationStateObserver(observer_, bundleNameList); if (ret == 0) { HILOG_DEBUG("success."); int64_t observerId = serialNumber; - observer_->AddJsObserverObject(observerId, info.argv[INDEX_ZERO]); + observer_->AddJsObserverObject(observerId, argv[INDEX_ZERO]); if (serialNumber < INT32_MAX) { serialNumber++; } else { serialNumber = 0; } - return engine.CreateNumber(observerId); + return CreateJsValue(env, observerId); } else { HILOG_ERROR("failed error:%{public}d.", ret); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } } - NativeValue* OnUnregisterApplicationStateObserver(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnUnregisterApplicationStateObserver(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); int32_t errCode = 0; int64_t observerId = -1; // only support 1 or 2 params - if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) { + if (argc != ARGC_ONE && argc != ARGC_TWO) { HILOG_ERROR("Not enough params"); errCode = ERR_NOT_OK; } else { // unwrap connectId - napi_get_value_int64(reinterpret_cast(&engine), - reinterpret_cast(info.argv[INDEX_ZERO]), &observerId); + napi_get_value_int64(env, argv[INDEX_ZERO], &observerId); bool isExist = observer_->FindObserverByObserverId(observerId); if (isExist) { // match id @@ -185,196 +173,196 @@ private: } } - AsyncTask::CompleteCallback complete = + NapiAsyncTask::CompleteCallback complete = [appManager = appManager_, observer = observer_, observerId, errCode]( - NativeEngine& engine, AsyncTask& task, int32_t status) { + napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (observer == nullptr || appManager == nullptr) { HILOG_ERROR("observer or appManager nullptr"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "observer or appManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "observer or appManager nullptr")); return; } int32_t ret = appManager->UnregisterApplicationStateObserver(observer); if (ret == 0 && observer->RemoveJsObserverObject(observerId)) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); HILOG_DEBUG("success size:%{public}zu", observer->GetJsObserverMapSize()); } else { HILOG_ERROR("failed error:%{public}d", ret); - task.Reject(engine, CreateJsError(engine, ret, "UnregisterApplicationStateObserver failed")); + task.Reject(env, CreateJsError(env, ret, "UnregisterApplicationStateObserver failed")); } }; - NativeValue* lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnUnregisterApplicationStateObserver", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_TWO) ? argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnUnregisterApplicationStateObserver", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetForegroundApplications(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnGetForegroundApplications(napi_env env, const size_t argc, napi_value* argv) { HILOG_DEBUG("called"); int32_t errCode = 0; // only support 0 or 1 params - if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) { + if (argc != ARGC_ZERO && argc != ARGC_ONE) { HILOG_ERROR("Not enough params"); errCode = ERR_NOT_OK; } - AsyncTask::CompleteCallback complete = - [appManager = appManager_, errCode](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [appManager = appManager_, errCode](napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (appManager == nullptr) { HILOG_ERROR("appManager nullptr"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "appManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "appManager nullptr")); return; } std::vector list; int32_t ret = appManager->GetForegroundApplications(list); if (ret == 0) { HILOG_DEBUG("success."); - task.Resolve(engine, CreateJsAppStateDataArray(engine, list)); + task.Resolve(env, CreateJsAppStateDataArray(env, list)); } else { HILOG_ERROR("failed error:%{public}d", ret); - task.Reject(engine, CreateJsError(engine, ret, "OnGetForegroundApplications failed")); + task.Reject(env, CreateJsError(env, ret, "OnGetForegroundApplications failed")); } }; - NativeValue* lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnGetForegroundApplications", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_ONE) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnGetForegroundApplications", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetProcessRunningInfos(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnGetProcessRunningInfos(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); int32_t errCode = 0; // only support 0 or 1 params - if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) { + if (argc != ARGC_ZERO && argc != ARGC_ONE) { HILOG_ERROR("Not enough params"); errCode = ERR_NOT_OK; } - AsyncTask::CompleteCallback complete = - [appManager = appManager_, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [appManager = appManager_, errCode](napi_env env, NapiAsyncTask &task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } std::vector infos; auto ret = appManager->GetAllRunningProcesses(infos); if (ret == 0) { - task.Resolve(engine, CreateJsProcessRunningInfoArray(engine, infos)); + task.Resolve(env, CreateJsProcessRunningInfoArray(env, infos)); } else { - task.Reject(engine, CreateJsError(engine, ret, "Get mission infos failed.")); + task.Reject(env, CreateJsError(env, ret, "Get mission infos failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnGetProcessRunningInfos", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_ONE) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnGetProcessRunningInfos", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnIsRunningInStabilityTest(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnIsRunningInStabilityTest(napi_env env, const size_t argc, napi_value* argv) { HILOG_DEBUG("called"); int32_t errCode = 0; // only support 0 or 1 params - if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) { + if (argc != ARGC_ZERO && argc != ARGC_ONE) { HILOG_ERROR("Not enough arguments"); errCode = ERR_NOT_OK; } - AsyncTask::CompleteCallback complete = - [abilityManager = abilityManager_, errCode](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [abilityManager = abilityManager_, errCode](napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "abilityManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "abilityManager nullptr")); return; } bool ret = abilityManager->IsRunningInStabilityTest(); HILOG_INFO("result:%{public}d", ret); - task.Resolve(engine, CreateJsValue(engine, ret)); + task.Resolve(env, CreateJsValue(env, ret)); }; - NativeValue* lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnIsRunningInStabilityTest", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_ONE) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnIsRunningInStabilityTest", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnkillProcessByBundleName(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnkillProcessByBundleName(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("OnkillProcessByBundleName called"); int32_t errCode = 0; std::string bundleName; // only support 1 or 2 params - if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) { + if (argc != ARGC_ONE && argc != ARGC_TWO) { HILOG_ERROR("Not enough arguments"); errCode = ERR_NOT_OK; } else { - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("get bundleName failed!"); errCode = ERR_NOT_OK; } } HILOG_INFO("kill process [%{public}s]", bundleName.c_str()); - AsyncTask::CompleteCallback complete = - [bundleName, abilityManager = abilityManager_, errCode](NativeEngine& engine, AsyncTask& task, + NapiAsyncTask::CompleteCallback complete = + [bundleName, abilityManager = abilityManager_, errCode](napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (abilityManager == nullptr) { HILOG_WARN("abilityManager null"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "abilityManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "abilityManager nullptr")); return; } auto ret = abilityManager->KillProcess(bundleName); if (ret == 0) { - task.Resolve(engine, CreateJsValue(engine, ret)); + task.Resolve(env, CreateJsValue(env, ret)); } else { - task.Reject(engine, CreateJsError(engine, ret, "kill process failed.")); + task.Reject(env, CreateJsError(env, ret, "kill process failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnkillProcessByBundleName", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_TWO) ? argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnkillProcessByBundleName", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnClearUpApplicationData(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnClearUpApplicationData(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); int32_t errCode = 0; std::string bundleName; // only support 1 or 2 params - if (info.argc != ARGC_ONE && info.argc != ARGC_TWO) { + if (argc != ARGC_ONE && argc != ARGC_TWO) { HILOG_ERROR("Not enough params"); errCode = ERR_NOT_OK; } else { - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("get bundleName failed!"); errCode = ERR_NOT_OK; } else { @@ -382,34 +370,34 @@ private: } } - AsyncTask::CompleteCallback complete = - [bundleName, abilityManager = abilityManager_, errCode](NativeEngine& engine, AsyncTask& task, + NapiAsyncTask::CompleteCallback complete = + [bundleName, abilityManager = abilityManager_, errCode](napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "abilityManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "abilityManager nullptr")); return; } auto ret = abilityManager->ClearUpApplicationData(bundleName); if (ret == 0) { - task.Resolve(engine, CreateJsValue(engine, ret)); + task.Resolve(env, CreateJsValue(env, ret)); } else { - task.Reject(engine, CreateJsError(engine, ret, "clear up application failed.")); + task.Reject(env, CreateJsError(env, ret, "clear up application failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnClearUpApplicationData", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_TWO) ? argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnClearUpApplicationData", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnKillProcessWithAccount(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnKillProcessWithAccount(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); int32_t errCode = 0; @@ -417,105 +405,105 @@ private: std::string bundleName; // only support 2 or 3 params - if (info.argc != ARGC_TWO && info.argc != ARGC_THREE) { + if (argc != ARGC_TWO && argc != ARGC_THREE) { HILOG_ERROR("Not enough params"); errCode = ERR_NOT_OK; } else { - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("Parse bundleName failed"); errCode = ERR_NOT_OK; } - if (!ConvertFromJsValue(engine, info.argv[1], accountId)) { + if (!ConvertFromJsValue(env, argv[1], accountId)) { HILOG_ERROR("Parse userId failed"); errCode = ERR_NOT_OK; } } - AsyncTask::CompleteCallback complete = - [appManager = appManager_, bundleName, accountId, errCode](NativeEngine &engine, AsyncTask &task, + NapiAsyncTask::CompleteCallback complete = + [appManager = appManager_, bundleName, accountId, errCode](napi_env env, NapiAsyncTask &task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } auto ret = appManager->GetAmsMgr()->KillProcessWithAccount(bundleName, accountId); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); } else { HILOG_DEBUG("failed error:%{public}d", ret); - task.Reject(engine, CreateJsError(engine, ret, "Kill processes failed.")); + task.Reject(env, CreateJsError(env, ret, "Kill processes failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_THREE) ? info.argv[INDEX_TWO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnKillProcessWithAccount", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_THREE) ? argv[INDEX_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnKillProcessWithAccount", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; HILOG_DEBUG("end"); } - NativeValue* OnGetAppMemorySize(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnGetAppMemorySize(napi_env env, const size_t argc, napi_value* argv) { int32_t errCode = 0; // only support 0 or 1 params - if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) { + if (argc != ARGC_ZERO && argc != ARGC_ONE) { HILOG_ERROR("Insufficient params"); errCode = ERR_NOT_OK; } - AsyncTask::CompleteCallback complete = - [abilityManager = abilityManager_, errCode](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [abilityManager = abilityManager_, errCode](napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "abilityManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "abilityManager nullptr")); return; } int32_t memorySize = abilityManager->GetAppMemorySize(); HILOG_INFO("memorySize:%{public}d", memorySize); - task.Resolve(engine, CreateJsValue(engine, memorySize)); + task.Resolve(env, CreateJsValue(env, memorySize)); }; - NativeValue* lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnGetAppMemorySize", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_ONE) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnGetAppMemorySize", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnIsRamConstrainedDevice(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnIsRamConstrainedDevice(napi_env env, const size_t argc, napi_value* argv) { int32_t errCode = 0; // only support 0 or 1 params - if (info.argc != ARGC_ZERO && info.argc != ARGC_ONE) { + if (argc != ARGC_ZERO && argc != ARGC_ONE) { HILOG_ERROR("Not enough parameters"); errCode = ERR_NOT_OK; } - AsyncTask::CompleteCallback complete = - [abilityManager = abilityManager_, errCode](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [abilityManager = abilityManager_, errCode](napi_env env, NapiAsyncTask& task, int32_t status) { if (errCode != 0) { - task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params.")); + task.Reject(env, CreateJsError(env, errCode, "Invalidate params.")); return; } if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, ERROR_CODE_ONE, "abilityManager nullptr")); + task.Reject(env, CreateJsError(env, ERROR_CODE_ONE, "abilityManager nullptr")); return; } bool ret = abilityManager->IsRamConstrainedDevice(); HILOG_INFO("result:%{public}d", ret); - task.Resolve(engine, CreateJsValue(engine, ret)); + task.Resolve(env, CreateJsValue(env, ret)); }; - NativeValue* lastParam = (info.argc == ARGC_ONE) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnIsRamConstrainedDevice", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_ONE) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnIsRamConstrainedDevice", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } }; @@ -538,49 +526,43 @@ OHOS::sptr GetAbilityManagerInstance() return OHOS::iface_cast(abilityObject); } -NativeValue* JsAppManagerInit(NativeEngine* engine, NativeValue* exportObj) +napi_value JsAppManagerInit(napi_env env, napi_value exportObj) { HILOG_DEBUG("JsAppManagerInit start"); - if (engine == nullptr || exportObj == nullptr) { - HILOG_WARN("engine or exportObj nullptr"); + if (env == nullptr || exportObj == nullptr) { + HILOG_WARN("env or exportObj null"); return nullptr; } - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_WARN("object nullptr"); - return nullptr; - } - - std::unique_ptr jsAppManager = - std::make_unique(GetAppManagerInstance(), GetAbilityManagerInstance()); - object->SetNativePointer(jsAppManager.release(), JsAppManager::Finalizer, nullptr); + std::unique_ptr jsAppManager = std::make_unique( + GetAppManagerInstance(), GetAbilityManagerInstance()); + napi_wrap(env, exportObj, jsAppManager.release(), JsAppManager::Finalizer, nullptr, nullptr); const char *moduleName = "JsAppManager"; - BindNativeFunction(*engine, *object, "registerApplicationStateObserver", moduleName, + BindNativeFunction(env, exportObj, "registerApplicationStateObserver", moduleName, JsAppManager::RegisterApplicationStateObserver); - BindNativeFunction(*engine, *object, "unregisterApplicationStateObserver", moduleName, + BindNativeFunction(env, exportObj, "unregisterApplicationStateObserver", moduleName, JsAppManager::UnregisterApplicationStateObserver); - BindNativeFunction(*engine, *object, "getForegroundApplications", moduleName, + BindNativeFunction(env, exportObj, "getForegroundApplications", moduleName, JsAppManager::GetForegroundApplications); - BindNativeFunction(*engine, *object, "getProcessRunningInfos", moduleName, + BindNativeFunction(env, exportObj, "getProcessRunningInfos", moduleName, JsAppManager::GetProcessRunningInfos); - BindNativeFunction(*engine, *object, "getProcessRunningInformation", moduleName, + BindNativeFunction(env, exportObj, "getProcessRunningInformation", moduleName, JsAppManager::GetProcessRunningInfos); - BindNativeFunction(*engine, *object, "isRunningInStabilityTest", moduleName, + BindNativeFunction(env, exportObj, "isRunningInStabilityTest", moduleName, JsAppManager::IsRunningInStabilityTest); - BindNativeFunction(*engine, *object, "killProcessWithAccount", moduleName, + BindNativeFunction(env, exportObj, "killProcessWithAccount", moduleName, JsAppManager::KillProcessWithAccount); - BindNativeFunction(*engine, *object, "killProcessesByBundleName", moduleName, + BindNativeFunction(env, exportObj, "killProcessesByBundleName", moduleName, JsAppManager::KillProcessesByBundleName); - BindNativeFunction(*engine, *object, "clearUpApplicationData", moduleName, + BindNativeFunction(env, exportObj, "clearUpApplicationData", moduleName, JsAppManager::ClearUpApplicationData); - BindNativeFunction(*engine, *object, "getAppMemorySize", moduleName, + BindNativeFunction(env, exportObj, "getAppMemorySize", moduleName, JsAppManager::GetAppMemorySize); - BindNativeFunction(*engine, *object, "isRamConstrainedDevice", moduleName, + BindNativeFunction(env, exportObj, "isRamConstrainedDevice", moduleName, JsAppManager::IsRamConstrainedDevice); HILOG_DEBUG("JsAppManagerInit end"); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/app/app_manager/js_app_manager.h b/frameworks/js/napi/app/app_manager/js_app_manager.h index ffff9d0fbbfa5091583f086d30e0af7713026201..9c37bebd97548612eba977ff16eadb29b1fe3e3e 100644 --- a/frameworks/js/napi/app/app_manager/js_app_manager.h +++ b/frameworks/js/napi/app/app_manager/js_app_manager.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* JsAppManagerInit(NativeEngine* engine, NativeValue* exportObj); +napi_value JsAppManagerInit(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_APP_MANAGER_H diff --git a/frameworks/js/napi/app/app_manager/js_app_manager_utils.cpp b/frameworks/js/napi/app/app_manager/js_app_manager_utils.cpp index 4ad17e8d4f5212992cae9386f4cbee195f410ec8..b308a9a744a2cebc899400716594e43f086c52e7 100644 --- a/frameworks/js/napi/app/app_manager/js_app_manager_utils.cpp +++ b/frameworks/js/napi/app/app_manager/js_app_manager_utils.cpp @@ -24,115 +24,98 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsAppStateData(NativeEngine &engine, const AppStateData &appStateData) +napi_value CreateJsAppStateData(napi_env env, const AppStateData &appStateData) { - HILOG_INFO("%{public}s CreateJsAppStateData start.", __func__); - NativeValue* objValue = engine.CreateObject(); - if (objValue == nullptr) { - HILOG_ERROR("objValue nullptr"); - return nullptr; - } - HILOG_INFO("%{public}s ConvertNativeValueTo start.", __func__); - NativeObject* object = ConvertNativeValueTo(objValue); + HILOG_DEBUG("called."); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - HILOG_ERROR("object nullptr"); + HILOG_ERROR("objValue nullptr."); return nullptr; } - HILOG_INFO("%{public}s SetProperty start.", __func__); - object->SetProperty("bundleName", CreateJsValue(engine, appStateData.bundleName)); - object->SetProperty("uid", CreateJsValue(engine, appStateData.uid)); - object->SetProperty("state", CreateJsValue(engine, appStateData.state)); - HILOG_INFO("%{public}s CreateJsAppStateData exit.", __func__); - return objValue; + napi_set_named_property(env, object, "bundleName", CreateJsValue(env, appStateData.bundleName)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, appStateData.uid)); + napi_set_named_property(env, object, "state", CreateJsValue(env, appStateData.state)); + HILOG_INFO("end."); + return object; } -NativeValue* CreateJsAbilityStateData(NativeEngine &engine, const AbilityStateData &abilityStateData) +napi_value CreateJsAbilityStateData(napi_env env, const AbilityStateData &abilityStateData) { - HILOG_INFO("%{public}s CreateJsAbilityStateData called.", __func__); - NativeValue* objValue = engine.CreateObject(); - if (objValue == nullptr) { - HILOG_ERROR("objValue null."); - return nullptr; - } - HILOG_INFO("%{public}s ConvertNativeValueTo start.", __func__); - NativeObject* object = ConvertNativeValueTo(objValue); + HILOG_DEBUG("called."); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - HILOG_ERROR("object null."); + HILOG_ERROR("objValue nullptr."); return nullptr; } - HILOG_INFO("%{public}s SetProperty start.", __func__); - object->SetProperty("bundleName", CreateJsValue(engine, abilityStateData.bundleName)); - object->SetProperty("moduleName", CreateJsValue(engine, abilityStateData.moduleName)); - object->SetProperty("abilityName", CreateJsValue(engine, abilityStateData.abilityName)); - object->SetProperty("pid", CreateJsValue(engine, abilityStateData.pid)); - object->SetProperty("uid", CreateJsValue(engine, abilityStateData.uid)); - object->SetProperty("state", CreateJsValue(engine, abilityStateData.abilityState)); - object->SetProperty("abilityType", CreateJsValue(engine, abilityStateData.abilityType)); - HILOG_INFO("%{public}s CreateJsAbilityStateData exit.", __func__); - return objValue; + napi_set_named_property(env, object, "bundleName", CreateJsValue(env, abilityStateData.bundleName)); + napi_set_named_property(env, object, "moduleName", CreateJsValue(env, abilityStateData.moduleName)); + napi_set_named_property(env, object, "abilityName", CreateJsValue(env, abilityStateData.abilityName)); + napi_set_named_property(env, object, "pid", CreateJsValue(env, abilityStateData.pid)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, abilityStateData.uid)); + napi_set_named_property(env, object, "state", CreateJsValue(env, abilityStateData.abilityState)); + napi_set_named_property(env, object, "abilityType", CreateJsValue(env, abilityStateData.abilityName)); + + HILOG_DEBUG("end."); + return object; } -NativeValue* CreateJsProcessData(NativeEngine &engine, const ProcessData &processData) +napi_value CreateJsProcessData(napi_env env, const ProcessData &processData) { - HILOG_INFO("%{public}s CreateJsProcessData start.", __func__); - NativeValue* objValue = engine.CreateObject(); - if (objValue == nullptr) { - HILOG_ERROR("objValue null."); - return nullptr; - } - HILOG_INFO("%{public}s ConvertNativeValueTo enter.", __func__); - NativeObject* object = ConvertNativeValueTo(objValue); + HILOG_DEBUG("called."); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - HILOG_ERROR("object null."); + HILOG_ERROR("objValue nullptr."); return nullptr; } - HILOG_INFO("%{public}s SetProperty enter.", __func__); - object->SetProperty("bundleName", CreateJsValue(engine, processData.bundleName)); - object->SetProperty("pid", CreateJsValue(engine, processData.pid)); - object->SetProperty("uid", CreateJsValue(engine, processData.uid)); - object->SetProperty("state", CreateJsValue(engine, processData.state)); - object->SetProperty("isContinuousTask", CreateJsValue(engine, processData.isContinuousTask)); - object->SetProperty("isKeepAlive", CreateJsValue(engine, processData.isKeepAlive)); - HILOG_INFO("%{public}s CreateJsProcessData end.", __func__); - return objValue; + napi_set_named_property(env, object, "bundleName", CreateJsValue(env, processData.bundleName)); + napi_set_named_property(env, object, "pid", CreateJsValue(env, processData.pid)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, processData.uid)); + napi_set_named_property(env, object, "state", CreateJsValue(env, processData.state)); + napi_set_named_property(env, object, "isContinuousTask", CreateJsValue(env, processData.isContinuousTask)); + napi_set_named_property(env, object, "isKeepAlive", CreateJsValue(env, processData.isKeepAlive)); + HILOG_DEBUG("end."); + return object; } -NativeValue* CreateJsAppStateDataArray(NativeEngine &engine, const std::vector &appStateDatas) +napi_value CreateJsAppStateDataArray(napi_env env, const std::vector &appStateDatas) { - HILOG_INFO("%{public}s CreateJsAppStateDataArray start.", __func__); - NativeValue* arrayValue = engine.CreateArray(appStateDatas.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, appStateDatas.size(), &arrayValue); uint32_t index = 0; for (const auto &appStateData : appStateDatas) { - array->SetElement(index++, CreateJsAppStateData(engine, appStateData)); + napi_set_element(env, arrayValue, index++, CreateJsAppStateData(env, appStateData)); } - HILOG_INFO("%{public}s CreateJsAppStateDataArray end.", __func__); return arrayValue; } -NativeValue* CreateJsProcessRunningInfoArray(NativeEngine &engine, const std::vector &infos) +napi_value CreateJsProcessRunningInfoArray(napi_env env, const std::vector &infos) { - NativeValue* arrayValue = engine.CreateArray(infos.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, infos.size(), &arrayValue); uint32_t index = 0; for (const auto &runningInfo : infos) { - array->SetElement(index++, CreateJsProcessRunningInfo(engine, runningInfo)); + napi_set_element(env, arrayValue, index++, CreateJsProcessRunningInfo(env, runningInfo)); } return arrayValue; } -NativeValue* CreateJsProcessRunningInfo(NativeEngine &engine, const RunningProcessInfo &info) +napi_value CreateJsProcessRunningInfo(napi_env env, const RunningProcessInfo &info) { - HILOG_DEBUG("enter"); - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - - object->SetProperty("processName", CreateJsValue(engine, info.processName_)); - object->SetProperty("pid", CreateJsValue(engine, info.pid_)); - object->SetProperty("uid", CreateJsValue(engine, info.uid_)); - object->SetProperty("bundleNames", CreateNativeArray(engine, info.bundleNames)); - object->SetProperty("state", CreateJsValue(engine, info.state_)); - return objValue; + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { + HILOG_ERROR("objValue nullptr."); + return nullptr; + } + napi_set_named_property(env, object, "processName", CreateJsValue(env, info.processName_)); + napi_set_named_property(env, object, "pid", CreateJsValue(env, info.pid_)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, info.uid_)); + napi_set_named_property(env, object, "bundleNames", CreateNativeArray(env, info.bundleNames)); + napi_set_named_property(env, object, "state", CreateJsValue(env, info.state_)); + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/app/app_manager/js_app_manager_utils.h b/frameworks/js/napi/app/app_manager/js_app_manager_utils.h index 8166e96e53b6b39c29ea269232e5c45eb8827c65..c92d31e0350d3cc448fadd372563c0d8a62a4efb 100644 --- a/frameworks/js/napi/app/app_manager/js_app_manager_utils.h +++ b/frameworks/js/napi/app/app_manager/js_app_manager_utils.h @@ -26,12 +26,12 @@ using OHOS::AppExecFwk::AppStateData; using OHOS::AppExecFwk::AbilityStateData; using OHOS::AppExecFwk::ProcessData; using OHOS::AppExecFwk::RunningProcessInfo; -NativeValue* CreateJsAppStateData(NativeEngine &engine, const AppStateData &appStateData); -NativeValue* CreateJsAbilityStateData(NativeEngine &engine, const AbilityStateData &abilityStateData); -NativeValue* CreateJsProcessData(NativeEngine &engine, const ProcessData &processData); -NativeValue* CreateJsAppStateDataArray(NativeEngine &engine, const std::vector &appStateDatas); -NativeValue* CreateJsProcessRunningInfoArray(NativeEngine &engine, const std::vector &infos); -NativeValue* CreateJsProcessRunningInfo(NativeEngine &engine, const RunningProcessInfo &info); +napi_value CreateJsAppStateData(napi_env env, const AppStateData &appStateData); +napi_value CreateJsAbilityStateData(napi_env env, const AbilityStateData &abilityStateData); +napi_value CreateJsProcessData(napi_env env, const ProcessData &processData); +napi_value CreateJsAppStateDataArray(napi_env env, const std::vector &appStateDatas); +napi_value CreateJsProcessRunningInfoArray(napi_env env, const std::vector &infos); +napi_value CreateJsProcessRunningInfo(napi_env env, const RunningProcessInfo &info); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_APP_MANAGER_UTILS_H diff --git a/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp b/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp index a49bbc08d0db4dbfd02676da0bb53da847ae822a..5beead82acd1ef3369ea703eea0d252011f7a705 100644 --- a/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp +++ b/frameworks/js/napi/app/app_manager/js_app_state_observer.cpp @@ -22,7 +22,7 @@ namespace OHOS { namespace AbilityRuntime { constexpr size_t ARGC_ONE = 1; -JSAppStateObserver::JSAppStateObserver(NativeEngine& engine) : engine_(engine) {} +JSAppStateObserver::JSAppStateObserver(napi_env env) : env_(env) {} JSAppStateObserver::~JSAppStateObserver() = default; @@ -31,8 +31,8 @@ void JSAppStateObserver::OnForegroundApplicationChanged(const AppStateData &appS HILOG_DEBUG("onForegroundApplicationChanged bundleName:%{public}s, uid:%{public}d, state:%{public}d", appStateData.bundleName.c_str(), appStateData.uid, appStateData.state); wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, appStateData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, appStateData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr null"); @@ -40,10 +40,10 @@ void JSAppStateObserver::OnForegroundApplicationChanged(const AppStateData &appS } jsObserverSptr->HandleOnForegroundApplicationChanged(appStateData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnForegroundApplicationChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnForegroundApplicationChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); HILOG_DEBUG("OnForegroundApplicationChanged end"); } @@ -53,9 +53,9 @@ void JSAppStateObserver::HandleOnForegroundApplicationChanged(const AppStateData appStateData.bundleName.c_str(), appStateData.uid, appStateData.state); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsAppStateData(engine_, appStateData)}; - CallJsFunction(value, "onForegroundApplicationChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsAppStateData(env_, appStateData)}; + CallJsFunction(obj, "onForegroundApplicationChanged", argv, ARGC_ONE); } } @@ -63,8 +63,8 @@ void JSAppStateObserver::OnAbilityStateChanged(const AbilityStateData &abilitySt { HILOG_INFO("OnAbilityStateChanged start"); wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, abilityStateData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, abilityStateData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr null"); @@ -72,10 +72,10 @@ void JSAppStateObserver::OnAbilityStateChanged(const AbilityStateData &abilitySt } jsObserverSptr->HandleOnAbilityStateChanged(abilityStateData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnAbilityStateChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnAbilityStateChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnAbilityStateChanged(const AbilityStateData &abilityStateData) @@ -83,9 +83,9 @@ void JSAppStateObserver::HandleOnAbilityStateChanged(const AbilityStateData &abi HILOG_INFO("HandleOnAbilityStateChanged start"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsAbilityStateData(engine_, abilityStateData)}; - CallJsFunction(value, "onAbilityStateChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsAbilityStateData(env_, abilityStateData)}; + CallJsFunction(obj, "onAbilityStateChanged", argv, ARGC_ONE); } } @@ -93,8 +93,8 @@ void JSAppStateObserver::OnExtensionStateChanged(const AbilityStateData &ability { HILOG_INFO("OnExtensionStateChanged start"); wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, abilityStateData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, abilityStateData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -102,10 +102,10 @@ void JSAppStateObserver::OnExtensionStateChanged(const AbilityStateData &ability } jsObserverSptr->HandleOnExtensionStateChanged(abilityStateData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnExtensionStateChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnExtensionStateChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnExtensionStateChanged(const AbilityStateData &abilityStateData) @@ -113,9 +113,9 @@ void JSAppStateObserver::HandleOnExtensionStateChanged(const AbilityStateData &a HILOG_INFO("HandleOnExtensionStateChanged start"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsAbilityStateData(engine_, abilityStateData)}; - CallJsFunction(value, "onAbilityStateChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsAbilityStateData(env_, abilityStateData)}; + CallJsFunction(obj, "onAbilityStateChanged", argv, ARGC_ONE); } } @@ -123,8 +123,8 @@ void JSAppStateObserver::OnProcessCreated(const ProcessData &processData) { HILOG_INFO("OnProcessCreated start"); wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, processData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, processData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -132,10 +132,10 @@ void JSAppStateObserver::OnProcessCreated(const ProcessData &processData) } jsObserverSptr->HandleOnProcessCreated(processData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnProcessCreated(const ProcessData &processData) @@ -143,9 +143,9 @@ void JSAppStateObserver::HandleOnProcessCreated(const ProcessData &processData) HILOG_INFO("HandleOnProcessCreated start"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsProcessData(engine_, processData)}; - CallJsFunction(value, "onProcessCreated", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsProcessData(env_, processData)}; + CallJsFunction(obj, "onProcessCreated", argv, ARGC_ONE); } } @@ -153,8 +153,8 @@ void JSAppStateObserver::OnProcessStateChanged(const ProcessData &processData) { HILOG_INFO("OnProcessStateChanged start"); wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, processData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, processData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -162,10 +162,10 @@ void JSAppStateObserver::OnProcessStateChanged(const ProcessData &processData) } jsObserverSptr->HandleOnProcessStateChanged(processData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnProcessStateChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnProcessStateChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnProcessStateChanged(const ProcessData &processData) @@ -173,9 +173,9 @@ void JSAppStateObserver::HandleOnProcessStateChanged(const ProcessData &processD HILOG_INFO("HandleOnProcessStateChanged begin"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsProcessData(engine_, processData)}; - CallJsFunction(value, "onProcessStateChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsProcessData(env_, processData)}; + CallJsFunction(obj, "onProcessStateChanged", argv, ARGC_ONE); } } @@ -183,8 +183,8 @@ void JSAppStateObserver::OnProcessDied(const ProcessData &processData) { HILOG_INFO("OnProcessDied begin"); wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, processData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, processData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -192,10 +192,10 @@ void JSAppStateObserver::OnProcessDied(const ProcessData &processData) } jsObserverSptr->HandleOnProcessDied(processData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnProcessDied(const ProcessData &processData) @@ -203,35 +203,37 @@ void JSAppStateObserver::HandleOnProcessDied(const ProcessData &processData) HILOG_INFO("HandleOnProcessDied start"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsProcessData(engine_, processData)}; - CallJsFunction(value, "onProcessDied", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsProcessData(env_, processData)}; + CallJsFunction(obj, "onProcessDied", argv, ARGC_ONE); } } void JSAppStateObserver::CallJsFunction( - NativeValue* value, const char *methodName, NativeValue *const *argv, size_t argc) + napi_value value, const char *methodName, napi_value* argv, size_t argc) { - HILOG_INFO("CallJsFunction start, method:%{public}s", methodName); - NativeObject* obj = ConvertNativeValueTo(value); - if (obj == nullptr) { + HILOG_INFO("CallJsFunction begin, method:%{public}s", methodName); + if (value == nullptr) { HILOG_ERROR("Failed to get object"); return; } - NativeValue* method = obj->GetProperty(methodName); + napi_value method = nullptr; + napi_get_named_property(env_, value, methodName, &method); if (method == nullptr) { - HILOG_ERROR("error to get from object"); + HILOG_ERROR("Failed to get from object"); return; } - engine_.CallFunction(value, method, argv, argc); - HILOG_INFO("CallJsFunction exit"); + napi_value callResult = nullptr; + napi_call_function(env_, nullptr, method, argc, argv, &callResult); + HILOG_INFO("CallJsFunction end"); } -void JSAppStateObserver::AddJsObserverObject(const int32_t observerId, NativeValue* jsObserverObject) +void JSAppStateObserver::AddJsObserverObject(const int32_t observerId, napi_value jsObserverObject) { - jsObserverObjectMap_.emplace( - observerId, std::shared_ptr(engine_.CreateReference(jsObserverObject, 1))); + napi_ref ref = nullptr; + napi_create_reference(env_, jsObserverObject, 1, &ref); + jsObserverObjectMap_.emplace(observerId, std::shared_ptr(reinterpret_cast(ref))); } bool JSAppStateObserver::RemoveJsObserverObject(const int32_t observerId) diff --git a/frameworks/js/napi/app/app_manager/js_app_state_observer.h b/frameworks/js/napi/app/app_manager/js_app_state_observer.h index 9986f6563fcb083d25c2771cde248de2800f45f5..34e3adf6383061ba0f864599a2bb6e4928ec3bba 100644 --- a/frameworks/js/napi/app/app_manager/js_app_state_observer.h +++ b/frameworks/js/napi/app/app_manager/js_app_state_observer.h @@ -28,7 +28,7 @@ using OHOS::AppExecFwk::AbilityStateData; using OHOS::AppExecFwk::ProcessData; class JSAppStateObserver : public ApplicationStateObserverStub { public: - explicit JSAppStateObserver(NativeEngine& engine); + explicit JSAppStateObserver(napi_env engine); ~JSAppStateObserver(); void OnForegroundApplicationChanged(const AppStateData &appStateData) override; void OnAbilityStateChanged(const AbilityStateData &abilityStateData) override; @@ -42,14 +42,14 @@ public: void HandleOnProcessCreated(const ProcessData &processData); void HandleOnProcessStateChanged(const ProcessData &processData); void HandleOnProcessDied(const ProcessData &processData); - void CallJsFunction(NativeValue* value, const char *methodName, NativeValue *const *argv, size_t argc); - void AddJsObserverObject(const int32_t observerId, NativeValue* jsObserverObject); + void CallJsFunction(napi_value value, const char *methodName, napi_value* argv, size_t argc); + void AddJsObserverObject(const int32_t observerId, napi_value jsObserverObject); bool RemoveJsObserverObject(const int32_t observerId); bool FindObserverByObserverId(const int32_t observerId); size_t GetJsObserverMapSize(); private: - NativeEngine& engine_; + napi_env env_; std::map> jsObserverObjectMap_; }; } // namespace AbilityRuntime diff --git a/frameworks/js/napi/app/js_app_manager/app_manager_module.cpp b/frameworks/js/napi/app/js_app_manager/app_manager_module.cpp index 235e84985baa6279f3b8a853c735494756320a45..43cd11732a0e3e0862cda5441f80a4ddc0209e3b 100644 --- a/frameworks/js/napi/app/js_app_manager/app_manager_module.cpp +++ b/frameworks/js/napi/app/js_app_manager/app_manager_module.cpp @@ -16,15 +16,14 @@ #include "native_engine/native_engine.h" #include "js_app_manager.h" -extern "C" __attribute__((constructor)) -void NAPI_app_ability_AppManager_AutoRegister() -{ - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.appManager", - .fileName = "app/ability/libappmanager.so/app_manager.js", - .registerCallback = OHOS::AbilityRuntime::JsAppManagerInit, - }; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.appManager", + .nm_filename = "app/ability/appmanager_napi.so/app_manager.js", + .nm_register_func = OHOS::AbilityRuntime::JsAppManagerInit, +}; - moduleManager->Register(&newModuleInfo); +extern "C" __attribute__((constructor)) void NAPI_app_ability_AppManager_AutoRegister(void) +{ + napi_module_register(&_module); } diff --git a/frameworks/js/napi/app/js_app_manager/js_app_manager.cpp b/frameworks/js/napi/app/js_app_manager/js_app_manager.cpp index f4f83cdb27e571239cab6e0acb4f8516e8dc8834..e7ce4087cb847a565252ef053f22f4ceac9e273d 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_manager.cpp +++ b/frameworks/js/napi/app/js_app_manager/js_app_manager.cpp @@ -61,88 +61,75 @@ public: } } - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsAbilityContext::Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* On(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value On(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnOn(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnOn); } - static NativeValue* Off(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value Off(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnOff(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnOff); } - static NativeValue* GetForegroundApplications(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetForegroundApplications(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetForegroundApplications(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetForegroundApplications); } - static NativeValue* GetRunningProcessInformation(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetRunningProcessInformation(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetRunningProcessInformation(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetRunningProcessInformation); } - static NativeValue* IsRunningInStabilityTest(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value IsRunningInStabilityTest(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsRunningInStabilityTest(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnIsRunningInStabilityTest); } - static NativeValue* KillProcessWithAccount(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value KillProcessWithAccount(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnKillProcessWithAccount(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnKillProcessWithAccount); } - static NativeValue* KillProcessesByBundleName(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value KillProcessesByBundleName(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnkillProcessesByBundleName(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnkillProcessesByBundleName); } - static NativeValue* ClearUpApplicationData(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value ClearUpApplicationData(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnClearUpApplicationData(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnClearUpApplicationData); } - static NativeValue* IsSharedBundleRunning(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value IsSharedBundleRunning(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsSharedBundleRunning(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnIsSharedBundleRunning); } - static NativeValue* GetAppMemorySize(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetAppMemorySize(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetAppMemorySize(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetAppMemorySize); } - static NativeValue* IsRamConstrainedDevice(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value IsRamConstrainedDevice(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsRamConstrainedDevice(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnIsRamConstrainedDevice); } - static NativeValue* GetProcessMemoryByPid(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetProcessMemoryByPid(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetProcessMemoryByPid(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetProcessMemoryByPid); } - static NativeValue* GetRunningProcessInfoByBundleName(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetRunningProcessInfoByBundleName(napi_env env, napi_callback_info info) { - JsAppManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetRunningProcessInfoByBundleName(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsAppManager, OnGetRunningProcessInfoByBundleName); } private: sptr appManager_ = nullptr; @@ -151,593 +138,590 @@ private: sptr observerSync_ = nullptr; int32_t serialNumber_ = 0; - NativeValue* OnOn(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnOn(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - std::string type = ParseParamType(engine, info); + std::string type = ParseParamType(env, argc, argv); if (type == ON_OFF_TYPE_SYNC) { - return OnOnNew(engine, info); + return OnOnNew(env, argc, argv); } - return OnOnOld(engine, info); + return OnOnOld(env, argc, argv); } - NativeValue* OnOnOld(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnOnOld(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_TWO) { // support 2 or 3 params, if > 3 params, ignore other params + if (argc < ARGC_TWO) { // support 2 or 3 params, if > 3 params, ignore other params HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (!CheckOnOffType(engine, info)) { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + if (!CheckOnOffType(env, argc, argv)) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } if (appManager_ == nullptr) { HILOG_ERROR("appManager nullptr"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } std::vector bundleNameList; // unwarp observer if (observer_ == nullptr) { - observer_ = new JSAppStateObserver(engine); + observer_ = new JSAppStateObserver(env); } - if (info.argc > ARGC_TWO) { - AppExecFwk::UnwrapArrayStringFromJS(reinterpret_cast(&engine), - reinterpret_cast(info.argv[INDEX_TWO]), bundleNameList); + if (argc > ARGC_TWO) { + AppExecFwk::UnwrapArrayStringFromJS(env, argv[INDEX_TWO], bundleNameList); } int32_t ret = appManager_->RegisterApplicationStateObserver(observer_, bundleNameList); if (ret == 0) { HILOG_DEBUG("success."); int64_t observerId = serialNumber_; - observer_->AddJsObserverObject(observerId, info.argv[INDEX_ONE]); + observer_->AddJsObserverObject(observerId, argv[INDEX_ONE]); if (serialNumber_ < INT32_MAX) { serialNumber_++; } else { serialNumber_ = 0; } - return engine.CreateNumber(observerId); + return CreateJsValue(env, observerId); } else { HILOG_ERROR("failed error:%{public}d.", ret); - ThrowErrorByNativeErr(engine, ret); - return engine.CreateUndefined(); + ThrowErrorByNativeErr(env, ret); + return CreateJsUndefined(env); } } - NativeValue* OnOnNew(NativeEngine& engine, NativeCallbackInfo& info) + napi_value OnOnNew(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_TWO) { // support 2 or 3 params, if > 3 params, ignore other params + if (argc < ARGC_TWO) { // support 2 or 3 params, if > 3 params, ignore other params HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_OBJECT) { + if (!AppExecFwk::IsTypeForNapiValue(env, argv[INDEX_ONE], napi_object)) { HILOG_ERROR("Invalid param"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } std::vector bundleNameList; - if (info.argc > ARGC_TWO) { - AppExecFwk::UnwrapArrayStringFromJS(reinterpret_cast(&engine), - reinterpret_cast(info.argv[INDEX_TWO]), bundleNameList); + if (argc > ARGC_TWO) { + AppExecFwk::UnwrapArrayStringFromJS(env, argv[INDEX_TWO], bundleNameList); } if (observerSync_ == nullptr) { - observerSync_ = new JSAppStateObserver(engine); + observerSync_ = new JSAppStateObserver(env); } if (appManager_ == nullptr || observerSync_ == nullptr) { HILOG_ERROR("appManager or observer is nullptr"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } int32_t ret = appManager_->RegisterApplicationStateObserver(observerSync_, bundleNameList); if (ret == 0) { HILOG_DEBUG("success."); int32_t observerId = serialNumber_; - observerSync_->AddJsObserverObject(observerId, info.argv[INDEX_ONE]); + observerSync_->AddJsObserverObject(observerId, argv[INDEX_ONE]); if (serialNumber_ < INT32_MAX) { serialNumber_++; } else { serialNumber_ = 0; } - return engine.CreateNumber(observerId); + return CreateJsValue(env, observerId); } else { HILOG_ERROR("failed error:%{public}d.", ret); - ThrowErrorByNativeErr(engine, ret); - return engine.CreateUndefined(); + ThrowErrorByNativeErr(env, ret); + return CreateJsUndefined(env); } } - NativeValue* OnOff(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnOff(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - std::string type = ParseParamType(engine, info); + std::string type = ParseParamType(env, argc, argv); if (type == ON_OFF_TYPE_SYNC) { - return OnOffNew(engine, info); + return OnOffNew(env, argc, argv); } - return OnOffOld(engine, info); + return OnOffOld(env, argc, argv); } - NativeValue* OnOffOld(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnOffOld(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_TWO) { + if (argc < ARGC_TWO) { HILOG_ERROR("Not enough params when off."); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (!CheckOnOffType(engine, info)) { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + if (!CheckOnOffType(env, argc, argv)) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int64_t observerId = -1; - napi_get_value_int64(reinterpret_cast(&engine), - reinterpret_cast(info.argv[INDEX_ONE]), &observerId); + napi_get_value_int64(env, argv[INDEX_ONE], &observerId); if (observer_ == nullptr) { HILOG_ERROR("observer_ is nullpter, please register first"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } if (!observer_->FindObserverByObserverId(observerId)) { HILOG_ERROR("not find observer, observer:%{public}d", static_cast(observerId)); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } HILOG_DEBUG("find observer exist observer:%{public}d", static_cast(observerId)); - AsyncTask::CompleteCallback complete = + NapiAsyncTask::CompleteCallback complete = [appManager = appManager_, observer = observer_, observerId]( - NativeEngine& engine, AsyncTask& task, int32_t status) { + napi_env env, NapiAsyncTask& task, int32_t status) { if (observer == nullptr || appManager == nullptr) { HILOG_ERROR("observer or appManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } int32_t ret = appManager->UnregisterApplicationStateObserver(observer); if (ret == 0 && observer->RemoveJsObserverObject(observerId)) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); HILOG_DEBUG("success size:%{public}zu", observer->GetJsObserverMapSize()); } else { HILOG_ERROR("failed error:%{public}d", ret); - task.Reject(engine, CreateJsErrorByNativeErr(engine, ret)); + task.Reject(env, CreateJsErrorByNativeErr(env, ret)); } }; - NativeValue* lastParam = (info.argc > ARGC_TWO) ? info.argv[INDEX_TWO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnUnregisterApplicationStateObserver", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > ARGC_TWO) ? argv[INDEX_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnUnregisterApplicationStateObserver", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnOffNew(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnOffNew(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_TWO) { + if (argc < ARGC_TWO) { HILOG_ERROR("Not enough params when off."); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t observerId = -1; - if (!ConvertFromJsValue(engine, info.argv[INDEX_ONE], observerId)) { + if (!ConvertFromJsValue(env, argv[INDEX_ONE], observerId)) { HILOG_ERROR("Parse observerId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } if (observerSync_ == nullptr || appManager_ == nullptr) { HILOG_ERROR("observer or appManager nullptr"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } if (!observerSync_->FindObserverByObserverId(observerId)) { HILOG_ERROR("not find observer, observer:%{public}d", static_cast(observerId)); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t ret = appManager_->UnregisterApplicationStateObserver(observerSync_); if (ret == 0 && observerSync_->RemoveJsObserverObject(observerId)) { HILOG_DEBUG("success size:%{public}zu", observerSync_->GetJsObserverMapSize()); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } else { HILOG_ERROR("failed error:%{public}d", ret); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } } - NativeValue* OnGetForegroundApplications(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnGetForegroundApplications(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - AsyncTask::CompleteCallback complete = - [appManager = appManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [appManager = appManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (appManager == nullptr) { HILOG_ERROR("appManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } std::vector list; int32_t ret = appManager->GetForegroundApplications(list); if (ret == 0) { HILOG_DEBUG("success."); - task.ResolveWithNoError(engine, CreateJsAppStateDataArray(engine, list)); + task.ResolveWithNoError(env, CreateJsAppStateDataArray(env, list)); } else { HILOG_ERROR("failed error:%{public}d", ret); - task.Reject(engine, CreateJsError(engine, GetJsErrorCodeByNativeError(ret))); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(ret))); } }; - NativeValue* lastParam = (info.argc > ARGC_ZERO) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnGetForegroundApplications", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > ARGC_ZERO) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnGetForegroundApplications", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetRunningProcessInformation(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnGetRunningProcessInformation(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - AsyncTask::CompleteCallback complete = - [appManager = appManager_](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [appManager = appManager_](napi_env env, NapiAsyncTask &task, int32_t status) { if (appManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } std::vector infos; auto ret = appManager->GetAllRunningProcesses(infos); if (ret == 0) { - task.ResolveWithNoError(engine, CreateJsRunningProcessInfoArray(engine, infos)); + task.ResolveWithNoError(env, CreateJsRunningProcessInfoArray(env, infos)); } else { - task.Reject(engine, CreateJsError(engine, GetJsErrorCodeByNativeError(ret))); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(ret))); } }; - NativeValue* lastParam = (info.argc > ARGC_ZERO) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnGetRunningProcessInformation", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > ARGC_ZERO) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnGetRunningProcessInformation", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnIsRunningInStabilityTest(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnIsRunningInStabilityTest(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - AsyncTask::CompleteCallback complete = - [abilityManager = abilityManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [abilityManager = abilityManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } bool ret = abilityManager->IsRunningInStabilityTest(); HILOG_INFO("result:%{public}d", ret); - task.ResolveWithNoError(engine, CreateJsValue(engine, ret)); + task.ResolveWithNoError(env, CreateJsValue(env, ret)); }; - NativeValue* lastParam = (info.argc > ARGC_ZERO) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnIsRunningInStabilityTest", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > ARGC_ZERO) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnIsRunningInStabilityTest", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnkillProcessesByBundleName(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnkillProcessesByBundleName(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string bundleName; - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("get bundleName failed!"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } HILOG_INFO("kill process [%{public}s]", bundleName.c_str()); - AsyncTask::CompleteCallback complete = - [bundleName, abilityManager = abilityManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [bundleName, abilityManager = abilityManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } auto ret = abilityManager->KillProcess(bundleName); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, ret, "kill process failed.")); + task.Reject(env, CreateJsErrorByNativeErr(env, ret, "kill process failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnkillProcessesByBundleName", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_TWO) ? argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnkillProcessesByBundleName", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnClearUpApplicationData(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnClearUpApplicationData(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string bundleName; - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("get bundleName failed!"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [bundleName, abilityManager = abilityManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [bundleName, abilityManager = abilityManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } auto ret = abilityManager->ClearUpApplicationData(bundleName); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, ret, "clear up application failed.")); + task.Reject(env, CreateJsErrorByNativeErr(env, ret, "clear up application failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("JSAppManager::OnClearUpApplicationData", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_TWO) ? argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JSAppManager::OnClearUpApplicationData", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnIsSharedBundleRunning(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnIsSharedBundleRunning(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_TWO) { + if (argc < ARGC_TWO) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string bundleName; - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("get bundleName failed!"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } uint32_t versionCode = 0; - if (!ConvertFromJsValue(engine, info.argv[1], versionCode)) { + if (!ConvertFromJsValue(env, argv[1], versionCode)) { HILOG_ERROR("get versionCode failed!"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [bundleName, versionCode, appManager = appManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [bundleName, versionCode, appManager = appManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (appManager == nullptr) { HILOG_WARN("appManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } bool ret = appManager->IsSharedBundleRunning(bundleName, versionCode); HILOG_INFO("result:%{public}d", ret); - task.ResolveWithNoError(engine, CreateJsValue(engine, ret)); + task.ResolveWithNoError(env, CreateJsValue(env, ret)); }; - NativeValue* lastParam = (info.argc == ARGC_THREE) ? info.argv[INDEX_TWO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnIsSharedBundleRunning", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_THREE) ? argv[INDEX_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnIsSharedBundleRunning", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnKillProcessWithAccount(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnKillProcessWithAccount(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_TWO) { + if (argc < ARGC_TWO) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string bundleName; - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("Parse bundleName failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t accountId = -1; - if (!ConvertFromJsValue(engine, info.argv[1], accountId)) { + if (!ConvertFromJsValue(env, argv[1], accountId)) { HILOG_ERROR("Parse userId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [appManager = appManager_, bundleName, accountId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [appManager = appManager_, bundleName, accountId](napi_env env, NapiAsyncTask &task, int32_t status) { if (appManager == nullptr || appManager->GetAmsMgr() == nullptr) { HILOG_WARN("appManager is nullptr or amsMgr is nullptr."); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } auto ret = appManager->GetAmsMgr()->KillProcessWithAccount(bundleName, accountId); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, ret, "Kill processes failed.")); + task.Reject(env, CreateJsErrorByNativeErr(env, ret, "Kill processes failed.")); } }; - NativeValue* lastParam = (info.argc == ARGC_THREE) ? info.argv[INDEX_TWO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnKillProcessWithAccount", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_THREE) ? argv[INDEX_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnKillProcessWithAccount", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetAppMemorySize(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnGetAppMemorySize(napi_env env, size_t argc, napi_value* argv) { - AsyncTask::CompleteCallback complete = - [abilityManager = abilityManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [abilityManager = abilityManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } int32_t memorySize = abilityManager->GetAppMemorySize(); HILOG_INFO("memorySize:%{public}d", memorySize); - task.ResolveWithNoError(engine, CreateJsValue(engine, memorySize)); + task.ResolveWithNoError(env, CreateJsValue(env, memorySize)); }; - NativeValue* lastParam = (info.argc > ARGC_ZERO) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnGetAppMemorySize", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > ARGC_ZERO) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnGetAppMemorySize", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnIsRamConstrainedDevice(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnIsRamConstrainedDevice(napi_env env, size_t argc, napi_value* argv) { - AsyncTask::CompleteCallback complete = - [abilityManager = abilityManager_](NativeEngine& engine, AsyncTask& task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [abilityManager = abilityManager_](napi_env env, NapiAsyncTask& task, int32_t status) { if (abilityManager == nullptr) { HILOG_WARN("abilityManager nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } bool ret = abilityManager->IsRamConstrainedDevice(); HILOG_INFO("result:%{public}d", ret); - task.ResolveWithNoError(engine, CreateJsValue(engine, ret)); + task.ResolveWithNoError(env, CreateJsValue(env, ret)); }; - NativeValue* lastParam = (info.argc > ARGC_ZERO) ? info.argv[INDEX_ZERO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnIsRamConstrainedDevice", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > ARGC_ZERO) ? argv[INDEX_ZERO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnIsRamConstrainedDevice", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetProcessMemoryByPid(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnGetProcessMemoryByPid(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t pid; - if (!ConvertFromJsValue(engine, info.argv[0], pid)) { + if (!ConvertFromJsValue(env, argv[0], pid)) { HILOG_ERROR("get pid failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [pid, appManager = appManager_](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [pid, appManager = appManager_](napi_env env, NapiAsyncTask &task, int32_t status) { if (appManager == nullptr) { HILOG_WARN("appManager is nullptr"); - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } int32_t memSize = 0; int32_t ret = appManager->GetProcessMemoryByPid(pid, memSize); if (ret == 0) { - task.ResolveWithNoError(engine, CreateJsValue(engine, memSize)); + task.ResolveWithNoError(env, CreateJsValue(env, memSize)); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, ret)); + task.Reject(env, CreateJsErrorByNativeErr(env, ret)); } }; - NativeValue* lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnGetProcessMemoryByPid", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc == ARGC_TWO) ? argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnGetProcessMemoryByPid", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetRunningProcessInfoByBundleName(NativeEngine& engine, const NativeCallbackInfo& info) + napi_value OnGetRunningProcessInfoByBundleName(napi_env env, size_t argc, napi_value* argv) { - if (info.argc < ARGC_ONE) { - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + if (argc < ARGC_ONE) { + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string bundleName; int userId = IPCSkeleton::GetCallingUid() / AppExecFwk::Constants::BASE_USER_RANGE; bool isPromiseType = false; - if (!ConvertFromJsValue(engine, info.argv[0], bundleName)) { + if (!ConvertFromJsValue(env, argv[0], bundleName)) { HILOG_ERROR("First parameter must be string"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - if (info.argc == ARGC_ONE) { + if (argc == ARGC_ONE) { isPromiseType = true; - } else if (info.argc == ARGC_TWO) { - if (ConvertFromJsValue(engine, info.argv[1], userId)) { + } else if (argc == ARGC_TWO) { + if (ConvertFromJsValue(env, argv[1], userId)) { isPromiseType = true; } - } else if (info.argc == ARGC_THREE) { - if (!ConvertFromJsValue(engine, info.argv[1], userId)) { + } else if (argc == ARGC_THREE) { + if (!ConvertFromJsValue(env, argv[1], userId)) { HILOG_WARN("Must input userid and use callback when argc is three."); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } } else { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [bundleName, userId, appManager = appManager_](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [bundleName, userId, appManager = appManager_](napi_env env, NapiAsyncTask &task, int32_t status) { if (appManager == nullptr) { - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_INNER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER)); return; } std::vector infos; int32_t ret = appManager->GetRunningProcessInformation(bundleName, userId, infos); if (ret == 0) { - task.ResolveWithNoError(engine, CreateJsRunningProcessInfoArray(engine, infos)); + task.ResolveWithNoError(env, CreateJsRunningProcessInfoArray(env, infos)); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, ret)); + task.Reject(env, CreateJsErrorByNativeErr(env, ret)); } }; - NativeValue* lastParam = isPromiseType ? nullptr : info.argv[info.argc - 1]; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("JSAppManager::OnGetRunningProcessInfoByBundleName", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = isPromiseType ? nullptr : argv[argc - 1]; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JSAppManager::OnGetRunningProcessInfoByBundleName", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - bool CheckOnOffType(NativeEngine& engine, const NativeCallbackInfo& info) + bool CheckOnOffType(napi_env env, size_t argc, napi_value* argv) { - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { return false; } - if (info.argv[0]->TypeOf() != NATIVE_STRING) { + if (!AppExecFwk::IsTypeForNapiValue(env, argv[0], napi_string)) { HILOG_ERROR("Param 0 is not string"); return false; } std::string type; - if (!ConvertFromJsValue(engine, info.argv[0], type)) { + if (!ConvertFromJsValue(env, argv[0], type)) { HILOG_ERROR("Parse on off type failed"); return false; } @@ -749,10 +733,10 @@ private: return true; } - std::string ParseParamType(NativeEngine& engine, const NativeCallbackInfo& info) + std::string ParseParamType(napi_env env, size_t argc, napi_value* argv) { std::string type; - if (info.argc > INDEX_ZERO && ConvertFromJsValue(engine, info.argv[INDEX_ZERO], type)) { + if (argc > INDEX_ZERO && ConvertFromJsValue(env, argv[INDEX_ZERO], type)) { return type; } return ""; @@ -777,58 +761,52 @@ OHOS::sptr GetAbilityManagerInstance() return OHOS::iface_cast(abilityObject); } -NativeValue* JsAppManagerInit(NativeEngine* engine, NativeValue* exportObj) +napi_value JsAppManagerInit(napi_env env, napi_value exportObj) { HILOG_DEBUG("called"); - if (engine == nullptr || exportObj == nullptr) { - HILOG_WARN("engine or exportObj null"); + if (env == nullptr || exportObj == nullptr) { + HILOG_WARN("env or exportObj null"); return nullptr; } - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_WARN("object null"); - return nullptr; - } - - std::unique_ptr jsAppManager = - std::make_unique(GetAppManagerInstance(), GetAbilityManagerInstance()); - object->SetNativePointer(jsAppManager.release(), JsAppManager::Finalizer, nullptr); + std::unique_ptr jsAppManager = std::make_unique( + GetAppManagerInstance(), GetAbilityManagerInstance()); + napi_wrap(env, exportObj, jsAppManager.release(), JsAppManager::Finalizer, nullptr, nullptr); - object->SetProperty("ApplicationState", ApplicationStateInit(engine)); - object->SetProperty("ProcessState", ProcessStateInit(engine)); + napi_set_named_property(env, exportObj, "ApplicationState", ApplicationStateInit(env)); + napi_set_named_property(env, exportObj, "ProcessState", ProcessStateInit(env)); const char *moduleName = "AppManager"; - BindNativeFunction(*engine, *object, "on", moduleName, JsAppManager::On); - BindNativeFunction(*engine, *object, "off", moduleName, JsAppManager::Off); - BindNativeFunction(*engine, *object, "getForegroundApplications", moduleName, + BindNativeFunction(env, exportObj, "on", moduleName, JsAppManager::On); + BindNativeFunction(env, exportObj, "off", moduleName, JsAppManager::Off); + BindNativeFunction(env, exportObj, "getForegroundApplications", moduleName, JsAppManager::GetForegroundApplications); - BindNativeFunction(*engine, *object, "getProcessRunningInfos", moduleName, + BindNativeFunction(env, exportObj, "getProcessRunningInfos", moduleName, JsAppManager::GetRunningProcessInformation); - BindNativeFunction(*engine, *object, "getProcessRunningInformation", moduleName, + BindNativeFunction(env, exportObj, "getProcessRunningInformation", moduleName, JsAppManager::GetRunningProcessInformation); - BindNativeFunction(*engine, *object, "getRunningProcessInformation", moduleName, + BindNativeFunction(env, exportObj, "getRunningProcessInformation", moduleName, JsAppManager::GetRunningProcessInformation); - BindNativeFunction(*engine, *object, "isRunningInStabilityTest", moduleName, + BindNativeFunction(env, exportObj, "isRunningInStabilityTest", moduleName, JsAppManager::IsRunningInStabilityTest); - BindNativeFunction(*engine, *object, "killProcessWithAccount", moduleName, + BindNativeFunction(env, exportObj, "killProcessWithAccount", moduleName, JsAppManager::KillProcessWithAccount); - BindNativeFunction(*engine, *object, "killProcessesByBundleName", moduleName, + BindNativeFunction(env, exportObj, "killProcessesByBundleName", moduleName, JsAppManager::KillProcessesByBundleName); - BindNativeFunction(*engine, *object, "clearUpApplicationData", moduleName, + BindNativeFunction(env, exportObj, "clearUpApplicationData", moduleName, JsAppManager::ClearUpApplicationData); - BindNativeFunction(*engine, *object, "getAppMemorySize", moduleName, + BindNativeFunction(env, exportObj, "getAppMemorySize", moduleName, JsAppManager::GetAppMemorySize); - BindNativeFunction(*engine, *object, "isRamConstrainedDevice", moduleName, + BindNativeFunction(env, exportObj, "isRamConstrainedDevice", moduleName, JsAppManager::IsRamConstrainedDevice); - BindNativeFunction(*engine, *object, "isSharedBundleRunning", moduleName, + BindNativeFunction(env, exportObj, "isSharedBundleRunning", moduleName, JsAppManager::IsSharedBundleRunning); - BindNativeFunction(*engine, *object, "getProcessMemoryByPid", moduleName, + BindNativeFunction(env, exportObj, "getProcessMemoryByPid", moduleName, JsAppManager::GetProcessMemoryByPid); - BindNativeFunction(*engine, *object, "getRunningProcessInfoByBundleName", moduleName, + BindNativeFunction(env, exportObj, "getRunningProcessInfoByBundleName", moduleName, JsAppManager::GetRunningProcessInfoByBundleName); HILOG_DEBUG("end"); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/app/js_app_manager/js_app_manager.h b/frameworks/js/napi/app/js_app_manager/js_app_manager.h index fc709edc4402a066289d9d13ebbf706bafc28847..de3d24faebb625afb87ab91bc33a37cc1ee1dbb6 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_manager.h +++ b/frameworks/js/napi/app/js_app_manager/js_app_manager.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* JsAppManagerInit(NativeEngine* engine, NativeValue* exportObj); +napi_value JsAppManagerInit(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_APP_MANAGER_H diff --git a/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.cpp b/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.cpp index 37b8d12e8add75f86bd4a1f191fdd59ca2ece6ef..1e40c41e8fa459c2b2ef39253ddf1fb84c44c606 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.cpp +++ b/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.cpp @@ -24,176 +24,156 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsAppStateData(NativeEngine &engine, const AppStateData &appStateData) +napi_value CreateJsAppStateData(napi_env env, const AppStateData &appStateData) { - HILOG_INFO("%{public}s called.", __func__); - NativeValue* objValue = engine.CreateObject(); - if (objValue == nullptr) { - HILOG_ERROR("objValue nullptr."); - return nullptr; - } - HILOG_INFO("%{public}s ConvertNativeValueTo begin.", __func__); - NativeObject* object = ConvertNativeValueTo(objValue); + HILOG_DEBUG("called."); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - HILOG_ERROR("object nullptr."); + HILOG_ERROR("objValue nullptr."); return nullptr; } - HILOG_INFO("%{public}s SetProperty begin.", __func__); - object->SetProperty("bundleName", CreateJsValue(engine, appStateData.bundleName)); - object->SetProperty("uid", CreateJsValue(engine, appStateData.uid)); - object->SetProperty("state", CreateJsValue(engine, appStateData.state)); - HILOG_INFO("%{public}s end.", __func__); - return objValue; + napi_set_named_property(env, object, "bundleName", CreateJsValue(env, appStateData.bundleName)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, appStateData.uid)); + napi_set_named_property(env, object, "state", CreateJsValue(env, appStateData.state)); + HILOG_DEBUG("end."); + return object; } -NativeValue* CreateJsAbilityStateData(NativeEngine &engine, const AbilityStateData &abilityStateData) +napi_value CreateJsAbilityStateData(napi_env env, const AbilityStateData &abilityStateData) { - HILOG_INFO("%{public}s called.", __func__); - NativeValue* objValue = engine.CreateObject(); - if (objValue == nullptr) { - HILOG_ERROR("objValue nullptr."); - return nullptr; - } - HILOG_INFO("%{public}s ConvertNativeValueTo begin.", __func__); - NativeObject* object = ConvertNativeValueTo(objValue); + HILOG_DEBUG("called."); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - HILOG_ERROR("object nullptr."); + HILOG_ERROR("objValue nullptr."); return nullptr; } - HILOG_INFO("%{public}s SetProperty begin.", __func__); - object->SetProperty("bundleName", CreateJsValue(engine, abilityStateData.bundleName)); - object->SetProperty("moduleName", CreateJsValue(engine, abilityStateData.moduleName)); - object->SetProperty("abilityName", CreateJsValue(engine, abilityStateData.abilityName)); - object->SetProperty("pid", CreateJsValue(engine, abilityStateData.pid)); - object->SetProperty("uid", CreateJsValue(engine, abilityStateData.uid)); - object->SetProperty("state", CreateJsValue(engine, abilityStateData.abilityState)); - object->SetProperty("abilityType", CreateJsValue(engine, abilityStateData.abilityType)); - HILOG_INFO("%{public}s end.", __func__); - return objValue; + napi_set_named_property(env, object, "bundleName", CreateJsValue(env, abilityStateData.bundleName)); + napi_set_named_property(env, object, "moduleName", CreateJsValue(env, abilityStateData.moduleName)); + napi_set_named_property(env, object, "abilityName", CreateJsValue(env, abilityStateData.abilityName)); + napi_set_named_property(env, object, "pid", CreateJsValue(env, abilityStateData.pid)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, abilityStateData.uid)); + napi_set_named_property(env, object, "state", CreateJsValue(env, abilityStateData.abilityState)); + napi_set_named_property(env, object, "abilityType", CreateJsValue(env, abilityStateData.abilityType)); + HILOG_DEBUG("end."); + return object; } -NativeValue* CreateJsProcessData(NativeEngine &engine, const ProcessData &processData) +napi_value CreateJsProcessData(napi_env env, const ProcessData &processData) { - HILOG_INFO("%{public}s called.", __func__); - NativeValue* objValue = engine.CreateObject(); - if (objValue == nullptr) { - HILOG_ERROR("objValue nullptr."); - return nullptr; - } - HILOG_INFO("%{public}s ConvertNativeValueTo begin.", __func__); - NativeObject* object = ConvertNativeValueTo(objValue); + HILOG_DEBUG("called."); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - HILOG_ERROR("object nullptr."); + HILOG_ERROR("objValue nullptr."); return nullptr; } - HILOG_INFO("%{public}s SetProperty begin.", __func__); - object->SetProperty("bundleName", CreateJsValue(engine, processData.bundleName)); - object->SetProperty("pid", CreateJsValue(engine, processData.pid)); - object->SetProperty("uid", CreateJsValue(engine, processData.uid)); - object->SetProperty("state", CreateJsValue(engine, processData.state)); - object->SetProperty("isContinuousTask", CreateJsValue(engine, processData.isContinuousTask)); - object->SetProperty("isKeepAlive", CreateJsValue(engine, processData.isKeepAlive)); - HILOG_INFO("%{public}s end.", __func__); - return objValue; + napi_set_named_property(env, object, "bundleName", CreateJsValue(env, processData.bundleName)); + napi_set_named_property(env, object, "pid", CreateJsValue(env, processData.pid)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, processData.uid)); + napi_set_named_property(env, object, "state", CreateJsValue(env, processData.state)); + napi_set_named_property(env, object, "isContinuousTask", CreateJsValue(env, processData.isContinuousTask)); + napi_set_named_property(env, object, "isKeepAlive", CreateJsValue(env, processData.isKeepAlive)); + HILOG_DEBUG("end."); + return object; } -NativeValue* CreateJsAppStateDataArray(NativeEngine &engine, const std::vector &appStateDatas) +napi_value CreateJsAppStateDataArray(napi_env env, const std::vector &appStateDatas) { - HILOG_INFO("%{public}s called.", __func__); - NativeValue* arrayValue = engine.CreateArray(appStateDatas.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, appStateDatas.size(), &arrayValue); uint32_t index = 0; for (const auto &appStateData : appStateDatas) { - array->SetElement(index++, CreateJsAppStateData(engine, appStateData)); + napi_set_element(env, arrayValue, index++, CreateJsAppStateData(env, appStateData)); } - HILOG_INFO("%{public}s end.", __func__); return arrayValue; } -NativeValue* CreateJsRunningProcessInfoArray(NativeEngine &engine, const std::vector &infos) +napi_value CreateJsRunningProcessInfoArray(napi_env env, const std::vector &infos) { - NativeValue* arrayValue = engine.CreateArray(infos.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, infos.size(), &arrayValue); uint32_t index = 0; for (const auto &runningInfo : infos) { - array->SetElement(index++, CreateJsRunningProcessInfo(engine, runningInfo)); + napi_set_element(env, arrayValue, index++, CreateJsRunningProcessInfo(env, runningInfo)); } return arrayValue; } -NativeValue* CreateJsRunningProcessInfo(NativeEngine &engine, const RunningProcessInfo &info) +napi_value CreateJsRunningProcessInfo(napi_env env, const RunningProcessInfo &info) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - - object->SetProperty("processName", CreateJsValue(engine, info.processName_)); - object->SetProperty("pid", CreateJsValue(engine, info.pid_)); - object->SetProperty("uid", CreateJsValue(engine, info.uid_)); - object->SetProperty("bundleNames", CreateNativeArray(engine, info.bundleNames)); - object->SetProperty("state", CreateJsValue(engine, info.state_)); - return objValue; + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { + HILOG_ERROR("objValue nullptr."); + return nullptr; + } + + napi_set_named_property(env, object, "processName", CreateJsValue(env, info.processName_)); + napi_set_named_property(env, object, "pid", CreateJsValue(env, info.pid_)); + napi_set_named_property(env, object, "uid", CreateJsValue(env, info.uid_)); + napi_set_named_property(env, object, "bundleNames", CreateNativeArray(env, info.bundleNames)); + napi_set_named_property(env, object, "state", CreateJsValue(env, info.state_)); + return object; } -NativeValue *ApplicationStateInit(NativeEngine *engine) +napi_value ApplicationStateInit(napi_env env) { - HILOG_INFO("enter"); + HILOG_DEBUG("enter"); - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("Invalid input parameters"); return nullptr; } - NativeValue *objValue = engine->CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } - object->SetProperty("STATE_CREATE", - CreateJsValue(*engine, static_cast(AppExecFwk::ApplicationState::APP_STATE_CREATE))); - object->SetProperty("STATE_FOREGROUND", - CreateJsValue(*engine, static_cast(AppExecFwk::ApplicationState::APP_STATE_FOREGROUND))); - object->SetProperty("STATE_ACTIVE", - CreateJsValue(*engine, static_cast(AppExecFwk::ApplicationState::APP_STATE_FOCUS))); - object->SetProperty("STATE_BACKGROUND", - CreateJsValue(*engine, static_cast(AppExecFwk::ApplicationState::APP_STATE_BACKGROUND))); - object->SetProperty("STATE_DESTROY", - CreateJsValue(*engine, static_cast(AppExecFwk::ApplicationState::APP_STATE_TERMINATED))); - - return objValue; + napi_set_named_property(env, object, "STATE_FOREGROUND", + CreateJsValue(env, static_cast(AppExecFwk::ApplicationState::APP_STATE_CREATE))); + napi_set_named_property(env, object, "STATE_FOREGROUND", + CreateJsValue(env, static_cast(AppExecFwk::ApplicationState::APP_STATE_FOREGROUND))); + napi_set_named_property(env, object, "STATE_ACTIVE", + CreateJsValue(env, static_cast(AppExecFwk::ApplicationState::APP_STATE_FOCUS))); + napi_set_named_property(env, object, "STATE_BACKGROUND", + CreateJsValue(env, static_cast(AppExecFwk::ApplicationState::APP_STATE_BACKGROUND))); + napi_set_named_property(env, object, "STATE_DESTROY", + CreateJsValue(env, static_cast(AppExecFwk::ApplicationState::APP_STATE_TERMINATED))); + + return object; } -NativeValue *ProcessStateInit(NativeEngine *engine) +napi_value ProcessStateInit(napi_env env) { - HILOG_INFO("enter"); + HILOG_DEBUG("enter"); - if (engine == nullptr) { + if (env == nullptr) { HILOG_ERROR("Invalid input parameters"); return nullptr; } - NativeValue *objValue = engine->CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { HILOG_ERROR("Failed to get object"); return nullptr; } - - object->SetProperty("STATE_CREATE", - CreateJsValue(*engine, static_cast(AppExecFwk::AppProcessState::APP_STATE_CREATE))); - object->SetProperty("STATE_FOREGROUND", - CreateJsValue(*engine, static_cast(AppExecFwk::AppProcessState::APP_STATE_FOREGROUND))); - object->SetProperty("STATE_ACTIVE", - CreateJsValue(*engine, static_cast(AppExecFwk::AppProcessState::APP_STATE_FOCUS))); - object->SetProperty("STATE_BACKGROUND", - CreateJsValue(*engine, static_cast(AppExecFwk::AppProcessState::APP_STATE_BACKGROUND))); - object->SetProperty("STATE_DESTROY", - CreateJsValue(*engine, static_cast(AppExecFwk::AppProcessState::APP_STATE_TERMINATED))); - - return objValue; + napi_set_named_property(env, object, "STATE_CREATE", + CreateJsValue(env, static_cast(AppExecFwk::AppProcessState::APP_STATE_CREATE))); + napi_set_named_property(env, object, "STATE_FOREGROUND", + CreateJsValue(env, static_cast(AppExecFwk::AppProcessState::APP_STATE_FOREGROUND))); + napi_set_named_property(env, object, "STATE_ACTIVE", + CreateJsValue(env, static_cast(AppExecFwk::AppProcessState::APP_STATE_FOCUS))); + napi_set_named_property(env, object, "STATE_BACKGROUND", + CreateJsValue(env, static_cast(AppExecFwk::AppProcessState::APP_STATE_BACKGROUND))); + napi_set_named_property(env, object, "STATE_DESTROY", + CreateJsValue(env, static_cast(AppExecFwk::AppProcessState::APP_STATE_TERMINATED))); + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.h b/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.h index dcba5e08983428e8c28c0c289046e566af3171fb..43b2210bab7a636da31a887b56e54d6634198281 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.h +++ b/frameworks/js/napi/app/js_app_manager/js_app_manager_utils.h @@ -26,14 +26,14 @@ using OHOS::AppExecFwk::AppStateData; using OHOS::AppExecFwk::AbilityStateData; using OHOS::AppExecFwk::ProcessData; using OHOS::AppExecFwk::RunningProcessInfo; -NativeValue* CreateJsAppStateData(NativeEngine &engine, const AppStateData &appStateData); -NativeValue* CreateJsAbilityStateData(NativeEngine &engine, const AbilityStateData &abilityStateData); -NativeValue* CreateJsProcessData(NativeEngine &engine, const ProcessData &processData); -NativeValue* CreateJsAppStateDataArray(NativeEngine &engine, const std::vector &appStateDatas); -NativeValue* CreateJsRunningProcessInfoArray(NativeEngine &engine, const std::vector &infos); -NativeValue* CreateJsRunningProcessInfo(NativeEngine &engine, const RunningProcessInfo &info); -NativeValue *ApplicationStateInit(NativeEngine *engine); -NativeValue *ProcessStateInit(NativeEngine *engine); +napi_value CreateJsAppStateData(napi_env env, const AppStateData &appStateData); +napi_value CreateJsAbilityStateData(napi_env env, const AbilityStateData &abilityStateData); +napi_value CreateJsProcessData(napi_env env, const ProcessData &processData); +napi_value CreateJsAppStateDataArray(napi_env env, const std::vector &appStateDatas); +napi_value CreateJsRunningProcessInfoArray(napi_env env, const std::vector &infos); +napi_value CreateJsRunningProcessInfo(napi_env env, const RunningProcessInfo &info); +napi_value ApplicationStateInit(napi_env env); +napi_value ProcessStateInit(napi_env env); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_JS_APP_MANAGER_UTILS_H diff --git a/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp b/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp index 920c4f8d7a66b6bdf95f5b02c1b63e36b0663ef6..63bbaf839b069dc7f6dc2e7a8ca2645416624657 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp +++ b/frameworks/js/napi/app/js_app_manager/js_app_state_observer.cpp @@ -22,7 +22,7 @@ namespace OHOS { namespace AbilityRuntime { constexpr size_t ARGC_ONE = 1; -JSAppStateObserver::JSAppStateObserver(NativeEngine& engine) : engine_(engine) {} +JSAppStateObserver::JSAppStateObserver(napi_env env) : env_(env) {} JSAppStateObserver::~JSAppStateObserver() = default; @@ -35,8 +35,8 @@ void JSAppStateObserver::OnForegroundApplicationChanged(const AppStateData &appS return; } wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, appStateData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, appStateData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -44,10 +44,10 @@ void JSAppStateObserver::OnForegroundApplicationChanged(const AppStateData &appS } jsObserverSptr->HandleOnForegroundApplicationChanged(appStateData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnForegroundApplicationChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnForegroundApplicationChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnForegroundApplicationChanged(const AppStateData &appStateData) @@ -56,9 +56,9 @@ void JSAppStateObserver::HandleOnForegroundApplicationChanged(const AppStateData appStateData.bundleName.c_str(), appStateData.uid, appStateData.state); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsAppStateData(engine_, appStateData)}; - CallJsFunction(value, "onForegroundApplicationChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsAppStateData(env_, appStateData)}; + CallJsFunction(obj, "onForegroundApplicationChanged", argv, ARGC_ONE); } } @@ -70,8 +70,8 @@ void JSAppStateObserver::OnAbilityStateChanged(const AbilityStateData &abilitySt return; } wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, abilityStateData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, abilityStateData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -79,10 +79,10 @@ void JSAppStateObserver::OnAbilityStateChanged(const AbilityStateData &abilitySt } jsObserverSptr->HandleOnAbilityStateChanged(abilityStateData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnAbilityStateChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnAbilityStateChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnAbilityStateChanged(const AbilityStateData &abilityStateData) @@ -90,9 +90,9 @@ void JSAppStateObserver::HandleOnAbilityStateChanged(const AbilityStateData &abi HILOG_INFO("HandleOnAbilityStateChanged begin"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsAbilityStateData(engine_, abilityStateData)}; - CallJsFunction(value, "onAbilityStateChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsAbilityStateData(env_, abilityStateData)}; + CallJsFunction(obj, "onAbilityStateChanged", argv, ARGC_ONE); } } @@ -104,8 +104,8 @@ void JSAppStateObserver::OnExtensionStateChanged(const AbilityStateData &ability return; } wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, abilityStateData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, abilityStateData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -113,10 +113,10 @@ void JSAppStateObserver::OnExtensionStateChanged(const AbilityStateData &ability } jsObserverSptr->HandleOnExtensionStateChanged(abilityStateData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnExtensionStateChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnExtensionStateChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnExtensionStateChanged(const AbilityStateData &abilityStateData) @@ -124,9 +124,9 @@ void JSAppStateObserver::HandleOnExtensionStateChanged(const AbilityStateData &a HILOG_INFO("HandleOnExtensionStateChanged begin"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsAbilityStateData(engine_, abilityStateData)}; - CallJsFunction(value, "onAbilityStateChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsAbilityStateData(env_, abilityStateData)}; + CallJsFunction(obj, "onAbilityStateChanged", argv, ARGC_ONE); } } @@ -138,8 +138,8 @@ void JSAppStateObserver::OnProcessCreated(const ProcessData &processData) return; } wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, processData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, processData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -147,10 +147,10 @@ void JSAppStateObserver::OnProcessCreated(const ProcessData &processData) } jsObserverSptr->HandleOnProcessCreated(processData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnProcessCreated(const ProcessData &processData) @@ -158,9 +158,9 @@ void JSAppStateObserver::HandleOnProcessCreated(const ProcessData &processData) HILOG_INFO("HandleOnProcessCreated begin"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsProcessData(engine_, processData)}; - CallJsFunction(value, "onProcessCreated", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsProcessData(env_, processData)}; + CallJsFunction(obj, "onProcessCreated", argv, ARGC_ONE); } } @@ -172,8 +172,8 @@ void JSAppStateObserver::OnProcessStateChanged(const ProcessData &processData) return; } wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, processData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, processData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -181,10 +181,10 @@ void JSAppStateObserver::OnProcessStateChanged(const ProcessData &processData) } jsObserverSptr->HandleOnProcessStateChanged(processData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnProcessStateChanged", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnProcessStateChanged", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnProcessStateChanged(const ProcessData &processData) @@ -192,9 +192,9 @@ void JSAppStateObserver::HandleOnProcessStateChanged(const ProcessData &processD HILOG_INFO("HandleOnProcessStateChanged begin"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsProcessData(engine_, processData)}; - CallJsFunction(value, "onProcessStateChanged", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsProcessData(env_, processData)}; + CallJsFunction(obj, "onProcessStateChanged", argv, ARGC_ONE); } } @@ -206,8 +206,8 @@ void JSAppStateObserver::OnProcessDied(const ProcessData &processData) return; } wptr jsObserver = this; - std::unique_ptr complete = std::make_unique - ([jsObserver, processData](NativeEngine &engine, AsyncTask &task, int32_t status) { + std::unique_ptr complete = std::make_unique + ([jsObserver, processData](napi_env env, NapiAsyncTask &task, int32_t status) { sptr jsObserverSptr = jsObserver.promote(); if (!jsObserverSptr) { HILOG_WARN("jsObserverSptr nullptr"); @@ -215,10 +215,10 @@ void JSAppStateObserver::OnProcessDied(const ProcessData &processData) } jsObserverSptr->HandleOnProcessDied(processData); }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", - engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JSAppStateObserver::OnProcessCreated", + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JSAppStateObserver::HandleOnProcessDied(const ProcessData &processData) @@ -226,35 +226,37 @@ void JSAppStateObserver::HandleOnProcessDied(const ProcessData &processData) HILOG_INFO("HandleOnProcessDied begin"); auto tmpMap = jsObserverObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = {CreateJsProcessData(engine_, processData)}; - CallJsFunction(value, "onProcessDied", argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = {CreateJsProcessData(env_, processData)}; + CallJsFunction(obj, "onProcessDied", argv, ARGC_ONE); } } void JSAppStateObserver::CallJsFunction( - NativeValue* value, const char *methodName, NativeValue *const *argv, size_t argc) + napi_value value, const char *methodName, napi_value* argv, size_t argc) { HILOG_INFO("CallJsFunction begin, method:%{public}s", methodName); - NativeObject* obj = ConvertNativeValueTo(value); - if (obj == nullptr) { + if (value == nullptr) { HILOG_ERROR("Failed to get object"); return; } - NativeValue* method = obj->GetProperty(methodName); + napi_value method = nullptr; + napi_get_named_property(env_, value, methodName, &method); if (method == nullptr) { HILOG_ERROR("Failed to get from object"); return; } - engine_.CallFunction(value, method, argv, argc); + napi_value callResult = nullptr; + napi_call_function(env_, nullptr, method, argc, argv, &callResult); HILOG_INFO("CallJsFunction end"); } -void JSAppStateObserver::AddJsObserverObject(const int32_t observerId, NativeValue* jsObserverObject) +void JSAppStateObserver::AddJsObserverObject(const int32_t observerId, napi_value jsObserverObject) { - jsObserverObjectMap_.emplace( - observerId, std::shared_ptr(engine_.CreateReference(jsObserverObject, 1))); + napi_ref ref = nullptr; + napi_create_reference(env_, jsObserverObject, 1, &ref); + jsObserverObjectMap_.emplace(observerId, std::shared_ptr(reinterpret_cast(ref))); } bool JSAppStateObserver::RemoveJsObserverObject(const int32_t observerId) diff --git a/frameworks/js/napi/app/js_app_manager/js_app_state_observer.h b/frameworks/js/napi/app/js_app_manager/js_app_state_observer.h index cb1ba9bd311514ba84e1029d5e1a801bc9671b26..fc44044a8a1bbe4c604d6d9986375c44697728ad 100644 --- a/frameworks/js/napi/app/js_app_manager/js_app_state_observer.h +++ b/frameworks/js/napi/app/js_app_manager/js_app_state_observer.h @@ -28,7 +28,7 @@ using OHOS::AppExecFwk::AbilityStateData; using OHOS::AppExecFwk::ProcessData; class JSAppStateObserver : public ApplicationStateObserverStub { public: - explicit JSAppStateObserver(NativeEngine& engine); + explicit JSAppStateObserver(napi_env engine); ~JSAppStateObserver(); void OnForegroundApplicationChanged(const AppStateData &appStateData) override; void OnAbilityStateChanged(const AbilityStateData &abilityStateData) override; @@ -42,15 +42,15 @@ public: void HandleOnProcessCreated(const ProcessData &processData); void HandleOnProcessStateChanged(const ProcessData &processData); void HandleOnProcessDied(const ProcessData &processData); - void CallJsFunction(NativeValue* value, const char *methodName, NativeValue *const *argv, size_t argc); - void AddJsObserverObject(const int32_t observerId, NativeValue* jsObserverObject); + void CallJsFunction(napi_value value, const char *methodName, napi_value* argv, size_t argc); + void AddJsObserverObject(const int32_t observerId, napi_value jsObserverObject); bool RemoveJsObserverObject(const int32_t observerId); bool FindObserverByObserverId(const int32_t observerId); size_t GetJsObserverMapSize(); void SetValid(const bool valid); private: - NativeEngine& engine_; + napi_env env_; volatile bool valid_ = true; std::map> jsObserverObjectMap_; }; diff --git a/frameworks/js/napi/js_mission_manager/js_mission_info_utils.cpp b/frameworks/js/napi/js_mission_manager/js_mission_info_utils.cpp index 0def00b06fe310983d320d4318d6769c82bfb82f..f43fd68d76202a72fa4cf8d00567cf2d3286b4f4 100755 --- a/frameworks/js/napi/js_mission_manager/js_mission_info_utils.cpp +++ b/frameworks/js/napi/js_mission_manager/js_mission_info_utils.cpp @@ -32,139 +32,141 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsMissionInfo(NativeEngine &engine, const AAFwk::MissionInfo &missionInfo) +napi_value CreateJsMissionInfo(napi_env env, const AAFwk::MissionInfo &missionInfo) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - object->SetProperty("missionId", CreateJsValue(engine, missionInfo.id)); - object->SetProperty("runningState", CreateJsValue(engine, missionInfo.runningState)); - object->SetProperty("lockedState", CreateJsValue(engine, missionInfo.lockedState)); - object->SetProperty("continuable", CreateJsValue(engine, missionInfo.continuable)); - object->SetProperty("timestamp", CreateJsValue(engine, missionInfo.time)); - object->SetProperty("want", CreateJsWant(engine, missionInfo.want)); - object->SetProperty("label", CreateJsValue(engine, missionInfo.label)); - object->SetProperty("iconPath", CreateJsValue(engine, missionInfo.iconPath)); - object->SetProperty("abilityState", CreateJsValue(engine, missionInfo.abilityState)); - object->SetProperty("unclearable", CreateJsValue(engine, missionInfo.unclearable)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + + napi_set_named_property(env, objValue, "missionId", CreateJsValue(env, missionInfo.id)); + napi_set_named_property(env, objValue, "runningState", CreateJsValue(env, missionInfo.runningState)); + napi_set_named_property(env, objValue, "lockedState", CreateJsValue(env, missionInfo.lockedState)); + napi_set_named_property(env, objValue, "continuable", CreateJsValue(env, missionInfo.continuable)); + napi_set_named_property(env, objValue, "timestamp", CreateJsValue(env, missionInfo.time)); + napi_set_named_property(env, objValue, "want", CreateJsWant(env, missionInfo.want)); + napi_set_named_property(env, objValue, "label", CreateJsValue(env, missionInfo.label)); + napi_set_named_property(env, objValue, "iconPath", CreateJsValue(env, missionInfo.iconPath)); + napi_set_named_property(env, objValue, "abilityState", CreateJsValue(env, missionInfo.abilityState)); + napi_set_named_property(env, objValue, "unclearable", CreateJsValue(env, missionInfo.unclearable)); return objValue; } -NativeValue* CreateJsWant(NativeEngine &engine, const AAFwk::Want &want) +napi_value CreateJsWant(napi_env env, const AAFwk::Want &want) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - object->SetProperty("deviceId", CreateJsValue(engine, want.GetElement().GetDeviceID())); - object->SetProperty("bundleName", CreateJsValue(engine, want.GetElement().GetBundleName())); - object->SetProperty("abilityName", CreateJsValue(engine, want.GetElement().GetAbilityName())); - object->SetProperty("uri", CreateJsValue(engine, want.GetUriString())); - object->SetProperty("type", CreateJsValue(engine, want.GetType())); - object->SetProperty("flags", CreateJsValue(engine, want.GetFlags())); - object->SetProperty("action", CreateJsValue(engine, want.GetAction())); - object->SetProperty("parameters", CreateJsWantParams(engine, want.GetParams())); - object->SetProperty("entities", CreateNativeArray(engine, want.GetEntities())); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + + napi_set_named_property(env, objValue, "deviceId", CreateJsValue(env, want.GetElement().GetDeviceID())); + napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, want.GetElement().GetBundleName())); + napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, want.GetElement().GetAbilityName())); + napi_set_named_property(env, objValue, "uri", CreateJsValue(env, want.GetUriString())); + napi_set_named_property(env, objValue, "type", CreateJsValue(env, want.GetType())); + napi_set_named_property(env, objValue, "flags", CreateJsValue(env, want.GetFlags())); + napi_set_named_property(env, objValue, "action", CreateJsValue(env, want.GetAction())); + napi_set_named_property(env, objValue, "parameters", CreateJsWantParams(env, want.GetParams())); + napi_set_named_property(env, objValue, "entities", CreateNativeArray(env, want.GetEntities())); return objValue; } -NativeValue* CreateJsWantParams(NativeEngine &engine, const AAFwk::WantParams &wantParams) +napi_value CreateJsWantParams(napi_env env, const AAFwk::WantParams &wantParams) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); const std::map> paramList = wantParams.GetParams(); for (auto iter = paramList.begin(); iter != paramList.end(); iter++) { if (AAFwk::IString::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IBoolean::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IShort::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IInteger::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::ILong::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IFloat::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IDouble::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IChar::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IByte::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IArray::Query(iter->second) != nullptr) { AAFwk::IArray *ao = AAFwk::IArray::Query(iter->second); if (ao != nullptr) { sptr array(ao); - WrapJsWantParamsArray(engine, object, iter->first, array); + WrapJsWantParamsArray(env, object, iter->first, array); } } else if (AAFwk::IWantParams::Query(iter->second) != nullptr) { - InnerWrapJsWantParamsWantParams(engine, object, iter->first, wantParams); + InnerWrapJsWantParamsWantParams(env, object, iter->first, wantParams); } } - return objValue; + return object; } -NativeValue* CreateJsMissionInfoArray(NativeEngine &engine, const std::vector &missionInfos) +napi_value CreateJsMissionInfoArray(napi_env env, const std::vector &missionInfos) { - NativeValue* arrayValue = engine.CreateArray(missionInfos.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, missionInfos.size(), &arrayValue); uint32_t index = 0; for (const auto &missionInfo : missionInfos) { - array->SetElement(index++, CreateJsMissionInfo(engine, missionInfo)); + napi_set_element(env, arrayValue, index++, CreateJsMissionInfo(env, missionInfo)); } return arrayValue; } bool InnerWrapJsWantParamsWantParams( - NativeEngine &engine, NativeObject* object, const std::string &key, const AAFwk::WantParams &wantParams) + napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams) { auto value = wantParams.GetParam(key); AAFwk::IWantParams *o = AAFwk::IWantParams::Query(value); if (o != nullptr) { AAFwk::WantParams wp = AAFwk::WantParamWrapper::Unbox(o); - object->SetProperty(key.c_str(), CreateJsWantParams(engine, wp)); + napi_set_named_property(env, object, key.c_str(), CreateJsWantParams(env, wp)); return true; } return false; } -bool WrapJsWantParamsArray(NativeEngine &engine, NativeObject* object, const std::string &key, sptr &ao) +bool WrapJsWantParamsArray(napi_env env, napi_value object, const std::string &key, sptr &ao) { - HILOG_INFO("%{public}s called. key=%{public}s", __func__, key.c_str()); + HILOG_INFO("called. key=%{public}s", key.c_str()); if (AAFwk::Array::IsStringArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsBooleanArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsShortArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsIntegerArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsLongArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsFloatArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsByteArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsCharArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsDoubleArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else { return false; } diff --git a/frameworks/js/napi/js_mission_manager/js_mission_info_utils.h b/frameworks/js/napi/js_mission_manager/js_mission_info_utils.h index 3d28e9060fe5562a5685fbd421049d48619c0f07..e2022ef42471e55f7d82206e0e1a02d121c4e339 100755 --- a/frameworks/js/napi/js_mission_manager/js_mission_info_utils.h +++ b/frameworks/js/napi/js_mission_manager/js_mission_info_utils.h @@ -28,34 +28,34 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsMissionInfo(NativeEngine &engine, const AAFwk::MissionInfo &missionInfo); -NativeValue* CreateJsWant(NativeEngine &engine, const AAFwk::Want &want); -NativeValue* CreateJsWantParams(NativeEngine &engine, const AAFwk::WantParams &wantParams); -NativeValue* CreateJsMissionInfoArray(NativeEngine &engine, const std::vector &missionInfos); +napi_value CreateJsMissionInfo(napi_env env, const AAFwk::MissionInfo &missionInfo); +napi_value CreateJsWant(napi_env env, const AAFwk::Want &want); +napi_value CreateJsWantParams(napi_env env, const AAFwk::WantParams &wantParams); +napi_value CreateJsMissionInfoArray(napi_env env, const std::vector &missionInfos); template bool InnerWrapJsWantParams( - NativeEngine &engine, NativeObject* object, const std::string &key, const AAFwk::WantParams &wantParams) + napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams) { auto value = wantParams.GetParam(key); TBase *ao = TBase::Query(value); if (ao != nullptr) { NativeT natValue = T::Unbox(ao); - object->SetProperty(key.c_str(), CreateJsValue(engine, natValue)); + napi_set_named_property(env, object, key.c_str(), CreateJsValue(env, natValue)); return true; } return false; } bool InnerWrapJsWantParamsWantParams( - NativeEngine &engine, NativeObject* object, const std::string &key, const AAFwk::WantParams &wantParams); + napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams); bool WrapJsWantParamsArray( - NativeEngine &engine, NativeObject* object, const std::string &key, sptr &ao); + napi_env env, napi_value object, const std::string &key, sptr &ao); template bool InnerWrapWantParamsArray( - NativeEngine &engine, NativeObject* object, const std::string &key, sptr &ao) + napi_env env, napi_value object, const std::string &key, sptr &ao) { long size = 0; if (ao->GetLength(size) != ERR_OK) { @@ -71,7 +71,7 @@ bool InnerWrapWantParamsArray( } } } - object->SetProperty(key.c_str(), CreateNativeArray(engine, natArray)); + napi_set_named_property(env, object, key.c_str(), CreateNativeArray(env, natArray)); return true; } } // namespace AbilityRuntime diff --git a/frameworks/js/napi/js_mission_manager/js_mission_listener.cpp b/frameworks/js/napi/js_mission_manager/js_mission_listener.cpp index 35f9fee25bf1b9024258020e84a01b5fdaaaf494..6b714f2946f0791df619db287a6d47ac3e6f9392 100755 --- a/frameworks/js/napi/js_mission_manager/js_mission_listener.cpp +++ b/frameworks/js/napi/js_mission_manager/js_mission_listener.cpp @@ -15,6 +15,8 @@ #include "js_mission_listener.h" +#include + #include "hilog_wrapper.h" #include "js_runtime_utils.h" @@ -56,14 +58,17 @@ void JsMissionListener::OnMissionLabelUpdated(int32_t missionId) CallJsMethod("onMissionLabelUpdated", missionId); } -void JsMissionListener::AddJsListenerObject(int32_t listenerId, NativeValue* jsListenerObject, bool isSync) +void JsMissionListener::AddJsListenerObject(int32_t listenerId, napi_value jsListenerObject, bool isSync) { + napi_ref ref = nullptr; if (isSync) { + napi_create_reference(env_, jsListenerObject, 1, &ref); jsListenerObjectMapSync_.emplace( - listenerId, std::shared_ptr(engine_->CreateReference(jsListenerObject, 1))); + listenerId, std::shared_ptr(reinterpret_cast(ref))); } else { + napi_create_reference(env_, jsListenerObject, 1, &ref); jsListenerObjectMap_.emplace( - listenerId, std::shared_ptr(engine_->CreateReference(jsListenerObject, 1))); + listenerId, std::shared_ptr(reinterpret_cast(ref))); } } @@ -86,65 +91,69 @@ bool JsMissionListener::IsEmpty() void JsMissionListener::CallJsMethod(const std::string &methodName, int32_t missionId) { HILOG_DEBUG("methodName = %{public}s", methodName.c_str()); - if (engine_ == nullptr) { - HILOG_ERROR("engine_ nullptr"); + if (env_ == nullptr) { + HILOG_ERROR("env_ nullptr"); return; } // js callback should run in js thread - std::unique_ptr complete = std::make_unique - ([jsMissionListener = this, methodName, missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { - if (jsMissionListener) { + wptr jsMissionListener = this; + std::unique_ptr complete = std::make_unique + ([jsMissionListener, methodName, missionId](napi_env env, NapiAsyncTask &task, int32_t status) { + sptr jsMissionListenerSptr = jsMissionListener.promote(); + if (jsMissionListener != nullptr) { jsMissionListener->CallJsMethodInner(methodName, missionId); } }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JsMissionListener::CallJsMethod:" + methodName, - *engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JsMissionListener::CallJsMethod:" + methodName, + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JsMissionListener::CallJsMethodInner(const std::string &methodName, int32_t missionId) { - // jsListenerObjectMap_ may be changed in engine_->CallFunction() + // jsListenerObjectMap_ may be changed in env_->CallFunction() auto tmpMap = jsListenerObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = { CreateJsValue(*engine_, missionId) }; - CallJsFunction(value, methodName.c_str(), argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = { CreateJsValue(env_, missionId) }; + CallJsFunction(obj, methodName.c_str(), argv, ARGC_ONE); } tmpMap = jsListenerObjectMapSync_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeValue* argv[] = { CreateJsValue(*engine_, missionId) }; - CallJsFunction(value, methodName.c_str(), argv, ARGC_ONE); + napi_value obj = (item.second)->GetNapiValue(); + napi_value argv[] = { CreateJsValue(env_, missionId) }; + CallJsFunction(obj, methodName.c_str(), argv, ARGC_ONE); } } void JsMissionListener::CallJsFunction( - NativeValue* value, const char* methodName, NativeValue* const* argv, size_t argc) + napi_value obj, const char* methodName, napi_value *argv, size_t argc) { HILOG_INFO("method:%{public}s", methodName); - NativeObject* obj = ConvertNativeValueTo(value); if (obj == nullptr) { HILOG_ERROR("Failed to get object"); return; } - NativeValue* method = obj->GetProperty(methodName); - if (method == nullptr || method->TypeOf() == NATIVE_UNDEFINED) { - HILOG_ERROR("Failed to get method"); + napi_value method = nullptr; + napi_get_named_property(env_, obj, methodName, &method); + if (method == nullptr || AppExecFwk::IsTypeForNapiValue(env_, method, napi_undefined) + || AppExecFwk::IsTypeForNapiValue(env_, method, napi_null)) { + HILOG_ERROR("Failed to get %{public}s from object", methodName); return; } - engine_->CallFunction(value, method, argv, argc); + napi_value callResult = nullptr; + napi_call_function(env_, nullptr, method, argc, argv, &callResult); } #ifdef SUPPORT_GRAPHICS void JsMissionListener::OnMissionIconUpdated(int32_t missionId, const std::shared_ptr &icon) { HILOG_DEBUG("OnMissionIconUpdated, missionId = %{public}d", missionId); - if (engine_ == nullptr) { - HILOG_ERROR("engine_ is nullptr"); + if (env_ == nullptr) { + HILOG_ERROR("env_ is nullptr"); return; } @@ -154,45 +163,48 @@ void JsMissionListener::OnMissionIconUpdated(int32_t missionId, const std::share } // js callback must run in js thread - std::unique_ptr complete = std::make_unique - ([jsMissionListener = this, missionId, icon](NativeEngine &engine, AsyncTask &task, int32_t status) { - if (jsMissionListener) { + wptr jsMissionListener = this; + std::unique_ptr complete = std::make_unique + ([jsMissionListener, missionId, icon](napi_env env, NapiAsyncTask &task, int32_t status) { + sptr jsMissionListenerSptr = jsMissionListener.promote(); + if (jsMissionListener != nullptr) { jsMissionListener->CallJsMissionIconUpdated(missionId, icon); } }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JsMissionListener::OnMissionIconUpdated", *engine_, - std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JsMissionListener::OnMissionIconUpdated", env_, + std::make_unique(callback, std::move(execute), std::move(complete))); } void JsMissionListener::CallJsMissionIconUpdated(int32_t missionId, const std::shared_ptr &icon) { - if (engine_ == nullptr) { - HILOG_ERROR("engine_ is nullptr, not call js mission updated."); + if (env_ == nullptr) { + HILOG_ERROR("env_ is nullptr, not call js mission updated."); return; } - NativeValue* nativeMissionId = CreateJsValue(*engine_, missionId); - auto nativeIcon = reinterpret_cast( - Media::PixelMapNapi::CreatePixelMap(reinterpret_cast(engine_), icon)); + napi_value nativeMissionId = CreateJsValue(env_, missionId); + auto nativeIcon = Media::PixelMapNapi::CreatePixelMap(env_, icon); auto tmpMap = jsListenerObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeObject* listenerObj = ConvertNativeValueTo(value); - if (listenerObj == nullptr) { + napi_value obj = (item.second)->GetNapiValue(); + if (obj == nullptr) { HILOG_ERROR("Failed to get js object"); continue; } - NativeValue* method = listenerObj->GetProperty("onMissionIconUpdated"); - if (method == nullptr || method->TypeOf() == NATIVE_UNDEFINED) { + napi_value method = nullptr; + napi_get_named_property(env_, obj, "onMissionIconUpdated", &method); + if (method == nullptr || AppExecFwk::IsTypeForNapiValue(env_, method, napi_undefined) + || AppExecFwk::IsTypeForNapiValue(env_, method, napi_null)) { HILOG_ERROR("Failed to get onMissionIconUpdated method from object"); continue; } - NativeValue* argv[] = { nativeMissionId, nativeIcon }; - engine_->CallFunction(value, method, argv, ArraySize(argv)); + napi_value argv[] = { nativeMissionId, nativeIcon }; + napi_value callResult = nullptr; + napi_call_function(env_, nullptr, method, ArraySize(argv), argv, &callResult); } } #endif diff --git a/frameworks/js/napi/js_mission_manager/js_mission_listener.h b/frameworks/js/napi/js_mission_manager/js_mission_listener.h index d2eba2807d15f1b5175588927998e4cf5933578b..e468918c36eba9efcbbeae491df95e2d02e0797f 100755 --- a/frameworks/js/napi/js_mission_manager/js_mission_listener.h +++ b/frameworks/js/napi/js_mission_manager/js_mission_listener.h @@ -22,12 +22,13 @@ #include "event_handler.h" #include "mission_listener_stub.h" #include "native_engine/native_engine.h" +#include "napi_common_util.h" namespace OHOS { namespace AbilityRuntime { class JsMissionListener : public AAFwk::MissionListenerStub { public: - explicit JsMissionListener(NativeEngine* engine) : engine_(engine) {} + explicit JsMissionListener(napi_env env) : env_(env) {} virtual ~JsMissionListener() = default; void OnMissionCreated(int32_t missionId) override; @@ -37,7 +38,7 @@ public: void OnMissionClosed(int32_t missionId) override; void OnMissionLabelUpdated(int32_t missionId) override; - void AddJsListenerObject(int32_t listenerId, NativeValue* jsListenerObject, bool isSync = false); + void AddJsListenerObject(int32_t listenerId, napi_value jsListenerObject, bool isSync = false); bool RemoveJsListenerObject(int32_t listenerId, bool isSync = false); bool IsEmpty(); @@ -52,9 +53,9 @@ private: private: void CallJsMethod(const std::string &methodName, int32_t missionId); void CallJsMethodInner(const std::string &methodName, int32_t missionId); - void CallJsFunction(NativeValue* value, const char* methodName, NativeValue* const *argv, size_t argc); + void CallJsFunction(napi_value value, const char* methodName, napi_value *argv, size_t argc); - NativeEngine* engine_ = nullptr; + napi_env env_ = nullptr; std::map> jsListenerObjectMap_; std::map> jsListenerObjectMapSync_; std::shared_ptr mainHandler_; diff --git a/frameworks/js/napi/js_mission_manager/mission_manager.cpp b/frameworks/js/napi/js_mission_manager/mission_manager.cpp index 86409b1eb3d28a625344af010a0309572e947175..e1c0b0cae83e07f076a32ac666aea67346c88053 100755 --- a/frameworks/js/napi/js_mission_manager/mission_manager.cpp +++ b/frameworks/js/napi/js_mission_manager/mission_manager.cpp @@ -25,6 +25,7 @@ #include "js_runtime_utils.h" #include "mission_snapshot.h" #include "napi_common_start_options.h" +#include "napi_common_util.h" #include "native_engine/native_value.h" #include "permission_constants.h" #ifdef SUPPORT_GRAPHICS @@ -52,264 +53,251 @@ public: JsMissionManager() = default; ~JsMissionManager() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsMissionManager::Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* On(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value On(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnOn(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnOn); } - static NativeValue* Off(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value Off(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnOff(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnOff); } - static NativeValue* GetMissionInfos(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetMissionInfos(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionInfos(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionInfos); } - static NativeValue* GetMissionInfo(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetMissionInfo(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionInfo(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionInfo); } - static NativeValue* GetMissionSnapShot(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetMissionSnapShot(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info, false) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionSnapShot); } - static NativeValue* GetLowResolutionMissionSnapShot(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetLowResolutionMissionSnapShot(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info, true) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetLowResolutionMissionSnapShot); } - static NativeValue* LockMission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value LockMission(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnLockMission(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnLockMission); } - static NativeValue* UnlockMission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value UnlockMission(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnUnlockMission(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnUnlockMission); } - static NativeValue* ClearMission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value ClearMission(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnClearMission(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnClearMission); } - static NativeValue* ClearAllMissions(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value ClearAllMissions(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnClearAllMissions(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnClearAllMissions); } - static NativeValue* MoveMissionToFront(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value MoveMissionToFront(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnMoveMissionToFront(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnMoveMissionToFront); } - static NativeValue* MoveMissionsToForeground(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value MoveMissionsToForeground(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnMoveMissionsToForeground(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnMoveMissionsToForeground); } - static NativeValue* MoveMissionsToBackground(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value MoveMissionsToBackground(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnMoveMissionsToBackground(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnMoveMissionsToBackground); } private: - NativeValue* OnOn(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnOn(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - std::string type = ParseParamType(engine, info); + std::string type = ParseParamType(env, argc, argv); if (type == ON_OFF_TYPE_SYNC) { - return OnOnNew(engine, info); + return OnOnNew(env, argc, argv); } - return OnOnOld(engine, info); + return OnOnOld(env, argc, argv); } - NativeValue* OnOnOld(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnOnOld(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARG_COUNT_TWO) { + if (argc < ARG_COUNT_TWO) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (!CheckOnOffType(engine, info)) { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + if (!CheckOnOffType(env, argc, argv)) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } missionListenerId_++; if (missionListener_ != nullptr) { - missionListener_->AddJsListenerObject(missionListenerId_, info.argv[ARGC_ONE]); - return engine.CreateNumber(missionListenerId_); + missionListener_->AddJsListenerObject(missionListenerId_, argv[ARGC_ONE]); + return CreateJsValue(env, missionListenerId_); } - missionListener_ = new JsMissionListener(&engine); + missionListener_ = new JsMissionListener(env); auto ret = AbilityManagerClient::GetInstance()->RegisterMissionListener(missionListener_); if (ret == 0) { - missionListener_->AddJsListenerObject(missionListenerId_, info.argv[ARGC_ONE]); - return engine.CreateNumber(missionListenerId_); + missionListener_->AddJsListenerObject(missionListenerId_, argv[ARGC_ONE]); + return CreateJsValue(env, missionListenerId_); } else { HILOG_ERROR("RegisterMissionListener failed, ret = %{public}d", ret); missionListener_ = nullptr; if (ret == CHECK_PERMISSION_FAILED) { - ThrowNoPermissionError(engine, PermissionConstants::PERMISSION_MANAGE_MISSION); + ThrowNoPermissionError(env, PermissionConstants::PERMISSION_MANAGE_MISSION); } else { - ThrowError(engine, GetJsErrorCodeByNativeError(ret)); + ThrowError(env, GetJsErrorCodeByNativeError(ret)); } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } } - NativeValue* OnOnNew(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnOnNew(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARG_COUNT_TWO) { + if (argc < ARG_COUNT_TWO) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (info.argv[INDEX_ONE]->TypeOf() != NativeValueType::NATIVE_OBJECT) { + if (!AppExecFwk::IsTypeForNapiValue(env, argv[1], napi_object)) { HILOG_ERROR("Invalid param"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } missionListenerId_++; if (missionListener_ != nullptr) { - missionListener_->AddJsListenerObject(missionListenerId_, info.argv[INDEX_ONE], true); - return engine.CreateNumber(missionListenerId_); + missionListener_->AddJsListenerObject(missionListenerId_, argv[INDEX_ONE], true); + return CreateJsValue(env, missionListenerId_); } - missionListener_ = new JsMissionListener(&engine); + missionListener_ = new JsMissionListener(env); auto ret = AbilityManagerClient::GetInstance()->RegisterMissionListener(missionListener_); if (ret == 0) { - missionListener_->AddJsListenerObject(missionListenerId_, info.argv[INDEX_ONE], true); - return engine.CreateNumber(missionListenerId_); + missionListener_->AddJsListenerObject(missionListenerId_, argv[INDEX_ONE], true); + return CreateJsValue(env, missionListenerId_); } else { HILOG_ERROR("RegisterMissionListener failed, ret = %{public}d", ret); missionListener_ = nullptr; if (ret == CHECK_PERMISSION_FAILED) { - ThrowNoPermissionError(engine, PermissionConstants::PERMISSION_MANAGE_MISSION); + ThrowNoPermissionError(env, PermissionConstants::PERMISSION_MANAGE_MISSION); } else { - ThrowError(engine, GetJsErrorCodeByNativeError(ret)); + ThrowError(env, GetJsErrorCodeByNativeError(ret)); } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } } - NativeValue* OnOff(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnOff(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - std::string type = ParseParamType(engine, info); + std::string type = ParseParamType(env, argc, argv); if (type == ON_OFF_TYPE_SYNC) { - return OnOffNew(engine, info); + return OnOffNew(env, argc, argv); } - return OnOffOld(engine, info); + return OnOffOld(env, argc, argv); } - NativeValue* OnOffOld(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnOffOld(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARG_COUNT_TWO) { + if (argc < ARG_COUNT_TWO) { HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - if (!CheckOnOffType(engine, info)) { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + if (!CheckOnOffType(env, argc, argv)) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t missionListenerId = -1; - if (!ConvertFromJsValue(engine, info.argv[ARGC_ONE], missionListenerId)) { + if (!ConvertFromJsValue(env, argv[ARGC_ONE], missionListenerId)) { HILOG_ERROR("Parse missionListenerId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = + NapiAsyncTask::CompleteCallback complete = [&missionListener = missionListener_, missionListenerId] - (NativeEngine &engine, AsyncTask &task, int32_t status) { + (napi_env env, NapiAsyncTask &task, int32_t status) { if (!missionListener || !missionListener->RemoveJsListenerObject(missionListenerId)) { - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER)); return; } if (!missionListener->IsEmpty()) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); return; } auto ret = AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); missionListener = nullptr; } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= ARG_COUNT_TWO) ? nullptr : info.argv[INDEX_TWO]; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnUnregisterMissionListener", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= ARG_COUNT_TWO) ? nullptr : argv[INDEX_TWO]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnUnregisterMissionListener", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnOffNew(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnOffNew(napi_env env, size_t argc, napi_value* argv) { HILOG_DEBUG("called"); - if (info.argc < ARG_COUNT_TWO) { + if (argc < ARG_COUNT_TWO) { HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionListenerId = -1; - if (!ConvertFromJsValue(engine, info.argv[INDEX_ONE], missionListenerId)) { + if (!ConvertFromJsValue(env, argv[INDEX_ONE], missionListenerId)) { HILOG_ERROR("Parse missionListenerId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } if (missionListener_ == nullptr) { HILOG_ERROR("missionListener_ is nullptr"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); } if (!missionListener_->RemoveJsListenerObject(missionListenerId, true)) { HILOG_ERROR("missionListenerId not found"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER); + return CreateJsUndefined(env); } if (!missionListener_->IsEmpty()) { HILOG_DEBUG("Off success, missionListener is not empty"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } auto ret = AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener_); if (ret == 0) { @@ -318,101 +306,113 @@ private: } else { HILOG_ERROR("UnRegisterMissionListener failed"); if (ret == CHECK_PERMISSION_FAILED) { - ThrowNoPermissionError(engine, PermissionConstants::PERMISSION_MANAGE_MISSION); + ThrowNoPermissionError(env, PermissionConstants::PERMISSION_MANAGE_MISSION); } else { - ThrowError(engine, GetJsErrorCodeByNativeError(ret)); + ThrowError(env, GetJsErrorCodeByNativeError(ret)); } } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - NativeValue* OnGetMissionInfos(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetMissionInfos(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc < 2) { // at least 2 parameters. + if (argc < 2) { // at least 2 parameters. HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string deviceId; - if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) { + if (!ConvertFromJsValue(env, argv[0], deviceId)) { HILOG_ERROR("Parse deviceId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int numMax = -1; - if (!ConvertFromJsValue(engine, info.argv[1], numMax)) { + if (!ConvertFromJsValue(env, argv[1], numMax)) { HILOG_ERROR("Parse numMax failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [deviceId, numMax](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [deviceId, numMax](napi_env env, NapiAsyncTask &task, int32_t status) { std::vector missionInfos; auto ret = AbilityManagerClient::GetInstance()->GetMissionInfos(deviceId, numMax, missionInfos); if (ret == 0) { - task.ResolveWithNoError(engine, CreateJsMissionInfoArray(engine, missionInfos)); + task.ResolveWithNoError(env, CreateJsMissionInfoArray(env, missionInfos)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= 2) ? nullptr : info.argv[2]; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnGetMissionInfos", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= 2) ? nullptr : argv[2]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnGetMissionInfos", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetMissionInfo(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetMissionInfo(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc < 2) { + if (argc < 2) { HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string deviceId; - if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) { + if (!ConvertFromJsValue(env, argv[0], deviceId)) { HILOG_ERROR("Parse deviceId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[1], missionId)) { + if (!ConvertFromJsValue(env, argv[1], missionId)) { HILOG_ERROR("Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [deviceId, missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [deviceId, missionId](napi_env env, NapiAsyncTask &task, int32_t status) { AAFwk::MissionInfo missionInfo; auto ret = AbilityManagerClient::GetInstance()->GetMissionInfo(deviceId, missionId, missionInfo); if (ret == 0) { - task.ResolveWithNoError(engine, CreateJsMissionInfo(engine, missionInfo)); + task.ResolveWithNoError(env, CreateJsMissionInfo(env, missionInfo)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= 2) ? nullptr : info.argv[2]; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnGetMissionInfo", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= 2) ? nullptr : argv[2]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnGetMissionInfo", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetMissionSnapShot(NativeEngine &engine, NativeCallbackInfo &info, bool isLowResolution) + napi_value OnGetMissionSnapShot(napi_env env, size_t argc, napi_value* argv) + { + HILOG_INFO("called"); + return GetMissionSnapShot(env, argc, argv, false); + } + + napi_value OnGetLowResolutionMissionSnapShot(napi_env env, size_t argc, napi_value* argv) + { + HILOG_INFO("called"); + return GetMissionSnapShot(env, argc, argv, true); + } + + napi_value GetMissionSnapShot(napi_env env, size_t argc, napi_value* argv, bool isLowResolution) { HILOG_INFO("%{public}s is called", __FUNCTION__); std::string deviceId; int32_t missionId = -1; - if (!CheckMissionSnapShotParams(engine, info, deviceId, missionId)) { - return engine.CreateUndefined(); + if (!CheckMissionSnapShotParams(env, argc, argv, deviceId, missionId)) { + return CreateJsUndefined(env); } class MissionSnapshotWrap { @@ -427,340 +427,335 @@ private: deviceId, missionId, snapshotWrap->missionSnapshot, isLowResolution); }; - auto complete = [snapshotWrap](NativeEngine &engine, AsyncTask &task, int32_t status) { + auto complete = [snapshotWrap](napi_env env, NapiAsyncTask &task, int32_t status) { if (snapshotWrap->result == 0) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - NativeValue* abilityValue = engine.CreateObject(); - NativeObject* abilityObj = ConvertNativeValueTo(abilityValue); - abilityObj->SetProperty( - "bundleName", CreateJsValue(engine, snapshotWrap->missionSnapshot.topAbility.GetBundleName())); - abilityObj->SetProperty( - "abilityName", CreateJsValue(engine, snapshotWrap->missionSnapshot.topAbility.GetAbilityName())); - object->SetProperty("ability", abilityValue); + napi_value object = nullptr; + napi_create_object(env, &object); + napi_value abilityObj = nullptr; + napi_create_object(env, &abilityObj); + napi_set_named_property(env, abilityObj, "bundleName", + CreateJsValue(env, snapshotWrap->missionSnapshot.topAbility.GetBundleName())); + napi_set_named_property(env, abilityObj, "abilityName", + CreateJsValue(env, snapshotWrap->missionSnapshot.topAbility.GetAbilityName())); + napi_set_named_property(env, object, "ability", abilityObj); #ifdef SUPPORT_GRAPHICS - auto snapshotValue = reinterpret_cast(Media::PixelMapNapi::CreatePixelMap( - reinterpret_cast(&engine), snapshotWrap->missionSnapshot.snapshot)); - object->SetProperty("snapshot", snapshotValue); + auto snapshotValue = Media::PixelMapNapi::CreatePixelMap( + env, snapshotWrap->missionSnapshot.snapshot); + napi_set_named_property(env, object, "snapshot", snapshotValue); #endif - task.ResolveWithNoError(engine, objValue); + task.ResolveWithNoError(env, object); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, snapshotWrap->result, + task.Reject(env, CreateJsErrorByNativeErr(env, snapshotWrap->result, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > ARG_COUNT_TWO) ? info.argv[ARG_COUNT_TWO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnGetMissionSnapShot", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, std::move(excute), std::move(complete), &result)); + napi_value lastParam = (argc > ARG_COUNT_TWO) ? argv[ARG_COUNT_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnGetMissionSnapShot", + env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(excute), std::move(complete), &result)); return result; } - bool CheckMissionSnapShotParams(NativeEngine &engine, NativeCallbackInfo &info, + bool CheckMissionSnapShotParams(napi_env env, size_t argc, napi_value* argv, std::string &deviceId, int32_t &missionId) { - if (info.argc < ARG_COUNT_TWO) { - ThrowTooFewParametersError(engine); + if (argc < ARG_COUNT_TWO) { + ThrowTooFewParametersError(env); return false; } - if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) { + if (!ConvertFromJsValue(env, argv[0], deviceId)) { HILOG_ERROR("missionSnapshot: Parse deviceId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); return false; } - if (!ConvertFromJsValue(engine, info.argv[1], missionId)) { + if (!ConvertFromJsValue(env, argv[1], missionId)) { HILOG_ERROR("missionSnapshot: Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); return false; } return true; } - NativeValue* OnLockMission(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnLockMission(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnLockMission Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnLockMission Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->LockMissionForCleanup(missionId); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnLockMission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 1) ? argv[1] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnLockMission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnUnlockMission(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnUnlockMission(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnUnlockMission Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnUnlockMission Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->UnlockMissionForCleanup(missionId); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnUnlockMission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 1) ? argv[1] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnUnlockMission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnClearMission(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnClearMission(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnClearMission Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnClearMission Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->CleanMission(missionId); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnClearMission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 1) ? argv[1] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnClearMission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnClearAllMissions(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnClearAllMissions(napi_env env, const size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - AsyncTask::CompleteCallback complete = - [](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->CleanAllMissions(); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 0) ? info.argv[0] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 0) ? argv[0] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnMoveMissionToFront(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnMoveMissionToFront(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnMoveMissionToFront Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnMoveMissionToFront Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - decltype(info.argc) unwrapArgc = 1; + decltype(argc) unwrapArgc = 1; AAFwk::StartOptions startOptions; - if (info.argc > ARGC_ONE && info.argv[1]->TypeOf() == NATIVE_OBJECT) { + if (argc > ARGC_ONE && AppExecFwk::IsTypeForNapiValue(env, argv[1], napi_object)) { HILOG_INFO("OnMoveMissionToFront start options is used."); - AppExecFwk::UnwrapStartOptions(reinterpret_cast(&engine), - reinterpret_cast(info.argv[1]), startOptions); + AppExecFwk::UnwrapStartOptions(env, argv[1], startOptions); unwrapArgc++; } - AsyncTask::CompleteCallback complete = - [missionId, startOptions, unwrapArgc](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId, startOptions, unwrapArgc](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = (unwrapArgc == 1) ? AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId) : AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId, startOptions); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > unwrapArgc) ? info.argv[unwrapArgc] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > unwrapArgc) ? argv[unwrapArgc] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue *OnMoveMissionsToForeground(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnMoveMissionsToForeground(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); std::vector missionIds; - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { HILOG_ERROR("OnMoveMissionsToForeground Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); - } - NativeArray *nativeArray = ConvertNativeValueTo(info.argv[0]); - if (nativeArray == nullptr) { - HILOG_ERROR("OnMoveMissionsToForeground Parse missionIds array failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); - } - for (uint32_t i = 0; i < nativeArray->GetLength(); i++) { - int32_t missionId; - if (!ConvertFromJsValue(engine, nativeArray->GetElement(i), missionId)) { + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); + } + uint32_t nativeArrayLen = 0; + napi_get_array_length(env, argv[0], &nativeArrayLen); + napi_value element = nullptr; + for (uint32_t i = 0; i < nativeArrayLen; i++) { + int32_t missionId = 0; + napi_get_element(env, argv[0], i, &element); + if (!ConvertFromJsValue(env, element, missionId)) { HILOG_ERROR("OnMoveMissionsToForeground Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } missionIds.push_back(missionId); } int topMissionId = -1; - decltype(info.argc) unwrapArgc = 1; - if (info.argc > ARGC_ONE && info.argv[1]->TypeOf() == NATIVE_NUMBER) { - if (!ConvertFromJsValue(engine, info.argv[1], topMissionId)) { + decltype(argc) unwrapArgc = 1; + if (argc > ARGC_ONE && AppExecFwk::IsTypeForNapiValue(env, argv[1], napi_number)) { + if (!ConvertFromJsValue(env, argv[1], topMissionId)) { HILOG_ERROR("OnMoveMissionsToForeground Parse topMissionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } unwrapArgc++; } - AsyncTask::CompleteCallback complete = - [missionIds, topMissionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionIds, topMissionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AAFwk::AbilityManagerClient::GetInstance()->MoveMissionsToForeground(missionIds, topMissionId); if (ret == 0) { - task.ResolveWithNoError(engine, engine.CreateUndefined()); + task.ResolveWithNoError(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > unwrapArgc) ? info.argv[unwrapArgc] : nullptr; - NativeValue *result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionsToForeground", engine, - CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > unwrapArgc) ? argv[unwrapArgc] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionsToForeground", env, + CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnMoveMissionsToBackground(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnMoveMissionsToBackground(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); std::vector missionIds; - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { HILOG_ERROR("OnMoveMissionsToBackground Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); - } - NativeArray *nativeArray = ConvertNativeValueTo(info.argv[0]); - if (nativeArray == nullptr) { - HILOG_ERROR("OnMoveMissionsToBackground Parse missionIds array failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } - for (uint32_t i = 0; i < nativeArray->GetLength(); i++) { + uint32_t nativeArrayLen = 0; + napi_get_array_length(env, argv[0], &nativeArrayLen); + napi_value element = nullptr; + for (uint32_t i = 0; i < nativeArrayLen; i++) { int32_t missionId; - if (!ConvertFromJsValue(engine, nativeArray->GetElement(i), missionId)) { + napi_get_element(env, argv[0], i, &element); + if (!ConvertFromJsValue(env, element, missionId)) { HILOG_ERROR("OnMoveMissionsToBackground Parse topMissionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } missionIds.push_back(missionId); } - AsyncTask::CompleteCallback complete = - [missionIds](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionIds](napi_env env, NapiAsyncTask &task, int32_t status) { std::vector resultMissionIds; auto ret = AbilityManagerClient::GetInstance()->MoveMissionsToBackground(missionIds, resultMissionIds); if (ret == 0) { - NativeValue* arrayValue = engine.CreateArray(resultMissionIds.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, resultMissionIds.size(), &arrayValue); uint32_t index = 0; for (const auto &missionId : resultMissionIds) { - array->SetElement(index++, CreateJsValue(engine, missionId)); + napi_set_element(env, arrayValue, index++, CreateJsValue(env, missionId)); } - task.ResolveWithNoError(engine, arrayValue); + task.ResolveWithNoError(env, arrayValue); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= 1) ? nullptr : info.argv[1]; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionsToBackground", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= 1) ? nullptr : argv[1]; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionsToBackground", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } private: - bool CheckOnOffType(NativeEngine &engine, NativeCallbackInfo &info) + bool CheckOnOffType(napi_env env, size_t argc, napi_value* argv) { - if (info.argc < ARGC_ONE) { + if (argc < ARGC_ONE) { return false; } - if (info.argv[0]->TypeOf() != NATIVE_STRING) { + if (!AppExecFwk::IsTypeForNapiValue(env, argv[0], napi_string)) { HILOG_ERROR("CheckOnOffType, Param 0 is not string"); return false; } std::string type; - if (!ConvertFromJsValue(engine, info.argv[0], type)) { + if (!ConvertFromJsValue(env, argv[0], type)) { HILOG_ERROR("CheckOnOffType, Parse on off type failed"); return false; } @@ -772,10 +767,10 @@ private: return true; } - std::string ParseParamType(NativeEngine& engine, const NativeCallbackInfo& info) + std::string ParseParamType(napi_env env, size_t argc, napi_value* argv) { std::string type; - if (info.argc > INDEX_ZERO && ConvertFromJsValue(engine, info.argv[INDEX_ZERO], type)) { + if (argc > INDEX_ZERO && ConvertFromJsValue(env, argv[INDEX_ZERO], type)) { return type; } return ""; @@ -785,41 +780,35 @@ private: uint32_t missionListenerId_ = 0; }; -NativeValue* JsMissionManagerInit(NativeEngine* engine, NativeValue* exportObj) +napi_value JsMissionManagerInit(napi_env env, napi_value exportObj) { HILOG_INFO("JsMissionManagerInit is called"); - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_INFO("Invalid input parameters"); return nullptr; } - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_INFO("object is nullptr"); - return nullptr; - } - std::unique_ptr jsMissionManager = std::make_unique(); - object->SetNativePointer(jsMissionManager.release(), JsMissionManager::Finalizer, nullptr); + napi_wrap(env, exportObj, jsMissionManager.release(), JsMissionManager::Finalizer, nullptr, nullptr); const char *moduleName = "JsMissionManager"; - BindNativeFunction(*engine, *object, "on", moduleName, JsMissionManager::On); - BindNativeFunction(*engine, *object, "off", moduleName, JsMissionManager::Off); - BindNativeFunction(*engine, *object, "getMissionInfos", moduleName, JsMissionManager::GetMissionInfos); - BindNativeFunction(*engine, *object, "getMissionInfo", moduleName, JsMissionManager::GetMissionInfo); - BindNativeFunction(*engine, *object, "getMissionSnapShot", moduleName, JsMissionManager::GetMissionSnapShot); - BindNativeFunction(*engine, *object, "getLowResolutionMissionSnapShot", moduleName, + BindNativeFunction(env, exportObj, "on", moduleName, JsMissionManager::On); + BindNativeFunction(env, exportObj, "off", moduleName, JsMissionManager::Off); + BindNativeFunction(env, exportObj, "getMissionInfos", moduleName, JsMissionManager::GetMissionInfos); + BindNativeFunction(env, exportObj, "getMissionInfo", moduleName, JsMissionManager::GetMissionInfo); + BindNativeFunction(env, exportObj, "getMissionSnapShot", moduleName, JsMissionManager::GetMissionSnapShot); + BindNativeFunction(env, exportObj, "getLowResolutionMissionSnapShot", moduleName, JsMissionManager::GetLowResolutionMissionSnapShot); - BindNativeFunction(*engine, *object, "lockMission", moduleName, JsMissionManager::LockMission); - BindNativeFunction(*engine, *object, "unlockMission", moduleName, JsMissionManager::UnlockMission); - BindNativeFunction(*engine, *object, "clearMission", moduleName, JsMissionManager::ClearMission); - BindNativeFunction(*engine, *object, "clearAllMissions", moduleName, JsMissionManager::ClearAllMissions); - BindNativeFunction(*engine, *object, "moveMissionToFront", moduleName, JsMissionManager::MoveMissionToFront); - BindNativeFunction(*engine, *object, + BindNativeFunction(env, exportObj, "lockMission", moduleName, JsMissionManager::LockMission); + BindNativeFunction(env, exportObj, "unlockMission", moduleName, JsMissionManager::UnlockMission); + BindNativeFunction(env, exportObj, "clearMission", moduleName, JsMissionManager::ClearMission); + BindNativeFunction(env, exportObj, "clearAllMissions", moduleName, JsMissionManager::ClearAllMissions); + BindNativeFunction(env, exportObj, "moveMissionToFront", moduleName, JsMissionManager::MoveMissionToFront); + BindNativeFunction(env, exportObj, "moveMissionsToForeground", moduleName, JsMissionManager::MoveMissionsToForeground); - BindNativeFunction(*engine, *object, + BindNativeFunction(env, exportObj, "moveMissionsToBackground", moduleName, JsMissionManager::MoveMissionsToBackground); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/js_mission_manager/mission_manager.h b/frameworks/js/napi/js_mission_manager/mission_manager.h index 21e3c038a78382e6be8fa7b6762e4108d588dc02..036bef3c28424e6bb39f60b174887bb977eacf1f 100755 --- a/frameworks/js/napi/js_mission_manager/mission_manager.h +++ b/frameworks/js/napi/js_mission_manager/mission_manager.h @@ -21,7 +21,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* JsMissionManagerInit(NativeEngine* engine, NativeValue* exportObj); +napi_value JsMissionManagerInit(napi_env env, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_H diff --git a/frameworks/js/napi/js_mission_manager/native_module.cpp b/frameworks/js/napi/js_mission_manager/native_module.cpp index 6a40c39f3ca629e313ec5cb432ae5f8cf7956b26..f059f5553f066d393d94d580b0f43e172b85177e 100755 --- a/frameworks/js/napi/js_mission_manager/native_module.cpp +++ b/frameworks/js/napi/js_mission_manager/native_module.cpp @@ -16,15 +16,14 @@ #include "mission_manager.h" #include "native_engine/native_engine.h" -extern "C" __attribute__((constructor)) -void NAPI_app_ability_missionmanager_AutoRegister() -{ - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "app.ability.missionManager", - .fileName = "app/ability/libmissionmanager.so/missionmanager.js", - .registerCallback = OHOS::AbilityRuntime::JsMissionManagerInit, - }; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "app.ability.missionManager", + .nm_filename = "app/ability/libmissionmanager_napi.so/missionmanager.js", + .nm_register_func = OHOS::AbilityRuntime::JsMissionManagerInit, +}; - moduleManager->Register(&newModuleInfo); +extern "C" __attribute__((constructor)) void NAPI_app_ability_missionmanager_AutoRegister(void) +{ + napi_module_register(&_module); } diff --git a/frameworks/js/napi/mission_manager/js_mission_info_utils.cpp b/frameworks/js/napi/mission_manager/js_mission_info_utils.cpp index 523c2b9b245fa02a9f035caf0e24d97815e8cf80..aa61efd8b9fb076e5ff65daaf3e5c634a3abc5f1 100644 --- a/frameworks/js/napi/mission_manager/js_mission_info_utils.cpp +++ b/frameworks/js/napi/mission_manager/js_mission_info_utils.cpp @@ -32,145 +32,142 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsMissionInfo(NativeEngine &engine, const AAFwk::MissionInfo &missionInfo) +napi_value CreateJsMissionInfo(napi_env env, const AAFwk::MissionInfo &missionInfo) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - object->SetProperty("missionId", CreateJsValue(engine, missionInfo.id)); - object->SetProperty("runningState", CreateJsValue(engine, missionInfo.runningState)); - object->SetProperty("lockedState", CreateJsValue(engine, missionInfo.lockedState)); - object->SetProperty("continuable", CreateJsValue(engine, missionInfo.continuable)); - object->SetProperty("timestamp", CreateJsValue(engine, missionInfo.time)); - object->SetProperty("want", CreateJsWant(engine, missionInfo.want)); - object->SetProperty("label", CreateJsValue(engine, missionInfo.label)); - object->SetProperty("iconPath", CreateJsValue(engine, missionInfo.iconPath)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + + napi_set_named_property(env, objValue, "missionId", CreateJsValue(env, missionInfo.id)); + napi_set_named_property(env, objValue, "runningState", CreateJsValue(env, missionInfo.runningState)); + napi_set_named_property(env, objValue, "lockedState", CreateJsValue(env, missionInfo.lockedState)); + napi_set_named_property(env, objValue, "continuable", CreateJsValue(env, missionInfo.continuable)); + napi_set_named_property(env, objValue, "timestamp", CreateJsValue(env, missionInfo.time)); + napi_set_named_property(env, objValue, "want", CreateJsWant(env, missionInfo.want)); + napi_set_named_property(env, objValue, "label", CreateJsValue(env, missionInfo.label)); + napi_set_named_property(env, objValue, "iconPath", CreateJsValue(env, missionInfo.iconPath)); return objValue; } -NativeValue* CreateJsWant(NativeEngine &engine, const AAFwk::Want &want) +napi_value CreateJsWant(napi_env env, const AAFwk::Want &want) { - HILOG_DEBUG("enter"); - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - object->SetProperty("deviceId", CreateJsValue(engine, want.GetElement().GetDeviceID())); - object->SetProperty("bundleName", CreateJsValue(engine, want.GetElement().GetBundleName())); - object->SetProperty("abilityName", CreateJsValue(engine, want.GetElement().GetAbilityName())); - object->SetProperty("uri", CreateJsValue(engine, want.GetUriString())); - object->SetProperty("type", CreateJsValue(engine, want.GetType())); - object->SetProperty("flags", CreateJsValue(engine, want.GetFlags())); - object->SetProperty("action", CreateJsValue(engine, want.GetAction())); - object->SetProperty("parameters", CreateJsWantParams(engine, want.GetParams())); - object->SetProperty("entities", CreateNativeArray(engine, want.GetEntities())); - HILOG_DEBUG("end"); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + + napi_set_named_property(env, objValue, "deviceId", CreateJsValue(env, want.GetElement().GetDeviceID())); + napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, want.GetElement().GetBundleName())); + napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, want.GetElement().GetAbilityName())); + napi_set_named_property(env, objValue, "uri", CreateJsValue(env, want.GetUriString())); + napi_set_named_property(env, objValue, "type", CreateJsValue(env, want.GetType())); + napi_set_named_property(env, objValue, "flags", CreateJsValue(env, want.GetFlags())); + napi_set_named_property(env, objValue, "action", CreateJsValue(env, want.GetAction())); + napi_set_named_property(env, objValue, "parameters", CreateJsWantParams(env, want.GetParams())); + napi_set_named_property(env, objValue, "entities", CreateNativeArray(env, want.GetEntities())); return objValue; } -NativeValue* CreateJsWantParams(NativeEngine &engine, const AAFwk::WantParams &wantParams) +napi_value CreateJsWantParams(napi_env env, const AAFwk::WantParams &wantParams) { - HILOG_DEBUG("enter"); - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); const std::map> paramList = wantParams.GetParams(); for (auto iter = paramList.begin(); iter != paramList.end(); iter++) { if (AAFwk::IString::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IBoolean::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IShort::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IInteger::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::ILong::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IFloat::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IDouble::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IChar::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IByte::Query(iter->second) != nullptr) { InnerWrapJsWantParams( - engine, object, iter->first, wantParams); + env, object, iter->first, wantParams); } else if (AAFwk::IArray::Query(iter->second) != nullptr) { AAFwk::IArray *ao = AAFwk::IArray::Query(iter->second); if (ao != nullptr) { sptr array(ao); - WrapJsWantParamsArray(engine, object, iter->first, array); + WrapJsWantParamsArray(env, object, iter->first, array); } } else if (AAFwk::IWantParams::Query(iter->second) != nullptr) { - InnerWrapJsWantParamsWantParams(engine, object, iter->first, wantParams); + InnerWrapJsWantParamsWantParams(env, object, iter->first, wantParams); } } - HILOG_DEBUG("end"); - return objValue; + return object; } -NativeValue* CreateJsMissionInfoArray(NativeEngine &engine, const std::vector &missionInfos) +napi_value CreateJsMissionInfoArray(napi_env env, const std::vector &missionInfos) { - HILOG_DEBUG("enter"); - NativeValue* arrayValue = engine.CreateArray(missionInfos.size()); - NativeArray* array = ConvertNativeValueTo(arrayValue); + napi_value arrayValue = nullptr; + napi_create_array_with_length(env, missionInfos.size(), &arrayValue); uint32_t index = 0; for (const auto &missionInfo : missionInfos) { - array->SetElement(index++, CreateJsMissionInfo(engine, missionInfo)); + napi_set_element(env, arrayValue, index++, CreateJsMissionInfo(env, missionInfo)); } HILOG_DEBUG("end"); return arrayValue; } bool InnerWrapJsWantParamsWantParams( - NativeEngine &engine, NativeObject* object, const std::string &key, const AAFwk::WantParams &wantParams) + napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams) { HILOG_DEBUG("enter"); auto value = wantParams.GetParam(key); AAFwk::IWantParams *o = AAFwk::IWantParams::Query(value); if (o != nullptr) { AAFwk::WantParams wp = AAFwk::WantParamWrapper::Unbox(o); - object->SetProperty(key.c_str(), CreateJsWantParams(engine, wp)); + napi_set_named_property(env, object, key.c_str(), CreateJsWantParams(env, wp)); return true; } HILOG_DEBUG("end"); return false; } -bool WrapJsWantParamsArray(NativeEngine &engine, NativeObject* object, const std::string &key, sptr &ao) +bool WrapJsWantParamsArray(napi_env env, napi_value object, const std::string &key, sptr &ao) { HILOG_INFO("%{public}s start. key=%{public}s", __func__, key.c_str()); if (AAFwk::Array::IsStringArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsBooleanArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsShortArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsIntegerArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsLongArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsFloatArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsByteArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsCharArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else if (AAFwk::Array::IsDoubleArray(ao)) { return InnerWrapWantParamsArray( - engine, object, key, ao); + env, object, key, ao); } else { return false; } diff --git a/frameworks/js/napi/mission_manager/js_mission_info_utils.h b/frameworks/js/napi/mission_manager/js_mission_info_utils.h index 3d28e9060fe5562a5685fbd421049d48619c0f07..e2022ef42471e55f7d82206e0e1a02d121c4e339 100644 --- a/frameworks/js/napi/mission_manager/js_mission_info_utils.h +++ b/frameworks/js/napi/mission_manager/js_mission_info_utils.h @@ -28,34 +28,34 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* CreateJsMissionInfo(NativeEngine &engine, const AAFwk::MissionInfo &missionInfo); -NativeValue* CreateJsWant(NativeEngine &engine, const AAFwk::Want &want); -NativeValue* CreateJsWantParams(NativeEngine &engine, const AAFwk::WantParams &wantParams); -NativeValue* CreateJsMissionInfoArray(NativeEngine &engine, const std::vector &missionInfos); +napi_value CreateJsMissionInfo(napi_env env, const AAFwk::MissionInfo &missionInfo); +napi_value CreateJsWant(napi_env env, const AAFwk::Want &want); +napi_value CreateJsWantParams(napi_env env, const AAFwk::WantParams &wantParams); +napi_value CreateJsMissionInfoArray(napi_env env, const std::vector &missionInfos); template bool InnerWrapJsWantParams( - NativeEngine &engine, NativeObject* object, const std::string &key, const AAFwk::WantParams &wantParams) + napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams) { auto value = wantParams.GetParam(key); TBase *ao = TBase::Query(value); if (ao != nullptr) { NativeT natValue = T::Unbox(ao); - object->SetProperty(key.c_str(), CreateJsValue(engine, natValue)); + napi_set_named_property(env, object, key.c_str(), CreateJsValue(env, natValue)); return true; } return false; } bool InnerWrapJsWantParamsWantParams( - NativeEngine &engine, NativeObject* object, const std::string &key, const AAFwk::WantParams &wantParams); + napi_env env, napi_value object, const std::string &key, const AAFwk::WantParams &wantParams); bool WrapJsWantParamsArray( - NativeEngine &engine, NativeObject* object, const std::string &key, sptr &ao); + napi_env env, napi_value object, const std::string &key, sptr &ao); template bool InnerWrapWantParamsArray( - NativeEngine &engine, NativeObject* object, const std::string &key, sptr &ao) + napi_env env, napi_value object, const std::string &key, sptr &ao) { long size = 0; if (ao->GetLength(size) != ERR_OK) { @@ -71,7 +71,7 @@ bool InnerWrapWantParamsArray( } } } - object->SetProperty(key.c_str(), CreateNativeArray(engine, natArray)); + napi_set_named_property(env, object, key.c_str(), CreateNativeArray(env, natArray)); return true; } } // namespace AbilityRuntime diff --git a/frameworks/js/napi/mission_manager/js_mission_listener.cpp b/frameworks/js/napi/mission_manager/js_mission_listener.cpp index 08b81d032a280f79408465a80d79510033571975..9511e37b3393edd63eb8eae3b1ee20e9667783fd 100644 --- a/frameworks/js/napi/mission_manager/js_mission_listener.cpp +++ b/frameworks/js/napi/mission_manager/js_mission_listener.cpp @@ -15,6 +15,7 @@ #include "js_mission_listener.h" + #include "hilog_wrapper.h" #include "js_runtime_utils.h" @@ -54,10 +55,12 @@ void JsMissionListener::OnMissionLabelUpdated(int32_t missionId) CallJsMethod("onMissionLabelUpdated", missionId); } -void JsMissionListener::AddJsListenerObject(int32_t listenerId, NativeValue* jsListenerObject) +void JsMissionListener::AddJsListenerObject(int32_t listenerId, napi_value jsListenerObject) { + napi_ref ref = nullptr; + napi_create_reference(env_, jsListenerObject, 1, &ref); jsListenerObjectMap_.emplace( - listenerId, std::shared_ptr(engine_->CreateReference(jsListenerObject, 1))); + listenerId, std::shared_ptr(reinterpret_cast(ref))); } bool JsMissionListener::RemoveJsListenerObject(int32_t listenerId) @@ -77,43 +80,45 @@ bool JsMissionListener::IsEmpty() void JsMissionListener::CallJsMethod(const std::string &methodName, int32_t missionId) { HILOG_INFO("methodName = %{public}s", methodName.c_str()); - if (engine_ == nullptr) { - HILOG_ERROR("engine_ null"); + if (env_ == nullptr) { + HILOG_ERROR("env_ null"); return; } // js callback should run in js thread - std::unique_ptr complete = std::make_unique - ([jsMissionListener = this, methodName, missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { - if (jsMissionListener) { + wptr jsMissionListener = this; + std::unique_ptr complete = std::make_unique + ([jsMissionListener, methodName, missionId](napi_env env, NapiAsyncTask &task, int32_t status) { + sptr jsMissionListenerSptr = jsMissionListener.promote(); + if (jsMissionListener != nullptr) { jsMissionListener->CallJsMethodInner(methodName, missionId); } }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JsMissionListener::CallJsMethod:" + methodName, - *engine_, std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JsMissionListener::CallJsMethod:" + methodName, + env_, std::make_unique(callback, std::move(execute), std::move(complete))); } void JsMissionListener::CallJsMethodInner(const std::string &methodName, int32_t missionId) { - // jsListenerObjectMap_ may be changed in engine_->CallFunction() - HILOG_DEBUG("CallJsMethodInner enter"); auto tmpMap = jsListenerObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeObject* obj = ConvertNativeValueTo(value); + napi_value obj = (item.second)->GetNapiValue(); if (obj == nullptr) { HILOG_ERROR("Failed to get object"); continue; } - NativeValue* method = obj->GetProperty(methodName.c_str()); - if (method == nullptr || method->TypeOf() == NATIVE_UNDEFINED) { + napi_value method = nullptr; + napi_get_named_property(env_, obj, methodName.c_str(), &method); + if (method == nullptr || AppExecFwk::IsTypeForNapiValue(env_, method, napi_undefined) + || AppExecFwk::IsTypeForNapiValue(env_, method, napi_null)) { HILOG_ERROR("Failed to get %{public}s from object", methodName.c_str()); continue; } - NativeValue* argv[] = { CreateJsValue(*engine_, missionId) }; - engine_->CallFunction(value, method, argv, ArraySize(argv)); + napi_value argv[] = { CreateJsValue(env_, missionId) }; + napi_value callResult = nullptr; + napi_call_function(env_, nullptr, method, ArraySize(argv), argv, &callResult); } } @@ -121,8 +126,8 @@ void JsMissionListener::CallJsMethodInner(const std::string &methodName, int32_t void JsMissionListener::OnMissionIconUpdated(int32_t missionId, const std::shared_ptr &icon) { HILOG_INFO("OnMissionIconUpdated, missionId = %{public}d.", missionId); - if (engine_ == nullptr) { - HILOG_ERROR("engine_ is null"); + if (env_ == nullptr) { + HILOG_ERROR("env_ is null"); return; } @@ -132,45 +137,48 @@ void JsMissionListener::OnMissionIconUpdated(int32_t missionId, const std::share } // js callback must run in js thread - std::unique_ptr complete = std::make_unique - ([jsMissionListener = this, missionId, icon](NativeEngine &engine, AsyncTask &task, int32_t status) { - if (jsMissionListener) { + wptr jsMissionListener = this; + std::unique_ptr complete = std::make_unique + ([jsMissionListener, missionId, icon](napi_env env, NapiAsyncTask &task, int32_t status) { + sptr jsMissionListenerSptr = jsMissionListener.promote(); + if (jsMissionListener != nullptr) { jsMissionListener->CallJsMissionIconUpdated(missionId, icon); } }); - NativeReference* callback = nullptr; - std::unique_ptr execute = nullptr; - AsyncTask::Schedule("JsMissionListener::OnMissionIconUpdated", *engine_, - std::make_unique(callback, std::move(execute), std::move(complete))); + napi_ref callback = nullptr; + std::unique_ptr execute = nullptr; + NapiAsyncTask::Schedule("JsMissionListener::OnMissionIconUpdated", env_, + std::make_unique(callback, std::move(execute), std::move(complete))); } void JsMissionListener::CallJsMissionIconUpdated(int32_t missionId, const std::shared_ptr &icon) { - if (engine_ == nullptr) { - HILOG_ERROR("engine_ is null, not call js mission updated."); + if (env_ == nullptr) { + HILOG_ERROR("env_ is null, not call js mission updated."); return; } - NativeValue* nativeMissionId = CreateJsValue(*engine_, missionId); - auto nativeIcon = reinterpret_cast( - Media::PixelMapNapi::CreatePixelMap(reinterpret_cast(engine_), icon)); + napi_value nativeMissionId = CreateJsValue(env_, missionId); + auto nativeIcon = Media::PixelMapNapi::CreatePixelMap(env_, icon); auto tmpMap = jsListenerObjectMap_; for (auto &item : tmpMap) { - NativeValue* value = (item.second)->Get(); - NativeObject* listenerObj = ConvertNativeValueTo(value); - if (listenerObj == nullptr) { - HILOG_ERROR("error to get js object"); + napi_value obj = (item.second)->GetNapiValue(); + if (obj == nullptr) { + HILOG_ERROR("Failed to get js object"); continue; } - NativeValue* method = listenerObj->GetProperty("onMissionIconUpdated"); - if (method == nullptr || method->TypeOf() == NATIVE_UNDEFINED) { - HILOG_ERROR("error to get onMissionIconUpdated method from object"); + napi_value method = nullptr; + napi_get_named_property(env_, obj, "onMissionIconUpdated", &method); + if (method == nullptr || AppExecFwk::IsTypeForNapiValue(env_, method, napi_undefined) + || AppExecFwk::IsTypeForNapiValue(env_, method, napi_null)) { + HILOG_ERROR("Failed to get onMissionIconUpdated method from object"); continue; } - NativeValue* argv[] = { nativeMissionId, nativeIcon }; - engine_->CallFunction(value, method, argv, ArraySize(argv)); + napi_value argv[] = { nativeMissionId, nativeIcon }; + napi_value callResult = nullptr; + napi_call_function(env_, nullptr, method, ArraySize(argv), argv, &callResult); } } #endif diff --git a/frameworks/js/napi/mission_manager/js_mission_listener.h b/frameworks/js/napi/mission_manager/js_mission_listener.h index e791279df5bd3feda5b32e73b851921f7178e5a7..ecc4537e4177b98b06390e61295b725fbcfbc8b8 100644 --- a/frameworks/js/napi/mission_manager/js_mission_listener.h +++ b/frameworks/js/napi/mission_manager/js_mission_listener.h @@ -22,12 +22,13 @@ #include "event_handler.h" #include "mission_listener_stub.h" #include "native_engine/native_engine.h" +#include "napi_common_util.h" namespace OHOS { namespace AbilityRuntime { class JsMissionListener : public AAFwk::MissionListenerStub { public: - explicit JsMissionListener(NativeEngine* engine) : engine_(engine) {} + explicit JsMissionListener(napi_env env) : env_(env) {} virtual ~JsMissionListener() = default; void OnMissionCreated(int32_t missionId) override; @@ -37,7 +38,7 @@ public: void OnMissionClosed(int32_t missionId) override; void OnMissionLabelUpdated(int32_t missionId) override; - void AddJsListenerObject(int32_t listenerId, NativeValue* jsListenerObject); + void AddJsListenerObject(int32_t listenerId, napi_value jsListenerObject); bool RemoveJsListenerObject(int32_t listenerId); bool IsEmpty(); @@ -53,7 +54,7 @@ private: void CallJsMethod(const std::string &methodName, int32_t missionId); void CallJsMethodInner(const std::string &methodName, int32_t missionId); - NativeEngine* engine_ = nullptr; + napi_env env_ = nullptr; std::map> jsListenerObjectMap_; std::shared_ptr mainHandler_; }; diff --git a/frameworks/js/napi/mission_manager/mission_manager.cpp b/frameworks/js/napi/mission_manager/mission_manager.cpp index ba8da62c2019ede5f59d945d469a90856fba0155..9cf8d5f51ff89cca5cb4396ed560f404d10439e4 100644 --- a/frameworks/js/napi/mission_manager/mission_manager.cpp +++ b/frameworks/js/napi/mission_manager/mission_manager.cpp @@ -25,6 +25,7 @@ #include "js_runtime_utils.h" #include "mission_snapshot.h" #include "napi_common_start_options.h" +#include "napi_common_util.h" #include "permission_constants.h" #ifdef SUPPORT_GRAPHICS #include "pixel_map_napi.h" @@ -46,243 +47,243 @@ public: JsMissionManager() = default; ~JsMissionManager() = default; - static void Finalizer(NativeEngine* engine, void* data, void* hint) + static void Finalizer(napi_env env, void* data, void* hint) { HILOG_INFO("JsMissionManager::Finalizer is called"); std::unique_ptr(static_cast(data)); } - static NativeValue* RegisterMissionListener(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value RegisterMissionListener(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnRegisterMissionListener(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnRegisterMissionListener); } - static NativeValue* UnregisterMissionListener(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value UnregisterMissionListener(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnUnregisterMissionListener(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnUnregisterMissionListener); } - static NativeValue* GetMissionInfos(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetMissionInfos(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionInfos(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionInfos); } - static NativeValue* GetMissionInfo(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetMissionInfo(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionInfo(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionInfo); } - static NativeValue* GetMissionSnapShot(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetMissionSnapShot(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info, false) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetMissionSnapShot); } - static NativeValue* GetLowResolutionMissionSnapShot(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value GetLowResolutionMissionSnapShot(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info, true) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnGetLowResolutionMissionSnapShot); } - static NativeValue* LockMission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value LockMission(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnLockMission(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnLockMission); } - static NativeValue* UnlockMission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value UnlockMission(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnUnlockMission(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnUnlockMission); } - static NativeValue* ClearMission(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value ClearMission(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnClearMission(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnClearMission); } - static NativeValue* ClearAllMissions(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value ClearAllMissions(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnClearAllMissions(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnClearAllMissions); } - static NativeValue* MoveMissionToFront(NativeEngine* engine, NativeCallbackInfo* info) + static napi_value MoveMissionToFront(napi_env env, napi_callback_info info) { - JsMissionManager* me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnMoveMissionToFront(*engine, *info) : nullptr; + GET_CB_INFO_AND_CALL(env, info, JsMissionManager, OnMoveMissionToFront); } private: - NativeValue* OnRegisterMissionListener(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnRegisterMissionListener(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc < 1) { + if (argc < 1) { HILOG_ERROR("Params not match"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } missionListenerId_++; if (missionListener_ != nullptr) { - missionListener_->AddJsListenerObject(missionListenerId_, info.argv[0]); - return engine.CreateNumber(missionListenerId_); + missionListener_->AddJsListenerObject(missionListenerId_, argv[0]); + return CreateJsValue(env, missionListenerId_); } - missionListener_ = new JsMissionListener(&engine); + missionListener_ = new JsMissionListener(env); auto ret = AbilityManagerClient::GetInstance()->RegisterMissionListener(missionListener_); if (ret == 0) { - missionListener_->AddJsListenerObject(missionListenerId_, info.argv[0]); - return engine.CreateNumber(missionListenerId_); + missionListener_->AddJsListenerObject(missionListenerId_, argv[0]); + return CreateJsValue(env, missionListenerId_); } else { HILOG_ERROR("RegisterMissionListener failed, ret = %{public}d", ret); missionListener_ = nullptr; if (ret == CHECK_PERMISSION_FAILED) { - ThrowNoPermissionError(engine, PermissionConstants::PERMISSION_MANAGE_MISSION); + ThrowNoPermissionError(env, PermissionConstants::PERMISSION_MANAGE_MISSION); } else { - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); } - return engine.CreateUndefined(); + return CreateJsUndefined(env); } } - NativeValue* OnUnregisterMissionListener(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnUnregisterMissionListener(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc < 1) { + if (argc < 1) { HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionListenerId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionListenerId)) { + if (!ConvertFromJsValue(env, argv[0], missionListenerId)) { HILOG_ERROR("Parse missionListenerId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = + NapiAsyncTask::CompleteCallback complete = [&missionListener = missionListener_, missionListenerId] - (NativeEngine &engine, AsyncTask &task, int32_t status) { + (napi_env env, NapiAsyncTask &task, int32_t status) { if (!missionListener || !missionListener->RemoveJsListenerObject(missionListenerId)) { - task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER)); + task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER)); return; } if (!missionListener->IsEmpty()) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); return; } auto ret = AbilityManagerClient::GetInstance()->UnRegisterMissionListener(missionListener); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); missionListener = nullptr; } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= 1) ? nullptr : info.argv[1]; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnUnregisterMissionListener", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= 1) ? nullptr : argv[1]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnUnregisterMissionListener", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetMissionInfos(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetMissionInfos(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc < 2) { // at least 2 parameters. + if (argc < 2) { // at least 2 parameters. HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string deviceId; - if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) { + if (!ConvertFromJsValue(env, argv[0], deviceId)) { HILOG_ERROR("Parse deviceId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int numMax = -1; - if (!ConvertFromJsValue(engine, info.argv[1], numMax)) { + if (!ConvertFromJsValue(env, argv[1], numMax)) { HILOG_ERROR("Parse numMax failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [deviceId, numMax](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [deviceId, numMax](napi_env env, NapiAsyncTask &task, int32_t status) { std::vector missionInfos; auto ret = AbilityManagerClient::GetInstance()->GetMissionInfos(deviceId, numMax, missionInfos); if (ret == 0) { - task.Resolve(engine, CreateJsMissionInfoArray(engine, missionInfos)); + task.Resolve(env, CreateJsMissionInfoArray(env, missionInfos)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= 2) ? nullptr : info.argv[2]; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnGetMissionInfos", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= 2) ? nullptr : argv[2]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnGetMissionInfos", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetMissionInfo(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnGetMissionInfo(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc < 2) { + if (argc < 2) { HILOG_ERROR("Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } std::string deviceId; - if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) { + if (!ConvertFromJsValue(env, argv[0], deviceId)) { HILOG_ERROR("Parse deviceId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[1], missionId)) { + if (!ConvertFromJsValue(env, argv[1], missionId)) { HILOG_ERROR("Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [deviceId, missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [deviceId, missionId](napi_env env, NapiAsyncTask &task, int32_t status) { AAFwk::MissionInfo missionInfo; auto ret = AbilityManagerClient::GetInstance()->GetMissionInfo(deviceId, missionId, missionInfo); if (ret == 0) { - task.Resolve(engine, CreateJsMissionInfo(engine, missionInfo)); + task.Resolve(env, CreateJsMissionInfo(env, missionInfo)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc <= 2) ? nullptr : info.argv[2]; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnGetMissionInfo", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc <= 2) ? nullptr : argv[2]; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::OnGetMissionInfo", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnGetMissionSnapShot(NativeEngine &engine, NativeCallbackInfo &info, bool isLowResolution) + napi_value OnGetMissionSnapShot(napi_env env, size_t argc, napi_value* argv) + { + HILOG_INFO("called"); + return GetMissionSnapShot(env, argc, argv, false); + } + + napi_value OnGetLowResolutionMissionSnapShot(napi_env env, size_t argc, napi_value* argv) + { + HILOG_INFO("called"); + return GetMissionSnapShot(env, argc, argv, true); + } + + napi_value GetMissionSnapShot(napi_env env, size_t argc, napi_value* argv, bool isLowResolution) { - HILOG_INFO("%{public}s is called", __FUNCTION__); std::string deviceId; int32_t missionId = -1; - if (!CheckMissionSnapShotParams(engine, info, deviceId, missionId)) { - return engine.CreateUndefined(); + if (!CheckMissionSnapShotParams(env, argc, argv, deviceId, missionId)) { + return CreateJsUndefined(env); } class MissionSnapshotWrap { @@ -297,217 +298,216 @@ private: deviceId, missionId, snapshotWrap->missionSnapshot, isLowResolution); }; - auto complete = [snapshotWrap](NativeEngine &engine, AsyncTask &task, int32_t status) { + auto complete = [snapshotWrap](napi_env env, NapiAsyncTask &task, int32_t status) { if (snapshotWrap->result == 0) { - NativeValue* objValue = engine.CreateObject(); - NativeObject* object = ConvertNativeValueTo(objValue); - NativeValue* abilityValue = engine.CreateObject(); - NativeObject* abilityObj = ConvertNativeValueTo(abilityValue); - abilityObj->SetProperty( - "bundleName", CreateJsValue(engine, snapshotWrap->missionSnapshot.topAbility.GetBundleName())); - abilityObj->SetProperty( - "abilityName", CreateJsValue(engine, snapshotWrap->missionSnapshot.topAbility.GetAbilityName())); - object->SetProperty("ability", abilityValue); + napi_value object = nullptr; + napi_create_object(env, &object); + napi_value abilityObj = nullptr; + napi_create_object(env, &abilityObj); + napi_set_named_property(env, abilityObj, "bundleName", + CreateJsValue(env, snapshotWrap->missionSnapshot.topAbility.GetBundleName())); + napi_set_named_property(env, abilityObj, "abilityName", + CreateJsValue(env, snapshotWrap->missionSnapshot.topAbility.GetAbilityName())); + napi_set_named_property(env, object, "ability", abilityObj); #ifdef SUPPORT_GRAPHICS - auto snapshotValue = reinterpret_cast(Media::PixelMapNapi::CreatePixelMap( - reinterpret_cast(&engine), snapshotWrap->missionSnapshot.snapshot)); - object->SetProperty("snapshot", snapshotValue); + auto snapshotValue = Media::PixelMapNapi::CreatePixelMap( + env, snapshotWrap->missionSnapshot.snapshot); + napi_set_named_property(env, object, "snapshot", snapshotValue); #endif - task.Resolve(engine, objValue); + task.Resolve(env, object); } else { - task.Reject(engine, CreateJsErrorByNativeErr(engine, snapshotWrap->result, + task.Reject(env, CreateJsErrorByNativeErr(env, snapshotWrap->result, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > ARG_COUNT_TWO) ? info.argv[ARG_COUNT_TWO] : nullptr; - NativeValue* result = nullptr; - AsyncTask::Schedule("MissioManager::OnGetMissionSnapShot", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, std::move(excute), std::move(complete), &result)); + napi_value lastParam = (argc > ARG_COUNT_TWO) ? argv[ARG_COUNT_TWO] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("MissioManager::GetMissionSnapShot", + env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(excute), std::move(complete), &result)); return result; } - bool CheckMissionSnapShotParams(NativeEngine &engine, NativeCallbackInfo &info, + bool CheckMissionSnapShotParams(napi_env env, size_t argc, napi_value* argv, std::string &deviceId, int32_t &missionId) { - if (info.argc < ARG_COUNT_TWO) { - ThrowTooFewParametersError(engine); + if (argc < ARG_COUNT_TWO) { + ThrowTooFewParametersError(env); return false; } - if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) { + if (!ConvertFromJsValue(env, argv[0], deviceId)) { HILOG_ERROR("missionSnapshot: Parse deviceId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); return false; } - if (!ConvertFromJsValue(engine, info.argv[1], missionId)) { + if (!ConvertFromJsValue(env, argv[1], missionId)) { HILOG_ERROR("missionSnapshot: Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); return false; } return true; } - NativeValue* OnLockMission(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnLockMission(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnLockMission Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnLockMission Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->LockMissionForCleanup(missionId); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnLockMission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 1) ? argv[1] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnLockMission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnUnlockMission(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnUnlockMission(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnUnlockMission Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnUnlockMission Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->UnlockMissionForCleanup(missionId); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnUnlockMission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 1) ? argv[1] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnUnlockMission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnClearMission(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnClearMission(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnClearMission Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnClearMission Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - AsyncTask::CompleteCallback complete = - [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->CleanMission(missionId); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnClearMission", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 1) ? argv[1] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnClearMission", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnClearAllMissions(NativeEngine &engine, const NativeCallbackInfo &info) + napi_value OnClearAllMissions(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - AsyncTask::CompleteCallback complete = - [](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = AbilityManagerClient::GetInstance()->CleanAllMissions(); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > 0) ? info.argv[0] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > 0) ? argv[0] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } - NativeValue* OnMoveMissionToFront(NativeEngine &engine, NativeCallbackInfo &info) + napi_value OnMoveMissionToFront(napi_env env, size_t argc, napi_value* argv) { HILOG_INFO("%{public}s is called", __FUNCTION__); - if (info.argc == 0) { + if (argc == 0) { HILOG_ERROR("OnMoveMissionToFront Not enough params"); - ThrowTooFewParametersError(engine); - return engine.CreateUndefined(); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); } int32_t missionId = -1; - if (!ConvertFromJsValue(engine, info.argv[0], missionId)) { + if (!ConvertFromJsValue(env, argv[0], missionId)) { HILOG_ERROR("OnMoveMissionToFront Parse missionId failed"); - ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); - return engine.CreateUndefined(); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); } - decltype(info.argc) unwrapArgc = 1; + decltype(argc) unwrapArgc = 1; AAFwk::StartOptions startOptions; - if (info.argc > ARGC_ONE && info.argv[1]->TypeOf() == NATIVE_OBJECT) { + if (argc > ARGC_ONE && AppExecFwk::IsTypeForNapiValue(env, argv[1], napi_object)) { HILOG_INFO("OnMoveMissionToFront start options is used."); - AppExecFwk::UnwrapStartOptions(reinterpret_cast(&engine), - reinterpret_cast(info.argv[1]), startOptions); + AppExecFwk::UnwrapStartOptions(env, argv[1], startOptions); unwrapArgc++; } - AsyncTask::CompleteCallback complete = - [missionId, startOptions, unwrapArgc](NativeEngine &engine, AsyncTask &task, int32_t status) { + NapiAsyncTask::CompleteCallback complete = + [missionId, startOptions, unwrapArgc](napi_env env, NapiAsyncTask &task, int32_t status) { auto ret = (unwrapArgc == 1) ? AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId) : AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId, startOptions); if (ret == 0) { - task.Resolve(engine, engine.CreateUndefined()); + task.Resolve(env, CreateJsUndefined(env)); } else { - task.Reject(engine, - CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); + task.Reject(env, + CreateJsErrorByNativeErr(env, ret, PermissionConstants::PERMISSION_MANAGE_MISSION)); } }; - NativeValue* lastParam = (info.argc > unwrapArgc) ? info.argv[unwrapArgc] : nullptr; - NativeValue* result = nullptr; - AsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", - engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result)); + napi_value lastParam = (argc > unwrapArgc) ? argv[unwrapArgc] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("MissioManager::OnMoveMissionToFront", + env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result)); return result; } @@ -515,39 +515,33 @@ private: uint32_t missionListenerId_ = 0; }; -NativeValue* JsMissionManagerInit(NativeEngine* engine, NativeValue* exportObj) +napi_value JsMissionManagerInit(napi_env env, napi_value exportObj) { HILOG_INFO("JsMissionManagerInit is called"); - if (engine == nullptr || exportObj == nullptr) { + if (env == nullptr || exportObj == nullptr) { HILOG_INFO("Invalid input parameters"); return nullptr; } - NativeObject* object = ConvertNativeValueTo(exportObj); - if (object == nullptr) { - HILOG_INFO("object is nullptr"); - return nullptr; - } - std::unique_ptr jsMissionManager = std::make_unique(); - object->SetNativePointer(jsMissionManager.release(), JsMissionManager::Finalizer, nullptr); + napi_wrap(env, exportObj, jsMissionManager.release(), JsMissionManager::Finalizer, nullptr, nullptr); const char *moduleName = "JsMissionManager"; - BindNativeFunction(*engine, *object, "registerMissionListener", + BindNativeFunction(env, exportObj, "registerMissionListener", moduleName, JsMissionManager::RegisterMissionListener); - BindNativeFunction(*engine, *object, "unregisterMissionListener", + BindNativeFunction(env, exportObj, "unregisterMissionListener", moduleName, JsMissionManager::UnregisterMissionListener); - BindNativeFunction(*engine, *object, "getMissionInfos", moduleName, JsMissionManager::GetMissionInfos); - BindNativeFunction(*engine, *object, "getMissionInfo", moduleName, JsMissionManager::GetMissionInfo); - BindNativeFunction(*engine, *object, "getMissionSnapShot", moduleName, JsMissionManager::GetMissionSnapShot); - BindNativeFunction(*engine, *object, "getLowResolutionMissionSnapShot", moduleName, + BindNativeFunction(env, exportObj, "getMissionInfos", moduleName, JsMissionManager::GetMissionInfos); + BindNativeFunction(env, exportObj, "getMissionInfo", moduleName, JsMissionManager::GetMissionInfo); + BindNativeFunction(env, exportObj, "getMissionSnapShot", moduleName, JsMissionManager::GetMissionSnapShot); + BindNativeFunction(env, exportObj, "getLowResolutionMissionSnapShot", moduleName, JsMissionManager::GetLowResolutionMissionSnapShot); - BindNativeFunction(*engine, *object, "lockMission", moduleName, JsMissionManager::LockMission); - BindNativeFunction(*engine, *object, "unlockMission", moduleName, JsMissionManager::UnlockMission); - BindNativeFunction(*engine, *object, "clearMission", moduleName, JsMissionManager::ClearMission); - BindNativeFunction(*engine, *object, "clearAllMissions", moduleName, JsMissionManager::ClearAllMissions); - BindNativeFunction(*engine, *object, "moveMissionToFront", moduleName, JsMissionManager::MoveMissionToFront); - return engine->CreateUndefined(); + BindNativeFunction(env, exportObj, "lockMission", moduleName, JsMissionManager::LockMission); + BindNativeFunction(env, exportObj, "unlockMission", moduleName, JsMissionManager::UnlockMission); + BindNativeFunction(env, exportObj, "clearMission", moduleName, JsMissionManager::ClearMission); + BindNativeFunction(env, exportObj, "clearAllMissions", moduleName, JsMissionManager::ClearAllMissions); + BindNativeFunction(env, exportObj, "moveMissionToFront", moduleName, JsMissionManager::MoveMissionToFront); + return CreateJsUndefined(env); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/js/napi/mission_manager/mission_manager.h b/frameworks/js/napi/mission_manager/mission_manager.h index 21e3c038a78382e6be8fa7b6762e4108d588dc02..625e74874f34d8c3e26d2d472955923466a2cc17 100644 --- a/frameworks/js/napi/mission_manager/mission_manager.h +++ b/frameworks/js/napi/mission_manager/mission_manager.h @@ -21,7 +21,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue* JsMissionManagerInit(NativeEngine* engine, NativeValue* exportObj); +napi_value JsMissionManagerInit(napi_env engine, napi_value exportObj); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_H diff --git a/frameworks/js/napi/mission_manager/native_module.cpp b/frameworks/js/napi/mission_manager/native_module.cpp index b47a5bc5494f9f73197d3e478f5cdf8d35dda3f0..14f55dae9ccd9612c641c5d2a7f779768e95b20e 100644 --- a/frameworks/js/napi/mission_manager/native_module.cpp +++ b/frameworks/js/napi/mission_manager/native_module.cpp @@ -16,15 +16,14 @@ #include "mission_manager.h" #include "native_engine/native_engine.h" -extern "C" __attribute__((constructor)) -void NAPI_application_missionmanager_AutoRegister() -{ - auto moduleManager = NativeModuleManager::GetInstance(); - NativeModule newModuleInfo = { - .name = "application.missionManager", - .fileName = "application/libmissionmanager_napi.so/missionmanager.js", - .registerCallback = OHOS::AbilityRuntime::JsMissionManagerInit, - }; +static napi_module _module = { + .nm_version = 0, + .nm_modname = "application.missionManager", + .nm_filename = "application/libmissionmanager_napi.so/missionmanager.js", + .nm_register_func = OHOS::AbilityRuntime::JsMissionManagerInit, +}; - moduleManager->Register(&newModuleInfo); +extern "C" __attribute__((constructor)) void NAPI_application_missionmanager_AutoRegister(void) +{ + napi_module_register(&_module); }