diff --git a/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_callback.cpp b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_callback.cpp new file mode 100644 index 0000000000..4ea6e56724 --- /dev/null +++ b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_callback.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "js_ability_auto_startup_callback.h" + +#include "hilog_wrapper.h" +#include "js_ability_auto_startup_manager_utils.h" +#include "js_runtime.h" +#include "js_runtime_utils.h" + +namespace OHOS { +namespace AbilityRuntime { +namespace { +const std::string METHOD_ON = "onAutoStartupOn"; +const std::string METHOD_OFF = "onAutoStartupOff"; +} // namespace +JsAbilityAutoStartupCallBack::JsAbilityAutoStartupCallBack(napi_env env) : env_(env) {} + +JsAbilityAutoStartupCallBack::~JsAbilityAutoStartupCallBack() {} + +void JsAbilityAutoStartupCallBack::OnAutoStartupOn(const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called."); + JSCallFunction(info, METHOD_ON); +} + +void JsAbilityAutoStartupCallBack::OnAutoStartupOff(const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called."); + JSCallFunction(info, METHOD_OFF); +} + +void JsAbilityAutoStartupCallBack::Register(napi_value value) +{ + HILOG_DEBUG("Called."); + std::lock_guard lock(mutexlock); + for (auto callback : callbacks_) { + if (IsJsCallbackEquals(callback, value)) { + HILOG_ERROR("The current callback already exists."); + return; + } + } + + napi_ref ref = nullptr; + napi_create_reference(env_, value, 1, &ref); + callbacks_.emplace_back(std::unique_ptr(reinterpret_cast(ref))); +} + +void JsAbilityAutoStartupCallBack::UnRegister(napi_value value) +{ + HILOG_DEBUG("Called."); + napi_valuetype type = napi_undefined; + napi_typeof(env_, value, &type); + std::lock_guard lock(mutexlock); + if (type == napi_undefined || type == napi_null) { + HILOG_DEBUG("jsCallback is nullptr, delete all callback."); + callbacks_.clear(); + return; + } + + for (auto item = callbacks_.begin(); item != callbacks_.end();) { + if (IsJsCallbackEquals(*item, value)) { + item = callbacks_.erase(item); + } else { + item++; + } + } +} + +bool JsAbilityAutoStartupCallBack::IsCallbacksEmpty() +{ + return callbacks_.empty(); +} + +void JsAbilityAutoStartupCallBack::JSCallFunction(const AutoStartupInfo &info, const std::string &methodName) +{ + wptr stub = iface_cast(AsObject()); + NapiAsyncTask::CompleteCallback complete = [stub, info, methodName]( + napi_env env, NapiAsyncTask &task, int32_t status) { + sptr obj = stub.promote(); + if (obj == nullptr) { + HILOG_ERROR("Callback object is nullptr"); + return; + } + + obj->JSCallFunctionWorker(info, methodName); + }; + + NapiAsyncTask::Schedule("JsAbilityAutoStartupCallBack::JSCallFunction:" + methodName, env_, + CreateAsyncTaskWithLastParam(env_, nullptr, nullptr, std::move(complete), nullptr)); +} + +void JsAbilityAutoStartupCallBack::JSCallFunctionWorker(const AutoStartupInfo &info, const std::string &methodName) +{ + std::lock_guard lock(mutexlock); + for (auto callback : callbacks_) { + if (callback == nullptr) { + HILOG_ERROR("callback is nullptr."); + continue; + } + + auto obj = callback->GetNapiValue(); + if (obj == nullptr) { + HILOG_ERROR("Failed to get value."); + continue; + } + + napi_value funcObject; + if (napi_get_named_property(env_, obj, methodName.c_str(), &funcObject) != napi_ok) { + HILOG_ERROR("Get function by name failed."); + continue; + } + + napi_value argv[] = { CreateJsAutoStartupInfo(env_, info) }; + napi_call_function(env_, obj, funcObject, ArraySize(argv), argv, nullptr); + } +} + +bool JsAbilityAutoStartupCallBack::IsJsCallbackEquals(std::shared_ptr callback, napi_value value) +{ + if (callback == nullptr) { + HILOG_ERROR("Invalid jsCallback."); + return false; + } + + auto object = callback->GetNapiValue(); + if (object == nullptr) { + HILOG_ERROR("Failed to get object."); + return false; + } + + bool result = false; + if (napi_strict_equals(env_, object, value, &result) != napi_ok) { + HILOG_ERROR("Object does not match value."); + return false; + } + + return result; +} +} // namespace AbilityRuntime +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_callback.h b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_callback.h new file mode 100644 index 0000000000..ddf14d303b --- /dev/null +++ b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_callback.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_CALLBACK_H +#define OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_CALLBACK_H + +#include +#include + +#include "auto_startup_callback_stub.h" +#include "auto_startup_info.h" +#include "native_engine/native_engine.h" +#include "native_engine/native_value.h" +#include "parcel.h" + +class NativeReference; +namespace OHOS { +namespace AbilityRuntime { +/** + * + * @class JsAbilityAutoStartupCallBack + */ +class JsAbilityAutoStartupCallBack : public AutoStartupCallBackStub { +public: + explicit JsAbilityAutoStartupCallBack(napi_env env); + virtual ~JsAbilityAutoStartupCallBack(); + void Register(napi_value value); + void UnRegister(napi_value value); + void OnAutoStartupOn(const AutoStartupInfo &info) override; + void OnAutoStartupOff(const AutoStartupInfo &info) override; + bool IsCallbacksEmpty(); + +private: + void JSCallFunction(const AutoStartupInfo &info, const std::string &methodName); + void JSCallFunctionWorker(const AutoStartupInfo &info, const std::string &methodName); + bool IsJsCallbackEquals(std::shared_ptr callback, napi_value value); + + napi_env env_; + std::vector> callbacks_; + std::mutex mutexlock; +}; +} // namespace AbilityRuntime +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_CALLBACK_H diff --git a/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_manager_utils.cpp b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_manager_utils.cpp new file mode 100644 index 0000000000..d153bd46ed --- /dev/null +++ b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_manager_utils.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "js_ability_auto_startup_manager_utils.h" +#include "napi_common_util.h" + +namespace OHOS { +namespace AbilityRuntime { +bool UnwrapAutoStartupInfo(napi_env env, napi_value param, AutoStartupInfo &info) +{ + if (!IsNormalObject(env, param)) { + HILOG_ERROR("param is invalid."); + return false; + } + + if (!AppExecFwk::UnwrapStringByPropertyName(env, param, "bundleName", info.bundleName)) { + HILOG_ERROR("Convert bundle name failed."); + return false; + } + + if (!AppExecFwk::UnwrapStringByPropertyName(env, param, "abilityName", info.abilityName)) { + HILOG_ERROR("Convert ability name failed."); + return false; + } + + AppExecFwk::UnwrapStringByPropertyName(env, param, "moduleName", info.moduleName); + return true; +} + +bool IsNormalObject(napi_env env, napi_value value) +{ + if (value == nullptr) { + HILOG_ERROR("value is nullptr."); + return false; + } + napi_valuetype type; + napi_typeof(env, value, &type); + if (type == napi_undefined || type == napi_null) { + HILOG_ERROR("value is invalid type."); + return false; + } + if (type != napi_object) { + HILOG_ERROR("Invalid type."); + return false; + } + return true; +} + +napi_value CreateJsAutoStartupInfoArray(napi_env env, const std::vector &infoList) +{ + HILOG_DEBUG("Called."); + napi_value arrayObj = nullptr; + napi_create_array(env, &arrayObj); + for (size_t i = 0; i < infoList.size(); ++i) { + auto object = CreateJsAutoStartupInfo(env, infoList.at(i)); + if (object == nullptr) { + HILOG_ERROR("Convert object failed."); + return nullptr; + } + + if (napi_set_element(env, arrayObj, i, object) != napi_ok) { + HILOG_ERROR("Inster object to array failed."); + return nullptr; + } + } + + return arrayObj; +} + +napi_value CreateJsAutoStartupInfo(napi_env env, const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called."); + napi_value object = AppExecFwk::CreateJSObject(env); + if (object == nullptr) { + HILOG_ERROR("object is nullptr."); + return nullptr; + } + + napi_value bundleName = AppExecFwk::WrapStringToJS(env, info.bundleName); + if (bundleName == nullptr) { + HILOG_ERROR("Convert bundle name failed."); + return nullptr; + } + + napi_value abilityName = AppExecFwk::WrapStringToJS(env, info.abilityName); + if (abilityName == nullptr) { + HILOG_ERROR("Convert ability name failed."); + return nullptr; + } + + napi_value moduleName = AppExecFwk::WrapStringToJS(env, info.moduleName); + if (moduleName == nullptr) { + HILOG_ERROR("Convert module name failed."); + return nullptr; + } + + napi_value abilityTypeName = AppExecFwk::WrapStringToJS(env, info.abilityTypeName); + if (abilityTypeName == nullptr) { + HILOG_ERROR("Convert ability type name failed."); + return nullptr; + } + + if (!(AppExecFwk::SetPropertyValueByPropertyName(env, object, "bundleName", bundleName) && + AppExecFwk::SetPropertyValueByPropertyName(env, object, "abilityName", abilityName) && + AppExecFwk::SetPropertyValueByPropertyName(env, object, "moduleName", moduleName) && + AppExecFwk::SetPropertyValueByPropertyName(env, object, "abilityTypeName", abilityTypeName))) { + HILOG_ERROR("Create js AutoStartupInfo failed."); + return nullptr; + } + return object; +} +} // namespace AbilityRuntime +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_manager_utils.h b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_manager_utils.h new file mode 100644 index 0000000000..db35f4e804 --- /dev/null +++ b/frameworks/js/napi/ability_auto_startup_callback/js_ability_auto_startup_manager_utils.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_MANAGER_UTILS_H +#define OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_MANAGER_UTILS_H + +#include "auto_startup_info.h" +#include "hilog_wrapper.h" +#include "js_runtime.h" +#include "js_runtime_utils.h" +#include "native_engine/native_engine.h" +#include "native_engine/native_value.h" + +namespace OHOS { +namespace AbilityRuntime { +bool UnwrapAutoStartupInfo(napi_env env, napi_value param, AutoStartupInfo &info); +bool IsNormalObject(napi_env env, napi_value value); +napi_value CreateJsAutoStartupInfoArray(napi_env env, const std::vector &infoList); +napi_value CreateJsAutoStartupInfo(napi_env env, const AutoStartupInfo &info); +} // namespace AbilityRuntime +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_MANAGER_UTILS_H \ No newline at end of file diff --git a/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp new file mode 100644 index 0000000000..3c1d2ba1c4 --- /dev/null +++ b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.cpp @@ -0,0 +1,328 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "js_ability_auto_startup_manager.h" + +#include "ability_business_error.h" +#include "ability_manager_client.h" +#include "ability_manager_interface.h" +#include "auto_startup_info.h" +#include "hilog_wrapper.h" +#include "ipc_skeleton.h" +#include "js_ability_auto_startup_manager_utils.h" +#include "js_error_utils.h" +#include "js_runtime_utils.h" +#include "permission_constants.h" +#include "tokenid_kit.h" + +namespace OHOS { +namespace AbilityRuntime { +using namespace OHOS::AAFwk; +namespace { +constexpr size_t ARGC_ONE = 1; +constexpr size_t ARGC_TWO = 2; +constexpr int32_t INDEX_ZERO = 0; +constexpr int32_t INDEX_ONE = 1; +constexpr const char *ON_OFF_TYPE_SYSTEM = "systemAutoStartup"; +} // namespace + +void JsAbilityAutoStartupManager::Finalizer(napi_env env, void *data, void *hint) +{ + HILOG_DEBUG("Called."); + std::unique_ptr(static_cast(data)); +} + +napi_value JsAbilityAutoStartupManager::RegisterAutoStartupCallback(napi_env env, napi_callback_info info) +{ + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnRegisterAutoStartupCallback); +} + +napi_value JsAbilityAutoStartupManager::UnregisterAutoStartupCallback(napi_env env, napi_callback_info info) +{ + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnUnregisterAutoStartupCallback); +} + +napi_value JsAbilityAutoStartupManager::SetApplicationAutoStartup(napi_env env, napi_callback_info info) +{ + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnSetApplicationAutoStartup); +} + +napi_value JsAbilityAutoStartupManager::CancelApplicationAutoStartup(napi_env env, napi_callback_info info) +{ + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnCancelApplicationAutoStartup); +} + +napi_value JsAbilityAutoStartupManager::QueryAllAutoStartupApplications(napi_env env, napi_callback_info info) +{ + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityAutoStartupManager, OnQueryAllAutoStartupApplications); +} + +bool JsAbilityAutoStartupManager::CheckCallerIsSystemApp() +{ + auto selfToken = IPCSkeleton::GetSelfTokenID(); + if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) { + HILOG_ERROR("Current app is not system app, not allow."); + return false; + } + return true; +} + +napi_value JsAbilityAutoStartupManager::OnRegisterAutoStartupCallback(napi_env env, NapiCallbackInfo &info) +{ + HILOG_DEBUG("Called."); + if (info.argc < ARGC_TWO) { + HILOG_ERROR("The param is invalid."); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); + } + + std::string type; + if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], type) || type != ON_OFF_TYPE_SYSTEM) { + HILOG_ERROR("The param is invalid."); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); + } + + if (!CheckCallerIsSystemApp()) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); + } + + if (jsAutoStartupCallback_ == nullptr) { + jsAutoStartupCallback_ = new (std::nothrow) JsAbilityAutoStartupCallBack(env); + if (jsAutoStartupCallback_ == nullptr) { + HILOG_ERROR("JsAutoStartupCallback_ is nullptr."); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); + } + + auto ret = + AbilityManagerClient::GetInstance()->RegisterAutoStartupSystemCallback(jsAutoStartupCallback_->AsObject()); + if (ret != ERR_OK) { + jsAutoStartupCallback_ = nullptr; + HILOG_ERROR("Register auto start up listener error[%{public}d].", ret); + ThrowError(env, GetJsErrorCodeByNativeError(ret)); + return CreateJsUndefined(env); + } + } + + jsAutoStartupCallback_->Register(info.argv[INDEX_ONE]); + return CreateJsUndefined(env); +} + +napi_value JsAbilityAutoStartupManager::OnUnregisterAutoStartupCallback(napi_env env, NapiCallbackInfo &info) +{ + HILOG_DEBUG("Called."); + if (info.argc < ARGC_ONE) { + HILOG_ERROR("The param is invalid."); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); + } + + std::string type; + if (!ConvertFromJsValue(env, info.argv[INDEX_ZERO], type) || type != ON_OFF_TYPE_SYSTEM) { + HILOG_ERROR("Failed to parse type."); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); + } + + if (!CheckCallerIsSystemApp()) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); + } + + if (jsAutoStartupCallback_ == nullptr) { + HILOG_ERROR("JsAutoStartupCallback_ is nullptr."); + ThrowError(env, AbilityErrorCode::ERROR_CODE_INNER); + return CreateJsUndefined(env); + } + + auto callback = info.argc > ARGC_ONE ? info.argv[INDEX_ONE] : CreateJsUndefined(env); + jsAutoStartupCallback_->UnRegister(callback); + if (jsAutoStartupCallback_->IsCallbacksEmpty()) { + auto ret = AbilityManagerClient::GetInstance()->UnregisterAutoStartupSystemCallback( + jsAutoStartupCallback_->AsObject()); + if (ret != ERR_OK) { + ThrowError(env, GetJsErrorCodeByNativeError(ret)); + } + jsAutoStartupCallback_ = nullptr; + } + + return CreateJsUndefined(env); +} + +napi_value JsAbilityAutoStartupManager::OnSetApplicationAutoStartup(napi_env env, NapiCallbackInfo &info) +{ + HILOG_DEBUG("Called."); + if (info.argc < ARGC_ONE) { + HILOG_ERROR("The param is invalid."); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); + } + + if (!CheckCallerIsSystemApp()) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); + } + + AutoStartupInfo autoStartupInfo; + if (!UnwrapAutoStartupInfo(env, info.argv[INDEX_ZERO], autoStartupInfo)) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); + } + + auto retVal = std::make_shared(0); + NapiAsyncTask::ExecuteCallback execute = [autoStartupInfo, ret = retVal] () { + if (ret == nullptr) { + HILOG_ERROR("The param is invalid."); + return; + } + *ret = AbilityManagerClient::GetInstance()->SetApplicationAutoStartup(autoStartupInfo); + }; + NapiAsyncTask::CompleteCallback complete = [ret = retVal](napi_env env, NapiAsyncTask &task, int32_t status) { + if (ret == nullptr) { + HILOG_ERROR("The param is invalid."); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(INNER_ERR))); + return; + } + if (*ret != ERR_OK) { + HILOG_ERROR("Failed error:%{public}d.", *ret); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(*ret))); + return; + } + task.ResolveWithNoError(env, CreateJsUndefined(env)); + }; + + napi_value lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::ScheduleHighQos("JsAbilityAutoStartupManager::OnSetApplicationAutoStartup", env, + CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); + return result; +} + +napi_value JsAbilityAutoStartupManager::OnCancelApplicationAutoStartup(napi_env env, NapiCallbackInfo &info) +{ + HILOG_DEBUG("Called."); + if (info.argc < ARGC_ONE) { + HILOG_ERROR("The param is invalid."); + ThrowTooFewParametersError(env); + return CreateJsUndefined(env); + } + + if (!CheckCallerIsSystemApp()) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); + } + + AutoStartupInfo autoStartupInfo; + if (!UnwrapAutoStartupInfo(env, info.argv[INDEX_ZERO], autoStartupInfo)) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_PARAM); + return CreateJsUndefined(env); + } + + auto retVal = std::make_shared(0); + NapiAsyncTask::ExecuteCallback execute = [autoStartupInfo, ret = retVal] () { + if (ret == nullptr) { + HILOG_ERROR("The param is invalid."); + return; + } + *ret = AbilityManagerClient::GetInstance()->CancelApplicationAutoStartup(autoStartupInfo); + }; + + NapiAsyncTask::CompleteCallback complete = [ret = retVal](napi_env env, NapiAsyncTask &task, int32_t status) { + if (ret == nullptr) { + HILOG_ERROR("The param is invalid."); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(INNER_ERR))); + return; + } + if (*ret != ERR_OK) { + HILOG_ERROR("Failed error:%{public}d.", *ret); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(*ret))); + return; + } + task.ResolveWithNoError(env, CreateJsUndefined(env)); + }; + + napi_value lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JsAbilityAutoStartupManager::OnCancelApplicationAutoStartup", env, + CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); + return result; +} + +napi_value JsAbilityAutoStartupManager::OnQueryAllAutoStartupApplications(napi_env env, const NapiCallbackInfo &info) +{ + HILOG_DEBUG("Called."); + if (!CheckCallerIsSystemApp()) { + ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP); + return CreateJsUndefined(env); + } + + auto retVal = std::make_shared(0); + auto infoList = std::make_shared>(); + NapiAsyncTask::ExecuteCallback execute = [infos = infoList, ret = retVal] () { + if (ret == nullptr || infos == nullptr) { + HILOG_ERROR("The param is invalid."); + return; + } + *ret = AbilityManagerClient::GetInstance()->QueryAllAutoStartupApplications(*infos); + }; + + NapiAsyncTask::CompleteCallback complete = [infos = infoList, ret = retVal] (napi_env env, NapiAsyncTask &task, int32_t status) { + if (ret == nullptr || infos == nullptr) { + HILOG_ERROR("The param is invalid."); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(INNER_ERR))); + return; + } + if (*ret != ERR_OK) { + HILOG_ERROR("Failed error:%{public}d.", *ret); + task.Reject(env, CreateJsError(env, GetJsErrorCodeByNativeError(*ret))); + return; + } + task.ResolveWithNoError(env, CreateJsAutoStartupInfoArray(env, *infos)); + }; + + napi_value lastParam = (info.argc == ARGC_TWO) ? info.argv[INDEX_ONE] : nullptr; + napi_value result = nullptr; + NapiAsyncTask::Schedule("JsAbilityAutoStartupManager::OnCancelApplicationAutoStartup", env, + CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result)); + return result; +} + +napi_value JsAbilityAutoStartupManagerInit(napi_env env, napi_value exportObj) +{ + HILOG_DEBUG("Called."); + if (env == nullptr || exportObj == nullptr) { + HILOG_ERROR("Env or exportObj nullptr."); + return nullptr; + } + + auto jsAbilityAutoStartupManager = std::make_unique(); + napi_wrap(env, exportObj, jsAbilityAutoStartupManager.release(), + JsAbilityAutoStartupManager::Finalizer, nullptr, nullptr); + + const char *moduleName = "JsAbilityAutoStartupManager"; + BindNativeFunction(env, exportObj, "on", moduleName, JsAbilityAutoStartupManager::RegisterAutoStartupCallback); + BindNativeFunction(env, exportObj, "off", moduleName, JsAbilityAutoStartupManager::UnregisterAutoStartupCallback); + BindNativeFunction(env, exportObj, "setApplicationAutoStartup", moduleName, + JsAbilityAutoStartupManager::SetApplicationAutoStartup); + BindNativeFunction(env, exportObj, "cancelApplicationAutoStartup", moduleName, + JsAbilityAutoStartupManager::CancelApplicationAutoStartup); + BindNativeFunction(env, exportObj, "queryAllAutoStartupApplications", moduleName, + JsAbilityAutoStartupManager::QueryAllAutoStartupApplications); + HILOG_DEBUG("End."); + return CreateJsUndefined(env); +} +} // namespace AbilityRuntime +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h new file mode 100644 index 0000000000..e6f0f72745 --- /dev/null +++ b/frameworks/js/napi/ability_auto_startup_manager/js_ability_auto_startup_manager.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_MANAGER_H +#define OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_MANAGER_H + +#include "js_ability_auto_startup_callback.h" +#include "js_runtime.h" +#include "js_runtime_utils.h" +#include "native_engine/native_engine.h" +#include "native_engine/native_value.h" + +namespace OHOS { +namespace AbilityRuntime { +class JsAbilityAutoStartupManager { +public: + JsAbilityAutoStartupManager() = default; + ~JsAbilityAutoStartupManager() = default; + static void Finalizer(napi_env env, void *data, void *hint); + static napi_value RegisterAutoStartupCallback(napi_env env, napi_callback_info info); + static napi_value UnregisterAutoStartupCallback(napi_env env, napi_callback_info info); + static napi_value SetApplicationAutoStartup(napi_env env, napi_callback_info info); + static napi_value CancelApplicationAutoStartup(napi_env env, napi_callback_info info); + static napi_value QueryAllAutoStartupApplications(napi_env env, napi_callback_info info); + +private: + napi_value OnRegisterAutoStartupCallback(napi_env env, NapiCallbackInfo &info); + napi_value OnUnregisterAutoStartupCallback(napi_env env, NapiCallbackInfo &info); + napi_value OnSetApplicationAutoStartup(napi_env env, NapiCallbackInfo &info); + napi_value OnCancelApplicationAutoStartup(napi_env env, NapiCallbackInfo &info); + napi_value OnQueryAllAutoStartupApplications(napi_env env, const NapiCallbackInfo &info); + bool CheckCallerIsSystemApp(); + + sptr jsAutoStartupCallback_; +}; +napi_value JsAbilityAutoStartupManagerInit(napi_env env, napi_value exportObj); +} // namespace AbilityRuntime +} // namespace OHOS + +#endif // OHOS_ABILITY_RUNTIME_JS_ABILITY_AUTO_STARTUP_MANAGER_H \ No newline at end of file diff --git a/frameworks/js/napi/js_child_process_manager/js_child_process_manager.cpp b/frameworks/js/napi/js_child_process_manager/js_child_process_manager.cpp index 5f7b5dbdc0..04229953e9 100644 --- a/frameworks/js/napi/js_child_process_manager/js_child_process_manager.cpp +++ b/frameworks/js/napi/js_child_process_manager/js_child_process_manager.cpp @@ -103,7 +103,7 @@ private: AbilityErrorCode preCheck() { - auto mgr = ChildProcessManager::GetInstance(); + auto &mgr = ChildProcessManager::GetInstance(); if (!mgr.MultiProcessModelEnabled()) { HILOG_ERROR("Starting child process is not supported"); return AbilityErrorCode::ERROR_CODE_OPERATION_NOT_SUPPORTED; diff --git a/frameworks/native/ability/native/ability.cpp b/frameworks/native/ability/native/ability.cpp index 81c3df3c5f..8f987a6eb1 100644 --- a/frameworks/native/ability/native/ability.cpp +++ b/frameworks/native/ability/native/ability.cpp @@ -1691,6 +1691,15 @@ void Ability::SetShowOnLockScreen(bool showOnLockScreen) HILOG_DEBUG("SetShowOnLockScreen come, addWindowFlag, showOnLockScreen is %{public}d", showOnLockScreen); if (showOnLockScreen) { window->AddWindowFlag(Rosen::WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED); + if (abilityInfo_ == nullptr) { + HILOG_ERROR("Ability::SetShowOnLockScreen abilityInfo_ == nullptr"); + return; + } + AAFwk::EventInfo eventInfo; + eventInfo.bundleName = abilityInfo_->bundleName; + eventInfo.moduleName = abilityInfo_->moduleName; + eventInfo.abilityName = abilityInfo_->name; + AAFwk::EventReport::SendKeyEvent(AAFwk::EventName::FA_SHOW_ON_LOCK, HiSysEventType::BEHAVIOR, eventInfo); } else { window->RemoveWindowFlag(Rosen::WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED); } diff --git a/frameworks/native/ability/native/auto_startup_callback_proxy.cpp b/frameworks/native/ability/native/auto_startup_callback_proxy.cpp new file mode 100644 index 0000000000..9acebe0f1b --- /dev/null +++ b/frameworks/native/ability/native/auto_startup_callback_proxy.cpp @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "auto_startup_callback_proxy.h" + +#include "ability_manager_errors.h" +#include "hilog_wrapper.h" +#include "ipc_types.h" +#include "message_parcel.h" + +namespace OHOS { +namespace AbilityRuntime { +using namespace OHOS::AAFwk; +void AutoStartupCallBackProxy::OnAutoStartupOn(const AutoStartupInfo &info) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(AutoStartupCallBackProxy::GetDescriptor())) { + HILOG_ERROR("Write interface token failed."); + return; + } + + if (!data.WriteParcelable(&info)) { + HILOG_ERROR("Write AutoStartupInfo failed."); + return; + } + + auto ret = SendRequest(AbilityManagerInterfaceCode::ON_AUTO_STARTUP_ON, data, reply, option); + if (ret != NO_ERROR) { + HILOG_ERROR("Send request error: %{public}d.", ret); + } +} + +void AutoStartupCallBackProxy::OnAutoStartupOff(const AutoStartupInfo &info) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(AutoStartupCallBackProxy::GetDescriptor())) { + HILOG_ERROR("Write interface token failed."); + return; + } + + if (!data.WriteParcelable(&info)) { + HILOG_ERROR("Write AutoStartupInfo failed."); + return; + } + + auto ret = SendRequest(AbilityManagerInterfaceCode::ON_AUTO_STARTUP_OFF, data, reply, option); + if (ret != NO_ERROR) { + HILOG_ERROR("Send request error: %{public}d.", ret); + } +} + +ErrCode AutoStartupCallBackProxy::SendRequest( + AbilityManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply, MessageOption &option) +{ + sptr remote = Remote(); + if (remote == nullptr) { + HILOG_ERROR("Remote is nullptr."); + return INNER_ERR; + } + + return remote->SendRequest(static_cast(code), data, reply, option); +} +} // namespace AbilityRuntime +} // namespace OHOS diff --git a/frameworks/native/ability/native/auto_startup_callback_stub.cpp b/frameworks/native/ability/native/auto_startup_callback_stub.cpp new file mode 100644 index 0000000000..8cead14d89 --- /dev/null +++ b/frameworks/native/ability/native/auto_startup_callback_stub.cpp @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "auto_startup_callback_stub.h" + +#include "ability_manager_ipc_interface_code.h" +#include "auto_startup_info.h" +#include "event_handler.h" +#include "hilog_wrapper.h" +#include "ipc_types.h" +#include "message_parcel.h" + +namespace OHOS { +namespace AbilityRuntime { +using namespace OHOS::AAFwk; +AutoStartupCallBackStub::AutoStartupCallBackStub() +{ + Init(); +} + +AutoStartupCallBackStub::~AutoStartupCallBackStub() +{ + requestFuncMap_.clear(); +} + +void AutoStartupCallBackStub::Init() +{ + requestFuncMap_[static_cast(AbilityManagerInterfaceCode::ON_AUTO_STARTUP_ON)] = + &AutoStartupCallBackStub::OnAutoStartupOnInner; + requestFuncMap_[static_cast(AbilityManagerInterfaceCode::ON_AUTO_STARTUP_OFF)] = + &AutoStartupCallBackStub::OnAutoStartupOffInner; +} + +int AutoStartupCallBackStub::OnRemoteRequest( + uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) +{ + std::u16string autoStartUpCallBackDescriptor = AutoStartupCallBackStub::GetDescriptor(); + std::u16string remoteDescriptor = data.ReadInterfaceToken(); + if (autoStartUpCallBackDescriptor != remoteDescriptor) { + HILOG_ERROR("Local descriptor is not equal to remote."); + return ERR_INVALID_STATE; + } + + auto itFunc = requestFuncMap_.find(code); + if (itFunc != requestFuncMap_.end()) { + auto requestFunc = itFunc->second; + if (requestFunc != nullptr) { + return (this->*requestFunc)(data, reply); + } + } + HILOG_WARN("Default case, need check."); + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); +} + +int32_t AutoStartupCallBackStub::OnAutoStartupOnInner(MessageParcel &data, MessageParcel &reply) +{ + sptr info = data.ReadParcelable(); + if (info == nullptr) { + HILOG_ERROR("Failed to read parcelable."); + return ERR_INVALID_VALUE; + } + + std::shared_ptr handler = + std::make_shared(AppExecFwk::EventRunner::GetMainEventRunner()); + wptr weak = this; + if (handler) { + handler->PostSyncTask([weak, info]() { + auto autoStartUpCallBackStub = weak.promote(); + if (autoStartUpCallBackStub == nullptr) { + HILOG_ERROR("autoStartUpCallBackStub is nullptr."); + return; + } + autoStartUpCallBackStub->OnAutoStartupOn(*info); + }); + } + + return NO_ERROR; +} + +int32_t AutoStartupCallBackStub::OnAutoStartupOffInner(MessageParcel &data, MessageParcel &reply) +{ + sptr info = data.ReadParcelable(); + if (info == nullptr) { + HILOG_ERROR("Failed to read parcelable."); + return ERR_INVALID_VALUE; + } + + std::shared_ptr handler = + std::make_shared(AppExecFwk::EventRunner::GetMainEventRunner()); + wptr weak = this; + if (handler) { + handler->PostSyncTask([weak, info]() { + auto autoStartUpCallBackStub = weak.promote(); + if (autoStartUpCallBackStub == nullptr) { + HILOG_ERROR("autoStartUpCallBackStub is nullptr."); + return; + } + autoStartUpCallBackStub->OnAutoStartupOff(*info); + }); + } + + return NO_ERROR; +} +} // namespace AbilityRuntime +} // namespace OHOS diff --git a/frameworks/native/ability/native/child_process_manager/child_process_manager.cpp b/frameworks/native/ability/native/child_process_manager/child_process_manager.cpp index aaf9329e62..00179d1c8e 100644 --- a/frameworks/native/ability/native/child_process_manager/child_process_manager.cpp +++ b/frameworks/native/ability/native/child_process_manager/child_process_manager.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #include "application_info.h" @@ -41,13 +42,33 @@ namespace OHOS { namespace AbilityRuntime { namespace { - constexpr pid_t INVALID_PID = -1; - const std::string SYS_PARAM_MULTI_PROCESS_MODEL = "persist.sys.multi_process_model"; +constexpr pid_t INVALID_PID = -1; +const std::string SYS_PARAM_MULTI_PROCESS_MODEL = "persist.sys.multi_process_model"; } +bool ChildProcessManager::signalRegistered_ = false; + ChildProcessManager::ChildProcessManager() { + HILOG_DEBUG("ChildProcessManager constructor called"); multiProcessModelEnabled_ = OHOS::system::GetBoolParameter(SYS_PARAM_MULTI_PROCESS_MODEL, false); + if (!signalRegistered_) { + signalRegistered_ = true; + HILOG_DEBUG("Register signal"); + signal(SIGCHLD, ChildProcessManager::HandleSigChild); + } +} + +ChildProcessManager::~ChildProcessManager() +{ + HILOG_DEBUG("ChildProcessManager deconstructor called"); +} + +void ChildProcessManager::HandleSigChild(int32_t signo) +{ + while (waitpid(-1, NULL, WNOHANG) > 0) { + continue; + } } pid_t ChildProcessManager::StartChildProcessBySelfFork(const std::string &srcEntry) @@ -73,7 +94,7 @@ pid_t ChildProcessManager::StartChildProcessBySelfFork(const std::string &srcEnt isChildProcess_ = true; HandleChildProcess(srcEntry, hapModuleInfo); HILOG_DEBUG("Child process end"); - kill(getpid(), SIGQUIT); + exit(0); } return pid; } diff --git a/frameworks/simulator/ability_simulator/include/js_ability_context.h b/frameworks/simulator/ability_simulator/include/js_ability_context.h index 372658679d..13d3d95bc3 100644 --- a/frameworks/simulator/ability_simulator/include/js_ability_context.h +++ b/frameworks/simulator/ability_simulator/include/js_ability_context.h @@ -21,6 +21,7 @@ #include #include "ability_context.h" #include "configuration.h" +#include "js_runtime_utils.h" class NativeObject; class NativeReference; @@ -33,40 +34,40 @@ public: explicit JsAbilityContext(const std::shared_ptr &context) : context_(context) {} ~JsAbilityContext() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint); + static void Finalizer(napi_env env, void *data, void *hint); - static NativeValue *StartAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityAsCaller(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartRecentAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityByCall(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityForResult(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartAbilityForResultWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StartServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StopServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *StopServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *ConnectAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *ConnectAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *DisconnectAbility(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *TerminateSelf(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *TerminateSelfWithResult(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *RestoreWindowStage(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *RequestDialogService(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *IsTerminating(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value StartAbility(napi_env env, napi_callback_info info); + static napi_value StartAbilityAsCaller(napi_env env, napi_callback_info info); + static napi_value StartRecentAbility(napi_env env, napi_callback_info info); + static napi_value StartAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value StartAbilityByCall(napi_env env, napi_callback_info info); + static napi_value StartAbilityForResult(napi_env env, napi_callback_info info); + static napi_value StartAbilityForResultWithAccount(napi_env env, napi_callback_info info); + static napi_value StartServiceExtensionAbility(napi_env env, napi_callback_info info); + static napi_value StartServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value StopServiceExtensionAbility(napi_env env, napi_callback_info info); + static napi_value StopServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value ConnectAbility(napi_env env, napi_callback_info info); + static napi_value ConnectAbilityWithAccount(napi_env env, napi_callback_info info); + static napi_value DisconnectAbility(napi_env env, napi_callback_info info); + static napi_value TerminateSelf(napi_env env, napi_callback_info info); + static napi_value TerminateSelfWithResult(napi_env env, napi_callback_info info); + static napi_value RestoreWindowStage(napi_env env, napi_callback_info info); + static napi_value RequestDialogService(napi_env env, napi_callback_info info); + static napi_value IsTerminating(napi_env env, napi_callback_info info); - static void ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, + static void ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config); private: - NativeValue *OnTerminateSelf(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnIsTerminating(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnTerminateSelfWithResult(NativeEngine &engine, NativeCallbackInfo &info); + napi_value OnTerminateSelf(napi_env env, NapiCallbackInfo &info); + napi_value OnIsTerminating(napi_env env, NapiCallbackInfo &info); + napi_value OnTerminateSelfWithResult(napi_env env, NapiCallbackInfo &info); std::weak_ptr context_; }; -NativeValue *CreateJsAbilityContext(NativeEngine &engine, const std::shared_ptr &context); -NativeValue *CreateJsErrorByNativeErr(NativeEngine &engine, int32_t err, const std::string &permission = ""); +napi_value CreateJsAbilityContext(napi_env env, const std::shared_ptr &context); +napi_value CreateJsErrorByNativeErr(napi_env env, int32_t err, const std::string &permission = ""); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_ABILITY_CONTEXT_H diff --git a/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h b/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h index dc22628c1e..11352ca425 100644 --- a/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h +++ b/frameworks/simulator/ability_simulator/include/js_ability_stage_context.h @@ -27,7 +27,7 @@ public: explicit JsAbilityStageContext(const std::shared_ptr &context) : context_(context) {} ~JsAbilityStageContext() = default; - static void ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, + static void ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config); std::shared_ptr GetContext() @@ -39,7 +39,7 @@ private: std::weak_ptr context_; }; -NativeValue *CreateJsAbilityStageContext(NativeEngine &engine, const std::shared_ptr &context); +napi_value CreateJsAbilityStageContext(napi_env env, const std::shared_ptr &context); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_ABILITY_STAGE_CONTEXT_H diff --git a/frameworks/simulator/ability_simulator/include/js_application_context_utils.h b/frameworks/simulator/ability_simulator/include/js_application_context_utils.h index dd66a82345..f66301c740 100644 --- a/frameworks/simulator/ability_simulator/include/js_application_context_utils.h +++ b/frameworks/simulator/ability_simulator/include/js_application_context_utils.h @@ -20,6 +20,7 @@ #include "native_engine/native_engine.h" #include "context.h" +#include "js_runtime_utils.h" namespace OHOS { namespace AbilityRuntime { @@ -27,42 +28,42 @@ class JsApplicationContextUtils { public: JsApplicationContextUtils(std::weak_ptr &&context) : context_(std::move(context)) {} virtual ~JsApplicationContextUtils() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint); - static NativeValue *RegisterAbilityLifecycleCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *UnregisterAbilityLifecycleCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *RegisterEnvironmentCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *UnregisterEnvironmentCallback(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *On(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *Off(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *SwitchArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetTempDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *KillProcessBySelf(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetRunningProcessInformation(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateJsApplicationContext(NativeEngine &engine, const std::shared_ptr &context); + static void Finalizer(napi_env env, void *data, void *hint); + static napi_value RegisterAbilityLifecycleCallback(napi_env env, napi_callback_info info); + static napi_value UnregisterAbilityLifecycleCallback(napi_env env, napi_callback_info info); + static napi_value RegisterEnvironmentCallback(napi_env env, napi_callback_info info); + static napi_value UnregisterEnvironmentCallback(napi_env env, napi_callback_info info); + static napi_value On(napi_env env, napi_callback_info info); + static napi_value Off(napi_env env, napi_callback_info info); + static napi_value CreateBundleContext(napi_env env, napi_callback_info info); + static napi_value SwitchArea(napi_env env, napi_callback_info info); + static napi_value GetArea(napi_env env, napi_callback_info info); + static napi_value CreateModuleContext(napi_env env, napi_callback_info info); + static napi_value GetCacheDir(napi_env env, napi_callback_info info); + static napi_value GetTempDir(napi_env env, napi_callback_info info); + static napi_value GetFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDistributedFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDatabaseDir(napi_env env, napi_callback_info info); + static napi_value GetPreferencesDir(napi_env env, napi_callback_info info); + static napi_value GetBundleCodeDir(napi_env env, napi_callback_info info); + static napi_value GetApplicationContext(napi_env env, napi_callback_info info); + static napi_value KillProcessBySelf(napi_env env, napi_callback_info info); + static napi_value GetRunningProcessInformation(napi_env env, napi_callback_info info); + static napi_value CreateJsApplicationContext(napi_env env, const std::shared_ptr &context); - NativeValue *OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetArea(NativeEngine &engine, NativeCallbackInfo &info); + napi_value OnGetCacheDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetTempDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetFilesDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetDatabaseDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetPreferencesDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetBundleCodeDir(napi_env env, NapiCallbackInfo& info); + napi_value OnGetArea(napi_env env, NapiCallbackInfo& info); private: - NativeValue *OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info); - static void BindNativeApplicationContext(NativeEngine &engine, NativeObject *object); + napi_value OnSwitchArea(napi_env env, NapiCallbackInfo& info); + napi_value OnGetApplicationContext(napi_env env, NapiCallbackInfo& info); + static void BindNativeApplicationContext(napi_env env, napi_value object); private: std::weak_ptr context_; diff --git a/frameworks/simulator/ability_simulator/include/js_console_log.h b/frameworks/simulator/ability_simulator/include/js_console_log.h index f975aca14e..693629abea 100644 --- a/frameworks/simulator/ability_simulator/include/js_console_log.h +++ b/frameworks/simulator/ability_simulator/include/js_console_log.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -void InitConsoleLogModule(NativeEngine &engine, NativeObject &globalObject); +void InitConsoleLogModule(napi_env env, napi_value globalObject); } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/include/js_context_utils.h b/frameworks/simulator/ability_simulator/include/js_context_utils.h index 91cf407528..c217388138 100644 --- a/frameworks/simulator/ability_simulator/include/js_context_utils.h +++ b/frameworks/simulator/ability_simulator/include/js_context_utils.h @@ -23,7 +23,7 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsBaseContext(NativeEngine &engine, std::shared_ptr context, bool keepContext = false); +napi_value CreateJsBaseContext(napi_env env, std::shared_ptr context, bool keepContext = false); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_CONTEXT_UTILS_H diff --git a/frameworks/simulator/ability_simulator/include/js_data_converter.h b/frameworks/simulator/ability_simulator/include/js_data_converter.h index cf23c94833..f871c22aff 100644 --- a/frameworks/simulator/ability_simulator/include/js_data_converter.h +++ b/frameworks/simulator/ability_simulator/include/js_data_converter.h @@ -20,6 +20,7 @@ #include "application_info.h" #include "hap_module_info.h" #include "configuration.h" +#include "native_engine/native_engine.h" #include "res_common.h" class NativeEngine; @@ -31,10 +32,10 @@ Global::Resource::Direction ConvertDirection(const std::string &direction); Global::Resource::ScreenDensity ConvertDensity(const std::string &density); int32_t ConvertDisplayId(const std::string &displayId); std::string GetDensityStr(float density); -NativeValue *CreateJsConfiguration(NativeEngine &engine, const AppExecFwk::Configuration &configuration); -NativeValue *CreateJsApplicationInfo(NativeEngine &engine, const AppExecFwk::ApplicationInfo &applicationInfo); -NativeValue *CreateJsHapModuleInfo(NativeEngine &engine, const AppExecFwk::HapModuleInfo &hapModuleInfo); -NativeValue *CreateJsAbilityInfo(NativeEngine &engine, const AppExecFwk::AbilityInfo &abilityInfo); +napi_value CreateJsConfiguration(napi_env env, const AppExecFwk::Configuration &configuration); +napi_value CreateJsApplicationInfo(napi_env env, const AppExecFwk::ApplicationInfo &applicationInfo); +napi_value CreateJsHapModuleInfo(napi_env env, const AppExecFwk::HapModuleInfo &hapModuleInfo); +napi_value CreateJsAbilityInfo(napi_env env, const AppExecFwk::AbilityInfo &abilityInfo); } // namespace AbilityRuntime } // namespace OHOS #endif // OHOS_ABILITY_RUNTIME_SIMULATOR_JS_DATA_CONVERTER_H diff --git a/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h b/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h index 298106fdd7..c286947792 100644 --- a/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h +++ b/frameworks/simulator/ability_simulator/include/js_resource_manager_utils.h @@ -17,6 +17,7 @@ #define OHOS_ABILITY_RUNTIME_JS_RESOURCE_MANAGER_UTILS_H #include "context.h" +#include "native_engine/native_engine.h" #include "resource_manager.h" class NativeEngine; @@ -24,7 +25,7 @@ class NativeValue; namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsResourceManager(NativeEngine &engine, +napi_value CreateJsResourceManager(napi_env env, std::shared_ptr resourceManager, std::shared_ptr context); } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/include/js_timer.h b/frameworks/simulator/ability_simulator/include/js_timer.h index ac380aa482..98649be115 100644 --- a/frameworks/simulator/ability_simulator/include/js_timer.h +++ b/frameworks/simulator/ability_simulator/include/js_timer.h @@ -20,7 +20,7 @@ namespace OHOS { namespace AbilityRuntime { -void InitTimer(NativeEngine &engine, NativeObject &globalObject); +void InitTimer(napi_env env, napi_value globalObject); } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_ability_context.cpp b/frameworks/simulator/ability_simulator/src/js_ability_context.cpp index 2f5f05d0dc..5af64ab82e 100644 --- a/frameworks/simulator/ability_simulator/src/js_ability_context.cpp +++ b/frameworks/simulator/ability_simulator/src/js_ability_context.cpp @@ -28,89 +28,88 @@ namespace { constexpr size_t ARGC_ZERO = 0; constexpr size_t ARGC_ONE = 1; } -void JsAbilityContext::Finalizer(NativeEngine *engine, void *data, void *hint) +void JsAbilityContext::Finalizer(napi_env env, void *data, void *hint) { HILOG_DEBUG("called"); std::unique_ptr(static_cast(data)); } -NativeValue *JsAbilityContext::StartAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityAsCaller(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityAsCaller(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartRecentAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartRecentAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityByCall(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityByCall(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityForResult(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityForResult(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartAbilityForResultWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartAbilityForResultWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartServiceExtensionAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StartServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StartServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StopServiceExtensionAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StopServiceExtensionAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::StopServiceExtensionAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::StopServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::ConnectAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::ConnectAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::ConnectAbilityWithAccount(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::ConnectAbilityWithAccount(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::DisconnectAbility(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::DisconnectAbility(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::TerminateSelf(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::TerminateSelf(napi_env env, napi_callback_info info) { - JsAbilityContext *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnTerminateSelf(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityContext, OnTerminateSelf); } -NativeValue *JsAbilityContext::OnTerminateSelf(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsAbilityContext::OnTerminateSelf(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("TerminateSelf"); auto abilityContext = context_.lock(); @@ -119,30 +118,29 @@ NativeValue *JsAbilityContext::OnTerminateSelf(NativeEngine &engine, NativeCallb } abilityContext->SetTerminating(true); - NativeValue *lastParam = (info.argc > ARGC_ZERO) ? info.argv[ARGC_ZERO] : nullptr; - NativeValue *result = nullptr; - auto task = CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, nullptr, &result); + napi_value lastParam = (info.argc > ARGC_ZERO) ? info.argv[ARGC_ZERO] : nullptr; + napi_value result = nullptr; + auto task = CreateAsyncTaskWithLastParam(env, lastParam, nullptr, nullptr, &result); if (task == nullptr) { return nullptr; } auto errcode = abilityContext->TerminateSelf(); if (errcode == 0) { - task->Resolve(engine, engine.CreateUndefined()); + task->Resolve(env, CreateJsUndefined(env)); } else { - task->Reject(engine, CreateJsErrorByNativeErr(engine, errcode)); + task->Reject(env, CreateJsErrorByNativeErr(env, errcode)); } return result; } -NativeValue *JsAbilityContext::TerminateSelfWithResult(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::TerminateSelfWithResult(napi_env env, napi_callback_info info) { - JsAbilityContext *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnTerminateSelfWithResult(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityContext, OnTerminateSelfWithResult); } -NativeValue *JsAbilityContext::OnTerminateSelfWithResult(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsAbilityContext::OnTerminateSelfWithResult(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("called."); auto abilityContext = context_.lock(); @@ -151,59 +149,58 @@ NativeValue *JsAbilityContext::OnTerminateSelfWithResult(NativeEngine &engine, N } abilityContext->SetTerminating(true); - NativeValue *lastParam = (info.argc > ARGC_ONE) ? info.argv[ARGC_ONE] : nullptr; - NativeValue *result = nullptr; - auto task = CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, nullptr, &result); + napi_value lastParam = (info.argc > ARGC_ONE) ? info.argv[ARGC_ONE] : nullptr; + napi_value result = nullptr; + auto task = CreateAsyncTaskWithLastParam(env, lastParam, nullptr, nullptr, &result); if (task == nullptr) { return nullptr; } auto errcode = abilityContext->TerminateSelf(); if (errcode == 0) { - task->Resolve(engine, engine.CreateUndefined()); + task->Resolve(env, CreateJsUndefined(env)); } else { - task->Reject(engine, CreateJsErrorByNativeErr(engine, errcode)); + task->Reject(env, CreateJsErrorByNativeErr(env, errcode)); } return result; } -NativeValue *JsAbilityContext::RestoreWindowStage(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::RestoreWindowStage(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::RequestDialogService(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::RequestDialogService(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsAbilityContext::IsTerminating(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsAbilityContext::IsTerminating(napi_env env, napi_callback_info info) { - JsAbilityContext *me = CheckParamsAndGetThis(engine, info); - return (me != nullptr) ? me->OnIsTerminating(*engine, *info) : nullptr; + GET_NAPI_INFO_AND_CALL(env, info, JsAbilityContext, OnIsTerminating); } -NativeValue *JsAbilityContext::OnIsTerminating(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsAbilityContext::OnIsTerminating(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("IsTerminating"); auto context = context_.lock(); if (context == nullptr) { HILOG_ERROR("OnIsTerminating context is nullptr"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - return engine.CreateBoolean(context->IsTerminating()); + return CreateJsValue(env, context->IsTerminating()); } -NativeValue *CreateJsErrorByNativeErr(NativeEngine &engine, int32_t err, const std::string &permission) +napi_value CreateJsErrorByNativeErr(napi_env env, int32_t err, const std::string &permission) { auto errCode = GetJsErrorCodeByNativeError(err); auto errMsg = (errCode == AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED && !permission.empty()) ? GetNoPermissionErrorMsg(permission) : GetErrorMsg(errCode); - return CreateJsError(engine, static_cast(errCode), errMsg); + return CreateJsError(env, static_cast(errCode), errMsg); } -void JsAbilityContext::ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, +void JsAbilityContext::ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config) { HILOG_DEBUG("called."); @@ -212,83 +209,86 @@ void JsAbilityContext::ConfigurationUpdated(NativeEngine *engine, std::shared_pt return; } - NativeValue *value = jsContext->Get(); - NativeObject *object = ConvertNativeValueTo(value); - if (object == nullptr) { - HILOG_ERROR("object is nullptr."); + napi_value value = jsContext->GetNapiValue(); + if (value == nullptr) { + HILOG_ERROR("value is nullptr."); return; } - NativeValue *method = object->GetProperty("onUpdateConfiguration"); + napi_value method = nullptr; + napi_get_named_property(env, value, "onUpdateConfiguration", &method); if (method == nullptr) { HILOG_ERROR("Failed to get onUpdateConfiguration from object"); return; } - NativeValue *argv[] = { CreateJsConfiguration(*engine, *config) }; - engine->CallFunction(value, method, argv, 1); + napi_value argv[] = { CreateJsConfiguration(env, *config) }; + napi_value callResult = nullptr; + napi_call_function(env, nullptr, method, 1, argv, &callResult); } -NativeValue *CreateJsAbilityContext(NativeEngine &engine, const std::shared_ptr &context) +napi_value CreateJsAbilityContext(napi_env env, const std::shared_ptr &context) { - NativeValue *objValue = CreateJsBaseContext(engine, context); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = CreateJsBaseContext(env, context); std::unique_ptr jsContext = std::make_unique(context); - object->SetNativePointer(jsContext.release(), JsAbilityContext::Finalizer, nullptr); + napi_wrap(env, object, jsContext.release(), JsAbilityContext::Finalizer, nullptr, nullptr); auto resourceManager = context->GetResourceManager(); if (resourceManager != nullptr) { - object->SetProperty("resourceManager", CreateJsResourceManager(engine, resourceManager, context)); + napi_set_named_property(env, object, "resourceManager", + CreateJsResourceManager(env, resourceManager, context)); } auto abilityInfo = context->GetAbilityInfo(); if (abilityInfo != nullptr) { - object->SetProperty("abilityInfo", CreateJsAbilityInfo(engine, *abilityInfo)); + napi_set_named_property( + env, object, "abilityInfo", CreateJsAbilityInfo(env, *abilityInfo)); } auto configuration = context->GetConfiguration(); if (configuration != nullptr) { - object->SetProperty("config", CreateJsConfiguration(engine, *configuration)); + napi_set_named_property( + env, object, "config", CreateJsConfiguration(env, *configuration)); } const char *moduleName = "JsAbilityContext"; - BindNativeFunction(engine, *object, "startAbility", moduleName, JsAbilityContext::StartAbility); - BindNativeFunction(engine, *object, "startAbilityAsCaller", moduleName, JsAbilityContext::StartAbilityAsCaller); - BindNativeFunction(engine, *object, "startAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "startAbility", moduleName, JsAbilityContext::StartAbility); + BindNativeFunction(env, object, "startAbilityAsCaller", moduleName, JsAbilityContext::StartAbilityAsCaller); + BindNativeFunction(env, object, "startAbilityWithAccount", moduleName, JsAbilityContext::StartAbilityWithAccount); - BindNativeFunction(engine, *object, "startAbilityByCall", moduleName, JsAbilityContext::StartAbilityByCall); - BindNativeFunction(engine, *object, "startAbilityForResult", moduleName, JsAbilityContext::StartAbilityForResult); - BindNativeFunction(engine, *object, "startAbilityForResultWithAccount", moduleName, + BindNativeFunction(env, object, "startAbilityByCall", moduleName, JsAbilityContext::StartAbilityByCall); + BindNativeFunction(env, object, "startAbilityForResult", moduleName, JsAbilityContext::StartAbilityForResult); + BindNativeFunction(env, object, "startAbilityForResultWithAccount", moduleName, JsAbilityContext::StartAbilityForResultWithAccount); - BindNativeFunction(engine, *object, "startServiceExtensionAbility", moduleName, + BindNativeFunction(env, object, "startServiceExtensionAbility", moduleName, JsAbilityContext::StartServiceExtensionAbility); - BindNativeFunction(engine, *object, "startServiceExtensionAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "startServiceExtensionAbilityWithAccount", moduleName, JsAbilityContext::StartServiceExtensionAbilityWithAccount); - BindNativeFunction(engine, *object, "stopServiceExtensionAbility", moduleName, + BindNativeFunction(env, object, "stopServiceExtensionAbility", moduleName, JsAbilityContext::StopServiceExtensionAbility); - BindNativeFunction(engine, *object, "stopServiceExtensionAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "stopServiceExtensionAbilityWithAccount", moduleName, JsAbilityContext::StopServiceExtensionAbilityWithAccount); - BindNativeFunction(engine, *object, "connectAbility", moduleName, JsAbilityContext::ConnectAbility); - BindNativeFunction(engine, *object, "connectServiceExtensionAbility", moduleName, JsAbilityContext::ConnectAbility); - BindNativeFunction(engine, *object, "connectAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "connectAbility", moduleName, JsAbilityContext::ConnectAbility); + BindNativeFunction(env, object, "connectServiceExtensionAbility", moduleName, JsAbilityContext::ConnectAbility); + BindNativeFunction(env, object, "connectAbilityWithAccount", moduleName, JsAbilityContext::ConnectAbilityWithAccount); - BindNativeFunction(engine, *object, "connectServiceExtensionAbilityWithAccount", moduleName, + BindNativeFunction(env, object, "connectServiceExtensionAbilityWithAccount", moduleName, JsAbilityContext::ConnectAbilityWithAccount); - BindNativeFunction(engine, *object, "disconnectAbility", moduleName, JsAbilityContext::DisconnectAbility); + BindNativeFunction(env, object, "disconnectAbility", moduleName, JsAbilityContext::DisconnectAbility); BindNativeFunction( - engine, *object, "disconnectServiceExtensionAbility", moduleName, JsAbilityContext::DisconnectAbility); - BindNativeFunction(engine, *object, "terminateSelf", moduleName, JsAbilityContext::TerminateSelf); - BindNativeFunction(engine, *object, "terminateSelfWithResult", moduleName, + env, object, "disconnectServiceExtensionAbility", moduleName, JsAbilityContext::DisconnectAbility); + BindNativeFunction(env, object, "terminateSelf", moduleName, JsAbilityContext::TerminateSelf); + BindNativeFunction(env, object, "terminateSelfWithResult", moduleName, JsAbilityContext::TerminateSelfWithResult); - BindNativeFunction(engine, *object, "restoreWindowStage", moduleName, JsAbilityContext::RestoreWindowStage); - BindNativeFunction(engine, *object, "isTerminating", moduleName, JsAbilityContext::IsTerminating); - BindNativeFunction(engine, *object, "startRecentAbility", moduleName, + BindNativeFunction(env, object, "restoreWindowStage", moduleName, JsAbilityContext::RestoreWindowStage); + BindNativeFunction(env, object, "isTerminating", moduleName, JsAbilityContext::IsTerminating); + BindNativeFunction(env, object, "startRecentAbility", moduleName, JsAbilityContext::StartRecentAbility); - BindNativeFunction(engine, *object, "requestDialogService", moduleName, + BindNativeFunction(env, object, "requestDialogService", moduleName, JsAbilityContext::RequestDialogService); - return objValue; + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp b/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp index 9dfb49ac0d..3219325fe9 100644 --- a/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp +++ b/frameworks/simulator/ability_simulator/src/js_ability_stage_context.cpp @@ -22,23 +22,22 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsAbilityStageContext(NativeEngine &engine, const std::shared_ptr &context) +napi_value CreateJsAbilityStageContext(napi_env env, const std::shared_ptr &context) { HILOG_DEBUG("called."); - NativeValue *objValue = CreateJsBaseContext(engine, context); + napi_value objValue = CreateJsBaseContext(env, context); if (context == nullptr) { return objValue; } - - NativeObject *object = ConvertNativeValueTo(objValue); auto configuration = context->GetConfiguration(); - if (configuration != nullptr && object != nullptr) { - object->SetProperty("config", CreateJsConfiguration(engine, *configuration)); + if (configuration != nullptr && objValue != nullptr) { + napi_set_named_property(env, objValue, "config", + CreateJsConfiguration(env, *configuration)); } return objValue; } -void JsAbilityStageContext::ConfigurationUpdated(NativeEngine *engine, std::shared_ptr &jsContext, +void JsAbilityStageContext::ConfigurationUpdated(napi_env env, std::shared_ptr &jsContext, const std::shared_ptr &config) { HILOG_DEBUG("called."); @@ -47,22 +46,23 @@ void JsAbilityStageContext::ConfigurationUpdated(NativeEngine *engine, std::shar return; } - NativeValue *value = jsContext->Get(); - NativeObject *object = ConvertNativeValueTo(value); - if (!object) { - HILOG_ERROR("object is nullptr."); + napi_value value = jsContext->GetNapiValue(); + if (value == nullptr) { + HILOG_ERROR("value is nullptr."); return; } - NativeValue *method = object->GetProperty("onUpdateConfiguration"); + napi_value method = nullptr; + napi_get_named_property(env, value, "onUpdateConfiguration", &method); if (!method) { HILOG_ERROR("Failed to get onUpdateConfiguration from object"); return; } HILOG_DEBUG("JsAbilityStageContext call onUpdateConfiguration."); - NativeValue *argv[] = { CreateJsConfiguration(*engine, *config) }; - engine->CallFunction(value, method, argv, 1); + napi_value argv[] = { CreateJsConfiguration(env, *config) }; + napi_value callResult = nullptr; + napi_call_function(env, value, method, 1, argv, &callResult); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp b/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp index fd7c66317e..ca320f20b9 100644 --- a/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_application_context_utils.cpp @@ -29,312 +29,287 @@ constexpr char APPLICATION_CONTEXT_NAME[] = "__application_context_ptr__"; const char *MD_NAME = "JsApplicationContextUtils"; } // namespace -NativeValue *JsApplicationContextUtils::CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::CreateBundleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::SwitchArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::SwitchArea(napi_env env, napi_callback_info info) { - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnSwitchArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnSwitchArea, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnSwitchArea(napi_env env, NapiCallbackInfo &info) { - NativeValue *thisVar = info.thisVar; - NativeObject *object = ConvertNativeValueTo(thisVar); + napi_value object = info.thisVar; if (object == nullptr) { HILOG_ERROR("object is null"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - BindNativeProperty(*object, "cacheDir", GetCacheDir); - BindNativeProperty(*object, "tempDir", GetTempDir); - BindNativeProperty(*object, "filesDir", GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", GetBundleCodeDir); - return engine.CreateUndefined(); + BindNativeProperty(env, object, "cacheDir", GetCacheDir); + BindNativeProperty(env, object, "tempDir", GetTempDir); + BindNativeProperty(env, object, "filesDir", GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", GetBundleCodeDir); + return CreateJsUndefined(env); } -NativeValue *JsApplicationContextUtils::CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::CreateModuleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::GetTempDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetTempDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetTempDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetTempDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetTempDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetTempDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetArea(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetArea, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetArea(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int area = context->GetArea(); - return engine.CreateNumber(area); + return CreateJsValue(env, area); } -NativeValue *JsApplicationContextUtils::GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetCacheDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetCacheDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetCacheDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetCacheDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetCacheDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetFilesDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetDistributedFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetDistributedFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, + OnGetDistributedFilesDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDistributedFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetDatabaseDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetDatabaseDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, OnGetDatabaseDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetDatabaseDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDatabaseDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetPreferencesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetPreferencesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, + info, JsApplicationContextUtils, OnGetPreferencesDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetPreferencesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetPreferencesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetBundleCodeDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetBundleCodeDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, + info, JsApplicationContextUtils, OnGetBundleCodeDir, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetBundleCodeDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetBundleCodeDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsApplicationContextUtils::KillProcessBySelf(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::KillProcessBySelf(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::GetRunningProcessInformation(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetRunningProcessInformation(napi_env env, napi_callback_info info) { return nullptr; } -void JsApplicationContextUtils::Finalizer(NativeEngine *engine, void *data, void *hint) +void JsApplicationContextUtils::Finalizer(napi_env env, void *data, void *hint) { std::unique_ptr(static_cast(data)); } -NativeValue *JsApplicationContextUtils::RegisterAbilityLifecycleCallback(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::RegisterAbilityLifecycleCallback(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::UnregisterAbilityLifecycleCallback( - NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::UnregisterAbilityLifecycleCallback( + napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::RegisterEnvironmentCallback(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::RegisterEnvironmentCallback(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::UnregisterEnvironmentCallback( - NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::UnregisterEnvironmentCallback( + napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::On(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::On(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::Off(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::Off(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsApplicationContextUtils::GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsApplicationContextUtils::GetApplicationContext(napi_env env, napi_callback_info info) { - JsApplicationContextUtils *me = - CheckParamsAndGetThis(engine, info, APPLICATION_CONTEXT_NAME); - return me != nullptr ? me->OnGetApplicationContext(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsApplicationContextUtils, + OnGetApplicationContext, APPLICATION_CONTEXT_NAME); } -NativeValue *JsApplicationContextUtils::OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsApplicationContextUtils::OnGetApplicationContext(napi_env env, NapiCallbackInfo &info) { - NativeValue *value = CreateJsApplicationContext(engine, context_.lock()); - auto systemModule = JsRuntime::LoadSystemModuleByEngine(&engine, "application.ApplicationContext", &value, 1); + napi_value value = CreateJsApplicationContext(env, context_.lock()); + auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.ApplicationContext", &value, 1); if (systemModule == nullptr) { HILOG_WARN("OnGetApplicationContext, invalid systemModule."); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - return systemModule->Get(); + return systemModule->GetNapiValue(); } -NativeValue *JsApplicationContextUtils::CreateJsApplicationContext( - NativeEngine &engine, const std::shared_ptr &context) +napi_value JsApplicationContextUtils::CreateJsApplicationContext( + napi_env env, const std::shared_ptr &context) { HILOG_DEBUG("called"); - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { - return objValue; + return object; } auto jsApplicationContextUtils = std::make_unique(context); - SetNamedNativePointer(engine, *object, APPLICATION_CONTEXT_NAME, jsApplicationContextUtils.release(), + SetNamedNativePointer(env, object, APPLICATION_CONTEXT_NAME, jsApplicationContextUtils.release(), JsApplicationContextUtils::Finalizer); auto appInfo = context->GetApplicationInfo(); if (appInfo != nullptr) { - object->SetProperty("applicationInfo", CreateJsApplicationInfo(engine, *appInfo)); + napi_set_named_property(env, object, "applicationInfo", CreateJsApplicationInfo(env, *appInfo)); } - BindNativeApplicationContext(engine, object); + BindNativeApplicationContext(env, object); - return objValue; + return object; } -void JsApplicationContextUtils::BindNativeApplicationContext(NativeEngine &engine, NativeObject *object) +void JsApplicationContextUtils::BindNativeApplicationContext(napi_env env, napi_value object) { - BindNativeProperty(*object, "cacheDir", JsApplicationContextUtils::GetCacheDir); - BindNativeProperty(*object, "tempDir", JsApplicationContextUtils::GetTempDir); - BindNativeProperty(*object, "filesDir", JsApplicationContextUtils::GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", JsApplicationContextUtils::GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", JsApplicationContextUtils::GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", JsApplicationContextUtils::GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", JsApplicationContextUtils::GetBundleCodeDir); - BindNativeFunction(engine, *object, "registerAbilityLifecycleCallback", MD_NAME, + BindNativeProperty(env, object, "cacheDir", JsApplicationContextUtils::GetCacheDir); + BindNativeProperty(env, object, "tempDir", JsApplicationContextUtils::GetTempDir); + BindNativeProperty(env, object, "filesDir", JsApplicationContextUtils::GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", JsApplicationContextUtils::GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", JsApplicationContextUtils::GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", JsApplicationContextUtils::GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", JsApplicationContextUtils::GetBundleCodeDir); + BindNativeFunction(env, object, "registerAbilityLifecycleCallback", MD_NAME, JsApplicationContextUtils::RegisterAbilityLifecycleCallback); - BindNativeFunction(engine, *object, "unregisterAbilityLifecycleCallback", MD_NAME, + BindNativeFunction(env, object, "unregisterAbilityLifecycleCallback", MD_NAME, JsApplicationContextUtils::UnregisterAbilityLifecycleCallback); - BindNativeFunction(engine, *object, "registerEnvironmentCallback", MD_NAME, + BindNativeFunction(env, object, "registerEnvironmentCallback", MD_NAME, JsApplicationContextUtils::RegisterEnvironmentCallback); - BindNativeFunction(engine, *object, "unregisterEnvironmentCallback", MD_NAME, + BindNativeFunction(env, object, "unregisterEnvironmentCallback", MD_NAME, JsApplicationContextUtils::UnregisterEnvironmentCallback); - BindNativeFunction(engine, *object, "createBundleContext", MD_NAME, JsApplicationContextUtils::CreateBundleContext); - BindNativeFunction(engine, *object, "switchArea", MD_NAME, JsApplicationContextUtils::SwitchArea); - BindNativeFunction(engine, *object, "getArea", MD_NAME, JsApplicationContextUtils::GetArea); - BindNativeFunction(engine, *object, "createModuleContext", MD_NAME, JsApplicationContextUtils::CreateModuleContext); - BindNativeFunction(engine, *object, "on", MD_NAME, JsApplicationContextUtils::On); - BindNativeFunction(engine, *object, "off", MD_NAME, JsApplicationContextUtils::Off); - BindNativeFunction(engine, *object, "getApplicationContext", MD_NAME, + BindNativeFunction(env, object, "createBundleContext", MD_NAME, JsApplicationContextUtils::CreateBundleContext); + BindNativeFunction(env, object, "switchArea", MD_NAME, JsApplicationContextUtils::SwitchArea); + BindNativeFunction(env, object, "getArea", MD_NAME, JsApplicationContextUtils::GetArea); + BindNativeFunction(env, object, "createModuleContext", MD_NAME, JsApplicationContextUtils::CreateModuleContext); + BindNativeFunction(env, object, "on", MD_NAME, JsApplicationContextUtils::On); + BindNativeFunction(env, object, "off", MD_NAME, JsApplicationContextUtils::Off); + BindNativeFunction(env, object, "getApplicationContext", MD_NAME, JsApplicationContextUtils::GetApplicationContext); - BindNativeFunction(engine, *object, "killAllProcesses", MD_NAME, JsApplicationContextUtils::KillProcessBySelf); - BindNativeFunction(engine, *object, "getProcessRunningInformation", MD_NAME, + BindNativeFunction(env, object, "killAllProcesses", MD_NAME, JsApplicationContextUtils::KillProcessBySelf); + BindNativeFunction(env, object, "getProcessRunningInformation", MD_NAME, JsApplicationContextUtils::GetRunningProcessInformation); - BindNativeFunction(engine, *object, "getRunningProcessInformation", MD_NAME, + BindNativeFunction(env, object, "getRunningProcessInformation", MD_NAME, JsApplicationContextUtils::GetRunningProcessInformation); } } // namespace AbilityRuntime diff --git a/frameworks/simulator/ability_simulator/src/js_console_log.cpp b/frameworks/simulator/ability_simulator/src/js_console_log.cpp index f5ff91f013..37e637a0e3 100644 --- a/frameworks/simulator/ability_simulator/src/js_console_log.cpp +++ b/frameworks/simulator/ability_simulator/src/js_console_log.cpp @@ -27,24 +27,29 @@ constexpr uint32_t JS_CONSOLE_LOG_MAX_LOG_LEN = 1024; constexpr uint32_t JS_CONSOLE_LOG_DOMAIN = 0xFEFE; constexpr char JS_CONSOLE_LOG_TAG[] = "JsApp"; -std::string MakeLogContent(NativeCallbackInfo &info) +std::string MakeLogContent(napi_env env, napi_callback_info info) { std::string content; - for (size_t i = 0; i < info.argc; i++) { - NativeValue *value = info.argv[i]; - if (value->TypeOf() != NATIVE_STRING) { - value = value->ToString(); + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + for (size_t i = 0; i < argc; i++) { + napi_value value = argv[i]; + if (!CheckTypeForNapiValue(env, value, napi_string)) { + napi_value resultStr = nullptr; + napi_coerce_to_string(env, value, &resultStr); + value = resultStr; } - NativeString *str = ConvertNativeValueTo(value); - if (str == nullptr) { + if (value == nullptr) { HILOG_ERROR("Failed to convert to string object"); continue; } - size_t bufferLen = str->GetLength(); - if (bufferLen >= JS_CONSOLE_LOG_MAX_LOG_LEN) { + size_t bufferLen = 0; + napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &bufferLen); + if (status != napi_ok || bufferLen == 0 || bufferLen >= JS_CONSOLE_LOG_MAX_LOG_LEN) { HILOG_DEBUG("Log length exceeds maximum"); return content; } @@ -56,7 +61,7 @@ std::string MakeLogContent(NativeCallbackInfo &info) } size_t strLen = 0; - str->GetCString(buff, bufferLen + 1, &strLen); + napi_get_value_string_utf8(env, value, buff, bufferLen + 1, &strLen); if (!content.empty()) { content.append(" "); } @@ -68,37 +73,37 @@ std::string MakeLogContent(NativeCallbackInfo &info) } template -NativeValue *ConsoleLog(NativeEngine *engine, NativeCallbackInfo *info) +napi_value ConsoleLog(napi_env env, napi_callback_info info) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("engine or callback info is nullptr"); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("env or callback info is nullptr"); return nullptr; } - std::string content = MakeLogContent(*info); + std::string content = MakeLogContent(env, info); HiLogPrint(LOG_APP, LEVEL, JS_CONSOLE_LOG_DOMAIN, JS_CONSOLE_LOG_TAG, "%{public}s", content.c_str()); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } -void InitConsoleLogModule(NativeEngine &engine, NativeObject &globalObject) +void InitConsoleLogModule(napi_env env, napi_value globalObject) { - NativeValue *consoleValue = engine.CreateObject(); - NativeObject *consoleObj = ConvertNativeValueTo(consoleValue); + napi_value consoleObj = nullptr; + napi_create_object(env, &consoleObj); if (consoleObj == nullptr) { HILOG_ERROR("Failed to create console object"); return; } const char *moduleName = "console"; - BindNativeFunction(engine, *consoleObj, "log", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "debug", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "info", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "warn", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "error", moduleName, ConsoleLog); - BindNativeFunction(engine, *consoleObj, "fatal", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "log", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "debug", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "info", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "warn", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "error", moduleName, ConsoleLog); + BindNativeFunction(env, consoleObj, "fatal", moduleName, ConsoleLog); - globalObject.SetProperty("console", consoleValue); + napi_set_named_property(env, globalObject, "console", consoleObj); } } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/simulator/ability_simulator/src/js_context_utils.cpp b/frameworks/simulator/ability_simulator/src/js_context_utils.cpp index a6852e4f85..94e3e3ab7a 100644 --- a/frameworks/simulator/ability_simulator/src/js_context_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_context_utils.cpp @@ -31,296 +31,276 @@ public: explicit JsBaseContext(std::weak_ptr &&context) : context_(std::move(context)) {} virtual ~JsBaseContext() = default; - static void Finalizer(NativeEngine *engine, void *data, void *hint); - static NativeValue *CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *SwitchArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetArea(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info); + static void Finalizer(napi_env env, void *data, void *hint); + static napi_value CreateBundleContext(napi_env env, napi_callback_info info); + static napi_value GetApplicationContext(napi_env env, napi_callback_info info); + static napi_value SwitchArea(napi_env env, napi_callback_info info); + static napi_value GetArea(napi_env env, napi_callback_info info); + static napi_value CreateModuleContext(napi_env env, napi_callback_info info); - static NativeValue *GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetTempDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info); - static NativeValue *GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info); + static napi_value GetCacheDir(napi_env env, napi_callback_info info); + static napi_value GetTempDir(napi_env env, napi_callback_info info); + static napi_value GetFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDistributedFilesDir(napi_env env, napi_callback_info info); + static napi_value GetDatabaseDir(napi_env env, napi_callback_info info); + static napi_value GetPreferencesDir(napi_env env, napi_callback_info info); + static napi_value GetBundleCodeDir(napi_env env, napi_callback_info info); - NativeValue *OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetArea(NativeEngine &engine, NativeCallbackInfo &info); - NativeValue *OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info); + napi_value OnGetCacheDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetTempDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetFilesDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetDatabaseDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetPreferencesDir(napi_env env, NapiCallbackInfo &info); + napi_value OnGetBundleCodeDir(napi_env env, NapiCallbackInfo &info); + napi_value OnSwitchArea(napi_env env, NapiCallbackInfo &info); + napi_value OnGetArea(napi_env env, NapiCallbackInfo &info); + napi_value OnGetApplicationContext(napi_env env, NapiCallbackInfo &info); protected: std::weak_ptr context_; }; -void JsBaseContext::Finalizer(NativeEngine *engine, void *data, void *hint) +void JsBaseContext::Finalizer(napi_env env, void *data, void *hint) { HILOG_DEBUG("called"); std::unique_ptr(static_cast(data)); } -NativeValue *JsBaseContext::CreateBundleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::CreateBundleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsBaseContext::GetApplicationContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetApplicationContext(napi_env env, napi_callback_info info) { - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetApplicationContext(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetApplicationContext, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::SwitchArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::SwitchArea(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnSwitchArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnSwitchArea, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnSwitchArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnSwitchArea(napi_env env, NapiCallbackInfo &info) { if (info.argc == 0) { HILOG_ERROR("Not enough params"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int mode = 0; - if (!ConvertFromJsValue(engine, info.argv[0], mode)) { + if (!ConvertFromJsValue(env, info.argv[0], mode)) { HILOG_ERROR("Parse mode failed"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } context->SwitchArea(mode); - NativeValue *thisVar = info.thisVar; - NativeObject *object = ConvertNativeValueTo(thisVar); + napi_value object = info.thisVar; if (object == nullptr) { HILOG_ERROR("object is nullptr"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - BindNativeProperty(*object, "cacheDir", GetCacheDir); - BindNativeProperty(*object, "tempDir", GetTempDir); - BindNativeProperty(*object, "filesDir", GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", GetBundleCodeDir); - return engine.CreateUndefined(); + BindNativeProperty(env, object, "cacheDir", GetCacheDir); + BindNativeProperty(env, object, "tempDir", GetTempDir); + BindNativeProperty(env, object, "filesDir", GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", GetBundleCodeDir); + return CreateJsUndefined(env); } -NativeValue *JsBaseContext::CreateModuleContext(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::CreateModuleContext(napi_env env, napi_callback_info info) { return nullptr; } -NativeValue *JsBaseContext::GetArea(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetArea(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetArea(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetArea, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetArea(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetArea(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } int area = context->GetArea(); - return engine.CreateNumber(area); + return CreateJsValue(env, area); } -NativeValue *JsBaseContext::GetCacheDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetCacheDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetCacheDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetCacheDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetCacheDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetCacheDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetTempDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetTempDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetTempDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetTempDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetTempDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetTempDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetTempDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetFilesDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetDistributedFilesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetDistributedFilesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetDistributedFilesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetDistributedFilesDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetDistributedFilesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetDistributedFilesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDistributedFilesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetDatabaseDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetDatabaseDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetDatabaseDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetDatabaseDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetDatabaseDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetDatabaseDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetDatabaseDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetPreferencesDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetPreferencesDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetPreferencesDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetPreferencesDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetPreferencesDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetPreferencesDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetPreferencesDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::GetBundleCodeDir(NativeEngine *engine, NativeCallbackInfo *info) +napi_value JsBaseContext::GetBundleCodeDir(napi_env env, napi_callback_info info) { - HILOG_DEBUG("called"); - JsBaseContext *me = CheckParamsAndGetThis(engine, info, BASE_CONTEXT_NAME); - return me != nullptr ? me->OnGetBundleCodeDir(*engine, *info) : nullptr; + GET_NAPI_INFO_WITH_NAME_AND_CALL(env, info, JsBaseContext, OnGetBundleCodeDir, BASE_CONTEXT_NAME); } -NativeValue *JsBaseContext::OnGetBundleCodeDir(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetBundleCodeDir(napi_env env, NapiCallbackInfo &info) { auto context = context_.lock(); if (!context) { HILOG_WARN("context is already released"); - return engine.CreateUndefined(); + return CreateJsUndefined(env); } std::string path = context->GetBundleCodeDir(); - return engine.CreateString(path.c_str(), path.length()); + return CreateJsValue(env, path); } -NativeValue *JsBaseContext::OnGetApplicationContext(NativeEngine &engine, NativeCallbackInfo &info) +napi_value JsBaseContext::OnGetApplicationContext(napi_env env, NapiCallbackInfo &info) { HILOG_DEBUG("called"); - NativeValue *value = JsApplicationContextUtils::CreateJsApplicationContext(engine, context_.lock()); - auto systemModule = JsRuntime::LoadSystemModuleByEngine(&engine, "application.ApplicationContext", &value, 1); + napi_value value = JsApplicationContextUtils::CreateJsApplicationContext(env, context_.lock()); + auto systemModule = JsRuntime::LoadSystemModuleByEngine(env, "application.ApplicationContext", &value, 1); if (systemModule == nullptr) { - return engine.CreateUndefined(); + return CreateJsUndefined(env); } - auto contextObj = systemModule->Get(); + auto contextObj = systemModule->GetNapiValue(); return contextObj; } } // namespace -NativeValue *CreateJsBaseContext(NativeEngine &engine, std::shared_ptr context, bool keepContext) +napi_value CreateJsBaseContext(napi_env env, std::shared_ptr context, bool keepContext) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { HILOG_WARN("invalid object."); - return objValue; + return object; } auto appInfo = context->GetApplicationInfo(); if (appInfo != nullptr) { - object->SetProperty("applicationInfo", CreateJsApplicationInfo(engine, *appInfo)); + napi_set_named_property(env, object, "applicationInfo", CreateJsApplicationInfo(env, *appInfo)); } auto hapModuleInfo = context->GetHapModuleInfo(); if (hapModuleInfo != nullptr) { - object->SetProperty("currentHapModuleInfo", CreateJsHapModuleInfo(engine, *hapModuleInfo)); + napi_set_named_property(env, object, "currentHapModuleInfo", CreateJsHapModuleInfo(env, *hapModuleInfo)); } auto jsContext = std::make_unique(context); - SetNamedNativePointer(engine, *object, BASE_CONTEXT_NAME, jsContext.release(), JsBaseContext::Finalizer); + SetNamedNativePointer(env, object, BASE_CONTEXT_NAME, jsContext.release(), JsBaseContext::Finalizer); - BindNativeProperty(*object, "cacheDir", JsBaseContext::GetCacheDir); - BindNativeProperty(*object, "tempDir", JsBaseContext::GetTempDir); - BindNativeProperty(*object, "filesDir", JsBaseContext::GetFilesDir); - BindNativeProperty(*object, "distributedFilesDir", JsBaseContext::GetDistributedFilesDir); - BindNativeProperty(*object, "databaseDir", JsBaseContext::GetDatabaseDir); - BindNativeProperty(*object, "preferencesDir", JsBaseContext::GetPreferencesDir); - BindNativeProperty(*object, "bundleCodeDir", JsBaseContext::GetBundleCodeDir); - BindNativeProperty(*object, "area", JsBaseContext::GetArea); + BindNativeProperty(env, object, "cacheDir", JsBaseContext::GetCacheDir); + BindNativeProperty(env, object, "tempDir", JsBaseContext::GetTempDir); + BindNativeProperty(env, object, "filesDir", JsBaseContext::GetFilesDir); + BindNativeProperty(env, object, "distributedFilesDir", JsBaseContext::GetDistributedFilesDir); + BindNativeProperty(env, object, "databaseDir", JsBaseContext::GetDatabaseDir); + BindNativeProperty(env, object, "preferencesDir", JsBaseContext::GetPreferencesDir); + BindNativeProperty(env, object, "bundleCodeDir", JsBaseContext::GetBundleCodeDir); + BindNativeProperty(env, object, "area", JsBaseContext::GetArea); const char *moduleName = "JsBaseContext"; - BindNativeFunction(engine, *object, "createBundleContext", moduleName, JsBaseContext::CreateBundleContext); - BindNativeFunction(engine, *object, "getApplicationContext", moduleName, JsBaseContext::GetApplicationContext); - BindNativeFunction(engine, *object, "switchArea", moduleName, JsBaseContext::SwitchArea); - BindNativeFunction(engine, *object, "getArea", moduleName, JsBaseContext::GetArea); - BindNativeFunction(engine, *object, "createModuleContext", moduleName, JsBaseContext::CreateModuleContext); + BindNativeFunction(env, object, "createBundleContext", moduleName, JsBaseContext::CreateBundleContext); + BindNativeFunction(env, object, "getApplicationContext", moduleName, JsBaseContext::GetApplicationContext); + BindNativeFunction(env, object, "switchArea", moduleName, JsBaseContext::SwitchArea); + BindNativeFunction(env, object, "getArea", moduleName, JsBaseContext::GetArea); + BindNativeFunction(env, object, "createModuleContext", moduleName, JsBaseContext::CreateModuleContext); - return objValue; + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_data_converter.cpp b/frameworks/simulator/ability_simulator/src/js_data_converter.cpp index a36bcdccd9..2fdfc59c53 100644 --- a/frameworks/simulator/ability_simulator/src/js_data_converter.cpp +++ b/frameworks/simulator/ability_simulator/src/js_data_converter.cpp @@ -92,73 +92,74 @@ Global::Resource::Direction ConvertDirection(const std::string &direction) return resolution; } -NativeValue *CreateJsConfiguration(NativeEngine &engine, const AppExecFwk::Configuration &configuration) +napi_value CreateJsConfiguration(napi_env env, const AppExecFwk::Configuration &configuration) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); + napi_value object = nullptr; + napi_create_object(env, &object); if (object == nullptr) { HILOG_ERROR("Native object is nullptr."); - return objValue; + return object; } - object->SetProperty("language", CreateJsValue(engine, + napi_set_named_property(env, object, "language", CreateJsValue(env, configuration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE))); - - object->SetProperty("colorMode", CreateJsValue(engine, + + napi_set_named_property(env, object, "colorMode", CreateJsValue(env, ConvertColorMode(configuration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE)))); std::string direction = configuration.GetItem(AppExecFwk::ConfigurationInner::APPLICATION_DIRECTION); - object->SetProperty("direction", CreateJsValue(engine, ConvertDirection(direction))); + napi_set_named_property(env, object, "direction", CreateJsValue(env, ConvertDirection(direction))); std::string density = configuration.GetItem(AppExecFwk::ConfigurationInner::APPLICATION_DENSITYDPI); - object->SetProperty("screenDensity", CreateJsValue(engine, ConvertDensity(density))); + napi_set_named_property(env, object, "screenDensity", CreateJsValue(env, ConvertDensity(density))); int32_t displayId = ConvertDisplayId(configuration.GetItem(AppExecFwk::ConfigurationInner::APPLICATION_DISPLAYID)); - object->SetProperty("displayId", CreateJsValue(engine, displayId)); + napi_set_named_property(env, object, "displayId", CreateJsValue(env, displayId)); std::string hasPointerDevice = configuration.GetItem(AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE); - object->SetProperty("hasPointerDevice", CreateJsValue(engine, hasPointerDevice == "true" ? true : false)); + napi_set_named_property( + env, object, "hasPointerDevice", CreateJsValue(env, hasPointerDevice == "true" ? true : false)); - return objValue; + return object; } -NativeValue *CreateJsApplicationInfo(NativeEngine &engine, const AppExecFwk::ApplicationInfo &applicationInfo) +napi_value CreateJsApplicationInfo(napi_env env, const AppExecFwk::ApplicationInfo &applicationInfo) { - NativeValue *objValue = engine.CreateObject(); - if (objValue == nullptr) { + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { HILOG_ERROR("Create object failed."); return nullptr; } - AppExecFwk::CommonFunc::ConvertApplicationInfo(reinterpret_cast(&engine), - reinterpret_cast(objValue), applicationInfo); - return objValue; + AppExecFwk::CommonFunc::ConvertApplicationInfo(env, object, applicationInfo); + return object; } -NativeValue *CreateJsHapModuleInfo(NativeEngine &engine, const AppExecFwk::HapModuleInfo &hapModuleInfo) +napi_value CreateJsHapModuleInfo(napi_env env, const AppExecFwk::HapModuleInfo &hapModuleInfo) { - NativeValue *objValue = engine.CreateObject(); - if (objValue == nullptr) { + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { HILOG_ERROR("Create object failed."); return nullptr; } - AppExecFwk::CommonFunc::ConvertHapModuleInfo(reinterpret_cast(&engine), hapModuleInfo, - reinterpret_cast(objValue)); - return objValue; + AppExecFwk::CommonFunc::ConvertHapModuleInfo(env, hapModuleInfo, object); + return object; } -NativeValue *CreateJsAbilityInfo(NativeEngine &engine, const AppExecFwk::AbilityInfo &abilityInfo) +napi_value CreateJsAbilityInfo(napi_env env, const AppExecFwk::AbilityInfo &abilityInfo) { - NativeValue *objValue = engine.CreateObject(); - if (objValue == nullptr) { + napi_value object = nullptr; + napi_create_object(env, &object); + if (object == nullptr) { HILOG_ERROR("Create object failed."); return nullptr; } - AppExecFwk::CommonFunc::ConvertAbilityInfo(reinterpret_cast(&engine), abilityInfo, - reinterpret_cast(objValue)); - return objValue; + AppExecFwk::CommonFunc::ConvertAbilityInfo(env, abilityInfo, object); + return object; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp b/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp index 8c12ed1f4d..9eee7737b8 100644 --- a/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp +++ b/frameworks/simulator/ability_simulator/src/js_resource_manager_utils.cpp @@ -20,12 +20,11 @@ namespace OHOS { namespace AbilityRuntime { -NativeValue *CreateJsResourceManager(NativeEngine &engine, +napi_value CreateJsResourceManager(napi_env env, std::shared_ptr resourceManager, std::shared_ptr context) { - napi_env env = reinterpret_cast(&engine); napi_value result = Global::Resource::ResourceManagerAddon::Create(env, "", resourceManager, context); - return reinterpret_cast(result); + return result; } } // namespace AbilityRuntime } // namespace OHOS diff --git a/frameworks/simulator/ability_simulator/src/js_timer.cpp b/frameworks/simulator/ability_simulator/src/js_timer.cpp index b459a86ef6..9d1dcff273 100644 --- a/frameworks/simulator/ability_simulator/src/js_timer.cpp +++ b/frameworks/simulator/ability_simulator/src/js_timer.cpp @@ -37,10 +37,16 @@ std::unordered_map> g_timerTable; class JsTimer final { public: - JsTimer(NativeEngine &nativeEngine, const std::shared_ptr &jsFunction, uint32_t id) - : nativeEngine_(nativeEngine), jsFunction_(jsFunction), id_(id) + JsTimer(napi_env env, const std::shared_ptr &jsFunction, uint32_t id) + : env_(env), jsFunction_(jsFunction), id_(id) { - uv_timer_init(nativeEngine.GetUVLoop(), &timerReq_); + uv_loop_s* loop = nullptr; + napi_get_uv_event_loop(env_, &loop); + if (loop == nullptr) { + HILOG_ERROR("loop == nullptr."); + return; + } + uv_timer_init(loop, &timerReq_); timerReq_.data = this; } @@ -59,12 +65,14 @@ public: void OnTimeout() { - std::vector args; + std::vector args; args.reserve(jsArgs_.size()); for (auto arg : jsArgs_) { - args.emplace_back(arg->Get()); + args.emplace_back(arg->GetNapiValue()); } - nativeEngine_.CallFunction(nativeEngine_.CreateUndefined(), jsFunction_->Get(), args.data(), args.size()); + napi_value res = nullptr; + napi_call_function(env_, CreateJsUndefined(env_), + jsFunction_->GetNapiValue(), args.size(), args.data(), &res); if (uv_timer_get_repeat(&timerReq_) == 0) { std::lock_guard lock(g_mutex); @@ -78,34 +86,44 @@ public: } private: - NativeEngine& nativeEngine_; + napi_env env_; std::shared_ptr jsFunction_; std::vector> jsArgs_; uv_timer_t timerReq_; uint32_t id_ = 0; }; -NativeValue *StartTimeoutOrInterval(NativeEngine *engine, NativeCallbackInfo *info, bool isInterval) +napi_value StartTimeoutOrInterval(napi_env env, napi_callback_info info, bool isInterval) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("Start timeout or interval failed with engine or callback info is nullptr."); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("Start timeout or interval failed with env or callback info is nullptr."); return nullptr; } + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); // parameter check, must have at least 2 params - if (info->argc < 2 || info->argv[0]->TypeOf() != NATIVE_FUNCTION || info->argv[1]->TypeOf() != NATIVE_NUMBER) { + if (argc < 2 ||!CheckTypeForNapiValue(env, argv[0], napi_function) + || !CheckTypeForNapiValue(env, argv[1], napi_number)) { HILOG_ERROR("Set callback timer failed with invalid parameter."); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } // parse parameter - std::shared_ptr jsFunction(engine->CreateReference(info->argv[0], 1)); - int64_t delayTime = *ConvertNativeValueTo(info->argv[1]); + napi_ref ref = nullptr; + napi_create_reference(env, argv[0], 1, &ref); + std::shared_ptr jsFunction(reinterpret_cast(ref)); + int64_t delayTime = 0; + napi_get_value_int64(env, argv[1], &delayTime); uint32_t callbackId = g_callbackId.fetch_add(1, std::memory_order_relaxed); - auto task = std::make_shared(*engine, jsFunction, callbackId); - for (size_t index = 2; index < info->argc; ++index) { - task->PushArgs(std::shared_ptr(engine->CreateReference(info->argv[index], 1))); + auto task = std::make_shared(env, jsFunction, callbackId); + for (size_t index = 2; index < argc; ++index) { + napi_ref taskRef = nullptr; + napi_create_reference(env, argv[index], 1, &taskRef); + task->PushArgs(std::shared_ptr(reinterpret_cast(taskRef))); } // if setInterval is called, interval must not be zero for repeat, so set to 1ms @@ -120,48 +138,52 @@ NativeValue *StartTimeoutOrInterval(NativeEngine *engine, NativeCallbackInfo *in g_timerTable.emplace(callbackId, task); } - return engine->CreateNumber(callbackId); + return CreateJsValue(env, callbackId); } -NativeValue *StartTimeout(NativeEngine *engine, NativeCallbackInfo *info) +napi_value StartTimeout(napi_env env, napi_callback_info info) { - return StartTimeoutOrInterval(engine, info, false); + return StartTimeoutOrInterval(env, info, false); } -NativeValue *StartInterval(NativeEngine *engine, NativeCallbackInfo *info) +napi_value StartInterval(napi_env env, napi_callback_info info) { - return StartTimeoutOrInterval(engine, info, true); + return StartTimeoutOrInterval(env, info, true); } -NativeValue *StopTimeoutOrInterval(NativeEngine *engine, NativeCallbackInfo *info) +napi_value StopTimeoutOrInterval(napi_env env, napi_callback_info info) { - if (engine == nullptr || info == nullptr) { - HILOG_ERROR("Stop timeout or interval failed with engine or callback info is nullptr."); + if (env == nullptr || info == nullptr) { + HILOG_ERROR("Stop timeout or interval failed with env or callback info is nullptr."); return nullptr; } + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr)); // parameter check, must have at least 1 param - if (info->argc < 1 || info->argv[0]->TypeOf() != NATIVE_NUMBER) { + if (argc < 1 || !CheckTypeForNapiValue(env, argv[0], napi_number)) { HILOG_ERROR("Clear callback timer failed with invalid parameter."); - return engine->CreateUndefined(); + return CreateJsUndefined(env); } - - uint32_t callbackId = *ConvertNativeValueTo(info->argv[0]); + uint32_t callbackId = 0; + napi_get_value_uint32(env, argv[0], &callbackId); { std::lock_guard lock(g_mutex); g_timerTable.erase(callbackId); } - return engine->CreateUndefined(); + return CreateJsUndefined(env); } } -void InitTimer(NativeEngine &engine, NativeObject &globalObject) +void InitTimer(napi_env env, napi_value globalObject) { const char *moduleName = "AsJsTimer"; - BindNativeFunction(engine, globalObject, "setTimeout", moduleName, StartTimeout); - BindNativeFunction(engine, globalObject, "setInterval", moduleName, StartInterval); - BindNativeFunction(engine, globalObject, "clearTimeout", moduleName, StopTimeoutOrInterval); - BindNativeFunction(engine, globalObject, "clearInterval", moduleName, StopTimeoutOrInterval); + BindNativeFunction(env, globalObject, "setTimeout", moduleName, StartTimeout); + BindNativeFunction(env, globalObject, "setInterval", moduleName, StartInterval); + BindNativeFunction(env, globalObject, "clearTimeout", moduleName, StopTimeoutOrInterval); + BindNativeFunction(env, globalObject, "clearInterval", moduleName, StopTimeoutOrInterval); } } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/simulator/ability_simulator/src/simulator.cpp b/frameworks/simulator/ability_simulator/src/simulator.cpp index ee41549cdb..05c579a249 100644 --- a/frameworks/simulator/ability_simulator/src/simulator.cpp +++ b/frameworks/simulator/ability_simulator/src/simulator.cpp @@ -101,25 +101,26 @@ public: private: bool OnInit(); void Run(); - NativeValue *LoadScript(const std::string &srcPath); + napi_value LoadScript(const std::string &srcPath); void InitResourceMgr(); - void InitJsAbilityContext(NativeValue *instanceValue); - void DispatchStartLifecycle(NativeValue *instanceValue); + void InitJsAbilityContext(napi_env env, napi_value instanceValue); + void DispatchStartLifecycle(napi_value instanceValue); std::unique_ptr CreateJsWindowStage(const std::shared_ptr &windowScene); - NativeValue *CreateJsWant(NativeEngine &engine); + napi_value CreateJsWant(napi_env env); bool LoadAbilityStage(uint8_t *buffer, size_t len); - void InitJsAbilityStageContext(NativeValue *instanceValue); - NativeValue *CreateJsLaunchParam(NativeEngine &engine); + void InitJsAbilityStageContext(napi_value instanceValue); + napi_value CreateJsLaunchParam(napi_env env); bool ParseBundleAndModuleInfo(); bool ParseAbilityInfo(const std::string &abilitySrcPath); - bool LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &globalObject); + bool LoadRuntimeEnv(napi_env env, napi_value globalObject); + static napi_value RequireNapi(napi_env env, napi_callback_info info); panda::ecmascript::EcmaVM *CreateJSVM(); Options options_; std::string abilityPath_; panda::ecmascript::EcmaVM *vm_ = nullptr; DebuggerTask debuggerTask_; - std::unique_ptr nativeEngine_; + napi_env nativeEngine_ = nullptr; int64_t currentId_ = 0; std::unordered_map> abilities_; @@ -159,11 +160,12 @@ SimulatorImpl::~SimulatorImpl() { if (nativeEngine_) { uv_close(reinterpret_cast(&debuggerTask_.onPostTaskSignal), nullptr); - uv_loop_t *uvLoop = nativeEngine_->GetUVLoop(); + uv_loop_t* uvLoop = nullptr; + napi_get_uv_event_loop(nativeEngine_, &uvLoop); if (uvLoop != nullptr) { uv_work_t work; uv_queue_work(uvLoop, &work, [](uv_work_t*) {}, [](uv_work_t *work, int32_t status) { - HILOG_DEBUG("Simulator stop uv loop"); + HILOG_ERROR("Simulator stop uv loop"); uv_stop(work->loop); }); } @@ -172,7 +174,7 @@ SimulatorImpl::~SimulatorImpl() panda::JSNApi::StopDebugger(vm_); abilities_.clear(); - nativeEngine_.reset(); + nativeEngine_ = nullptr; panda::JSNApi::DestroyJSVM(vm_); vm_ = nullptr; } @@ -180,7 +182,7 @@ SimulatorImpl::~SimulatorImpl() bool SimulatorImpl::Initialize(const Options &options) { if (nativeEngine_) { - HILOG_DEBUG("Simulator is already initialized"); + HILOG_ERROR("Simulator is already initialized"); return true; } @@ -189,7 +191,8 @@ bool SimulatorImpl::Initialize(const Options &options) return false; } - uv_loop_t *uvLoop = nativeEngine_->GetUVLoop(); + uv_loop_t* uvLoop = nullptr; + napi_get_uv_event_loop(nativeEngine_, &uvLoop); if (uvLoop == nullptr) { return false; } @@ -201,23 +204,25 @@ bool SimulatorImpl::Initialize(const Options &options) return true; } -void CallObjectMethod(NativeEngine &engine, NativeValue *value, const char *name, NativeValue *const *argv, size_t argc) +void CallObjectMethod(napi_env env, napi_value obj, const char *name, napi_value const *argv, size_t argc) { - NativeObject *obj = ConvertNativeValueTo(value); if (obj == nullptr) { HILOG_ERROR("%{public}s, Failed to get Ability object", __func__); return; } - - NativeValue *methodOnCreate = obj->GetProperty(name); + napi_value methodOnCreate = nullptr; + napi_get_named_property(env, obj, name, &methodOnCreate); if (methodOnCreate == nullptr) { HILOG_ERROR("Failed to get '%{public}s' from Ability object", name); return; } - engine.CallFunction(value, methodOnCreate, argv, argc); + napi_status status = napi_call_function(env, obj, methodOnCreate, argc, argv, nullptr); + if (status != napi_ok) { + HILOG_ERROR("Failed to napi call function"); + } } -NativeValue *SimulatorImpl::LoadScript(const std::string &srcPath) +napi_value SimulatorImpl::LoadScript(const std::string &srcPath) { panda::Local objRef = panda::JSNApi::GetExportObject(vm_, srcPath, "default"); if (objRef->IsNull()) { @@ -225,8 +230,10 @@ NativeValue *SimulatorImpl::LoadScript(const std::string &srcPath) return nullptr; } - auto obj = ArkNativeEngine::ArkValueToNativeValue(static_cast(nativeEngine_.get()), objRef); - return nativeEngine_->CreateInstance(obj, nullptr, 0); + auto obj = ArkNativeEngine::ArkValueToNapiValue(nativeEngine_, objRef); + napi_value instanceValue = nullptr; + napi_new_instance(nativeEngine_, obj, 0, nullptr, &instanceValue); + return instanceValue; } bool SimulatorImpl::ParseBundleAndModuleInfo() @@ -326,12 +333,12 @@ int64_t SimulatorImpl::StartAbility(const std::string &abilitySrcPath, Terminate } abilityPath_ = BUNDLE_INSTALL_PATH + options_.moduleName + "/" + abilitySrcPath; - if (!nativeEngine_->RunScriptBuffer(abilityPath_, buf, len, false)) { + if (!reinterpret_cast(nativeEngine_)->RunScriptBuffer(abilityPath_, buf, len, false)) { HILOG_ERROR("Failed to run script: %{public}s", abilityPath_.c_str()); return -1; } - NativeValue *instanceValue = LoadScript(abilityPath_); + napi_value instanceValue = LoadScript(abilityPath_); if (instanceValue == nullptr) { HILOG_ERROR("Failed to create object instance"); return -1; @@ -339,9 +346,11 @@ int64_t SimulatorImpl::StartAbility(const std::string &abilitySrcPath, Terminate ++currentId_; InitResourceMgr(); - InitJsAbilityContext(instanceValue); + InitJsAbilityContext(nativeEngine_, instanceValue); DispatchStartLifecycle(instanceValue); - abilities_.emplace(currentId_, nativeEngine_->CreateReference(instanceValue, 1)); + napi_ref ref = nullptr; + napi_create_reference(nativeEngine_, instanceValue, 1, &ref); + abilities_.emplace(currentId_, std::shared_ptr(reinterpret_cast(ref))); return currentId_; } @@ -368,56 +377,56 @@ bool SimulatorImpl::LoadAbilityStage(uint8_t *buffer, size_t len) auto moduleSrcPath = BUNDLE_INSTALL_PATH + options_.moduleName + "/" + srcEntrance; HILOG_DEBUG("moduleSrcPath is %{public}s", moduleSrcPath.c_str()); - if (!nativeEngine_->RunScriptBuffer(moduleSrcPath, buffer, len, false)) { + if (!reinterpret_cast(nativeEngine_)->RunScriptBuffer(moduleSrcPath, buffer, len, false)) { HILOG_ERROR("Failed to run ability stage script: %{public}s", moduleSrcPath.c_str()); return false; } - NativeValue *instanceValue = LoadScript(moduleSrcPath); + napi_value instanceValue = LoadScript(moduleSrcPath); if (instanceValue == nullptr) { HILOG_ERROR("Failed to create ability stage instance"); return false; } InitJsAbilityStageContext(instanceValue); + CallObjectMethod(nativeEngine_, instanceValue, "onCreate", nullptr, 0); - CallObjectMethod(*nativeEngine_, instanceValue, "onCreate", nullptr, 0); - NativeValue *wantArgv[] = { - CreateJsWant(*nativeEngine_) + napi_value wantArgv[] = { + CreateJsWant(nativeEngine_) }; - CallObjectMethod(*nativeEngine_, instanceValue, "onAcceptWant", wantArgv, ArraySize(wantArgv)); - - abilityStage_ = std::shared_ptr(nativeEngine_->CreateReference(instanceValue, 1)); + CallObjectMethod(nativeEngine_, instanceValue, "onAcceptWant", wantArgv, ArraySize(wantArgv)); + napi_ref ref = nullptr; + napi_create_reference(nativeEngine_, instanceValue, 1, &ref); + abilityStage_ = std::shared_ptr(reinterpret_cast(ref)); return true; } -void SimulatorImpl::InitJsAbilityStageContext(NativeValue *instanceValue) +void SimulatorImpl::InitJsAbilityStageContext(napi_value obj) { - NativeValue *contextObj = CreateJsAbilityStageContext(*nativeEngine_, stageContext_); + napi_value contextObj = CreateJsAbilityStageContext(nativeEngine_, stageContext_); if (contextObj == nullptr) { HILOG_ERROR("contextObj is nullptr"); return; } jsStageContext_ = std::shared_ptr( - JsRuntime::LoadSystemModuleByEngine(nativeEngine_.get(), "application.AbilityStageContext", &contextObj, 1)); + JsRuntime::LoadSystemModuleByEngine(nativeEngine_, "application.AbilityStageContext", &contextObj, 1)); if (jsStageContext_ == nullptr) { HILOG_ERROR("Failed to get LoadSystemModuleByEngine"); return; } - contextObj = jsStageContext_->Get(); + contextObj = jsStageContext_->GetNapiValue(); if (contextObj == nullptr) { HILOG_ERROR("contextObj is nullptr."); return; } - NativeObject *obj = ConvertNativeValueTo(instanceValue); if (obj == nullptr) { HILOG_ERROR("obj is nullptr"); return; } - obj->SetProperty("context", contextObj); + napi_set_named_property(nativeEngine_, obj, "context", contextObj); } void SimulatorImpl::TerminateAbility(int64_t abilityId) @@ -435,14 +444,14 @@ void SimulatorImpl::TerminateAbility(int64_t abilityId) std::shared_ptr ref = it->second; abilities_.erase(it); - auto instanceValue = ref->Get(); + auto instanceValue = ref->GetNapiValue(); if (instanceValue == nullptr) { return; } - CallObjectMethod(*nativeEngine_, instanceValue, "onBackground", nullptr, 0); - CallObjectMethod(*nativeEngine_, instanceValue, "onWindowStageDestroy", nullptr, 0); - CallObjectMethod(*nativeEngine_, instanceValue, "onDestroy", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onBackground", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onWindowStageDestroy", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onDestroy", nullptr, 0); auto windowSceneIter = windowScenes_.find(abilityId); if (windowSceneIter != windowScenes_.end()) { @@ -477,29 +486,29 @@ void SimulatorImpl::UpdateConfiguration(const AppExecFwk::Configuration &config) stageContext_->SetConfiguration(configuration); } - NativeValue *configArgv[] = { - CreateJsConfiguration(*nativeEngine_, config) + napi_value configArgv[] = { + CreateJsConfiguration(nativeEngine_, config) }; - auto abilityStage = abilityStage_->Get(); + auto abilityStage = abilityStage_->GetNapiValue(); if (abilityStage == nullptr) { HILOG_ERROR("abilityStage is nullptr"); return; } - CallObjectMethod(*nativeEngine_, abilityStage, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); - CallObjectMethod(*nativeEngine_, abilityStage, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); - JsAbilityStageContext::ConfigurationUpdated(nativeEngine_.get(), jsStageContext_, configuration); + CallObjectMethod(nativeEngine_, abilityStage, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); + CallObjectMethod(nativeEngine_, abilityStage, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); + JsAbilityStageContext::ConfigurationUpdated(nativeEngine_, jsStageContext_, configuration); for (auto iter = abilities_.begin(); iter != abilities_.end(); iter++) { - auto ability = iter->second->Get(); + auto ability = iter->second->GetNapiValue(); if (ability == nullptr) { HILOG_ERROR("ability is nullptr"); continue; } - CallObjectMethod(*nativeEngine_, ability, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); - CallObjectMethod(*nativeEngine_, ability, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); - JsAbilityContext::ConfigurationUpdated(nativeEngine_.get(), iter->second, configuration); + CallObjectMethod(nativeEngine_, ability, "onConfigurationUpdated", configArgv, ArraySize(configArgv)); + CallObjectMethod(nativeEngine_, ability, "onConfigurationUpdate", configArgv, ArraySize(configArgv)); + JsAbilityContext::ConfigurationUpdated(nativeEngine_, iter->second, configuration); } } @@ -524,7 +533,7 @@ void SimulatorImpl::InitResourceMgr() HILOG_DEBUG("Add resource success."); } -void SimulatorImpl::InitJsAbilityContext(NativeValue *instanceValue) +void SimulatorImpl::InitJsAbilityContext(napi_env env, napi_value obj) { if (context_ == nullptr) { context_ = std::make_shared(); @@ -534,66 +543,67 @@ void SimulatorImpl::InitJsAbilityContext(NativeValue *instanceValue) context_->SetResourceManager(resourceMgr_); context_->SetAbilityInfo(abilityInfo_); } - NativeValue *contextObj = CreateJsAbilityContext(*nativeEngine_, context_); + napi_value contextObj = CreateJsAbilityContext(nativeEngine_, context_); auto systemModule = std::shared_ptr( - JsRuntime::LoadSystemModuleByEngine(nativeEngine_.get(), "application.AbilityContext", &contextObj, 1)); + JsRuntime::LoadSystemModuleByEngine(nativeEngine_, "application.AbilityContext", &contextObj, 1)); if (systemModule == nullptr) { HILOG_ERROR("systemModule is nullptr."); return; } - - contextObj = systemModule->Get(); + contextObj = systemModule->GetNapiValue(); if (contextObj == nullptr) { HILOG_ERROR("contextObj is nullptr."); return; } - NativeObject *obj = ConvertNativeValueTo(instanceValue); if (obj == nullptr) { HILOG_ERROR("obj is nullptr"); return; } - obj->SetProperty("context", contextObj); + napi_set_named_property(env, obj, "context", contextObj); jsContexts_.emplace(currentId_, systemModule); } -NativeValue *SimulatorImpl::CreateJsWant(NativeEngine &engine) +napi_value SimulatorImpl::CreateJsWant(napi_env env) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - - object->SetProperty("deviceId", CreateJsValue(engine, "")); - object->SetProperty("bundleName", CreateJsValue(engine, options_.bundleName)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_set_named_property(env, objValue, "deviceId", CreateJsValue(env, std::string(""))); + napi_set_named_property(env, objValue, "bundleName", CreateJsValue(env, options_.bundleName)); if (abilityInfo_) { - object->SetProperty("abilityName", CreateJsValue(engine, abilityInfo_->name)); + napi_set_named_property(env, objValue, "abilityName", CreateJsValue(env, abilityInfo_->name)); } - object->SetProperty("moduleName", CreateJsValue(engine, options_.moduleName)); - object->SetProperty("uri", CreateJsValue(engine, "")); - object->SetProperty("type", CreateJsValue(engine, "")); - object->SetProperty("flags", CreateJsValue(engine, 0)); - object->SetProperty("action", CreateJsValue(engine, "")); - object->SetProperty("parameters", engine.CreateObject()); - object->SetProperty("entities", engine.CreateArray(0)); + napi_set_named_property(env, objValue, "moduleName", CreateJsValue(env, options_.moduleName)); + + napi_set_named_property(env, objValue, "uri", CreateJsValue(env, std::string(""))); + napi_set_named_property(env, objValue, "type", CreateJsValue(env, std::string(""))); + napi_set_named_property(env, objValue, "flags", CreateJsValue(env, 0)); + napi_set_named_property(env, objValue, "type", CreateJsValue(env, std::string(""))); + napi_value object = nullptr; + napi_create_object(env, &object); + napi_set_named_property(env, objValue, "parameters", object); + napi_value array = nullptr; + napi_create_array_with_length(env, 0, &array); + napi_set_named_property(env, objValue, "entities", array); return objValue; } -NativeValue *SimulatorImpl::CreateJsLaunchParam(NativeEngine &engine) +napi_value SimulatorImpl::CreateJsLaunchParam(napi_env env) { - NativeValue *objValue = engine.CreateObject(); - NativeObject *object = ConvertNativeValueTo(objValue); - object->SetProperty("launchReason", CreateJsValue(engine, AAFwk::LAUNCHREASON_UNKNOWN)); - object->SetProperty("lastExitReason", CreateJsValue(engine, AAFwk::LASTEXITREASON_UNKNOWN)); + napi_value objValue = nullptr; + napi_create_object(env, &objValue); + napi_set_named_property(env, objValue, "launchReason", CreateJsValue(env, AAFwk::LAUNCHREASON_UNKNOWN)); + napi_set_named_property(env, objValue, "lastExitReason", CreateJsValue(env, AAFwk::LASTEXITREASON_UNKNOWN)); return objValue; } -void SimulatorImpl::DispatchStartLifecycle(NativeValue *instanceValue) +void SimulatorImpl::DispatchStartLifecycle(napi_value instanceValue) { - NativeValue *wantArgv[] = { - CreateJsWant(*nativeEngine_), - CreateJsLaunchParam(*nativeEngine_) + napi_value wantArgv[] = { + CreateJsWant(nativeEngine_), + CreateJsLaunchParam(nativeEngine_) }; - CallObjectMethod(*nativeEngine_, instanceValue, "onCreate", wantArgv, ArraySize(wantArgv)); - + CallObjectMethod(nativeEngine_, instanceValue, "onCreate", wantArgv, ArraySize(wantArgv)); auto windowScene = std::make_shared(); if (windowScene == nullptr) { return; @@ -604,10 +614,10 @@ void SimulatorImpl::DispatchStartLifecycle(NativeValue *instanceValue) if (jsWindowStage == nullptr) { return; } - NativeValue *argv[] = { jsWindowStage->Get() }; - CallObjectMethod(*nativeEngine_, instanceValue, "onWindowStageCreate", argv, ArraySize(argv)); + napi_value argv[] = { jsWindowStage->GetNapiValue() }; + CallObjectMethod(nativeEngine_, instanceValue, "onWindowStageCreate", argv, ArraySize(argv)); - CallObjectMethod(*nativeEngine_, instanceValue, "onForeground", nullptr, 0); + CallObjectMethod(nativeEngine_, instanceValue, "onForeground", nullptr, 0); windowScenes_.emplace(currentId_, windowScene); jsWindowStages_.emplace(currentId_, std::shared_ptr(jsWindowStage.release())); @@ -616,12 +626,13 @@ void SimulatorImpl::DispatchStartLifecycle(NativeValue *instanceValue) std::unique_ptr SimulatorImpl::CreateJsWindowStage( const std::shared_ptr &windowScene) { - NativeValue *jsWindowStage = Rosen::CreateJsWindowStage(*nativeEngine_, windowScene); + auto engine = reinterpret_cast(nativeEngine_); + napi_value jsWindowStage = reinterpret_cast(Rosen::CreateJsWindowStage(*engine, windowScene)); if (jsWindowStage == nullptr) { HILOG_ERROR("Failed to create jsWindowSatge object"); return nullptr; } - return JsRuntime::LoadSystemModuleByEngine(nativeEngine_.get(), "application.WindowStage", &jsWindowStage, 1); + return JsRuntime::LoadSystemModuleByEngine(nativeEngine_, "application.WindowStage", &jsWindowStage, 1); } panda::ecmascript::EcmaVM *SimulatorImpl::CreateJSVM() @@ -673,18 +684,23 @@ bool SimulatorImpl::OnInit() panda::JSNApi::StartDebugger(vm_, debugOption, 0, std::bind(&DebuggerTask::OnPostTask, &debuggerTask_, std::placeholders::_1)); - auto nativeEngine = std::make_unique(vm_, nullptr); + auto nativeEngine = new (std::nothrow) ArkNativeEngine(vm_, nullptr); if (nativeEngine == nullptr) { HILOG_ERROR("nativeEngine is nullptr"); return false; } - NativeObject *globalObj = ConvertNativeValueTo(nativeEngine->GetGlobal()); + napi_env env = reinterpret_cast(nativeEngine); + + napi_value globalObj; + napi_get_global(env, &globalObj); if (globalObj == nullptr) { + delete nativeEngine; HILOG_ERROR("Failed to get global object"); return false; } - if (!LoadRuntimeEnv(*nativeEngine, *globalObj)) { + if (!LoadRuntimeEnv(env, globalObj)) { + delete nativeEngine; HILOG_ERROR("Load runtime env failed."); return false; } @@ -694,18 +710,40 @@ bool SimulatorImpl::OnInit() panda::JSNApi::SetModuleName(vm_, options_.moduleName); panda::JSNApi::SetAssetPath(vm_, options_.modulePath); - nativeEngine_ = std::move(nativeEngine); + nativeEngine_ = env; return true; } -bool SimulatorImpl::LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &globalObj) +napi_value SimulatorImpl::RequireNapi(napi_env env, napi_callback_info info) { - JsSysModule::Console::InitConsoleModule(reinterpret_cast(&nativeEngine)); - auto ret = JsSysModule::Timer::RegisterTime(reinterpret_cast(&nativeEngine)); + napi_value globalObj; + napi_get_global(env, &globalObj); + napi_value requireNapi = nullptr; + napi_get_named_property(env, globalObj, "requireNapiPreview", &requireNapi); + size_t argc = ARGC_MAX_COUNT; + napi_value argv[ARGC_MAX_COUNT] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + napi_value result = nullptr; + napi_call_function(env, CreateJsUndefined(env), requireNapi, argc, argv, &result); + if (!CheckTypeForNapiValue(env, result, napi_undefined)) { + return result; + } + napi_value mockRequireNapi = nullptr; + napi_get_named_property(env, globalObj, "mockRequireNapi", &mockRequireNapi); + napi_call_function(env, CreateJsUndefined(env), mockRequireNapi, argc, argv, &result); + return result; +} + +bool SimulatorImpl::LoadRuntimeEnv(napi_env env, napi_value globalObj) +{ + JsSysModule::Console::InitConsoleModule(env); + auto ret = JsSysModule::Timer::RegisterTime(env); if (!ret) { HILOG_ERROR("Register timer failed"); } - globalObj.SetProperty("group", nativeEngine.CreateObject()); + napi_value object = nullptr; + napi_create_object(env, &object); + napi_set_named_property(env, globalObj, "group", object); uintptr_t bufferStart = reinterpret_cast(_binary_jsMockSystemPlugin_abc_start); uintptr_t bufferEnd = reinterpret_cast(_binary_jsMockSystemPlugin_abc_end); @@ -713,12 +751,12 @@ bool SimulatorImpl::LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &glo size_t size = bufferEnd - bufferStart; panda::JSNApi::Execute(vm_, buffer, size, "_GLOBAL::func_main_0"); - NativeValue *mockRequireNapi = globalObj.GetProperty("requireNapi"); - globalObj.SetProperty("mockRequireNapi", mockRequireNapi); - - auto* moduleManager = nativeEngine.GetModuleManager(); + napi_value mockRequireNapi = nullptr; + napi_get_named_property(env, globalObj, "requireNapi", &mockRequireNapi); + napi_set_named_property(env, globalObj, "mockRequireNapi", mockRequireNapi); + auto* moduleManager = reinterpret_cast(env)->GetModuleManager(); if (moduleManager != nullptr) { - HILOG_DEBUG("moduleManager SetPreviewSearchPath: %{public}s", options_.containerSdkPath.c_str()); + HILOG_ERROR("moduleManager SetPreviewSearchPath: %{public}s", options_.containerSdkPath.c_str()); moduleManager->SetPreviewSearchPath(options_.containerSdkPath); } @@ -735,25 +773,14 @@ bool SimulatorImpl::LoadRuntimeEnv(NativeEngine &nativeEngine, NativeObject &glo } const char *moduleName = "SimulatorImpl"; - BindNativeFunction(nativeEngine, globalObj, "requireNapi", moduleName, - [](NativeEngine *engine, NativeCallbackInfo *info) { - NativeObject *globalObj = ConvertNativeValueTo(engine->GetGlobal()); - NativeValue *requireNapi = globalObj->GetProperty("requireNapiPreview"); - - NativeValue *result = engine->CallFunction(engine->CreateUndefined(), requireNapi, info->argv, info->argc); - if (result->TypeOf() != NATIVE_UNDEFINED) { - return result; - } - - NativeValue *mockRequireNapi = globalObj->GetProperty("mockRequireNapi"); - return engine->CallFunction(engine->CreateUndefined(), mockRequireNapi, info->argv, info->argc); - }); + BindNativeFunction(env, globalObj, "requireNapi", moduleName, SimulatorImpl::RequireNapi); return true; } void SimulatorImpl::Run() { - uv_loop_t *uvLoop = nativeEngine_->GetUVLoop(); + uv_loop_t* uvLoop = nullptr; + napi_get_uv_event_loop(nativeEngine_, &uvLoop); if (uvLoop != nullptr) { uv_run(uvLoop, UV_RUN_NOWAIT); } diff --git a/hisysevent.yaml b/hisysevent.yaml index 4a67d2c1d5..a387806cb7 100644 --- a/hisysevent.yaml +++ b/hisysevent.yaml @@ -218,7 +218,11 @@ APP_LAUNCH: VERSION_NAME: {type: STRING, desc: version name} PROCESS_NAME: {type: STRING, desc: process name} BUNDLE_NAME: {type: STRING, desc: bundle name} - CALLER_BUNDLE_NAME: {type: STRING, desc: bundle name} + CALLER_BUNDLE_NAME: {type: STRING, desc: caller bundle name} + CALLER_VERSION_NAME: {type: STRING, desc: caller version name} + CALLER_VERSION_CODE: {type: UINT32, desc: caller version code} + CALLER_UID: {type: INT32, desc: caller app uid} + CALLER_STATE: {type: INT32, desc: caller app state} APP_FOREGROUND: __BASE: {type: BEHAVIOR, level: MINOR, tag: PowerStats, desc: foreground app} @@ -287,4 +291,30 @@ DRAWN_COMPLETED: APP_PID: {type: INT32, desc: app pid} BUNDLE_NAME: {type: STRING, desc: bundle name} MODULE_NAME: {type: STRING, desc: module name} - ABILITY_NAME: {type: STRING, desc: ability name} \ No newline at end of file + ABILITY_NAME: {type: STRING, desc: ability name} + +FA_SHOW_ON_LOCK: + __BASE: {type: BEHAVIOR, level: MINOR, desc: fa show on lock} + BUNDLE_NAME: {type: STRING, desc: bundle name} + MODULE_NAME: {type: STRING, desc: module name} + ABILITY_NAME: {type: STRING, desc: ability name} + +GRANT_URI_PERMISSION: + __BASE: {type: BEHAVIOR, level: MINOR, desc: grant uri permission form SA to third-party app} + BUNDLE_NAME: {type: STRING, desc: callee bundle name} + CALLER_BUNDLE_NAME: {type: STRING, desc: caller bundle name} + URI: {type: STRING, desc: uri information} + +START_PRIVATE_ABILITY: + __BASE: {type: BEHAVIOR, level: MINOR, desc: start private ability} + BUNDLE_NAME: {type: STRING, desc: bundle name} + MODULE_NAME: {type: STRING, desc: module name} + ABILITY_NAME: {type: STRING, desc: ability name} + +RESTART_PROCESS_BY_SAME_APP: + __BASE: {type: BEHAVIOR, level: MINOR, desc: reStart process by different processes from the same app} + RESTART_TIME: {type: STRING, desc: process reStart time} + APP_UID: {type: INT32, desc: app uid} + CALLER_PROCESS_NAME: {type: STRING, desc: caller process name} + PROCESS_NAME: {type: STRING, desc: process name} + BUNDLE_NAME: {type: STRING, desc: bundle name} diff --git a/interfaces/inner_api/ability_manager/include/auto_startup_info.h b/interfaces/inner_api/ability_manager/include/auto_startup_info.h new file mode 100644 index 0000000000..19bd805a47 --- /dev/null +++ b/interfaces/inner_api/ability_manager/include/auto_startup_info.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_AUTO_STARTUP_INFO_H +#define OHOS_ABILITY_RUNTIME_AUTO_STARTUP_INFO_H + +#include + +#include "parcel.h" + +namespace OHOS { +namespace AbilityRuntime { +/** + * @struct AutoStartupInfo + * Defines auto startup info. + */ +struct AutoStartupInfo : public Parcelable { +public: + std::string bundleName; + std::string abilityName; + std::string moduleName; + std::string abilityTypeName; + + bool ReadFromParcel(Parcel &parcel); + virtual bool Marshalling(Parcel &parcel) const override; + static AutoStartupInfo *Unmarshalling(Parcel &parcel); +}; + +struct AutoStartupStatus { + int32_t code; + bool isAutoStartup; + bool isEdmForce; +}; +} // namespace AbilityRuntime +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_AUTO_STARTUP_INFO_H \ No newline at end of file diff --git a/interfaces/inner_api/child_process_manager/include/child_process_manager.h b/interfaces/inner_api/child_process_manager/include/child_process_manager.h index 5203af23d3..0b12139f52 100644 --- a/interfaces/inner_api/child_process_manager/include/child_process_manager.h +++ b/interfaces/inner_api/child_process_manager/include/child_process_manager.h @@ -31,8 +31,9 @@ public: static ChildProcessManager instance; return instance; } - ~ChildProcessManager() = default; - + ~ChildProcessManager(); + + static void HandleSigChild(int32_t signo); pid_t StartChildProcessBySelfFork(const std::string &srcEntry); bool MultiProcessModelEnabled(); bool IsChildProcess(); @@ -46,8 +47,11 @@ private: const std::string &moduleName, AppExecFwk::HapModuleInfo &hapModuleInfo); std::unique_ptr CreateRuntime(AppExecFwk::HapModuleInfo &hapModuleInfo); + static bool signalRegistered_; bool multiProcessModelEnabled_ = false; bool isChildProcess_ = false; + + DISALLOW_COPY_AND_MOVE(ChildProcessManager); }; } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/include/ability_auto_startup_service.h b/services/abilitymgr/include/ability_auto_startup_service.h new file mode 100644 index 0000000000..0e47258e7d --- /dev/null +++ b/services/abilitymgr/include/ability_auto_startup_service.h @@ -0,0 +1,178 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_ABILITY_AUTO_STARTUP_SERVICE_H +#define OHOS_ABILITY_RUNTIME_ABILITY_AUTO_STARTUP_SERVICE_H + +#include +#include +#include + +#include "auto_startup_info.h" +#include "bundle_mgr_client.h" +#include "iremote_object.h" +#include "singleton.h" + +namespace OHOS { +namespace AbilityRuntime { +class AbilityAutoStartupService : public std::enable_shared_from_this { +public: + explicit AbilityAutoStartupService(); + + virtual ~AbilityAutoStartupService(); + + /** + * @brief Register auto start up callback for system api. + * @param callback The point of JsAbilityAutoStartupCallBack. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t RegisterAutoStartupSystemCallback(const sptr &callback); + + /** + * @brief Unregister auto start up callback for system api. + * @param callback The point of JsAbilityAutoStartupCallBack. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t UnregisterAutoStartupSystemCallback(const sptr &callback); + + /** + * @brief Set every application auto start up state. + * @param info The auto startup info,include bundle name, module name, ability name. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t SetApplicationAutoStartup(const AutoStartupInfo &info); + + /** + * @brief Cancel every application auto start up . + * @param info The auto startup info,include bundle name, module name, ability name. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t CancelApplicationAutoStartup(const AutoStartupInfo &info); + + /** + * @brief Query auto startup state all application. + * @param infoList Output parameters, return auto startup info list. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t QueryAllAutoStartupApplications(std::vector &infoList); + + /** + * @brief Query auto startup state all application without permission. + * @param infoList Output parameters, return auto startup info list. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t QueryAllAutoStartupApplicationsWithoutPermission(std::vector &infoList); + + /** + * @brief Register auto start up callback. + * @param callback The point of JsAbilityAutoStartupCallBack. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t RegisterAutoStartupCallback(const sptr &callback); + + /** + * @brief Unregister auto start up callback. + * @param callback The point of JsAbilityAutoStartupCallBack. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t UnregisterAutoStartupCallback(const sptr &callback); + + /** + * @brief Set current application auto start up state. + * @param info The auto startup info,include bundle name, module name, ability name. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t SetAutoStartup(const AutoStartupInfo &info); + + /** + * @brief Cancel current application auto start up state. + * @param info The auto startup info, include bundle name, module name, ability name. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t CancelAutoStartup(const AutoStartupInfo &info); + + /** + * @brief Check current application auto start up state. + * @param info The auto startup info, include bundle name, module name, ability name. + * @param isAutoStartup Output parameters, return auto start up state. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t IsAutoStartup(const AutoStartupInfo &info, bool &isAutoStartup); + + /** + * @brief Delete current bundleName auto start up data. + * @param bundleName The current bundleName. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t DeleteAutoStartupData(const std::string &bundleName); + + /** + * @brief Check current bundleName auto start up data. + * @param bundleName The current bundleName. + * @param uid The uid. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t CheckAutoStartupData(const std::string &bundleName, int32_t uid); + + /** + * @class ClientDeathRecipient + * notices IRemoteBroker died. + */ + class ClientDeathRecipient : public IRemoteObject::DeathRecipient { + public: + /** + * @brief Constructor + */ + explicit ClientDeathRecipient(const std::weak_ptr &weakPtr); + virtual ~ClientDeathRecipient() = default; + /** + * @brief handle remote object died event. + * @param remote remote object. + */ + void OnRemoteDied(const wptr &remote) override; + + private: + std::weak_ptr weakPtr_; + }; + +private: + int32_t InnerSetApplicationAutoStartup(const AutoStartupInfo &info); + int32_t InnerCancelApplicationAutoStartup(const AutoStartupInfo &info); + int32_t InnerSetAutoStartup(const AutoStartupInfo &info); + int32_t InnerCancelAutoStartup(const AutoStartupInfo &info); + void ExecuteCallbacks(bool isCallOn, const AutoStartupInfo &info); + void SetDeathRecipient( + const sptr &callback, const sptr &deathRecipient); + void CleanResource(const wptr &remote); + std::string GetSelfApplicationBundleName(); + bool CheckSelfApplication(const std::string &bundleName); + bool GetBundleInfo(const std::string &bundleName, AppExecFwk::BundleInfo &bundleInfo, int32_t uid = -1); + bool GetAbilityData(const AutoStartupInfo &info, bool &isVisible, std::string &abilityTypeName); + std::string GetAbilityTypeName(AppExecFwk::AbilityInfo abilityInfo); + std::string GetExtensionTypeName(AppExecFwk::ExtensionAbilityInfo extensionInfo); + std::shared_ptr GetBundleMgrClient(); + int32_t CheckPermissionForSystem(); + int32_t CheckPermissionForSelf(const std::string &bundleName); + + mutable std::mutex autoStartUpMutex_; + mutable std::mutex deathRecipientsMutex_; + std::vector> callbackVector_; + std::map> callbackMaps_; + std::map, sptr> deathRecipients_; + std::shared_ptr bundleMgrClient_; +}; +} // namespace AbilityRuntime +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_ABILITY_AUTO_STARTUP_SERVICE_H \ No newline at end of file diff --git a/services/abilitymgr/include/mission_list_manager.h b/services/abilitymgr/include/mission_list_manager.h index e97796029b..3d5c1ffa56 100644 --- a/services/abilitymgr/include/mission_list_manager.h +++ b/services/abilitymgr/include/mission_list_manager.h @@ -519,6 +519,8 @@ private: const std::shared_ptr &targetMission, InnerMissionInfo &info); bool GetContentAndTypeId(uint32_t msgId, std::string &msgContent, int &typeId) const; + void SendKeyEvent(const AbilityRequest &abilityRequest); + int userId_; mutable ffrt::mutex managerLock_; // launcher list is also in currentMissionLists_ diff --git a/services/abilitymgr/src/ability_auto_startup_service.cpp b/services/abilitymgr/src/ability_auto_startup_service.cpp new file mode 100644 index 0000000000..0686fe9dee --- /dev/null +++ b/services/abilitymgr/src/ability_auto_startup_service.cpp @@ -0,0 +1,714 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ability_auto_startup_service.h" + +#include +#include + +#include "ability_auto_startup_data_manager.h" +#include "ability_manager_errors.h" +#include "auto_startup_info.h" +#include "auto_startup_interface.h" +#include "hilog_wrapper.h" +#include "in_process_call_wrapper.h" +#include "ipc_skeleton.h" +#include "parameters.h" +#include "permission_constants.h" +#include "permission_verification.h" + +namespace OHOS { +namespace AbilityRuntime { +using namespace OHOS::AAFwk; +namespace { +constexpr char PRODUCT_APPBOOT_SETTING_ENABLED[] = "const.product.appboot.setting.enabled"; +} // namespace + +AbilityAutoStartupService::AbilityAutoStartupService() {} + +AbilityAutoStartupService::~AbilityAutoStartupService() {} + +int32_t AbilityAutoStartupService::RegisterAutoStartupSystemCallback(const sptr &callback) +{ + HILOG_DEBUG("Called."); + int32_t code = CheckPermissionForSystem(); + if (code != ERR_OK) { + return code; + } + + { + std::lock_guard lock(autoStartUpMutex_); + bool isFound = false; + auto item = callbackVector_.begin(); + while (item != callbackVector_.end()) { + if (*item == callback) { + isFound = true; + break; + } + item++; + } + if (!isFound) { + callbackVector_.emplace_back(callback); + SetDeathRecipient( + callback, new (std::nothrow) AbilityAutoStartupService::ClientDeathRecipient(weak_from_this())); + } else { + HILOG_DEBUG("Callback is already exist."); + } + } + return ERR_OK; +} + +int32_t AbilityAutoStartupService::UnregisterAutoStartupSystemCallback(const sptr &callback) +{ + HILOG_DEBUG("Called."); + int32_t code = CheckPermissionForSystem(); + if (code != ERR_OK) { + return code; + } + + { + std::lock_guard lock(autoStartUpMutex_); + bool isFound = false; + auto item = callbackVector_.begin(); + while (item != callbackVector_.end()) { + if (*item == callback) { + item = callbackVector_.erase(item); + isFound = true; + } else { + item++; + } + } + if (!isFound) { + HILOG_DEBUG("Callback is not exist."); + } + } + return ERR_OK; +} + +int32_t AbilityAutoStartupService::SetApplicationAutoStartup(const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called, bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", + info.bundleName.c_str(), info.moduleName.c_str(), info.abilityName.c_str()); + int32_t code = CheckPermissionForSystem(); + if (code != ERR_OK) { + return code; + } + + bool isVisible; + std::string abilityTypeName; + if (!GetAbilityData(info, isVisible, abilityTypeName)) { + HILOG_ERROR("Failed to get ability data."); + return INNER_ERR; + } + + if (!isVisible) { + HILOG_ERROR("Current ability is not visible."); + return ABILITY_VISIBLE_FALSE_DENY_REQUEST; + } + + AutoStartupInfo fullInfo(info); + fullInfo.abilityTypeName = abilityTypeName; + + return InnerSetApplicationAutoStartup(fullInfo); +} + +int32_t AbilityAutoStartupService::InnerSetApplicationAutoStartup(const AutoStartupInfo &info) +{ + AutoStartupStatus status = + DelayedSingleton::GetInstance()->QueryAutoStartupData(info); + if (status.code != ERR_OK && status.code != ERR_NAME_NOT_FOUND) { + HILOG_ERROR("Query auto startup data failed."); + return status.code; + } + + int32_t result; + if (status.code == ERR_NAME_NOT_FOUND) { + HILOG_INFO("Query data is not exist."); + result = + DelayedSingleton::GetInstance()->InsertAutoStartupData(info, true, false); + if (result == ERR_OK) { + ExecuteCallbacks(true, info); + } + return result; + } + if (status.isEdmForce) { + HILOG_ERROR("Edm application abnormal."); + return ERR_EDM_APP_CONTROLLED; + } + if (!status.isAutoStartup) { + result = + DelayedSingleton::GetInstance()->UpdateAutoStartupData(info, true, false); + if (result == ERR_OK) { + ExecuteCallbacks(true, info); + } + return result; + } + return ERR_ALREADY_EXISTS; +} + +int32_t AbilityAutoStartupService::CancelApplicationAutoStartup(const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called, bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", + info.bundleName.c_str(), info.moduleName.c_str(), info.abilityName.c_str()); + int32_t code = CheckPermissionForSystem(); + if (code != ERR_OK) { + return code; + } + + bool isVisible; + std::string abilityTypeName; + if (!GetAbilityData(info, isVisible, abilityTypeName)) { + HILOG_ERROR("Failed to get ability data."); + return INNER_ERR; + } + + if (!isVisible) { + HILOG_ERROR("Current ability is not visible."); + return ABILITY_VISIBLE_FALSE_DENY_REQUEST; + } + + AutoStartupInfo fullInfo(info); + fullInfo.abilityTypeName = abilityTypeName; + + return InnerCancelApplicationAutoStartup(fullInfo); +} + +int32_t AbilityAutoStartupService::InnerCancelApplicationAutoStartup(const AutoStartupInfo &info) +{ + AutoStartupStatus status = + DelayedSingleton::GetInstance()->QueryAutoStartupData(info); + if (status.code != ERR_OK) { + HILOG_ERROR("Query auto startup data failed."); + return status.code; + } + + if (status.isEdmForce) { + HILOG_ERROR("Edm application abnormal."); + return ERR_EDM_APP_CONTROLLED; + } + + if (status.isAutoStartup) { + int32_t result = DelayedSingleton::GetInstance()->DeleteAutoStartupData(info); + if (result == ERR_OK) { + ExecuteCallbacks(false, info); + } + return result; + } + return ERR_OK; +} + +int32_t AbilityAutoStartupService::QueryAllAutoStartupApplications(std::vector &infoList) +{ + HILOG_DEBUG("Called."); + int32_t code = CheckPermissionForSystem(); + if (code != ERR_OK) { + return code; + } + + return DelayedSingleton::GetInstance()->QueryAllAutoStartupApplications(infoList); +} + +int32_t AbilityAutoStartupService::QueryAllAutoStartupApplicationsWithoutPermission( + std::vector &infoList) +{ + HILOG_DEBUG("Called."); + if (!system::GetBoolParameter(PRODUCT_APPBOOT_SETTING_ENABLED, false)) { + HILOG_ERROR("Product configuration item is disable."); + return ERR_NOT_SUPPORTED_PRODUCT_TYPE; + } + + return DelayedSingleton::GetInstance()->QueryAllAutoStartupApplications(infoList); +} + +int32_t AbilityAutoStartupService::RegisterAutoStartupCallback(const sptr &callback) +{ + HILOG_DEBUG("Called."); + if (!system::GetBoolParameter(PRODUCT_APPBOOT_SETTING_ENABLED, false)) { + HILOG_ERROR("Product configuration item is disable."); + return ERR_NOT_SUPPORTED_PRODUCT_TYPE; + } + + std::string bundleName = GetSelfApplicationBundleName(); + if (bundleName.empty()) { + HILOG_ERROR("Get self application bundleName failed."); + return ERR_INVALID_OPERATION; + } + { + std::lock_guard lock(autoStartUpMutex_); + auto item = callbackMaps_.find(bundleName); + if (item != callbackMaps_.end()) { + HILOG_DEBUG("Callback is already exist."); + return ERR_OK; + } + callbackMaps_.emplace(bundleName, callback); + SetDeathRecipient( + callback, new (std::nothrow) AbilityAutoStartupService::ClientDeathRecipient(weak_from_this())); + } + + return ERR_OK; +} + +int32_t AbilityAutoStartupService::UnregisterAutoStartupCallback(const sptr &callback) +{ + HILOG_DEBUG("Called."); + if (!system::GetBoolParameter(PRODUCT_APPBOOT_SETTING_ENABLED, false)) { + HILOG_ERROR("Product configuration item is disable."); + return ERR_NOT_SUPPORTED_PRODUCT_TYPE; + } + + std::string bundleName = GetSelfApplicationBundleName(); + if (bundleName.empty()) { + HILOG_ERROR("Get self application bundleName failed."); + return ERR_INVALID_OPERATION; + } + { + std::lock_guard lock(autoStartUpMutex_); + auto item = callbackMaps_.find(bundleName); + if (item == callbackMaps_.end()) { + HILOG_DEBUG("BundleName is not exist."); + return ERR_NAME_NOT_FOUND; + } + if (item->second != callback) { + HILOG_DEBUG("Callback is not exist."); + return ERR_NAME_NOT_FOUND; + } + callbackMaps_.erase(item); + } + + return ERR_OK; +} + +int32_t AbilityAutoStartupService::SetAutoStartup(const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called, bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", + info.bundleName.c_str(), info.moduleName.c_str(), info.abilityName.c_str()); + int32_t code = CheckPermissionForSelf(info.bundleName); + if (code != ERR_OK) { + return code; + } + + bool isVisible; + std::string abilityTypeName; + if (!GetAbilityData(info, isVisible, abilityTypeName)) { + HILOG_ERROR("Failed to get ability data."); + return INNER_ERR; + } + + if (!isVisible) { + HILOG_ERROR("Current ability is not visible."); + return ABILITY_VISIBLE_FALSE_DENY_REQUEST; + } + + AutoStartupInfo fullInfo(info); + fullInfo.abilityTypeName = abilityTypeName; + + return InnerSetAutoStartup(fullInfo); +} + +int32_t AbilityAutoStartupService::InnerSetAutoStartup(const AutoStartupInfo &info) +{ + AutoStartupStatus status = + DelayedSingleton::GetInstance()->QueryAutoStartupData(info); + if (status.code != ERR_OK && status.code != ERR_NAME_NOT_FOUND) { + HILOG_ERROR("Query auto startup data failed."); + return status.code; + } + + int32_t result; + if (status.code == ERR_NAME_NOT_FOUND) { + HILOG_INFO("Query data is not exist."); + result = + DelayedSingleton::GetInstance()->InsertAutoStartupData(info, true, false); + if (result == ERR_OK) { + ExecuteCallbacks(true, info); + } + return result; + } + + if (status.isEdmForce) { + HILOG_ERROR("Edm application abnormal."); + return ERR_EDM_APP_CONTROLLED; + } + + if (!status.isAutoStartup) { + result = + DelayedSingleton::GetInstance()->UpdateAutoStartupData(info, true, false); + if (result == ERR_OK) { + ExecuteCallbacks(true, info); + } + return result; + } + return ERR_ALREADY_EXISTS; +} + +int32_t AbilityAutoStartupService::CancelAutoStartup(const AutoStartupInfo &info) +{ + HILOG_DEBUG("Called, bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", + info.bundleName.c_str(), info.moduleName.c_str(), info.abilityName.c_str()); + int32_t code = CheckPermissionForSelf(info.bundleName); + if (code != ERR_OK) { + return code; + } + + bool isVisible; + std::string abilityTypeName; + if (!GetAbilityData(info, isVisible, abilityTypeName)) { + HILOG_ERROR("Failed to get ability data."); + return INNER_ERR; + } + + if (!isVisible) { + HILOG_ERROR("Current ability is not visible."); + return ABILITY_VISIBLE_FALSE_DENY_REQUEST; + } + + AutoStartupInfo fullInfo(info); + fullInfo.abilityTypeName = abilityTypeName; + + return InnerCancelAutoStartup(fullInfo); +} + +int32_t AbilityAutoStartupService::InnerCancelAutoStartup(const AutoStartupInfo &info) +{ + AutoStartupStatus status = + DelayedSingleton::GetInstance()->QueryAutoStartupData(info); + if (status.code != ERR_OK) { + HILOG_ERROR("Query auto startup data failed."); + return status.code; + } + + if (status.isEdmForce) { + HILOG_ERROR("Edm application abnormal."); + return ERR_EDM_APP_CONTROLLED; + } + + if (status.isAutoStartup) { + int32_t result = DelayedSingleton::GetInstance()->DeleteAutoStartupData(info); + if (result == ERR_OK) { + ExecuteCallbacks(false, info); + } + return result; + } + + return ERR_OK; +} + +int32_t AbilityAutoStartupService::IsAutoStartup(const AutoStartupInfo &info, bool &isAutoStartup) +{ + HILOG_DEBUG("Called, bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", + info.bundleName.c_str(), info.moduleName.c_str(), info.abilityName.c_str()); + int32_t code = CheckPermissionForSelf(info.bundleName); + if (code != ERR_OK) { + return code; + } + + AutoStartupStatus status = + DelayedSingleton::GetInstance()->QueryAutoStartupData(info); + if (status.code != ERR_OK) { + HILOG_DEBUG("Query auto startup data failed."); + isAutoStartup = false; + } else { + isAutoStartup = status.isAutoStartup; + } + return ERR_OK; +} + +int32_t AbilityAutoStartupService::DeleteAutoStartupData(const std::string &bundleName) +{ + HILOG_DEBUG("Called."); + return DelayedSingleton::GetInstance()->DeleteAutoStartupData(bundleName); +} + +int32_t AbilityAutoStartupService::CheckAutoStartupData(const std::string &bundleName, int32_t uid) +{ + std::vector infoList; + int32_t result = DelayedSingleton::GetInstance()->GetCurrentAppAutoStartupData( + bundleName, infoList); + if (result != ERR_OK) { + HILOG_ERROR("Failed to get auto startup data."); + return result; + } + if (infoList.size() == 0) { + return ERR_OK; + } + + AppExecFwk::BundleInfo bundleInfo; + if (!GetBundleInfo(bundleName, bundleInfo, uid)) { + return INNER_ERR; + } + + bool isFound = false; + for (auto info : infoList) { + for (auto abilityInfo : bundleInfo.abilityInfos) { + if ((abilityInfo.bundleName == info.bundleName) && (abilityInfo.name == info.abilityName) && + (info.moduleName.empty() || (abilityInfo.moduleName == info.moduleName))) { + isFound = true; + break; + } + } + } + + if (!isFound) { + HILOG_DEBUG("Current bundleName not found in Datebase."); + return DelayedSingleton::GetInstance()->DeleteAutoStartupData(bundleName); + } + return ERR_OK; +} + +void AbilityAutoStartupService::ExecuteCallbacks(bool isCallOn, const AutoStartupInfo &info) +{ + HILOG_DEBUG("bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", info.bundleName.c_str(), + info.moduleName.c_str(), info.abilityName.c_str()); + for (auto item : callbackVector_) { + auto remoteSystemCallback = iface_cast(item); + if (remoteSystemCallback != nullptr) { + if (isCallOn) { + remoteSystemCallback->OnAutoStartupOn(info); + } else { + remoteSystemCallback->OnAutoStartupOff(info); + } + } + } + + auto it = callbackMaps_.find(info.bundleName); + if (it != callbackMaps_.end()) { + auto remoteCallback = iface_cast(it->second); + if (remoteCallback != nullptr) { + if (isCallOn) { + remoteCallback->OnAutoStartupOn(info); + } else { + remoteCallback->OnAutoStartupOff(info); + } + } + } +} + +void AbilityAutoStartupService::SetDeathRecipient( + const sptr &callback, const sptr &deathRecipient) +{ + HILOG_DEBUG("Called."); + if (callback == nullptr || deathRecipient == nullptr) { + HILOG_ERROR("The callerToken or the deathRecipient is empty."); + return; + } + std::lock_guard lock(deathRecipientsMutex_); + auto iter = deathRecipients_.find(callback); + if (iter == deathRecipients_.end()) { + deathRecipients_.emplace(callback, deathRecipient); + callback->AddDeathRecipient(deathRecipient); + return; + } + HILOG_DEBUG("The deathRecipient has been added."); +} + +void AbilityAutoStartupService::CleanResource(const wptr &remote) +{ + HILOG_DEBUG("Called."); + auto object = remote.promote(); + if (object == nullptr) { + HILOG_ERROR("Remote object is nullptr."); + return; + } + + // Clean the callbackVector_ and callbackMaps_. + { + std::lock_guard lock(autoStartUpMutex_); + for (auto item = callbackVector_.begin(); item != callbackVector_.end();) { + if (*item == object) { + item = callbackVector_.erase(item); + } else { + item++; + } + } + + for (auto it = callbackMaps_.begin(); it != callbackMaps_.end();) { + auto &callback = it->second; + if (callback == object) { + it = callbackMaps_.erase(it); + } else { + it++; + } + } + } + { + std::lock_guard deathLock(deathRecipientsMutex_); + auto iter = deathRecipients_.find(object); + if (iter != deathRecipients_.end()) { + auto deathRecipient = iter->second; + deathRecipients_.erase(iter); + object->RemoveDeathRecipient(deathRecipient); + } + } +} + +AbilityAutoStartupService::ClientDeathRecipient::ClientDeathRecipient( + const std::weak_ptr &weakPtr) +{ + weakPtr_ = weakPtr; +} + +void AbilityAutoStartupService::ClientDeathRecipient::OnRemoteDied(const wptr &remote) +{ + HILOG_DEBUG("Called."); + auto abilityAutoStartupService = weakPtr_.lock(); + if (abilityAutoStartupService == nullptr) { + HILOG_ERROR("abilityAutoStartupService is nullptr."); + return; + } + abilityAutoStartupService->CleanResource(remote); +} + +std::string AbilityAutoStartupService::GetSelfApplicationBundleName() +{ + auto bundleMgrClient = GetBundleMgrClient(); + if (bundleMgrClient == nullptr) { + HILOG_ERROR("Failed to get BundleMgrClient."); + return ""; + } + + std::string bundleName; + int32_t callerUid = IPCSkeleton::GetCallingUid(); + if (IN_PROCESS_CALL(bundleMgrClient->GetNameForUid(callerUid, bundleName)) != ERR_OK) { + HILOG_ERROR("Get Bundle Name failed."); + return ""; + } + HILOG_DEBUG("Get bundle name: %{public}s.", bundleName.c_str()); + return bundleName; +} + +bool AbilityAutoStartupService::CheckSelfApplication(const std::string &bundleName) +{ + HILOG_DEBUG("Called, bundleName: %{public}s.", bundleName.c_str()); + return GetSelfApplicationBundleName() == bundleName ? true : false; +} + +bool AbilityAutoStartupService::GetBundleInfo( + const std::string &bundleName, AppExecFwk::BundleInfo &bundleInfo, int32_t uid) +{ + HILOG_DEBUG("Called."); + auto bundleMgrClient = GetBundleMgrClient(); + if (bundleMgrClient == nullptr) { + HILOG_ERROR("Failed to get BundleMgrClient."); + return false; + } + + int32_t userId; + if (uid == -1) { + userId = IPCSkeleton::GetCallingUid() / AppExecFwk::Constants::BASE_USER_RANGE; + } else { + userId = uid / AppExecFwk::Constants::BASE_USER_RANGE; + } + HILOG_DEBUG("Current userId: %{public}d.", userId); + auto flags = + AppExecFwk::BundleFlag::GET_BUNDLE_WITH_ABILITIES | AppExecFwk::BundleFlag::GET_BUNDLE_WITH_EXTENSION_INFO; + if (!IN_PROCESS_CALL(bundleMgrClient->GetBundleInfo( + bundleName, static_cast(flags), bundleInfo, userId))) { + HILOG_ERROR("Failed to get bundle info."); + return false; + } + + return true; +} + +bool AbilityAutoStartupService::GetAbilityData( + const AutoStartupInfo &info, bool &isVisible, std::string &abilityTypeName) +{ + HILOG_DEBUG("Called, bundleName: %{public}s, moduleName: %{public}s, abilityName: %{public}s.", + info.bundleName.c_str(), info.moduleName.c_str(), info.abilityName.c_str()); + AppExecFwk::BundleInfo bundleInfo; + if (!GetBundleInfo(info.bundleName, bundleInfo)) { + return false; + } + + for (auto abilityInfo : bundleInfo.abilityInfos) { + if ((abilityInfo.bundleName == info.bundleName) && (abilityInfo.name == info.abilityName)) { + if (info.moduleName.empty() || (abilityInfo.moduleName == info.moduleName)) { + isVisible = abilityInfo.visible; + abilityTypeName = GetAbilityTypeName(abilityInfo); + HILOG_DEBUG("Get ability info success."); + return true; + } + } + } + + for (auto extensionInfo : bundleInfo.extensionInfos) { + if ((extensionInfo.bundleName == info.bundleName) && (extensionInfo.name == info.abilityName)) { + if (info.moduleName.empty() || (extensionInfo.moduleName == info.moduleName)) { + isVisible = extensionInfo.visible; + abilityTypeName = GetExtensionTypeName(extensionInfo); + HILOG_DEBUG("Get extension info success."); + return true; + } + } + } + return false; +} + +std::string AbilityAutoStartupService::GetAbilityTypeName(AppExecFwk::AbilityInfo abilityInfo) +{ + std::string abilityTypeName; + if (abilityInfo.type == AppExecFwk::AbilityType::PAGE) { + abilityTypeName = "UIAbility"; + } + return abilityTypeName; +} + +std::string AbilityAutoStartupService::GetExtensionTypeName(AppExecFwk::ExtensionAbilityInfo extensionInfo) +{ + std::string abilityTypeName; + if (extensionInfo.type == AppExecFwk::ExtensionAbilityType::SERVICE) { + abilityTypeName = "ServiceExtension"; + } + return abilityTypeName; +} + +std::shared_ptr AbilityAutoStartupService::GetBundleMgrClient() +{ + HILOG_DEBUG("Called."); + if (bundleMgrClient_ == nullptr) { + bundleMgrClient_ = DelayedSingleton::GetInstance(); + } + return bundleMgrClient_; +} + +int32_t AbilityAutoStartupService::CheckPermissionForSystem() +{ + if (!system::GetBoolParameter(PRODUCT_APPBOOT_SETTING_ENABLED, false)) { + HILOG_ERROR("Product configuration item is disable."); + return ERR_NOT_SUPPORTED_PRODUCT_TYPE; + } + + if (!PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) { + HILOG_ERROR("The caller is not system-app, can not use system-api."); + return ERR_NOT_SYSTEM_APP; + } + return ERR_OK; +} + +int32_t AbilityAutoStartupService::CheckPermissionForSelf(const std::string &bundleName) +{ + if (!system::GetBoolParameter(PRODUCT_APPBOOT_SETTING_ENABLED, false)) { + HILOG_ERROR("Product configuration item is disable."); + return ERR_NOT_SUPPORTED_PRODUCT_TYPE; + } + + if (!CheckSelfApplication(bundleName)) { + HILOG_ERROR("Not self application."); + return ERR_NOT_SELF_APPLICATION; + } + return ERR_OK; +} +} // namespace AbilityRuntime +} // namespace OHOS diff --git a/services/abilitymgr/src/ability_connect_manager.cpp b/services/abilitymgr/src/ability_connect_manager.cpp index b2f7072b2a..5e22f1be08 100644 --- a/services/abilitymgr/src/ability_connect_manager.cpp +++ b/services/abilitymgr/src/ability_connect_manager.cpp @@ -108,6 +108,7 @@ int AbilityConnectManager::StartAbilityLocked(const AbilityRequest &abilityReque } if (!isLoadedAbility) { + HILOG_INFO("Target service has not been loaded."); LoadAbility(targetService); } else if (targetService->IsAbilityState(AbilityState::ACTIVE)) { // It may have been started through connect diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index aa5cd006ce..01a9e5c9c4 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -831,7 +831,7 @@ int AbilityManagerService::StartAbilityInner(const Want &want, const sptrStartAbility(abilityRequest); } diff --git a/services/abilitymgr/src/app_scheduler.cpp b/services/abilitymgr/src/app_scheduler.cpp index ba24d4f476..77072552bf 100644 --- a/services/abilitymgr/src/app_scheduler.cpp +++ b/services/abilitymgr/src/app_scheduler.cpp @@ -83,7 +83,7 @@ int AppScheduler::LoadAbility(const sptr &token, const sptrReadFromParcel(parcel)) { + delete info; + info = nullptr; + } + return info; +} + +bool AutoStartupInfo::Marshalling(Parcel &parcel) const +{ + if (!parcel.WriteString16(Str8ToStr16(bundleName))) { + return false; + } + if (!parcel.WriteString16(Str8ToStr16(abilityName))) { + return false; + } + if (!parcel.WriteString16(Str8ToStr16(moduleName))) { + return false; + } + if (!parcel.WriteString16(Str8ToStr16(abilityTypeName))) { + return false; + } + return true; +} +} // namespace AbilityRuntime +} // namespace OHOS diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp index 48efcc74cb..c13e96ffe9 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -172,6 +172,9 @@ int MissionListManager::StartAbility(AbilityRequest &abilityRequest) abilityRequest.callerAccessTokenId = IPCSkeleton::GetCallingTokenID(); int ret = StartAbility(currentTopAbility, callerAbility, abilityRequest); + if (ret == 0 && !abilityRequest.abilityInfo.visible) { + SendKeyEvent(abilityRequest); + } NotifyStartAbilityResult(abilityRequest, ret); return ret; } @@ -326,7 +329,9 @@ void MissionListManager::StartWaitingAbility() HILOG_INFO("name:%{public}s", abilityRequest.abilityInfo.name.c_str()); waitingAbilityQueue_.pop(); auto callerAbility = GetAbilityRecordByTokenInner(abilityRequest.callerToken); - StartAbility(topAbility, callerAbility, abilityRequest); + if (StartAbility(topAbility, callerAbility, abilityRequest) == 0 && !abilityRequest.abilityInfo.visible) { + SendKeyEvent(abilityRequest); + } return; } } @@ -3402,7 +3407,9 @@ void MissionListManager::OnStartSpecifiedAbilityTimeoutResponse(const AAFwk::Wan auto currentTopAbility = GetCurrentTopAbilityLocked(); auto callerAbility = GetAbilityRecordByTokenInner(abilityRequest.callerToken); - StartAbility(currentTopAbility, callerAbility, abilityRequest); + if (StartAbility(currentTopAbility, callerAbility, abilityRequest) == 0 && !abilityRequest.abilityInfo.visible) { + SendKeyEvent(abilityRequest); + } } std::shared_ptr MissionListManager::GetMissionBySpecifiedFlag( @@ -4128,5 +4135,15 @@ int32_t MissionListManager::TerminateMission(int32_t missionId) std::lock_guard guard(managerLock_); return TerminateAbilityInner(abilityRecord, DEFAULT_INVAL_VALUE, nullptr, true); } + +void MissionListManager::SendKeyEvent(const AbilityRequest &abilityRequest) +{ + auto abilityInfo = abilityRequest.abilityInfo; + EventInfo eventInfo; + eventInfo.abilityName = abilityInfo.name; + eventInfo.bundleName = abilityInfo.bundleName; + eventInfo.moduleName = abilityInfo.moduleName; + EventReport::SendKeyEvent(EventName::START_PRIVATE_ABILITY, HiSysEventType::BEHAVIOR, eventInfo); +} } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp index 846f85914a..4fffaf8fe9 100644 --- a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp +++ b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp @@ -136,6 +136,14 @@ int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sp uiAbilityRecord->SetSpecifiedFlag(specifiedInfo.flag); specifiedAbilityMap_.emplace(specifiedInfo, uiAbilityRecord); } + auto abilityInfo = abilityRequest.abilityInfo; + if (abilityInfo.visible == false) { + EventInfo eventInfo; + eventInfo.abilityName = abilityInfo.name; + eventInfo.bundleName = abilityInfo.bundleName; + eventInfo.moduleName = abilityInfo.moduleName; + EventReport::SendKeyEvent(EventName::START_PRIVATE_ABILITY, HiSysEventType::BEHAVIOR, eventInfo); + } return ERR_OK; } diff --git a/services/appmgr/BUILD.gn b/services/appmgr/BUILD.gn index e449cb04f9..682c79af0f 100644 --- a/services/appmgr/BUILD.gn +++ b/services/appmgr/BUILD.gn @@ -52,6 +52,7 @@ ohos_shared_library("libappms") { "src/quick_fix_callback_with_record.cpp", "src/remote_client_manager.cpp", "src/window_focus_changed_listener.cpp", + "src/window_visibility_changed_listener.cpp", ] defines = [ "AMS_LOG_TAG = \"AppMgrService\"" ] diff --git a/services/appmgr/include/app_mgr_service_inner.h b/services/appmgr/include/app_mgr_service_inner.h index dc8153e7ab..8be565f364 100644 --- a/services/appmgr/include/app_mgr_service_inner.h +++ b/services/appmgr/include/app_mgr_service_inner.h @@ -40,7 +40,9 @@ #include "appexecfwk_errors.h" #include "bundle_info.h" #include "cpp/mutex.h" +#include "event_report.h" #include "fault_data.h" +#include "hisysevent.h" #include "iapp_state_callback.h" #include "iapplication_state_observer.h" #include "iconfiguration_observer.h" @@ -55,6 +57,7 @@ #include "task_handler_wrap.h" #include "want.h" #include "window_focus_changed_listener.h" +#include "window_visibility_changed_listener.h" namespace OHOS { namespace AppExecFwk { @@ -647,6 +650,12 @@ public: void HandleFocused(const sptr &focusChangeInfo); void HandleUnfocused(const sptr &focusChangeInfo); + /** + * Handle window visibility changed. + */ + void HandleWindowVisibilityChanged( + const std::vector> &windowVisibilityInfos); + /** * Set the current userId, only used by abilityMgr. * @@ -721,6 +730,16 @@ public: void FreeFocusListener(); /** + * Init window visibility changed listener. + */ + void InitWindowVisibilityChangedListener(); + + /** + * Free window visibility changed listener. + */ + void FreeWindowVisibilityChangedListener(); + + /* * @brief Notify NativeEngine GC of status change. * * @param state GC state @@ -1045,6 +1064,9 @@ private: int32_t NotifyAbilitysDebugChange(const std::string &bundleName, const bool &isAppDebug); bool JudgeSelfCalledByToken(const sptr &token, const PageStateData &pageStateData); + + void SendReStartProcessEvent(const AAFwk::EventInfo &eventInfo, + const std::shared_ptr &appRecord); private: /** * Notify application status. @@ -1077,6 +1099,7 @@ private: ffrt::mutex configurationObserverLock_; std::vector> configurationObservers_; sptr focusListener_; + sptr windowVisibilityChangedListener_; std::vector> restartResedentTaskList_; std::map> runningSharedBundleList_; std::unordered_set renderUidSet_; @@ -1086,6 +1109,8 @@ private: int32_t lastRenderUid_ = Constants::START_UID_FOR_RENDER_PROCESS; sptr abilityDebugResponse_; std::shared_ptr appDebugManager_; + ffrt::mutex killpedProcessMapLock_; + mutable std::map killedPorcessMap_; }; } // namespace AppExecFwk } // namespace OHOS diff --git a/services/appmgr/include/app_running_manager.h b/services/appmgr/include/app_running_manager.h index f143f9877c..c8a26095cf 100644 --- a/services/appmgr/include/app_running_manager.h +++ b/services/appmgr/include/app_running_manager.h @@ -209,6 +209,7 @@ public: bool IsApplicationBackground(const std::string &bundleName); bool IsApplicationFirstFocused(const AppRunningRecord &foregroundingRecord); bool IsApplicationUnfocused(const std::string &bundleName); + void OnWindowVisibilityChanged(const std::vector> &windowVisibilityInfos); /** * @brief Set attach app debug mode. diff --git a/services/appmgr/include/app_running_record.h b/services/appmgr/include/app_running_record.h index ff6732cc4e..764d40b771 100644 --- a/services/appmgr/include/app_running_record.h +++ b/services/appmgr/include/app_running_record.h @@ -42,6 +42,7 @@ #include "module_running_record.h" #include "app_spawn_msg_wrapper.h" #include "app_malloc_info.h" +#include "window_visibility_changed_listener.h" namespace OHOS { namespace AppExecFwk { @@ -627,6 +628,10 @@ public: int32_t NotifyAppFault(const FaultData &faultData); + void OnWindowVisibilityChanged(const std::vector> &windowVisibilityInfos); + + bool IsAbilitytiesBackground(); + inline void SetAbilityForegroundingFlag() { isAbilityForegrounding_.store(true); @@ -788,6 +793,8 @@ private: int32_t callerTokenId_ = -1; ProcessType processType_ = ProcessType::NORMAL; ExtensionAbilityType extensionType_ = ExtensionAbilityType::UNSPECIFIED; + + std::set windowIds_; }; } // namespace AppExecFwk } // namespace OHOS diff --git a/services/appmgr/include/module_running_record.h b/services/appmgr/include/module_running_record.h index d2079fb990..14e6e883b2 100644 --- a/services/appmgr/include/module_running_record.h +++ b/services/appmgr/include/module_running_record.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -157,6 +157,8 @@ public: const std::shared_ptr GetAppInfo(); bool RemoveTerminateAbilityTimeoutTask(const sptr& token) const; + + bool IsAbilitiesBackgrounded(); private: void SendEvent(uint32_t msg, int64_t timeOut, const std::shared_ptr &abilityRecord); diff --git a/services/appmgr/include/window_visibility_changed_listener.h b/services/appmgr/include/window_visibility_changed_listener.h new file mode 100644 index 0000000000..09be1f3297 --- /dev/null +++ b/services/appmgr/include/window_visibility_changed_listener.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_APP_MANAGER_WINDOW_VISIBILITY_CHANGE_LISTENER_H +#define OHOS_APP_MANAGER_WINDOW_VISIBILITY_CHANGE_LISTENER_H + +#include "task_handler_wrap.h" +#include "window_manager.h" + +namespace OHOS { +namespace AppExecFwk { +class AppMgrServiceInner; +class WindowVisibilityChangedListener : public OHOS::Rosen::IVisibilityChangedListener { +public: + WindowVisibilityChangedListener( + const std::weak_ptr &appInner, const std::shared_ptr &handler); + virtual ~WindowVisibilityChangedListener() {} + + void OnWindowVisibilityChanged( + const std::vector> &windowVisibilityInfos) override; + +private: + std::weak_ptr appServiceInner_; + std::shared_ptr taskHandler_; +}; +} // namespace AppExecFwk +} // namespace OHOS +#endif // OHOS_APP_MANAGER_WINDOW_VISIBILITY_CHANGE_LISTENER_H diff --git a/services/appmgr/src/ams_mgr_scheduler.cpp b/services/appmgr/src/ams_mgr_scheduler.cpp index eb8e198bd6..49aa8225fb 100644 --- a/services/appmgr/src/ams_mgr_scheduler.cpp +++ b/services/appmgr/src/ams_mgr_scheduler.cpp @@ -71,6 +71,7 @@ void AmsMgrScheduler::LoadAbility(const sptr &token, const sptrbundleName.c_str(), abilityInfo->name.c_str()); std::function loadAbilityFunc = std::bind(&AppMgrServiceInner::LoadAbility, amsMgrServiceInner_, token, preToken, abilityInfo, appInfo, want); @@ -174,13 +175,13 @@ void AmsMgrScheduler::KillProcessesByUserId(int32_t userId) HILOG_ERROR("The caller is not system-app, can not use system-api"); return; } - + auto permission = AAFwk::PermissionConstants::PERMISSION_CLEAN_BACKGROUND_PROCESSES; if (amsMgrServiceInner_->VerifyAccountPermission(permission, userId) == ERR_PERMISSION_DENIED) { HILOG_ERROR("%{public}s: Permission verification failed", __func__); return; } - + std::function killProcessesByUserIdFunc = std::bind(&AppMgrServiceInner::KillProcessesByUserId, amsMgrServiceInner_, userId); amsHandler_->SubmitTask(killProcessesByUserIdFunc, TASK_KILL_PROCESSES_BY_USERID); diff --git a/services/appmgr/src/app_lifecycle_deal.cpp b/services/appmgr/src/app_lifecycle_deal.cpp index 24d5be7ab8..e6cda77cc4 100644 --- a/services/appmgr/src/app_lifecycle_deal.cpp +++ b/services/appmgr/src/app_lifecycle_deal.cpp @@ -63,16 +63,22 @@ void AppLifeCycleDeal::AddAbilityStage(const HapModuleInfo &abilityStage) void AppLifeCycleDeal::LaunchAbility(const std::shared_ptr &ability) { if (appThread_ && ability) { - auto &abilityInfo = ability->GetAbilityInfo(); - if (abilityInfo != nullptr && abilityInfo->type == AbilityType::PAGE) { + auto abilityInfo = ability->GetAbilityInfo(); + if (abilityInfo == nullptr) { + HILOG_WARN("LoadLifecycle: abilityInfo null."); + return; + } + if (abilityInfo->type == AbilityType::PAGE) { FreezeUtil::LifecycleFlow flow = {ability->GetToken(), FreezeUtil::TimeoutState::LOAD}; auto entry = std::to_string(AbilityRuntime::TimeUtil::SystemTimeMillisecond()) + "; AppLifeCycleDeal::LaunchAbility; the LoadAbility lifecycle."; FreezeUtil::GetInstance().AddLifecycleEvent(flow, entry); } HILOG_INFO("LoadLifecycle: Launch ability."); - appThread_->ScheduleLaunchAbility(*(ability->GetAbilityInfo()), ability->GetToken(), + appThread_->ScheduleLaunchAbility(*abilityInfo, ability->GetToken(), ability->GetWant()); + } else { + HILOG_WARN("LoadLifecycle."); } } diff --git a/services/appmgr/src/app_mgr_service.cpp b/services/appmgr/src/app_mgr_service.cpp index 808d25fbce..5f892122fb 100644 --- a/services/appmgr/src/app_mgr_service.cpp +++ b/services/appmgr/src/app_mgr_service.cpp @@ -807,6 +807,7 @@ void AppMgrService::OnAddSystemAbility(int32_t systemAbilityId, const std::strin } appMgrServiceInner_->InitFocusListener(); + appMgrServiceInner_->InitWindowVisibilityChangedListener(); } void AppMgrService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) @@ -822,6 +823,7 @@ void AppMgrService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::st } appMgrServiceInner_->FreeFocusListener(); + appMgrServiceInner_->FreeWindowVisibilityChangedListener(); } int32_t AppMgrService::ChangeAppGcState(pid_t pid, int32_t state) diff --git a/services/appmgr/src/app_mgr_service_inner.cpp b/services/appmgr/src/app_mgr_service_inner.cpp index 66e91e7c13..4dc3cc4009 100644 --- a/services/appmgr/src/app_mgr_service_inner.cpp +++ b/services/appmgr/src/app_mgr_service_inner.cpp @@ -37,10 +37,8 @@ #include "common_event_support.h" #include "datetime_ex.h" #include "distributed_data_mgr.h" -#include "event_report.h" #include "freeze_util.h" #include "hilog_wrapper.h" -#include "hisysevent.h" #include "hitrace_meter.h" #include "in_process_call_wrapper.h" #include "ipc_skeleton.h" @@ -88,6 +86,7 @@ constexpr int KILL_PROCESS_TIMEOUT_MICRO_SECONDS = 1000; constexpr int KILL_PROCESS_DELAYTIME_MICRO_SECONDS = 200; // delay register focus listener to wms constexpr int REGISTER_FOCUS_DELAY = 5000; +constexpr int REGISTER_VISIBILITY_DELAY = 5000; const std::string CLASS_NAME = "ohos.app.MainThread"; const std::string FUNC_NAME = "main"; const std::string RENDER_PARAM = "invalidparam"; @@ -210,6 +209,7 @@ void AppMgrServiceInner::LoadAbility(const sptr &token, const spt auto appRecord = appRunningManager_->CheckAppRunningRecordIsExist(appInfo->name, processName, appInfo->uid, bundleInfo); if (!appRecord) { + HILOG_INFO("appRecord null"); bool appExistFlag = appRunningManager_->CheckAppRunningRecordIsExistByBundleName(bundleInfo.name); appRecord = CreateAppRunningRecord(token, preToken, appInfo, abilityInfo, processName, bundleInfo, hapModuleInfo, want); @@ -219,7 +219,7 @@ void AppMgrServiceInner::LoadAbility(const sptr &token, const spt } if (hapModuleInfo.isStageBasedModel && !IsMainProcess(appInfo, hapModuleInfo)) { appRecord->SetKeepAliveAppState(false, false); - HILOG_DEBUG("The process %{public}s will not keepalive", hapModuleInfo.process.c_str()); + HILOG_INFO("The process %{public}s will not keepalive", hapModuleInfo.process.c_str()); } SendAppStartupTypeEvent(appRecord, abilityInfo, AppStartType::COLD); auto callRecord = GetAppRunningRecordByAbilityToken(preToken); @@ -277,6 +277,7 @@ void AppMgrServiceInner::MakeProcessName(const std::shared_ptr &abi return; } if (!abilityInfo->process.empty()) { + HILOG_INFO("Process not null"); processName = abilityInfo->process; return; } @@ -290,13 +291,14 @@ void AppMgrServiceInner::MakeProcessName( const std::shared_ptr &appInfo, const HapModuleInfo &hapModuleInfo, std::string &processName) const { if (!appInfo) { + HILOG_ERROR("appInfo nill"); return; } // check after abilityInfo, because abilityInfo contains extension process. if (hapModuleInfo.isStageBasedModel && !hapModuleInfo.process.empty() && hapModuleInfo.process != appInfo->bundleName) { processName = hapModuleInfo.process; - HILOG_DEBUG("Stage mode, Make processName:%{public}s", processName.c_str()); + HILOG_INFO("Stage mode, Make processName:%{public}s", processName.c_str()); return; } bool isRunInIsolationMode = CheckIsolationMode(hapModuleInfo); @@ -481,6 +483,13 @@ void AppMgrServiceInner::LaunchApplication(const std::shared_ptrGetBundleName(); + eventInfo.callerUid = callerRecord->GetUid(); + eventInfo.callerState = static_cast(callerRecord->GetState()); + auto applicationInfo = callerRecord->GetApplicationInfo(); + if (applicationInfo != nullptr) { + eventInfo.callerVersionName = applicationInfo->versionName; + eventInfo.callerVersionCode = applicationInfo->versionCode; + } } else { HILOG_ERROR("callerRecord is nullptr, can not get callerBundleName."); } @@ -1135,6 +1144,11 @@ int32_t AppMgrServiceInner::KillProcessByPid(const pid_t pid) const eventInfo.versionName = applicationInfo->versionName; eventInfo.versionCode = applicationInfo->versionCode; } + if (ret >= 0) { + int64_t killTime = std::chrono::duration_cast(std::chrono:: + system_clock::now().time_since_epoch()).count(); + killedPorcessMap_.emplace(killTime, appRecord->GetProcessName()); + } eventInfo.pid = appRecord->GetPriorityObject()->GetPid(); eventInfo.processName = appRecord->GetProcessName(); AAFwk::EventReport::SendAppEvent(AAFwk::EventName::APP_TERMINATE, HiSysEventType::BEHAVIOR, eventInfo); @@ -1851,6 +1865,7 @@ void AppMgrServiceInner::StartProcess(const std::string &appName, const std::str const std::string &bundleName, const int32_t bundleIndex, bool appExistFlag) { HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__); + HILOG_INFO("StartProcess: %{public}s", bundleName.c_str()); if (!appRecord) { HILOG_ERROR("appRecord is null"); return; @@ -1891,7 +1906,7 @@ void AppMgrServiceInner::StartProcess(const std::string &appName, const std::str HspList hspList; ErrCode ret = bundleMgr_->GetBaseSharedBundleInfos(bundleName, hspList); if (ret != ERR_OK) { - HILOG_ERROR("GetBaseSharedBundleInfos failed: %d", ret); + HILOG_ERROR("GetBaseSharedBundleInfos failed: %{public}d", ret); appRunningManager_->RemoveAppRunningRecordById(appRecord->GetRecordId()); return; } @@ -1933,7 +1948,7 @@ void AppMgrServiceInner::StartProcess(const std::string &appName, const std::str SetOverlayInfo(bundleName, userId, startMsg); - HILOG_DEBUG("Start process, apl is %{public}s, bundleName is %{public}s, startFlags is %{public}d.", + HILOG_INFO("Start process, apl is %{public}s, bundleName is %{public}s, startFlags is %{public}d.", startMsg.apl.c_str(), bundleName.c_str(), startFlags); bundleMgrResult = IN_PROCESS_CALL(bundleMgr_->GetBundleGidsByUid(bundleName, uid, startMsg.gids)); @@ -2084,6 +2099,7 @@ bool AppMgrServiceInner::SendProcessStartEvent(const std::shared_ptr::GetInstance()->OnProcessStateChanged(appRecord); } +void AppMgrServiceInner::InitWindowVisibilityChangedListener() +{ + HILOG_DEBUG("Begin."); + if (windowVisibilityChangedListener_ != nullptr) { + HILOG_WARN("Visibility listener has been initiated."); + return; + } + windowVisibilityChangedListener_ = + new (std::nothrow) WindowVisibilityChangedListener(weak_from_this(), taskHandler_); + auto registerTask = [innerService = weak_from_this()] () { + auto inner = innerService.lock(); + if (inner == nullptr) { + HILOG_ERROR("Service inner is nullptr."); + return; + } + if (inner->windowVisibilityChangedListener_ == nullptr) { + HILOG_ERROR("Window visibility changed listener is nullptr."); + return; + } + WindowManager::GetInstance().RegisterVisibilityChangedListener(inner->windowVisibilityChangedListener_); + }; + + if (taskHandler_ == nullptr) { + HILOG_ERROR("Task handler is nullptr."); + return; + } + taskHandler_->SubmitTask(registerTask, "RegisterVisibilityListener.", REGISTER_VISIBILITY_DELAY); + HILOG_DEBUG("End."); +} + +void AppMgrServiceInner::FreeWindowVisibilityChangedListener() +{ + HILOG_DEBUG("Called."); + if (windowVisibilityChangedListener_ == nullptr) { + HILOG_WARN("Visibility listener has been freed."); + return; + } + WindowManager::GetInstance().UnregisterVisibilityChangedListener(windowVisibilityChangedListener_); +} + +void AppMgrServiceInner::HandleWindowVisibilityChanged( + const std::vector> &windowVisibilityInfos) +{ + HILOG_DEBUG("Called."); + if (windowVisibilityInfos.empty()) { + HILOG_WARN("Window visibility info is empty."); + return; + } + if (appRunningManager_ == nullptr) { + HILOG_ERROR("App running manager is nullptr."); + return; + } + appRunningManager_->OnWindowVisibilityChanged(windowVisibilityInfos); +} + void AppMgrServiceInner::PointerDeviceEventCallback(const char *key, const char *value, void *context) { HILOG_INFO("%{public}s called.", __func__); @@ -4506,5 +4577,39 @@ bool AppMgrServiceInner::JudgeSelfCalledByToken(const sptr &token } return true; } + +void AppMgrServiceInner::SendReStartProcessEvent(const AAFwk::EventInfo &eventInfo, + const std::shared_ptr &appRecord) +{ + HILOG_DEBUG("Called."); + if (!appRecord) { + HILOG_ERROR("appRecord is nullptr"); + return; + } + std::lock_guard lock(killpedProcessMapLock_); + int64_t restartTime = std::chrono::duration_cast(std::chrono:: + system_clock::now().time_since_epoch()).count(); + for (auto iter = killedPorcessMap_.begin(); iter != killedPorcessMap_.end();) { + int64_t killTime = iter->first; + if (restartTime - killTime > 2000) { + killedPorcessMap_.erase(iter++); + continue; + } + AAFwk::EventInfo currentEventInfo; + currentEventInfo = eventInfo; + currentEventInfo.time = restartTime; + std::string processName = appRecord->GetProcessName(); + currentEventInfo.appUid = appRecord->GetUid(); + if (currentEventInfo.bundleName == currentEventInfo.callerBundleName && + processName != currentEventInfo.callerProcessName) { + currentEventInfo.processName = processName; + AAFwk::EventReport::SendKeyEvent(AAFwk::EventName::RESTART_PROCESS_BY_SAME_APP, + HiSysEventType::BEHAVIOR, eventInfo); + killedPorcessMap_.erase(iter++); + continue; + } + iter++; + } +} } // namespace AppExecFwk } // namespace OHOS diff --git a/services/appmgr/src/app_running_manager.cpp b/services/appmgr/src/app_running_manager.cpp index ddbbf5ec71..8fc0d1b35e 100644 --- a/services/appmgr/src/app_running_manager.cpp +++ b/services/appmgr/src/app_running_manager.cpp @@ -854,6 +854,24 @@ bool AppRunningManager::IsApplicationBackground(const std::string &bundleName) return true; } +void AppRunningManager::OnWindowVisibilityChanged( + const std::vector> &windowVisibilityInfos) +{ + HILOG_DEBUG("Called."); + for (const auto &info : windowVisibilityInfos) { + if (info == nullptr) { + HILOG_ERROR("Window visibility info is nullptr."); + continue; + } + auto appRecord = GetAppRunningRecordByPidInner(info->pid_); + if (appRecord == nullptr) { + HILOG_ERROR("App running record is nullptr."); + return; + } + appRecord->OnWindowVisibilityChanged(windowVisibilityInfos); + } +} + bool AppRunningManager::IsApplicationFirstFocused(const AppRunningRecord &focusedRecord) { HILOG_DEBUG("check focus function called."); diff --git a/services/appmgr/src/app_running_record.cpp b/services/appmgr/src/app_running_record.cpp index a0e4399909..88a9347575 100644 --- a/services/appmgr/src/app_running_record.cpp +++ b/services/appmgr/src/app_running_record.cpp @@ -886,7 +886,7 @@ void AppRunningRecord::AbilityBackground(const std::shared_ptrNotifyAppFault(faultData); } +bool AppRunningRecord::IsAbilitytiesBackground() +{ + std::lock_guard hapModulesLock(hapModulesLock_); + for (const auto &iter : hapModules_) { + for (const auto &moduleRecord : iter.second) { + if (moduleRecord == nullptr) { + HILOG_ERROR("Module record is nullptr."); + continue; + } + if (!moduleRecord->IsAbilitiesBackgrounded()) { + return false; + } + } + } + return true; +} + +void AppRunningRecord::OnWindowVisibilityChanged( + const std::vector> &windowVisibilityInfos) +{ + HILOG_DEBUG("Called."); + if (windowVisibilityInfos.empty()) { + HILOG_WARN("Window visibility info is empty."); + return; + } + + for (const auto &info : windowVisibilityInfos) { + if (info == nullptr) { + HILOG_ERROR("Window visibility info is nullptr."); + continue; + } + if (info->pid_ != GetPriorityObject()->GetPid()) { + continue; + } + auto iter = windowIds_.find(info->windowId_); + if (iter != windowIds_.end() && !info->isVisible_) { + windowIds_.erase(iter); + continue; + } + if (iter == windowIds_.end() && info->isVisible_) { + windowIds_.emplace(info->windowId_); + } + } + + if (!windowIds_.empty() && curState_ != ApplicationState::APP_STATE_FOREGROUND) { + SetUpdateStateFromService(true); + ScheduleForegroundRunning(); + return; + } + + if (windowIds_.empty() && IsAbilitytiesBackground() && curState_ == ApplicationState::APP_STATE_FOREGROUND) { + SetUpdateStateFromService(true); + ScheduleBackgroundRunning(); + } +} + bool AppRunningRecord::IsContinuousTask() { return isContinuousTask_; diff --git a/services/appmgr/src/module_running_record.cpp b/services/appmgr/src/module_running_record.cpp index 9a487577fe..79b889bab3 100644 --- a/services/appmgr/src/module_running_record.cpp +++ b/services/appmgr/src/module_running_record.cpp @@ -300,6 +300,31 @@ bool ModuleRunningRecord::RemoveTerminateAbilityTimeoutTask(const sptr lock(abilitiesMutex_); + for (const auto &iter : abilities_) { + const auto &ability = iter.second; + if (ability == nullptr) { + HILOG_ERROR("Ability is nullptr."); + continue; + } + const auto &abilityInfo = ability->GetAbilityInfo(); + if (abilityInfo != nullptr && abilityInfo->type != AbilityType::PAGE) { + continue; + } + + const auto &state = ability->GetState(); + if (state != AbilityState::ABILITY_STATE_BACKGROUND && + state != AbilityState::ABILITY_STATE_TERMINATED && + state != AbilityState::ABILITY_STATE_END) { + return false; + } + } + return true; +} + void ModuleRunningRecord::SetAppMgrServiceInner(const std::weak_ptr &inner) { appMgrServiceInner_ = inner; diff --git a/services/appmgr/src/window_visibility_changed_listener.cpp b/services/appmgr/src/window_visibility_changed_listener.cpp new file mode 100644 index 0000000000..89ade7a70a --- /dev/null +++ b/services/appmgr/src/window_visibility_changed_listener.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "window_visibility_changed_listener.h" + +#include "app_mgr_service_inner.h" +#include "hilog_wrapper.h" + +namespace OHOS { +namespace AppExecFwk { +using namespace OHOS::Rosen; +WindowVisibilityChangedListener::WindowVisibilityChangedListener( + const std::weak_ptr &appInner, const std::shared_ptr &handler) + : appServiceInner_(appInner), taskHandler_(handler) +{} + +void WindowVisibilityChangedListener::OnWindowVisibilityChanged( + const std::vector> &windowVisibilityInfos) +{ + HILOG_DEBUG("Called."); + if (windowVisibilityInfos.empty()) { + HILOG_WARN("Window visibility info is empty."); + return; + } + + if (taskHandler_ == nullptr) { + HILOG_ERROR("Task handler is nullptr."); + return; + } + + auto task = [inner = appServiceInner_, windowVisibilityInfos] { + auto serviceInner = inner.lock(); + if (serviceInner == nullptr) { + HILOG_ERROR("Failed to get app mgr service inner."); + return; + } + serviceInner->HandleWindowVisibilityChanged(windowVisibilityInfos); + }; + taskHandler_->SubmitTask(task); +} +} // namespace AppExecFwk +} // namespace OHOS diff --git a/services/common/include/event_report.h b/services/common/include/event_report.h index fab3e76dd6..1281a374f6 100644 --- a/services/common/include/event_report.h +++ b/services/common/include/event_report.h @@ -44,6 +44,11 @@ struct EventInfo { int32_t exitResult = -1; int32_t bundleType = -1; int32_t startType = 0; + int32_t appUid = -1; + int32_t callerState = -1; + uint32_t callerVersionCode = -1; + std::string callerVersionName; + std::string uri; }; enum class EventName { @@ -82,6 +87,12 @@ enum class EventName { PROCESS_EXIT, DRAWN_COMPLETED, APP_STARTUP_TYPE, + + // key behavior event + GRANT_URI_PERMISSION, + FA_SHOW_ON_LOCK, + START_PRIVATE_ABILITY, + RESTART_PROCESS_BY_SAME_APP, }; class EventReport { @@ -89,6 +100,7 @@ public: static void SendAppEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo); static void SendAbilityEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo); static void SendExtensionEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo); + static void SendKeyEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo); private: static std::string ConvertEventName(const EventName &eventName); diff --git a/services/common/src/event_report.cpp b/services/common/src/event_report.cpp index 12fdbe92a1..9bc02475a4 100644 --- a/services/common/src/event_report.cpp +++ b/services/common/src/event_report.cpp @@ -44,6 +44,12 @@ constexpr const char *EVENT_KEY_EXIT_RESULT = "EXIT_RESULT"; constexpr const char *EVENT_KEY_EXIT_PID = "EXIT_PID"; constexpr const char *EVENT_KEY_BUNDLE_TYPE = "BUNDLE_TYPE"; constexpr const char *EVENT_KEY_START_TYPE = "START_TYPE"; +constexpr const char *EVENT_KEY_CALLER_STATE = "CALLER_STATE"; +constexpr const char *EVENT_KEY_CALLER_VERSION_NAME = "CALLER_VERSION_NAME"; +constexpr const char *EVENT_KEY_CALLER_VERSION_CODE = "CALLER_VERSION_CODE"; +constexpr const char *EVENT_KEY_URI = "URI"; +constexpr const char *EVENT_KEY_RESTART_TIME = "RESTART_TIME"; +constexpr const char *EVENT_KEY_APP_UID = "APP_UID"; const std::map eventNameToStrMap_ = { std::map::value_type(EventName::START_ABILITY_ERROR, "START_ABILITY_ERROR"), std::map::value_type(EventName::TERMINATE_ABILITY_ERROR, "TERMINATE_ABILITY_ERROR"), @@ -71,6 +77,11 @@ const std::map eventNameToStrMap_ = { std::map::value_type(EventName::PROCESS_EXIT, "PROCESS_EXIT"), std::map::value_type(EventName::DRAWN_COMPLETED, "DRAWN_COMPLETED"), std::map::value_type(EventName::APP_STARTUP_TYPE, "APP_STARTUP_TYPE"), + std::map::value_type(EventName::GRANT_URI_PERMISSION, "GRANT_URI_PERMISSION"), + std::map::value_type(EventName::FA_SHOW_ON_LOCK, "FA_SHOW_ON_LOCK"), + std::map::value_type(EventName::START_PRIVATE_ABILITY, "START_PRIVATE_ABILITY"), + std::map::value_type(EventName::RESTART_PROCESS_BY_SAME_APP, + "RESTART_PROCESS_BY_SAME_APP"), }; } @@ -176,7 +187,11 @@ void EventReport::SendAppEvent(const EventName &eventName, HiSysEventType type, EVENT_KEY_VERSION_NAME, eventInfo.versionName, EVENT_KEY_VERSION_CODE, eventInfo.versionCode, EVENT_KEY_PROCESS_NAME, eventInfo.processName, - EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName); + EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName, + EVENT_KEY_CALLER_VERSION_NAME, eventInfo.callerVersionName, + EVENT_KEY_CALLER_VERSION_CODE, eventInfo.callerVersionCode, + EVENT_KEY_CALLER_UID, eventInfo.callerUid, + EVENT_KEY_CALLER_STATE, eventInfo.callerState); break; default: HiSysEventWrite( @@ -324,6 +339,50 @@ void EventReport::SendExtensionEvent(const EventName &eventName, HiSysEventType } } +void EventReport::SendKeyEvent(const EventName &eventName, HiSysEventType type, const EventInfo &eventInfo) +{ + std::string name = ConvertEventName(eventName); + if (name == "INVALIDEVENTNAME") { + HILOG_ERROR("invalid eventName"); + return; + } + HILOG_INFO("name is %{public}s", name.c_str()); + switch (eventName) { + case EventName::GRANT_URI_PERMISSION: + HiSysEventWrite( + HiSysEvent::Domain::AAFWK, + name, + type, + EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName, + EVENT_KEY_CALLER_BUNDLE_NAME, eventInfo.callerBundleName, + EVENT_KEY_URI, eventInfo.uri); + break; + case EventName::FA_SHOW_ON_LOCK: + case EventName::START_PRIVATE_ABILITY: + HiSysEventWrite( + HiSysEvent::Domain::AAFWK, + name, + type, + EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName, + EVENT_KEY_MODULE_NAME, eventInfo.moduleName, + EVENT_KEY_ABILITY_NAME, eventInfo.abilityName); + break; + case EventName::RESTART_PROCESS_BY_SAME_APP: + HiSysEventWrite( + HiSysEvent::Domain::AAFWK, + name, + type, + EVENT_KEY_RESTART_TIME, eventInfo.time, + EVENT_KEY_APP_UID, eventInfo.appUid, + EVENT_KEY_CALLER_PROCESS_NAME, eventInfo.callerProcessName, + EVENT_KEY_PROCESS_NAME, eventInfo.processName, + EVENT_KEY_BUNDLE_NAME, eventInfo.bundleName); + break; + default: + break; + } +} + std::string EventReport::ConvertEventName(const EventName &eventName) { auto it = eventNameToStrMap_.find(eventName); diff --git a/services/quickfixmgr/quick_fix.cfg b/services/quickfixmgr/quick_fix.cfg index 462594ce9b..0a87385556 100644 --- a/services/quickfixmgr/quick_fix.cfg +++ b/services/quickfixmgr/quick_fix.cfg @@ -5,7 +5,9 @@ "ondemand" : true, "uid" : "quickfixserver", "gid" : ["system"], - "secon" : "u:r:quick_fix:s0" + "secon" : "u:r:quick_fix:s0", + "apl" : "system_basic", + "permission" : ["ohos.permission.RUNNING_STATE_OBSERVER"] } ] } diff --git a/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp b/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp index bb9d943e9c..68ec23cd70 100644 --- a/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp +++ b/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp @@ -19,6 +19,7 @@ #include "ability_manager_errors.h" #include "accesstoken_kit.h" +#include "event_report.h" #include "hilog_wrapper.h" #include "if_system_ability_manager.h" #include "in_process_call_wrapper.h" @@ -147,6 +148,18 @@ int UriPermissionManagerStubImpl::GrantUriPermission(const std::vector &uri targetTokenId, autoremove); if (tempRet == ERR_OK) { ret = ERR_OK; + auto isSaCall = PermissionVerification::GetInstance()->IsSACall(); + auto calleeTokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(targetTokenId); + if (isSaCall && calleeTokenType != Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE) { + EventInfo eventInfo; + Uri uri_inner = uriVec[0]; + eventInfo.bundleName = targetBundleName; + eventInfo.callerBundleName = uri_inner.GetAuthority(); + eventInfo.uri = uri_inner.ToString(); + EventReport::SendKeyEvent(EventName::GRANT_URI_PERMISSION, HiSysEventType::BEHAVIOR, eventInfo); + } else { + HILOG_INFO("caller is not SA or callee is SA"); + } } } return ret; diff --git a/test/mock/frameworks_kits_ability_native_test/include/mock_form_mgr_service.h b/test/mock/frameworks_kits_ability_native_test/include/mock_form_mgr_service.h index 021b00c6fd..8ad4dd5b64 100644 --- a/test/mock/frameworks_kits_ability_native_test/include/mock_form_mgr_service.h +++ b/test/mock/frameworks_kits_ability_native_test/include/mock_form_mgr_service.h @@ -197,13 +197,13 @@ public: return ERR_INVALID_VALUE; } } - ErrCode GetRunningFormInfos(std::vector &runningFormInfos) + ErrCode GetRunningFormInfos(bool isUnusedIncluded, std::vector &runningFormInfos) { return ERR_OK; } - ErrCode GetRunningFormInfosByBundleName(const std::string &bundleName, - std::vector &runningFormInfos) + ErrCode GetRunningFormInfosByBundleName( + const std::string &bundleName, bool isUnusedIncluded, std::vector &runningFormInfos) { return ERR_OK; } diff --git a/test/mock/services_abilitymgr_test/libs/appexecfwk_core/include/bundlemgr/mock_app_control_manager.h b/test/mock/services_abilitymgr_test/libs/appexecfwk_core/include/bundlemgr/mock_app_control_manager.h index f62539db01..1bc23c4357 100644 --- a/test/mock/services_abilitymgr_test/libs/appexecfwk_core/include/bundlemgr/mock_app_control_manager.h +++ b/test/mock/services_abilitymgr_test/libs/appexecfwk_core/include/bundlemgr/mock_app_control_manager.h @@ -23,6 +23,9 @@ namespace OHOS { namespace AppExecFwk { +namespace { +const int32_t UNSPECIFIED_USER_ID = -2; +} class AppControlProxy : public IRemoteProxy { public: using Want = OHOS::AAFwk::Want; @@ -59,9 +62,12 @@ public: virtual ErrCode GetAppJumpControlRule(const std::string &callerBundleName, const std::string &targetBundleName, int32_t userId, AppJumpControlRule &controlRule) override; - virtual ErrCode SetDisposedStatus(const std::string& appId, const Want& want) override; - virtual ErrCode DeleteDisposedStatus(const std::string& appId) override; - virtual ErrCode GetDisposedStatus(const std::string& appId, Want& want) override; + virtual ErrCode SetDisposedStatus( + const std::string& appId, const Want& want, int32_t userId = UNSPECIFIED_USER_ID) override; + virtual ErrCode DeleteDisposedStatus( + const std::string& appId, int32_t userId = UNSPECIFIED_USER_ID) override; + virtual ErrCode GetDisposedStatus( + const std::string& appId, Want& want, int32_t userId = UNSPECIFIED_USER_ID) override; }; } // namespace AppExecFwk } // namespace OHOS diff --git a/test/mock/services_abilitymgr_test/libs/appexecfwk_core/src/bundlemgr/mock_app_control_manager.cpp b/test/mock/services_abilitymgr_test/libs/appexecfwk_core/src/bundlemgr/mock_app_control_manager.cpp index f40e7798c5..92985f3b4e 100644 --- a/test/mock/services_abilitymgr_test/libs/appexecfwk_core/src/bundlemgr/mock_app_control_manager.cpp +++ b/test/mock/services_abilitymgr_test/libs/appexecfwk_core/src/bundlemgr/mock_app_control_manager.cpp @@ -122,17 +122,17 @@ ErrCode AppControlProxy::GetAppJumpControlRule(const std::string &callerBundleNa return ERR_OK; } -ErrCode AppControlProxy::SetDisposedStatus(const std::string& appId, const Want& want) +ErrCode AppControlProxy::SetDisposedStatus(const std::string& appId, const Want& want, int32_t userId) { return ERR_OK; } -ErrCode AppControlProxy::DeleteDisposedStatus(const std::string& appId) +ErrCode AppControlProxy::DeleteDisposedStatus(const std::string& appId, int32_t userId) { return ERR_OK; } -ErrCode AppControlProxy::GetDisposedStatus(const std::string& appId, Want& want) +ErrCode AppControlProxy::GetDisposedStatus(const std::string& appId, Want& want, int32_t userId) { return ERR_OK; } diff --git a/test/moduletest/common/ams/ability_running_record_test/BUILD.gn b/test/moduletest/common/ams/ability_running_record_test/BUILD.gn index 2a91eb8636..39b1afc0a5 100644 --- a/test/moduletest/common/ams/ability_running_record_test/BUILD.gn +++ b/test/moduletest/common/ams/ability_running_record_test/BUILD.gn @@ -34,6 +34,8 @@ ohos_moduletest("AmsAbilityRunningRecordModuleTest") { "hilog:libhilog", "ipc:ipc_core", "safwk:system_ability_fwk", + "window_manager:libwm", + "window_manager:libwsutils", ] if (background_task_mgr_continuous_task_enable) { diff --git a/test/unittest/ams_app_workflow_test/BUILD.gn b/test/unittest/ams_app_workflow_test/BUILD.gn index 90baa90884..ee953c6fd9 100644 --- a/test/unittest/ams_app_workflow_test/BUILD.gn +++ b/test/unittest/ams_app_workflow_test/BUILD.gn @@ -41,6 +41,7 @@ ohos_unittest("AmsWorkFlowTest") { "${ability_runtime_services_path}/appmgr/src/module_running_record.cpp", "${ability_runtime_services_path}/appmgr/src/remote_client_manager.cpp", "${ability_runtime_services_path}/appmgr/src/window_focus_changed_listener.cpp", + "${ability_runtime_services_path}/appmgr/src/window_visibility_changed_listener.cpp", ] sources += [ "ams_workflow_test.cpp" ] diff --git a/test/unittest/ams_recent_app_list_test/BUILD.gn b/test/unittest/ams_recent_app_list_test/BUILD.gn index 28199dd1ab..c25432839f 100644 --- a/test/unittest/ams_recent_app_list_test/BUILD.gn +++ b/test/unittest/ams_recent_app_list_test/BUILD.gn @@ -39,6 +39,7 @@ ohos_unittest("AmsRecentAppListTest") { "${ability_runtime_services_path}/appmgr/src/module_running_record.cpp", "${ability_runtime_services_path}/appmgr/src/remote_client_manager.cpp", "${ability_runtime_services_path}/appmgr/src/window_focus_changed_listener.cpp", + "${ability_runtime_services_path}/appmgr/src/window_visibility_changed_listener.cpp", "${ability_runtime_test_path}/mock/services_appmgr_test/src/mock_bundle_manager.cpp", "${ability_runtime_test_path}/mock/services_appmgr_test/src/mock_overlay_manager.cpp", ] diff --git a/test/unittest/ams_service_load_ability_process_test/BUILD.gn b/test/unittest/ams_service_load_ability_process_test/BUILD.gn index 8231b6da8a..79ecae2125 100644 --- a/test/unittest/ams_service_load_ability_process_test/BUILD.gn +++ b/test/unittest/ams_service_load_ability_process_test/BUILD.gn @@ -38,6 +38,7 @@ ohos_unittest("AmsServiceLoadAbilityProcessTest") { "${ability_runtime_services_path}/appmgr/src/module_running_record.cpp", "${ability_runtime_services_path}/appmgr/src/remote_client_manager.cpp", "${ability_runtime_services_path}/appmgr/src/window_focus_changed_listener.cpp", + "${ability_runtime_services_path}/appmgr/src/window_visibility_changed_listener.cpp", "${ability_runtime_test_path}/mock/services_appmgr_test/src/mock_bundle_manager.cpp", "${ability_runtime_test_path}/mock/services_appmgr_test/src/mock_overlay_manager.cpp", ] diff --git a/test/unittest/app_mgr_service_event_handler_test/BUILD.gn b/test/unittest/app_mgr_service_event_handler_test/BUILD.gn index f92b8e3304..84e6b6ea47 100644 --- a/test/unittest/app_mgr_service_event_handler_test/BUILD.gn +++ b/test/unittest/app_mgr_service_event_handler_test/BUILD.gn @@ -38,6 +38,7 @@ ohos_unittest("AMSEventHandlerTest") { "${ability_runtime_services_path}/appmgr/src/module_running_record.cpp", "${ability_runtime_services_path}/appmgr/src/remote_client_manager.cpp", "${ability_runtime_services_path}/appmgr/src/window_focus_changed_listener.cpp", + "${ability_runtime_services_path}/appmgr/src/window_visibility_changed_listener.cpp", ] sources += [ "app_mgr_service_event_handler_test.cpp" ] diff --git a/test/unittest/app_running_manager_test/BUILD.gn b/test/unittest/app_running_manager_test/BUILD.gn index 3770305a1c..8097057b94 100644 --- a/test/unittest/app_running_manager_test/BUILD.gn +++ b/test/unittest/app_running_manager_test/BUILD.gn @@ -23,7 +23,8 @@ ohos_unittest("app_running_manager_test") { configs = [ "${ability_runtime_services_path}/appmgr:appmgr_config" ] - sources = [ "app_running_manager_test.cpp" ] + sources = [ "${ability_runtime_services_path}/appmgr/src/window_visibility_changed_listener.cpp" ] + sources += [ "app_running_manager_test.cpp" ] deps = [ "${ability_runtime_innerkits_path}/app_manager:app_manager", @@ -58,6 +59,7 @@ ohos_unittest("app_running_manager_test") { "memory_utils:libmeminfo", "safwk:system_ability_fwk", "samgr:samgr_proxy", + "window_manager:libwm", "window_manager:libwsutils", ] } diff --git a/test/unittest/frameworks_kits_appkit_native_test/form_extension_context_mock_test.h b/test/unittest/frameworks_kits_appkit_native_test/form_extension_context_mock_test.h index a334dfaec4..7a10036d25 100644 --- a/test/unittest/frameworks_kits_appkit_native_test/form_extension_context_mock_test.h +++ b/test/unittest/frameworks_kits_appkit_native_test/form_extension_context_mock_test.h @@ -214,12 +214,12 @@ public: { return 0; } - ErrCode GetRunningFormInfos(std::vector &runningFormInfos) override + ErrCode GetRunningFormInfos(bool isUnusedIncluded, std::vector &runningFormInfos) override { return ERR_OK; } - ErrCode GetRunningFormInfosByBundleName(const std::string &bundleName, - std::vector &runningFormInfos) override + ErrCode GetRunningFormInfosByBundleName( + const std::string &bundleName, bool isUnusedIncluded, std::vector &runningFormInfos) override { return ERR_OK; } diff --git a/test/unittest/pending_want_test/pending_want_test.cpp b/test/unittest/pending_want_test/pending_want_test.cpp index c29d06c6a1..1fa5506708 100644 --- a/test/unittest/pending_want_test/pending_want_test.cpp +++ b/test/unittest/pending_want_test/pending_want_test.cpp @@ -39,6 +39,7 @@ #include "wants_info.h" #include "want_params.h" #include "want_receiver_stub.h" +#include "want_agent_client.h" #include "want_agent_helper.h" #include "want_sender_info.h" #include "want_sender_stub.h" @@ -1243,7 +1244,8 @@ HWTEST_F(PendingWantTest, PendingWant_6700, Function | MediumTest | Level1) sptr target = nullptr; std::shared_ptr pendingWant = std::make_shared(); ErrCode err = pendingWant->Cancel(target); - EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT); + ErrCode err1 = WantAgentClient::GetInstance().CancelWantSender(target); + EXPECT_EQ(err, err1); HILOG_INFO("PendingWant_6700 end."); } diff --git a/test/unittest/quick_fix/quick_fix_manager_service_test/BUILD.gn b/test/unittest/quick_fix/quick_fix_manager_service_test/BUILD.gn index dafecff6cd..a7e52d9572 100644 --- a/test/unittest/quick_fix/quick_fix_manager_service_test/BUILD.gn +++ b/test/unittest/quick_fix/quick_fix_manager_service_test/BUILD.gn @@ -97,6 +97,9 @@ ohos_unittest("quick_fix_manager_apply_task_test") { "ability_runtime:abilitykit_native", "ability_runtime:app_manager", "ability_runtime:quickfix_manager", + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken", + "access_token:libtoken_setproc", "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", diff --git a/test/unittest/quick_fix/quick_fix_manager_service_test/quick_fix_manager_apply_task_test.cpp b/test/unittest/quick_fix/quick_fix_manager_service_test/quick_fix_manager_apply_task_test.cpp index c9a1103293..998051383f 100644 --- a/test/unittest/quick_fix/quick_fix_manager_service_test/quick_fix_manager_apply_task_test.cpp +++ b/test/unittest/quick_fix/quick_fix_manager_service_test/quick_fix_manager_apply_task_test.cpp @@ -20,12 +20,14 @@ #include "iservice_registry.h" #include "mock_bundle_manager.h" #include "mock_quick_fix_util.h" +#include "nativetoken_kit.h" #include "quick_fix_error_utils.h" #define private public #include "quick_fix_manager_service.h" #undef private #include "quick_fix_result_info.h" #include "system_ability_definition.h" +#include "token_setproc.h" using namespace testing; using namespace testing::ext; @@ -58,6 +60,27 @@ static void WaitUntilTaskDone(const std::shared_ptr& h auto f = [&taskCalled]() { taskCalled.store(true); }; WaitUntilTaskCalled(f, handler, taskCalled); } + +static void SetPermission() +{ + uint64_t tokenId; + const char **perms = new const char *[1]; + perms[0] = "ohos.permission.RUNNING_STATE_OBSERVER"; + NativeTokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 1, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .aplStr = "system_basic", + }; + + infoInstance.processName = "SetUpTestCase"; + tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + delete[] perms; +} } // namespace class QuickFixManagerApplyTaskTest : public testing::Test { @@ -453,6 +476,7 @@ HWTEST_F(QuickFixManagerApplyTaskTest, PostNotifyHotReloadPageTask_0200, TestSiz HWTEST_F(QuickFixManagerApplyTaskTest, RegAppStateObserver_0100, TestSize.Level1) { HILOG_INFO("%{public}s start.", __func__); + SetPermission(); auto applyTask = std::make_shared(bundleQfMgr_, appMgr_, quickFixMs_->eventHandler_, quickFixMs_); ASSERT_NE(applyTask, nullptr); @@ -469,6 +493,7 @@ HWTEST_F(QuickFixManagerApplyTaskTest, RegAppStateObserver_0100, TestSize.Level1 HWTEST_F(QuickFixManagerApplyTaskTest, RegAppStateObserver_0200, TestSize.Level1) { HILOG_INFO("%{public}s start.", __func__); + SetPermission(); auto applyTask = std::make_shared(bundleQfMgr_, nullptr, quickFixMs_->eventHandler_, quickFixMs_); ASSERT_NE(applyTask, nullptr); diff --git a/test/unittest/uri_permission_impl_test/BUILD.gn b/test/unittest/uri_permission_impl_test/BUILD.gn index 6170e1bd0f..2d16861a26 100755 --- a/test/unittest/uri_permission_impl_test/BUILD.gn +++ b/test/unittest/uri_permission_impl_test/BUILD.gn @@ -37,6 +37,7 @@ ohos_unittest("uri_permission_impl_test") { deps = [ "${ability_runtime_innerkits_path}/uri_permission:uri_permission_mgr", + "${ability_runtime_services_path}/common:event_report", "${ability_runtime_services_path}/uripermmgr:libupms_static", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", diff --git a/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp b/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp index 31d68fbb23..d65d65474d 100755 --- a/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp +++ b/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp @@ -15,6 +15,7 @@ #include +#include "event_report.h" #include "mock_native_token.h" #include "system_ability_definition.h" #include "system_ability_manager_client.h" diff --git a/test/unittest/uri_permission_persistable_test/BUILD.gn b/test/unittest/uri_permission_persistable_test/BUILD.gn index be6985cce0..dbdb2fe7c7 100755 --- a/test/unittest/uri_permission_persistable_test/BUILD.gn +++ b/test/unittest/uri_permission_persistable_test/BUILD.gn @@ -39,6 +39,7 @@ ohos_unittest("uri_permission_persistable_test") { deps = [ "${ability_runtime_innerkits_path}/uri_permission:uri_permission_mgr", + "${ability_runtime_services_path}/common:event_report", "${ability_runtime_services_path}/uripermmgr:libupms_static", "//third_party/googletest:gmock_main", "//third_party/googletest:gtest_main", diff --git a/test/unittest/uri_permission_persistable_test/uri_permission_persistable_test.cpp b/test/unittest/uri_permission_persistable_test/uri_permission_persistable_test.cpp index 7f89b2b067..371622e1c8 100755 --- a/test/unittest/uri_permission_persistable_test/uri_permission_persistable_test.cpp +++ b/test/unittest/uri_permission_persistable_test/uri_permission_persistable_test.cpp @@ -15,6 +15,7 @@ #include #include "ability_manager_errors.h" +#include "event_report.h" #include "mock_permission_verification.h" #include "mock_native_token.h" #include "system_ability_definition.h" diff --git a/test/unittest/uri_permission_test/BUILD.gn b/test/unittest/uri_permission_test/BUILD.gn index 8c94b51a5d..73f9dabe93 100755 --- a/test/unittest/uri_permission_test/BUILD.gn +++ b/test/unittest/uri_permission_test/BUILD.gn @@ -29,6 +29,7 @@ ohos_unittest("uri_permission_test") { deps = [ "${ability_runtime_innerkits_path}/uri_permission:uri_permission_mgr", + "${ability_runtime_services_path}/common:event_report", "${ability_runtime_services_path}/uripermmgr:libupms_static", ] diff --git a/test/unittest/uri_permission_test/uri_permission_test.cpp b/test/unittest/uri_permission_test/uri_permission_test.cpp index 62c0c6cb78..bbbbb46325 100755 --- a/test/unittest/uri_permission_test/uri_permission_test.cpp +++ b/test/unittest/uri_permission_test/uri_permission_test.cpp @@ -15,6 +15,7 @@ #include +#include "event_report.h" #include "istorage_manager.h" #include "storage_manager_proxy.h" #include "system_ability_definition.h"