diff --git a/frameworks/ets/ani/ani_common/BUILD.gn b/frameworks/ets/ani/ani_common/BUILD.gn index aa4d97e986e2cfa66713c082d598e48c76d61e83..b3633e030e9f17c4e300a412ff4c78925b957b44 100644 --- a/frameworks/ets/ani/ani_common/BUILD.gn +++ b/frameworks/ets/ani/ani_common/BUILD.gn @@ -52,6 +52,7 @@ ohos_shared_library("ani_common") { "src/ani_common_want.cpp", "src/ani_task.cpp", "src/context_transfer.cpp", + "src/ets_ability_lifecycle_callback.cpp", "src/ets_application_context_utils.cpp", "src/ets_application_state_change_callback.cpp", "src/ets_context_utils.cpp", diff --git a/interfaces/kits/native/appkit/ability_runtime/context/ets_ability_lifecycle_callback.h b/frameworks/ets/ani/ani_common/include/ets_ability_lifecycle_callback.h similarity index 39% rename from interfaces/kits/native/appkit/ability_runtime/context/ets_ability_lifecycle_callback.h rename to frameworks/ets/ani/ani_common/include/ets_ability_lifecycle_callback.h index 18e0346b4d299f89c332666e811171290dd55f7d..7e3635422cd76930826d9d67d4f9d0a8882e8b66 100644 --- a/interfaces/kits/native/appkit/ability_runtime/context/ets_ability_lifecycle_callback.h +++ b/frameworks/ets/ani/ani_common/include/ets_ability_lifecycle_callback.h @@ -32,19 +32,50 @@ namespace AppExecFwk { struct ETSNativeReference; } // namespace AppExecFwk namespace AbilityRuntime { +class EtsAbilityLifecycleCallbackArgs : public AbilityLifecycleCallbackArgs { +public: + explicit EtsAbilityLifecycleCallbackArgs(std::shared_ptr ref) : ref_(ref) + { + type_ = AbilityLifecycleCallbackType::ETS; + } + bool IsValid() const override { return ref_ != nullptr; } + std::shared_ptr ref_; +}; class EtsAbilityLifecycleCallback : public AbilityLifecycleCallback, - public std::enable_shared_from_this { + public std::enable_shared_from_this { public: explicit EtsAbilityLifecycleCallback(ani_env *env); - void OnAbilityCreate(std::shared_ptr ability) override; - void OnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage) override; - void OnWindowStageDestroy(std::shared_ptr ability, - std::shared_ptr windowStage) override; - void OnAbilityDestroy(std::shared_ptr ability) override; - void OnAbilityForeground(std::shared_ptr ability) override; - void OnAbilityBackground(std::shared_ptr ability) override; + void OnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityForeground(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityBackground(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability) override; + void OnNewWant(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability) override; + void OnWillNewWant(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageInactive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageActive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; int32_t Register(ani_object callback); bool Unregister(int32_t callbackId); @@ -57,6 +88,10 @@ private: void CallObjectMethod(const char *methodName, const char *signature, std::shared_ptr ability, std::shared_ptr windowStage); + void CallObjectProperty(const char *name, std::shared_ptr ability); + void CallObjectProperty(const char *name, std::shared_ptr ability, + std::shared_ptr windowStage); + void CallObjectPropertyCommon(ani_env *env, const char *name, ani_ref ability, ani_ref windowStage); private: static int32_t serialNumber_; diff --git a/frameworks/native/appkit/ability_runtime/context/ets_ability_lifecycle_callback.cpp b/frameworks/ets/ani/ani_common/src/ets_ability_lifecycle_callback.cpp similarity index 37% rename from frameworks/native/appkit/ability_runtime/context/ets_ability_lifecycle_callback.cpp rename to frameworks/ets/ani/ani_common/src/ets_ability_lifecycle_callback.cpp index 05fccbc18cedaec0d8fbf7fb23345e4598441cad..5a87e7e9716bc1c57101a1886d90505ec00fb985 100644 --- a/frameworks/native/appkit/ability_runtime/context/ets_ability_lifecycle_callback.cpp +++ b/frameworks/ets/ani/ani_common/src/ets_ability_lifecycle_callback.cpp @@ -15,6 +15,7 @@ #include "ets_ability_lifecycle_callback.h" +#include "ani_common_util.h" #include "hilog_tag_wrapper.h" #include "js_runtime_utils.h" #include "napi/native_api.h" @@ -28,14 +29,15 @@ namespace { constexpr const char *SIGNATURE_UIABILITY = "L@ohos/app/ability/UIAbility/UIAbility;:V"; constexpr const char *SIGNATURE_UIABILITY_WINDOW_STAGE = "L@ohos/app/ability/UIAbility/UIAbility;L@ohos/window/window/WindowStage;:V"; -constexpr const char *SIGNATURE_ABILITY_LIFECYCLE_CALLBACK = - "L@ohos/app/ability/AbilityLifecycleCallback/AbilityLifecycleCallbackInner;"; constexpr const int32_t ERROR_CODE_NULL_ENV = -1; constexpr const int32_t ERROR_CODE_NULL_CALLBACK = -2; constexpr const int32_t ERROR_CODE_NULL_REF = -3; +constexpr int32_t ARGC_ONE = 1; +constexpr int32_t ARGC_TWO = 2; } EtsAbilityLifecycleCallback::EtsAbilityLifecycleCallback(ani_env *env) { + type_ = AbilityLifecycleCallbackType::ETS; if (env == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null env"); return; @@ -72,29 +74,14 @@ void EtsAbilityLifecycleCallback::CallObjectMethod(const char *methodName, TAG_LOGE(AAFwkTag::APPKIT, "null aniEnv or ability"); return; } - ani_ref aniAbilityRef = ability->aniRef; ani_status status = ANI_ERROR; - ani_class cls = nullptr; - if ((status = aniEnv->FindClass(SIGNATURE_ABILITY_LIFECYCLE_CALLBACK, &cls)) != ANI_OK || cls == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "failed to find class, status=%{public}d", status); - return; - } - - ani_method method = nullptr; - if ((status = aniEnv->Class_FindMethod(cls, methodName, signature, &method)) != ANI_OK || method == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "failed to find method, status=%{public}d", status); - return; - } - - ani_value aniAbility {}; - aniAbility.r = aniAbilityRef; for (const auto &callback : callbacks_) { if (callback.second == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null callback"); return; } - if ((status = aniEnv->Object_CallMethod_Void( - reinterpret_cast(callback.second), method, aniAbility)) != ANI_OK) { + if ((status = aniEnv->Object_CallMethodByName_Void( + reinterpret_cast(callback.second), methodName, signature, ability->aniRef)) != ANI_OK) { TAG_LOGE(AAFwkTag::APPKIT, "failed to call method %{public}s, status=%{public}d", methodName, status); return; } @@ -110,35 +97,77 @@ void EtsAbilityLifecycleCallback::CallObjectMethod(const char *methodName, const TAG_LOGE(AAFwkTag::APPKIT, "null aniEnv or ability or windowStage"); return; } - ani_ref aniAbilityRef = ability->aniRef; - ani_ref aniWindowStageRef = windowStage->aniRef; ani_status status = ANI_ERROR; - ani_class cls = nullptr; - if ((status = aniEnv->FindClass(SIGNATURE_ABILITY_LIFECYCLE_CALLBACK, &cls)) != ANI_OK || cls == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "failed to find class, status=%{public}d", status); + for (const auto &callback : callbacks_) { + if (callback.second == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + return; + } + if ((status = aniEnv->Object_CallMethodByName_Void( + reinterpret_cast(callback.second), methodName, signature, ability->aniRef, + windowStage->aniRef)) != ANI_OK) { + TAG_LOGE(AAFwkTag::APPKIT, "failed to call method %{public}s, status=%{public}d", methodName, status); + return; + } + } +} + +void EtsAbilityLifecycleCallback::CallObjectProperty(const char *name, + std::shared_ptr ability) +{ + ani_env *aniEnv = GetAniEnv(); + if (aniEnv == nullptr || ability == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null aniEnv or ability"); return; } + CallObjectPropertyCommon(aniEnv, name, ability->aniRef, nullptr); +} - ani_method method = nullptr; - if ((status = aniEnv->Class_FindMethod(cls, methodName, signature, &method)) != ANI_OK || method == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "failed to find method, status=%{public}d", status); +void EtsAbilityLifecycleCallback::CallObjectProperty(const char *name, + std::shared_ptr ability, + std::shared_ptr windowStage) +{ + ani_env *aniEnv = GetAniEnv(); + if (aniEnv == nullptr || ability == nullptr || windowStage == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null aniEnv or ability or windowStage"); return; } + CallObjectPropertyCommon(aniEnv, name, ability->aniRef, windowStage->aniRef); +} - ani_value aniAbility {}; - aniAbility.r = aniAbilityRef; - ani_value aniWindowStage {}; - aniWindowStage.r = aniWindowStageRef; +void EtsAbilityLifecycleCallback::CallObjectPropertyCommon(ani_env *env, const char *name, + ani_ref ability, ani_ref windowStage) +{ + ani_status status = ANI_ERROR; for (const auto &callback : callbacks_) { if (callback.second == nullptr) { TAG_LOGE(AAFwkTag::APPKIT, "null callback"); return; } - if ((status = aniEnv->Object_CallMethod_Void(reinterpret_cast(callback.second), - method, aniAbility, aniWindowStage)) != ANI_OK) { - TAG_LOGE(AAFwkTag::APPKIT, "failed to call method %{public}s, status=%{public}d", methodName, status); + ani_ref funRef = nullptr; + if ((status = env->Object_GetPropertyByName_Ref(reinterpret_cast(callback.second), + name, &funRef)) != ANI_OK) { + TAG_LOGE(AAFwkTag::APPKIT, "failed to get property, status : %{public}d", status); return; } + if (!AppExecFwk::IsValidProperty(env, funRef)) { + continue; + } + + ani_ref result = nullptr; + if (windowStage != nullptr) { + std::vector argv = { ability, windowStage }; + if ((status = env->FunctionalObject_Call(reinterpret_cast(funRef), ARGC_TWO, argv.data(), + &result)) != ANI_OK) { + TAG_LOGE(AAFwkTag::APPKIT, "failed to call property, status: %{public}d", status); + } + } else { + std::vector argv = { ability }; + if ((status = env->FunctionalObject_Call(reinterpret_cast(funRef), ARGC_ONE, argv.data(), + &result)) != ANI_OK) { + TAG_LOGE(AAFwkTag::APPKIT, "failed to call property, status: %{public}d", status); + } + } } } @@ -176,36 +205,152 @@ bool EtsAbilityLifecycleCallback::Unregister(int32_t callbackId) return callbacks_.erase(callbackId); } -void EtsAbilityLifecycleCallback::OnAbilityCreate(std::shared_ptr ability) +void EtsAbilityLifecycleCallback::OnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) { - CallObjectMethod("onAbilityCreate", SIGNATURE_UIABILITY, ability); + CallObjectMethod("onAbilityCreate", SIGNATURE_UIABILITY, + static_cast(ability).ref_); } -void EtsAbilityLifecycleCallback::OnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage) +void EtsAbilityLifecycleCallback::OnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallObjectMethod("onWindowStageCreate", SIGNATURE_UIABILITY_WINDOW_STAGE, ability, windowStage); + CallObjectMethod("onWindowStageCreate", SIGNATURE_UIABILITY_WINDOW_STAGE, + static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void EtsAbilityLifecycleCallback::OnWindowStageDestroy(std::shared_ptr ability, - std::shared_ptr windowStage) +void EtsAbilityLifecycleCallback::OnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) +{ + CallObjectMethod("onWindowStageDestroy", SIGNATURE_UIABILITY_WINDOW_STAGE, + static_cast(ability).ref_, + static_cast(windowStage).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectMethod("onAbilityDestroy", SIGNATURE_UIABILITY, + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityForeground(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectMethod("onAbilityForeground", SIGNATURE_UIABILITY, + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityBackground(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectMethod("onAbilityBackground", SIGNATURE_UIABILITY, + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onAbilitySaveState", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) +{ + CallObjectProperty("onWindowStageRestore", + static_cast(ability).ref_, + static_cast(windowStage).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onAbilityWillDestroy", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) +{ + CallObjectProperty("onWindowStageWillDestroy", + static_cast(ability).ref_, + static_cast(windowStage).ref_); +} + +void EtsAbilityLifecycleCallback::OnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) +{ + CallObjectProperty("onWindowStageWillCreate", + static_cast(ability).ref_, + static_cast(windowStage).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onAbilityWillBackground", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) +{ + CallObjectProperty("onWindowStageWillRestore", + static_cast(ability).ref_, + static_cast(windowStage).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onAbilityWillCreate", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onAbilityWillForeground", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnNewWant(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onNewWant", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onAbilityWillContinue", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnWillNewWant(const AbilityLifecycleCallbackArgs &ability) +{ + CallObjectProperty("onWillNewWant", + static_cast(ability).ref_); +} + +void EtsAbilityLifecycleCallback::OnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability) { - CallObjectMethod("onWindowStageDestroy", SIGNATURE_UIABILITY_WINDOW_STAGE, ability, windowStage); + CallObjectProperty("onAbilityWillSaveState", + static_cast(ability).ref_); } -void EtsAbilityLifecycleCallback::OnAbilityDestroy(std::shared_ptr ability) +void EtsAbilityLifecycleCallback::OnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) { - CallObjectMethod("onAbilityDestroy", SIGNATURE_UIABILITY, ability); + CallObjectMethod("onAbilityContinue", SIGNATURE_UIABILITY, + static_cast(ability).ref_); } -void EtsAbilityLifecycleCallback::OnAbilityForeground(std::shared_ptr ability) +void EtsAbilityLifecycleCallback::OnWindowStageInactive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallObjectMethod("onAbilityForeground", SIGNATURE_UIABILITY, ability); + CallObjectMethod("onWindowStageInactive", SIGNATURE_UIABILITY_WINDOW_STAGE, + static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void EtsAbilityLifecycleCallback::OnAbilityBackground(std::shared_ptr ability) +void EtsAbilityLifecycleCallback::OnWindowStageActive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallObjectMethod("onAbilityBackground", SIGNATURE_UIABILITY, ability); + CallObjectMethod("onWindowStageActive", SIGNATURE_UIABILITY_WINDOW_STAGE, + static_cast(ability).ref_, + static_cast(windowStage).ref_); } } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/ets/ani/ui_ability/include/ets_ui_ability.h b/frameworks/ets/ani/ui_ability/include/ets_ui_ability.h index 4dedffbc9ce495457d3aeb68d3fd7d777bd6397a..3565c73adad732c257f9d6de35900169ba1978d1 100644 --- a/frameworks/ets/ani/ui_ability/include/ets_ui_ability.h +++ b/frameworks/ets/ani/ui_ability/include/ets_ui_ability.h @@ -139,6 +139,8 @@ public: sptr CallRequest() override; + void OnAfterFocusedCommon(bool isFocused) override; + static void CreateAndBindContext(const std::shared_ptr &abilityContext, const std::unique_ptr& runtime); diff --git a/frameworks/ets/ani/ui_ability/src/ets_ui_ability.cpp b/frameworks/ets/ani/ui_ability/src/ets_ui_ability.cpp index a2bc538fd4220f97b532f4cfe9c2f934d43cc15a..fd007e4f06e2237e2793da45d1a7977e844853b9 100644 --- a/frameworks/ets/ani/ui_ability/src/ets_ui_ability.cpp +++ b/frameworks/ets/ani/ui_ability/src/ets_ui_ability.cpp @@ -30,6 +30,7 @@ #include "context/application_context.h" #include "display_util.h" #include "ets_ability_context.h" +#include "ets_ability_lifecycle_callback.h" #include "ets_data_struct_converter.h" #include "hilog_tag_wrapper.h" #include "hitrace_meter.h" @@ -360,6 +361,11 @@ void EtsUIAbility::OnStart(const Want &want, sptr sessionInf TAG_LOGE(AAFwkTag::UIABILITY, "WrapLaunchParam failed"); return; } + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityWillCreate(ability); + } CallObjectMethod(false, "onCreate", nullptr, wantObj, launchParamObj); auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator( AbilityRuntime::Runtime::Language::ETS); @@ -367,10 +373,11 @@ void EtsUIAbility::OnStart(const Want &want, sptr sessionInf TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformStart"); delegator->PostPerformStart(CreateADelegatorAbilityProperty()); } - auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { TAG_LOGD(AAFwkTag::UIABILITY, "call DispatchOnAbilityCreate"); - applicationContext->DispatchOnAbilityCreate(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityCreate(ability); std::shared_ptr interopObject = std::make_shared(env, etsAbilityObj_->aniRef); applicationContext->DispatchOnAbilityCreate(interopObject); @@ -405,7 +412,11 @@ void EtsUIAbility::OnStop() abilityContext_->SetTerminating(true); } UIAbility::OnStop(); - + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityWillDestroy(ability); + } CallObjectMethod(false, "onDestroy", nullptr); OnStopCallback(); TAG_LOGD(AAFwkTag::UIABILITY, "OnStop end"); @@ -425,6 +436,11 @@ void EtsUIAbility::OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callback abilityContext_->SetTerminating(true); } UIAbility::OnStop(); + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityWillDestroy(ability); + } std::weak_ptr weakPtr = shared_from_this(); auto asyncCallback = [abilityWeakPtr = weakPtr]() { auto ability = abilityWeakPtr.lock(); @@ -477,7 +493,8 @@ void EtsUIAbility::OnStopCallback() auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { TAG_LOGD(AAFwkTag::UIABILITY, "call DispatchOnAbilityDestroy"); - applicationContext->DispatchOnAbilityDestroy(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityDestroy(ability); std::shared_ptr interopObject = std::make_shared( etsRuntime_.GetAniEnv(), etsAbilityObj_->aniRef); applicationContext->DispatchOnAbilityDestroy(interopObject); @@ -506,6 +523,12 @@ void EtsUIAbility::OnSceneCreated() ani_ref entryObjectRef = nullptr; env->GlobalReference_Create(etsAppWindowStage, &entryObjectRef); etsWindowStageObj_->aniRef = entryObjectRef; + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs stage(etsWindowStageObj_); + applicationContext->DispatchOnWindowStageWillCreate(ability, stage); + } CallObjectMethod(false, "onWindowStageCreate", nullptr, etsAppWindowStage); auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator( AbilityRuntime::Runtime::Language::ETS); @@ -514,10 +537,12 @@ void EtsUIAbility::OnSceneCreated() delegator->PostPerformScenceCreated(CreateADelegatorAbilityProperty()); } - auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { TAG_LOGD(AAFwkTag::UIABILITY, "call DispatchOnWindowStageCreate"); - applicationContext->DispatchOnWindowStageCreate(etsAbilityObj_, etsWindowStageObj_); + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs stage(etsWindowStageObj_); + applicationContext->DispatchOnWindowStageCreate(ability, stage); std::shared_ptr interopAbility = std::make_shared( etsRuntime_.GetAniEnv(), etsAbilityObj_->aniRef); std::shared_ptr interopWindowStage = std::make_shared( @@ -552,7 +577,17 @@ void EtsUIAbility::OnSceneRestored() ani_ref entryObjectRef = nullptr; env->GlobalReference_Create(etsAppWindowStage, &entryObjectRef); etsWindowStageObj_->aniRef = entryObjectRef; + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs stage(etsWindowStageObj_); + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + applicationContext->DispatchOnWindowStageWillRestore(ability, stage); + } CallObjectMethod(false, "onWindowStageRestore", nullptr, etsAppWindowStage); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + applicationContext->DispatchOnWindowStageRestore(ability, stage); + } } void EtsUIAbility::OnSceneWillDestroy() @@ -569,6 +604,12 @@ void EtsUIAbility::onSceneDestroyed() { TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str()); UIAbility::onSceneDestroyed(); + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs stage(etsWindowStageObj_); + applicationContext->DispatchOnWindowStageWillDestroy(ability, stage); + } UpdateEtsWindowStage(nullptr); CallObjectMethod(false, "onWindowStageDestroy", nullptr); if (scene_ != nullptr) { @@ -585,14 +626,16 @@ void EtsUIAbility::onSceneDestroyed() delegator->PostPerformScenceDestroyed(CreateADelegatorAbilityProperty()); } - auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { TAG_LOGD(AAFwkTag::UIABILITY, "call DispatchOnWindowStageDestroy"); if (etsAbilityObj_ == nullptr || etsWindowStageObj_ == nullptr) { TAG_LOGE(AAFwkTag::UIABILITY, "null ability or window stage"); return; } - applicationContext->DispatchOnWindowStageDestroy(etsAbilityObj_, etsWindowStageObj_); + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs stage(etsWindowStageObj_); + applicationContext->DispatchOnWindowStageDestroy(ability, stage); std::shared_ptr interopAbility = std::make_shared( etsRuntime_.GetAniEnv(), etsAbilityObj_->aniRef); std::shared_ptr interopWindowStage = std::make_shared( @@ -632,6 +675,11 @@ void EtsUIAbility::CallOnForegroundFunc(const Want &want) TAG_LOGE(AAFwkTag::UIABILITY, "null wantObj"); return; } + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityWillForeground(ability); + } if ((status = env->Object_SetFieldByName_Ref(etsAbilityObj_->aniObj, "lastRequestWant", wantRef)) != ANI_OK) { TAG_LOGE(AAFwkTag::UIABILITY, "lastRequestWant Object_SetFieldByName_Ref status: %{public}d", status); return; @@ -644,10 +692,11 @@ void EtsUIAbility::CallOnForegroundFunc(const Want &want) delegator->PostPerformForeground(CreateADelegatorAbilityProperty()); } - auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { TAG_LOGD(AAFwkTag::UIABILITY, "call DispatchOnAbilityForeground"); - applicationContext->DispatchOnAbilityForeground(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityForeground(ability); std::shared_ptr interopObject = std::make_shared(env, etsAbilityObj_->aniRef); applicationContext->DispatchOnAbilityForeground(interopObject); @@ -659,6 +708,11 @@ void EtsUIAbility::OnBackground() { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str()); + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityWillBackground(ability); + } CallObjectMethod(false, "onBackground", nullptr); UIAbility::OnBackground(); auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator( @@ -668,7 +722,7 @@ void EtsUIAbility::OnBackground() delegator->PostPerformBackground(CreateADelegatorAbilityProperty()); } - auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { auto env = etsRuntime_.GetAniEnv(); if (env == nullptr || etsAbilityObj_ == nullptr) { @@ -676,7 +730,8 @@ void EtsUIAbility::OnBackground() return; } TAG_LOGD(AAFwkTag::UIABILITY, "call DispatchOnAbilityBackground"); - applicationContext->DispatchOnAbilityBackground(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + applicationContext->DispatchOnAbilityBackground(ability); std::shared_ptr interopObject = std::make_shared(env, etsAbilityObj_->aniRef); applicationContext->DispatchOnAbilityBackground(interopObject); @@ -1278,6 +1333,11 @@ void EtsUIAbility::OnNewWant(const Want &want) TAG_LOGE(AAFwkTag::UIABILITY, "null wantObj"); return; } + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + applicationContext->DispatchOnWillNewWant(ability); + } ani_status status = env->Object_SetFieldByName_Ref(etsAbilityObj_->aniObj, "lastRequestWant", wantObj); if (status != ANI_OK) { TAG_LOGE(AAFwkTag::UIABILITY, "lastRequestWant Object_SetFieldByName_Ref status: %{public}d", status); @@ -1294,6 +1354,10 @@ void EtsUIAbility::OnNewWant(const Want &want) } std::string methodName = "OnNewWant"; CallObjectMethod(false, "onNewWant", nullptr, wantObj, launchParamObj); + applicationContext = AbilityRuntime::Context::GetApplicationContext(); + if (applicationContext != nullptr) { + applicationContext->DispatchOnNewWant(ability); + } TAG_LOGD(AAFwkTag::UIABILITY, "OnNewWant end"); } @@ -1389,6 +1453,27 @@ sptr EtsUIAbility::CallRequest() return remoteObj; } +void EtsUIAbility::OnAfterFocusedCommon(bool isFocused) +{ + auto abilityContext = GetAbilityContext(); + if (abilityContext == nullptr) { + TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext"); + return; + } + auto applicationContext = abilityContext->GetApplicationContext(); + if (applicationContext == nullptr || applicationContext->IsAbilityLifecycleCallbackEmpty()) { + TAG_LOGD(AAFwkTag::UIABILITY, "null applicationContext or lifecycleCallback"); + return; + } + EtsAbilityLifecycleCallbackArgs ability(etsAbilityObj_); + EtsAbilityLifecycleCallbackArgs stage(etsWindowStageObj_); + if (isFocused) { + applicationContext->DispatchWindowStageFocus(ability, stage); + } else { + applicationContext->DispatchWindowStageUnfocus(ability, stage); + } +} + bool EtsUIAbility::CallObjectMethod(bool withResult, const char *name, const char *signature, ...) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, std::string("CallObjectMethod:") + name); diff --git a/frameworks/ets/ani/ui_extension_ability/include/ets_ui_extension.h b/frameworks/ets/ani/ui_extension_ability/include/ets_ui_extension.h index 6a76379394b5d48ca80d979f043cf60cb701c7e7..a93bf6c87f340566ae4469293ec5717d03b897db 100644 --- a/frameworks/ets/ani/ui_extension_ability/include/ets_ui_extension.h +++ b/frameworks/ets/ani/ui_extension_ability/include/ets_ui_extension.h @@ -85,7 +85,10 @@ public: */ void OnStop() override; void OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callbackInfo, bool &isAsyncCallback) override; - + /** + * @brief The callback of OnStop. + */ + virtual void OnStopCallBack() override; /** * @brief Called when this extension enters the STATE_FOREGROUND state. * diff --git a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension.cpp b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension.cpp index 58157cb3f789f83159fa6fa3559705fcea86eef5..a0fdddf6ec7a60ac9031c97c3697c6181a27cd62 100644 --- a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension.cpp +++ b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension.cpp @@ -25,6 +25,7 @@ #include "configuration_utils.h" #include "connection_manager.h" #include "context.h" +#include "ets_ability_lifecycle_callback.h" #include "ets_data_struct_converter.h" #include "ets_extension_common.h" #include "ets_extension_context.h" @@ -323,6 +324,16 @@ void EtsUIExtension::OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callba } } +void EtsUIExtension::OnStopCallBack() +{ + UIExtension::OnStopCallBack(); + auto applicationContext = Context::GetApplicationContext(); + if (applicationContext != nullptr) { + EtsAbilityLifecycleCallbackArgs ability(etsObj_); + applicationContext->DispatchOnAbilityDestroy(ability); + } +} + bool EtsUIExtension::ForegroundWindowInitInsightIntentExecutorInfo(const AAFwk::Want &want, const sptr &sessionInfo, InsightIntentExecutorInfo &executorInfo) { diff --git a/frameworks/ets/ani/ui_extension_base/src/ets_ui_extension_base.cpp b/frameworks/ets/ani/ui_extension_base/src/ets_ui_extension_base.cpp index ef84af974ad6e9aee0fa0bdf9e77808fac4241f1..d64cc948e7038a2e6e246690f4d55537fa6c708e 100644 --- a/frameworks/ets/ani/ui_extension_base/src/ets_ui_extension_base.cpp +++ b/frameworks/ets/ani/ui_extension_base/src/ets_ui_extension_base.cpp @@ -30,6 +30,7 @@ #include "configuration_utils.h" #include "connection_manager.h" #include "context.h" +#include "ets_ability_lifecycle_callback.h" #include "ets_data_struct_converter.h" #include "ets_extension_common.h" #include "ets_extension_context.h" @@ -376,7 +377,8 @@ void EtsUIExtensionBase::OnStopCallBack() auto applicationContext = Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityDestroy(etsObj_); + EtsAbilityLifecycleCallbackArgs ability(etsObj_); + applicationContext->DispatchOnAbilityDestroy(ability); } } diff --git a/frameworks/ets/ets/@ohos.app.ability.AbilityLifecycleCallback.ets b/frameworks/ets/ets/@ohos.app.ability.AbilityLifecycleCallback.ets index f5ee1094e9249059773fcac3ba2e32d8963f8a51..be67633af0a55e5c581daaf7dbba4450d8c32550 100644 --- a/frameworks/ets/ets/@ohos.app.ability.AbilityLifecycleCallback.ets +++ b/frameworks/ets/ets/@ohos.app.ability.AbilityLifecycleCallback.ets @@ -16,6 +16,21 @@ import UIAbility from '@ohos.app.ability.UIAbility'; import window from '@ohos.window'; +export type OnNewWantFn = (ability: UIAbility) => void; +export type OnAbilityWillBackgroundFn = (ability: UIAbility) => void; +export type OnAbilityWillForegroundFn = (ability: UIAbility) => void; +export type OnAbilityWillCreateFn = (ability: UIAbility) => void; +export type OnWindowStageWillDestroyFn = (ability: UIAbility, windowStage: window.WindowStage) => void; +export type OnAbilityWillDestroyFn = (ability: UIAbility) => void; +export type OnWindowStageRestoreFn = (ability: UIAbility, windowStage: window.WindowStage) => void; +export type OnAbilitySaveStateFn = (ability: UIAbility) => void; +export type OnAbilityWillContinueFn = (ability: UIAbility) => void; +export type OnAbilityWillSaveStateFn = (ability: UIAbility) => void; +export type OnWillNewWantFn = (ability: UIAbility) => void; +export type OnWindowStageWillCreateFn = (ability: UIAbility, windowStage: window.WindowStage) => void; +export type OnWindowStageWillRestoreFn = (ability: UIAbility, windowStage: window.WindowStage) => void; + + interface AbilityLifecycleCallback { onAbilityCreate(ability: UIAbility): void; onAbilityForeground(ability: UIAbility): void; @@ -23,6 +38,23 @@ interface AbilityLifecycleCallback { onAbilityDestroy(ability: UIAbility): void; onWindowStageCreate(ability: UIAbility, windowStage: window.WindowStage): void; onWindowStageDestroy(ability: UIAbility, windowStage: window.WindowStage): void; + onAbilityContinue(ability: UIAbility): void; + onWindowStageInactive(ability: UIAbility, windowStage: window.WindowStage): void; + onWindowStageActive(ability: UIAbility, windowStage: window.WindowStage): void; + + onNewWant?: OnNewWantFn; + onAbilityWillBackground?: OnAbilityWillBackgroundFn; + onAbilityWillForeground?: OnAbilityWillForegroundFn; + onAbilityWillCreate?: OnAbilityWillCreateFn; + onWindowStageWillDestroy?: OnWindowStageWillDestroyFn; + onAbilityWillDestroy?: OnAbilityWillDestroyFn; + onWindowStageRestore?: OnWindowStageRestoreFn; + onAbilitySaveState?: OnAbilitySaveStateFn; + onAbilityWillContinue?: OnAbilityWillContinueFn; + onAbilityWillSaveState?: OnAbilityWillSaveStateFn; + onWillNewWant?: OnWillNewWantFn; + onWindowStageWillCreate?: OnWindowStageWillCreateFn; + onWindowStageWillRestore?: OnWindowStageWillRestoreFn; } class AbilityLifecycleCallbackInner implements AbilityLifecycleCallback { @@ -32,6 +64,23 @@ class AbilityLifecycleCallbackInner implements AbilityLifecycleCallback { onAbilityDestroy(ability: UIAbility): void {}; onWindowStageCreate(ability: UIAbility, windowStage: window.WindowStage): void {}; onWindowStageDestroy(ability: UIAbility, windowStage: window.WindowStage): void {}; + onAbilityContinue(ability: UIAbility): void {}; + onWindowStageInactive(ability: UIAbility, windowStage: window.WindowStage): void {}; + onWindowStageActive(ability: UIAbility, windowStage: window.WindowStage): void {}; + + onNewWant?: OnNewWantFn; + onAbilityWillBackground?: OnAbilityWillBackgroundFn; + onAbilityWillForeground?: OnAbilityWillForegroundFn; + onAbilityWillCreate?: OnAbilityWillCreateFn; + onWindowStageWillDestroy?: OnWindowStageWillDestroyFn; + onAbilityWillDestroy?: OnAbilityWillDestroyFn; + onWindowStageRestore?: OnWindowStageRestoreFn; + onAbilitySaveState?: OnAbilitySaveStateFn; + onAbilityWillContinue?: OnAbilityWillContinueFn; + onAbilityWillSaveState?: OnAbilityWillSaveStateFn; + onWillNewWant?: OnWillNewWantFn; + onWindowStageWillCreate?: OnWindowStageWillCreateFn; + onWindowStageWillRestore?: OnWindowStageWillRestoreFn; } export default AbilityLifecycleCallback; \ No newline at end of file diff --git a/frameworks/native/ability/native/ability_impl.cpp b/frameworks/native/ability/native/ability_impl.cpp index 499d50e8d8b1e58f3d05ea5380ec2efef5bda8c5..8c655ec4e31c90b7abb0ff12fc1e8d53641f543f 100644 --- a/frameworks/native/ability/native/ability_impl.cpp +++ b/frameworks/native/ability/native/ability_impl.cpp @@ -21,6 +21,7 @@ #include "freeze_util.h" #include "hilog_tag_wrapper.h" #include "hitrace_meter.h" +#include "js_ability_lifecycle_callback.h" #include "ohos_application.h" #ifdef SUPPORT_SCREEN #include "scene_board_judgement.h" @@ -580,10 +581,12 @@ void AbilityImpl::AfterFocusedCommon(bool isFocused) return; } auto& jsAbility = static_cast(*(impl->ability_)); + AbilityRuntime::JsAbilityLifecycleCallbackArgs ability(jsAbility.GetJsAbility()); + AbilityRuntime::JsAbilityLifecycleCallbackArgs stage(jsAbility.GetJsWindowStage()); if (focuseMode) { - applicationContext->DispatchWindowStageFocus(jsAbility.GetJsAbility(), jsAbility.GetJsWindowStage()); + applicationContext->DispatchWindowStageFocus(ability, stage); } else { - applicationContext->DispatchWindowStageUnfocus(jsAbility.GetJsAbility(), jsAbility.GetJsWindowStage()); + applicationContext->DispatchWindowStageUnfocus(ability, stage); } return; } diff --git a/frameworks/native/ability/native/ability_runtime/js_ability.cpp b/frameworks/native/ability/native/ability_runtime/js_ability.cpp index 97f22d0bd451e9ec15b65ceee32fd4eda43c777e..6e88b309fac1c81e465b9e23da3f71cac4fdc24c 100644 --- a/frameworks/native/ability/native/ability_runtime/js_ability.cpp +++ b/frameworks/native/ability/native/ability_runtime/js_ability.cpp @@ -26,6 +26,7 @@ #include "connection_manager.h" #include "display_util.h" #include "hilog_tag_wrapper.h" +#include "js_ability_lifecycle_callback.h" #include "js_data_struct_converter.h" #include "js_runtime.h" #include "js_runtime_utils.h" @@ -286,7 +287,8 @@ void JsAbility::OnStart(const Want &want, sptr sessionInfo) } auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityCreate(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityCreate(ability); } TAG_LOGD(AAFwkTag::ABILITY, "end, ability:%{public}s", GetAbilityName().c_str()); } @@ -399,7 +401,8 @@ void JsAbility::OnStopCallback() auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityDestroy(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityDestroy(ability); } } @@ -437,7 +440,9 @@ void JsAbility::OnSceneCreated() jsWindowStageObj_ = std::shared_ptr(jsAppWindowStage.release()); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageCreate(jsAbilityObj_, jsWindowStageObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); + applicationContext->DispatchOnWindowStageCreate(ability, stage); } TAG_LOGD(AAFwkTag::ABILITY, "end, ability:%{public}s", GetAbilityName().c_str()); @@ -488,7 +493,9 @@ void JsAbility::onSceneDestroyed() auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageDestroy(jsAbilityObj_, jsWindowStageObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); + applicationContext->DispatchOnWindowStageDestroy(ability, stage); } TAG_LOGD(AAFwkTag::ABILITY, "end, ability:%{public}s", GetAbilityName().c_str()); } @@ -535,7 +542,8 @@ void JsAbility::OnForeground(const Want &want) auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityForeground(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityForeground(ability); } TAG_LOGD(AAFwkTag::ABILITY, "end, ability:%{public}s", GetAbilityName().c_str()); } @@ -560,7 +568,8 @@ void JsAbility::OnBackground() auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityBackground(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityBackground(ability); } TAG_LOGD(AAFwkTag::ABILITY, "end, ability:%{public}s", GetAbilityName().c_str()); } @@ -814,7 +823,8 @@ int32_t JsAbility::OnContinue(WantParams &wantParams) auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityContinue(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityContinue(ability); } return numberResult; diff --git a/frameworks/native/ability/native/ability_runtime/js_ui_ability.cpp b/frameworks/native/ability/native/ability_runtime/js_ui_ability.cpp index 7d702757b3829d1ad87cfe463acd1eacfe7e4897..038f530aa0b82e44e8b01f4318c28b9262b0938c 100644 --- a/frameworks/native/ability/native/ability_runtime/js_ui_ability.cpp +++ b/frameworks/native/ability/native/ability_runtime/js_ui_ability.cpp @@ -35,6 +35,7 @@ #include "insight_intent_executor_mgr.h" #include "insight_intent_execute_param.h" #include "js_ability_context.h" +#include "js_ability_lifecycle_callback.h" #include "js_data_struct_converter.h" #include "js_insight_intent_page.h" #include "js_runtime.h" @@ -441,7 +442,8 @@ void JsUIAbility::OnStart(const Want &want, sptr sessionInfo auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillCreate(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillCreate(ability); } AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName); @@ -450,7 +452,8 @@ void JsUIAbility::OnStart(const Want &want, sptr sessionInfo HandleAbilityDelegatorStart(); applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityCreate(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityCreate(ability); std::shared_ptr interopObject = std::make_shared(env, jsAbilityObj_->GetNapiValue()); applicationContext->DispatchOnAbilityCreate(interopObject); @@ -518,7 +521,8 @@ void JsUIAbility::OnStop() HandleScope handleScope(jsRuntime_); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillDestroy(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillDestroy(ability); } CallObjectMethod("onDestroy"); OnStopCallback(); @@ -545,7 +549,8 @@ void JsUIAbility::OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callbackI HandleScope handleScope(jsRuntime_); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillDestroy(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillDestroy(ability); } napi_value result = CallObjectMethod("onDestroy", nullptr, 0, true); if (!CheckPromise(result)) { @@ -590,7 +595,8 @@ void JsUIAbility::OnStopCallback() auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityDestroy(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityDestroy(ability); std::shared_ptr interopObject = std::make_shared( jsRuntime_.GetNapiEnv(), jsAbilityObj_->GetNapiValue()); applicationContext->DispatchOnAbilityDestroy(interopObject); @@ -615,7 +621,9 @@ void JsUIAbility::OnSceneCreated() jsWindowStageObj_ = std::shared_ptr(jsAppWindowStage.release()); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageWillCreate(jsAbilityObj_, jsWindowStageObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); + applicationContext->DispatchOnWindowStageWillCreate(ability, stage); } { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "onWindowStageCreate"); @@ -635,7 +643,9 @@ void JsUIAbility::OnSceneCreated() applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageCreate(jsAbilityObj_, jsWindowStageObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); + applicationContext->DispatchOnWindowStageCreate(ability, stage); std::shared_ptr interopAbility = std::make_shared( jsRuntime_.GetNapiEnv(), jsAbilityObj_->GetNapiValue()); std::shared_ptr interopWindowStage = std::make_shared( @@ -661,12 +671,14 @@ void JsUIAbility::OnSceneRestored() napi_value argv[] = {jsAppWindowStage->GetNapiValue()}; jsWindowStageObj_ = std::shared_ptr(jsAppWindowStage.release()); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageWillRestore(jsAbilityObj_, jsWindowStageObj_); + applicationContext->DispatchOnWindowStageWillRestore(ability, stage); } CallObjectMethod("onWindowStageRestore", argv, ArraySize(argv)); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageRestore(jsAbilityObj_, jsWindowStageObj_); + applicationContext->DispatchOnWindowStageRestore(ability, stage); } auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(); @@ -701,7 +713,9 @@ void JsUIAbility::onSceneDestroyed() auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnWindowStageWillDestroy(jsAbilityObj_, jsWindowStageObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); + applicationContext->DispatchOnWindowStageWillDestroy(ability, stage); } HandleScope handleScope(jsRuntime_); UpdateJsWindowStage(nullptr); @@ -729,7 +743,9 @@ void JsUIAbility::onSceneDestroyed() TAG_LOGE(AAFwkTag::UIABILITY, "null ability or window stage"); return; } - applicationContext->DispatchOnWindowStageDestroy(jsAbilityObj_, jsWindowStageObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs stage(jsWindowStageObj_); + applicationContext->DispatchOnWindowStageDestroy(ability, stage); std::shared_ptr interopAbility = std::make_shared( jsRuntime_.GetNapiEnv(), jsAbilityObj_->GetNapiValue()); std::shared_ptr interopWindowStage = std::make_shared( @@ -779,7 +795,8 @@ void JsUIAbility::CallOnForegroundFunc(const Want &want) auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillForeground(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillForeground(ability); } napi_set_named_property(env, obj, "lastRequestWant", jsWant); @@ -798,7 +815,8 @@ void JsUIAbility::CallOnForegroundFunc(const Want &want) applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityForeground(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityForeground(ability); std::shared_ptr interopObject = std::make_shared(env, jsAbilityObj_->GetNapiValue()); applicationContext->DispatchOnAbilityForeground(interopObject); @@ -812,7 +830,8 @@ void JsUIAbility::OnBackground() TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str()); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillBackground(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillBackground(ability); } std::string methodName = "OnBackground"; HandleScope handleScope(jsRuntime_); @@ -832,7 +851,8 @@ void JsUIAbility::OnBackground() applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr && jsAbilityObj_ != nullptr) { - applicationContext->DispatchOnAbilityBackground(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityBackground(ability); std::shared_ptr interopObject = std::make_shared( jsRuntime_.GetNapiEnv(), jsAbilityObj_->GetNapiValue()); applicationContext->DispatchOnAbilityBackground(interopObject); @@ -1471,7 +1491,8 @@ int32_t JsUIAbility::OnContinue(WantParams &wantParams, bool &isAsyncOnContinue, } auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillContinue(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillContinue(ability); } napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParams); napi_value result = CallObjectMethod("onContinue", &jsWantParams, 1, true); @@ -1539,7 +1560,8 @@ int32_t JsUIAbility::OnContinueAsyncCB(napi_ref jsWantParamsRef, int32_t status, OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityContinue(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityContinue(ability); } Want want; @@ -1568,7 +1590,8 @@ int32_t JsUIAbility::OnContinueSyncCB(napi_value result, WantParams &wantParams, OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityContinue(jsAbilityObj_); + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); + applicationContext->DispatchOnAbilityContinue(ability); } TAG_LOGI(AAFwkTag::UIABILITY, "end"); return onContinueRes; @@ -1586,9 +1609,10 @@ int32_t JsUIAbility::OnSaveState(int32_t reason, WantParams &wantParams, TAG_LOGE(AAFwkTag::UIABILITY, "get ability object failed"); return CALL_BACK_ERROR; } + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityWillSaveState(jsAbilityObj_); + applicationContext->DispatchOnAbilityWillSaveState(ability); } napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParams); @@ -1607,7 +1631,7 @@ int32_t JsUIAbility::OnSaveState(int32_t reason, WantParams &wantParams, CallOnSaveStateInfo info = { callbackInfo, wantParams, stateReason }; int32_t status = CallSaveStatePromise(onSaveStateAsyncResult, info); if (status == ERR_OK && applicationContext != nullptr) { - applicationContext->DispatchOnAbilitySaveState(jsAbilityObj_); + applicationContext->DispatchOnAbilitySaveState(ability); } isAsync = true; return status; @@ -1627,7 +1651,7 @@ int32_t JsUIAbility::OnSaveState(int32_t reason, WantParams &wantParams, } if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilitySaveState(jsAbilityObj_); + applicationContext->DispatchOnAbilitySaveState(ability); } AppExecFwk::OnSaveStateResult saveStateResult = {numberResult, wantParams, stateReason}; callbackInfo->Call(saveStateResult); @@ -1749,9 +1773,10 @@ void JsUIAbility::OnNewWant(const Want &want) return; } + JsAbilityLifecycleCallbackArgs ability(jsAbilityObj_); auto applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnWillNewWant(jsAbilityObj_); + applicationContext->DispatchOnWillNewWant(ability); } napi_set_named_property(env, obj, "lastRequestWant", jsWant); @@ -1770,7 +1795,7 @@ void JsUIAbility::OnNewWant(const Want &want) applicationContext = AbilityRuntime::Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnNewWant(jsAbilityObj_); + applicationContext->DispatchOnNewWant(ability); } TAG_LOGD(AAFwkTag::UIABILITY, "end"); } @@ -2208,10 +2233,12 @@ void JsUIAbility::OnAfterFocusedCommon(bool isFocused) TAG_LOGD(AAFwkTag::UIABILITY, "null applicationContext or lifecycleCallback"); return; } + JsAbilityLifecycleCallbackArgs ability(GetJsAbility()); + JsAbilityLifecycleCallbackArgs stage(GetJsWindowStage()); if (isFocused) { - applicationContext->DispatchWindowStageFocus(GetJsAbility(), GetJsWindowStage()); + applicationContext->DispatchWindowStageFocus(ability, stage); } else { - applicationContext->DispatchWindowStageUnfocus(GetJsAbility(), GetJsWindowStage()); + applicationContext->DispatchWindowStageUnfocus(ability, stage); } } diff --git a/frameworks/native/ability/native/auto_fill_extension_ability/js_auto_fill_extension.cpp b/frameworks/native/ability/native/auto_fill_extension_ability/js_auto_fill_extension.cpp index 9a23275aa4daf9ab66ad9b71ed8dcf211489ef55..339b715a47ba749a9f7eac4baaa552690b2d4698 100644 --- a/frameworks/native/ability/native/auto_fill_extension_ability/js_auto_fill_extension.cpp +++ b/frameworks/native/ability/native/auto_fill_extension_ability/js_auto_fill_extension.cpp @@ -25,6 +25,7 @@ #include "hitrace_meter.h" #include "hilog_tag_wrapper.h" #include "int_wrapper.h" +#include "js_ability_lifecycle_callback.h" #include "js_auto_fill_extension_util.h" #include "js_auto_fill_extension_context.h" #include "js_fill_request_callback.h" @@ -290,7 +291,8 @@ void JsAutoFillExtension::OnStopCallBack() auto applicationContext = Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityDestroy(jsObj_); + JsAbilityLifecycleCallbackArgs ability(jsObj_); + applicationContext->DispatchOnAbilityDestroy(ability); } } diff --git a/frameworks/native/ability/native/ui_extension_ability/js_ui_extension.cpp b/frameworks/native/ability/native/ui_extension_ability/js_ui_extension.cpp index a74f6920083b94eac44cb660a1519d6d893dce18..0542f6103389c18b7b000ba20777f9613c6871b6 100755 --- a/frameworks/native/ability/native/ui_extension_ability/js_ui_extension.cpp +++ b/frameworks/native/ability/native/ui_extension_ability/js_ui_extension.cpp @@ -27,6 +27,7 @@ #include "hilog_tag_wrapper.h" #include "insight_intent_executor_mgr.h" #include "int_wrapper.h" +#include "js_ability_lifecycle_callback.h" #include "js_data_struct_converter.h" #include "js_embeddable_ui_ability_context.h" #include "js_embeddable_window_stage.h" @@ -357,7 +358,8 @@ void JsUIExtension::OnStopCallBack() auto applicationContext = Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityDestroy(jsObj_); + JsAbilityLifecycleCallbackArgs ability(jsObj_); + applicationContext->DispatchOnAbilityDestroy(ability); } } diff --git a/frameworks/native/ability/native/ui_extension_base/js_ui_extension_base.cpp b/frameworks/native/ability/native/ui_extension_base/js_ui_extension_base.cpp index f8f67de6ff92e3c324cbd27b43de985f982ac665..d0dad2ef713831cc0b81b64f786852abbdda272f 100644 --- a/frameworks/native/ability/native/ui_extension_base/js_ui_extension_base.cpp +++ b/frameworks/native/ability/native/ui_extension_base/js_ui_extension_base.cpp @@ -29,6 +29,7 @@ #include "hitrace_meter.h" #include "insight_intent_executor_mgr.h" #include "int_wrapper.h" +#include "js_ability_lifecycle_callback.h" #include "js_data_struct_converter.h" #include "js_extension_common.h" #include "js_extension_context.h" @@ -377,7 +378,8 @@ void JsUIExtensionBase::OnStopCallBack() auto applicationContext = Context::GetApplicationContext(); if (applicationContext != nullptr) { - applicationContext->DispatchOnAbilityDestroy(jsObj_); + JsAbilityLifecycleCallbackArgs ability(jsObj_); + applicationContext->DispatchOnAbilityDestroy(ability); } } diff --git a/frameworks/native/appkit/BUILD.gn b/frameworks/native/appkit/BUILD.gn index 26a1bfdfbb266df91b47eee351e5eaac0a4d717a..1f30de6a616a0d86d515ea15356241a1f7269a00 100644 --- a/frameworks/native/appkit/BUILD.gn +++ b/frameworks/native/appkit/BUILD.gn @@ -445,16 +445,15 @@ ohos_shared_library("app_context") { public_configs = [ ":appkit_public_config" ] sources = [ - "${ability_runtime_native_path}/appkit/ability_runtime/context/ability_lifecycle_callback.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/ability_stage_context.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/application_context.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/application_state_change_callback.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/bindable_sub_thread.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/context_impl.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/environment_callback.cpp", - "${ability_runtime_native_path}/appkit/ability_runtime/context/ets_ability_lifecycle_callback.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/ets_interop_ability_lifecycle_callback.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/interop_object.cpp", + "${ability_runtime_native_path}/appkit/ability_runtime/context/js_ability_lifecycle_callback.cpp", "${ability_runtime_native_path}/appkit/ability_runtime/context/js_interop_ability_lifecycle_callback.cpp", "${ability_runtime_native_path}/appkit/app/overlay_event_subscriber.cpp", "${ability_runtime_native_path}/appkit/app/sys_mgr_client.cpp", diff --git a/frameworks/native/appkit/ability_runtime/context/application_context.cpp b/frameworks/native/appkit/ability_runtime/context/application_context.cpp index f46585ea50ccbe37cc983adbe193ebbe8c154e2c..bba5ddb534f7687af418269004c95ab36c030d26 100644 --- a/frameworks/native/appkit/ability_runtime/context/application_context.cpp +++ b/frameworks/native/appkit/ability_runtime/context/application_context.cpp @@ -134,31 +134,22 @@ void ApplicationContext::RegisterApplicationStateChangeCallback( applicationStateCallback_.push_back(applicationStateChangeCallback); } -void ApplicationContext::DispatchOnAbilityCreate(std::shared_ptr ability) +void ApplicationContext::DispatchOnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityCreate(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } - } -} - -void ApplicationContext::DispatchOnAbilityCreate(std::shared_ptr ability) -{ - if (!ability) { - TAG_LOGE(AAFwkTag::APPKIT, "null ability"); - return; - } - std::lock_guard lock(callbackLock_); - for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityCreate(ability); + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityCreate(ability); } } @@ -178,33 +169,24 @@ void ApplicationContext::DispatchOnAbilityCreate(std::shared_ptr } } -void ApplicationContext::DispatchOnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage) +void ApplicationContext::DispatchOnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - if (!ability || !windowStage) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageCreate(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } - } -} - -void ApplicationContext::DispatchOnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage) -{ - if (!ability || !windowStage) { - TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); - return; - } - std::lock_guard lock(callbackLock_); - for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageCreate(ability, windowStage); + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; } + callback->OnWindowStageCreate(ability, windowStage); } } @@ -225,33 +207,24 @@ void ApplicationContext::DispatchOnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage) +void ApplicationContext::DispatchOnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - if (!ability || !windowStage) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageDestroy(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } - } -} - -void ApplicationContext::DispatchOnWindowStageDestroy(std::shared_ptr ability, - std::shared_ptr windowStage) -{ - if (ability == nullptr || windowStage == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "null env or ability or windowStage"); - return; - } - std::lock_guard lock(callbackLock_); - for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageDestroy(ability, windowStage); + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; } + callback->OnWindowStageDestroy(ability, windowStage); } } @@ -272,63 +245,66 @@ void ApplicationContext::DispatchOnWindowStageDestroy(std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void ApplicationContext::DispatchWindowStageFocus(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability || !windowStage) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageActive(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; } + callback->OnWindowStageActive(ability, windowStage); } } -void ApplicationContext::DispatchWindowStageUnfocus(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void ApplicationContext::DispatchWindowStageUnfocus(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability || !windowStage) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageInactive(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; + } + callback->OnWindowStageInactive(ability, windowStage); } } -void ApplicationContext::DispatchOnAbilityDestroy(std::shared_ptr ability) +void ApplicationContext::DispatchOnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityDestroy(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } - } -} - -void ApplicationContext::DispatchOnAbilityDestroy(std::shared_ptr ability) -{ - if (ability == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "null env or ability"); - return; - } - std::lock_guard lock(callbackLock_); - for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityDestroy(ability); + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityDestroy(ability); } } @@ -348,31 +324,22 @@ void ApplicationContext::DispatchOnAbilityDestroy(std::shared_ptr } } -void ApplicationContext::DispatchOnAbilityForeground(std::shared_ptr ability) +void ApplicationContext::DispatchOnAbilityForeground(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityForeground(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } - } -} - -void ApplicationContext::DispatchOnAbilityForeground(std::shared_ptr ability) -{ - if (ability == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "null env or ability"); - return; - } - std::lock_guard lock(callbackLock_); - for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityForeground(ability); + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityForeground(ability); } } @@ -392,31 +359,22 @@ void ApplicationContext::DispatchOnAbilityForeground(std::shared_ptr ability) +void ApplicationContext::DispatchOnAbilityBackground(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityBackground(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } - } -} - -void ApplicationContext::DispatchOnAbilityBackground(std::shared_ptr ability) -{ - if (ability == nullptr) { - TAG_LOGE(AAFwkTag::APPKIT, "null env or ability"); - return; - } - std::lock_guard lock(callbackLock_); - for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityBackground(ability); + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityBackground(ability); } } @@ -436,99 +394,131 @@ void ApplicationContext::DispatchOnAbilityBackground(std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityContinue(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityContinue(ability); } } -void ApplicationContext::DispatchOnAbilityWillContinue(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "Dispatch onAbilityWillContinue"); - if (ability == nullptr) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityWillContinue(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityWillContinue(ability); } } -void ApplicationContext::DispatchOnWindowStageWillRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void ApplicationContext::DispatchOnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { TAG_LOGD(AAFwkTag::APPKIT, "Dispatch onWindowStageWillRestore"); - if (ability == nullptr || windowStage == nullptr) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageWillRestore(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; + } + callback->OnWindowStageWillRestore(ability, windowStage); } } -void ApplicationContext::DispatchOnWindowStageRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void ApplicationContext::DispatchOnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { TAG_LOGD(AAFwkTag::APPKIT, "Dispatch onWindowStageRestore"); - if (ability == nullptr || windowStage == nullptr) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageRestore(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; + } + callback->OnWindowStageRestore(ability, windowStage); } } -void ApplicationContext::DispatchOnAbilityWillSaveState(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "Dispatch onAbilityWillSaveState"); - if (ability == nullptr) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityWillSaveState(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_) { + continue; + } + callback->OnAbilityWillSaveState(ability); } } -void ApplicationContext::DispatchOnAbilitySaveState(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (ability == nullptr) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilitySaveState(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_) { + continue; + } + callback->OnAbilitySaveState(ability); } } @@ -574,123 +564,165 @@ void ApplicationContext::NotifyApplicationBackground() } } -void ApplicationContext::DispatchOnWillNewWant(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnWillNewWant(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWillNewWant(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_) { + continue; } + callback->OnWillNewWant(ability); } } -void ApplicationContext::DispatchOnNewWant(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnNewWant(const AbilityLifecycleCallbackArgs &ability) { - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnNewWant(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_) { + continue; + } + callback->OnNewWant(ability); } } -void ApplicationContext::DispatchOnAbilityWillCreate(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityWillCreate(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityWillCreate(ability); } } -void ApplicationContext::DispatchOnWindowStageWillCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void ApplicationContext::DispatchOnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability || !windowStage) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageWillCreate(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; + } + callback->OnWindowStageWillCreate(ability, windowStage); } } -void ApplicationContext::DispatchOnWindowStageWillDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void ApplicationContext::DispatchOnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability || !windowStage) { + if (!ability.IsValid() || !windowStage.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability or windowStage"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnWindowStageWillDestroy(ability, windowStage); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_ || + windowStage.type_ != callback->type_) { + continue; } + callback->OnWindowStageWillDestroy(ability, windowStage); } } -void ApplicationContext::DispatchOnAbilityWillDestroy(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityWillDestroy(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; } + if (ability.type_ != callback->type_) { + continue; + } + callback->OnAbilityWillDestroy(ability); } } -void ApplicationContext::DispatchOnAbilityWillForeground(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityWillForeground(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityWillForeground(ability); } } -void ApplicationContext::DispatchOnAbilityWillBackground(const std::shared_ptr &ability) +void ApplicationContext::DispatchOnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability) { TAG_LOGD(AAFwkTag::APPKIT, "called"); - if (!ability) { + if (!ability.IsValid()) { TAG_LOGE(AAFwkTag::APPKIT, "null ability"); return; } std::lock_guard lock(callbackLock_); for (auto callback : callbacks_) { - if (callback != nullptr) { - callback->OnAbilityWillBackground(ability); + if (callback == nullptr) { + TAG_LOGE(AAFwkTag::APPKIT, "null callback"); + continue; + } + if (ability.type_ != callback->type_) { + continue; } + callback->OnAbilityWillBackground(ability); } } diff --git a/frameworks/native/appkit/ability_runtime/context/ability_lifecycle_callback.cpp b/frameworks/native/appkit/ability_runtime/context/js_ability_lifecycle_callback.cpp similarity index 45% rename from frameworks/native/appkit/ability_runtime/context/ability_lifecycle_callback.cpp rename to frameworks/native/appkit/ability_runtime/context/js_ability_lifecycle_callback.cpp index e4826d9e306fb577da876ea1389c9a0252e677a1..64363d3cf3f25b331b7f071ec28429158112cd50 100644 --- a/frameworks/native/appkit/ability_runtime/context/ability_lifecycle_callback.cpp +++ b/frameworks/native/appkit/ability_runtime/context/js_ability_lifecycle_callback.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "ability_lifecycle_callback.h" +#include "js_ability_lifecycle_callback.h" #include "hilog_tag_wrapper.h" #include "js_runtime_utils.h" @@ -23,6 +23,7 @@ namespace AbilityRuntime { JsAbilityLifecycleCallback::JsAbilityLifecycleCallback(napi_env env) : env_(env) { + type_ = AbilityLifecycleCallbackType::JS; } int32_t JsAbilityLifecycleCallback::serialNumber_ = 0; @@ -98,80 +99,87 @@ void JsAbilityLifecycleCallback::CallWindowStageJsMethod(const std::string &meth CallJsMethodInnerCommon(methodName, ability, windowStage, callbacksSync_); } -void JsAbilityLifecycleCallback::OnAbilityCreate(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityCreate", ability); + CallJsMethod("onAbilityCreate", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageCreate", ability, windowStage); + CallWindowStageJsMethod("onWindowStageCreate", static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageDestroy", ability, windowStage); + CallWindowStageJsMethod("onWindowStageDestroy", static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageActive(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageActive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageActive", ability, windowStage); + CallWindowStageJsMethod("onWindowStageActive", static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageInactive(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageInactive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageInactive", ability, windowStage); + CallWindowStageJsMethod("onWindowStageInactive", static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnAbilityDestroy(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityDestroy", ability); + CallJsMethod("onAbilityDestroy", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityForeground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityForeground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityForeground", ability); + CallJsMethod("onAbilityForeground", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityBackground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityBackground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityBackground", ability); + CallJsMethod("onAbilityBackground", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityContinue(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityContinue", ability); + CallJsMethod("onAbilityContinue", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityWillContinue(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityWillContinue", ability); + CallJsMethod("onAbilityWillContinue", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageWillRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageWillRestore", ability, windowStage); + CallWindowStageJsMethod("onWindowStageWillRestore", + static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageRestore", ability, windowStage); + CallWindowStageJsMethod("onWindowStageRestore", static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnAbilityWillSaveState(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityWillSaveState", ability); + CallJsMethod("onAbilityWillSaveState", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilitySaveState(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilitySaveState", ability); + CallJsMethod("onAbilitySaveState", static_cast(ability).ref_); } int32_t JsAbilityLifecycleCallback::Register(napi_value jsCallback, bool isSync) @@ -215,46 +223,50 @@ bool JsAbilityLifecycleCallback::UnRegister(int32_t callbackId, bool isSync) return callbacks_.erase(callbackId) == 1; } -void JsAbilityLifecycleCallback::OnNewWant(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnNewWant(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onNewWant", ability); + CallJsMethod("onNewWant", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnWillNewWant(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnWillNewWant(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onWillNewWant", ability); + CallJsMethod("onWillNewWant", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityWillCreate(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityWillCreate", ability); + CallJsMethod("onAbilityWillCreate", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageWillCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageWillCreate", ability, windowStage); + CallWindowStageJsMethod("onWindowStageWillCreate", + static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnWindowStageWillDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) +void JsAbilityLifecycleCallback::OnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) { - CallWindowStageJsMethod("onWindowStageWillDestroy", ability, windowStage); + CallWindowStageJsMethod("onWindowStageWillDestroy", + static_cast(ability).ref_, + static_cast(windowStage).ref_); } -void JsAbilityLifecycleCallback::OnAbilityWillDestroy(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityWillDestroy", ability); + CallJsMethod("onAbilityWillDestroy", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityWillForeground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityWillForeground", ability); + CallJsMethod("onAbilityWillForeground", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnAbilityWillBackground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onAbilityWillBackground", ability); + CallJsMethod("onAbilityWillBackground", static_cast(ability).ref_); } bool JsAbilityLifecycleCallback::IsEmpty() const @@ -262,24 +274,24 @@ bool JsAbilityLifecycleCallback::IsEmpty() const return callbacks_.empty() && callbacksSync_.empty(); } -void JsAbilityLifecycleCallback::OnWillForeground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnWillForeground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onWillForeground", ability); + CallJsMethod("onWillForeground", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnDidForeground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnDidForeground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onDidForeground", ability); + CallJsMethod("onDidForeground", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnWillBackground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnWillBackground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onWillBackground", ability); + CallJsMethod("onWillBackground", static_cast(ability).ref_); } -void JsAbilityLifecycleCallback::OnDidBackground(const std::shared_ptr &ability) +void JsAbilityLifecycleCallback::OnDidBackground(const AbilityLifecycleCallbackArgs &ability) { - CallJsMethod("onDidBackground", ability); + CallJsMethod("onDidBackground", static_cast(ability).ref_); } } // namespace AbilityRuntime } // namespace OHOS diff --git a/interfaces/kits/native/appkit/ability_runtime/context/ability_lifecycle_callback.h b/interfaces/kits/native/appkit/ability_runtime/context/ability_lifecycle_callback.h index 5f281fe3621f35c2d840cf562c4bf7df23b77b08..29afd985afcf198065231c6cc8f147d107c7e0b2 100644 --- a/interfaces/kits/native/appkit/ability_runtime/context/ability_lifecycle_callback.h +++ b/interfaces/kits/native/appkit/ability_runtime/context/ability_lifecycle_callback.h @@ -19,120 +19,58 @@ #include #include -class NativeReference; -typedef struct napi_env__* napi_env; -typedef struct napi_value__* napi_value; - namespace OHOS { -namespace AppExecFwk { -struct ETSNativeReference; -} namespace AbilityRuntime { +enum AbilityLifecycleCallbackType { + JS = 0, + ETS, +}; +class AbilityLifecycleCallbackArgs { +public: + AbilityLifecycleCallbackType type_ = AbilityLifecycleCallbackType::JS; + virtual bool IsValid() const = 0; +}; class AbilityLifecycleCallback { public: virtual ~AbilityLifecycleCallback() {} -/*----------------------------------for arkts 1.1 listening UIAbility 1.1--------------------------------------------*/ - virtual void OnAbilityCreate(const std::shared_ptr &ability) {} - virtual void OnWindowStageCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnWindowStageDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnWindowStageActive(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnWindowStageInactive(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnAbilityDestroy(const std::shared_ptr &ability) {} - virtual void OnNewWant(const std::shared_ptr &ability) {} - virtual void OnWillNewWant(const std::shared_ptr &ability) {} - virtual void OnAbilityWillCreate(const std::shared_ptr &ability) {} - virtual void OnWindowStageWillCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnWindowStageWillDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnAbilityWillDestroy(const std::shared_ptr &ability) {} - virtual void OnAbilityWillForeground(const std::shared_ptr &ability) {} - virtual void OnAbilityWillBackground(const std::shared_ptr &ability) {} - virtual void OnAbilityForeground(const std::shared_ptr &ability) {} - virtual void OnAbilityBackground(const std::shared_ptr &ability) {} - virtual void OnAbilityContinue(const std::shared_ptr &ability) {} - virtual void OnAbilityWillContinue(const std::shared_ptr &ability) {} - virtual void OnWindowStageWillRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnWindowStageRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) {} - virtual void OnAbilityWillSaveState(const std::shared_ptr &ability) {} - virtual void OnAbilitySaveState(const std::shared_ptr &ability) {} - virtual void OnWillForeground(const std::shared_ptr &ability) {} - virtual void OnDidForeground(const std::shared_ptr &ability) {} - virtual void OnWillBackground(const std::shared_ptr &ability) {} - virtual void OnDidBackground(const std::shared_ptr &ability) {} + virtual void OnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnWindowStageActive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnWindowStageInactive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnNewWant(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnWillNewWant(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityForeground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityBackground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) {} + virtual void OnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnWillForeground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnDidForeground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnWillBackground(const AbilityLifecycleCallbackArgs &ability) {} + virtual void OnDidBackground(const AbilityLifecycleCallbackArgs &ability) {} -/*----------------------------------for arkts 1.2 listening UIAbility 1.2--------------------------------------------*/ - virtual void OnAbilityCreate(std::shared_ptr ability) {} - virtual void OnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage) {} - virtual void OnWindowStageDestroy(std::shared_ptr ability, - std::shared_ptr windowStage) {} - virtual void OnAbilityDestroy(std::shared_ptr ability) {} - virtual void OnAbilityForeground(std::shared_ptr ability) {} - virtual void OnAbilityBackground(std::shared_ptr ability) {} -}; - -class JsAbilityLifecycleCallback : public AbilityLifecycleCallback, - public std::enable_shared_from_this { public: - explicit JsAbilityLifecycleCallback(napi_env env); - void OnAbilityCreate(const std::shared_ptr &ability) override; - void OnWindowStageCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnWindowStageDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnWindowStageActive(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnWindowStageInactive(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnAbilityWillCreate(const std::shared_ptr &ability) override; - void OnWindowStageWillCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnWindowStageWillDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnAbilityWillDestroy(const std::shared_ptr &ability) override; - void OnAbilityWillForeground(const std::shared_ptr &ability) override; - void OnAbilityWillBackground(const std::shared_ptr &ability) override; - void OnNewWant(const std::shared_ptr &ability) override; - void OnWillNewWant(const std::shared_ptr &ability) override; - void OnAbilityDestroy(const std::shared_ptr &ability) override; - void OnAbilityForeground(const std::shared_ptr &ability) override; - void OnAbilityBackground(const std::shared_ptr &ability) override; - void OnAbilityContinue(const std::shared_ptr &ability) override; - void OnAbilityWillContinue(const std::shared_ptr &ability) override; - void OnWindowStageWillRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnWindowStageRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override; - void OnAbilityWillSaveState(const std::shared_ptr &ability) override; - void OnAbilitySaveState(const std::shared_ptr &ability) override; - int32_t Register(napi_value jsCallback, bool isSync = false); - bool UnRegister(int32_t callbackId, bool isSync = false); - bool IsEmpty() const; - void OnWillForeground(const std::shared_ptr &ability) override; - void OnDidForeground(const std::shared_ptr &ability) override; - void OnWillBackground(const std::shared_ptr &ability) override; - void OnDidBackground(const std::shared_ptr &ability) override; - static int32_t serialNumber_; - -private: - napi_env env_ = nullptr; - std::shared_ptr jsCallback_; - std::map> callbacks_; - std::map> callbacksSync_; - void CallJsMethod(const std::string &methodName, const std::shared_ptr &ability); - void CallWindowStageJsMethod(const std::string &methodName, const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void CallJsMethodInnerCommon(const std::string &methodName, const std::shared_ptr &ability, - const std::shared_ptr &windowStage, - const std::map> callbacks); + AbilityLifecycleCallbackType type_ = AbilityLifecycleCallbackType::JS; }; } // namespace AbilityRuntime } // namespace OHOS diff --git a/interfaces/kits/native/appkit/ability_runtime/context/application_context.h b/interfaces/kits/native/appkit/ability_runtime/context/application_context.h index 4080b633e2d83434e22f9b5ef87dbe1028e55978..d891315bed76f43788a18168de4b83321bfeb0fc 100644 --- a/interfaces/kits/native/appkit/ability_runtime/context/application_context.h +++ b/interfaces/kits/native/appkit/ability_runtime/context/application_context.h @@ -47,56 +47,48 @@ public: void UnregisterEnvironmentCallback(const std::shared_ptr &environmentCallback); void RegisterApplicationStateChangeCallback( const std::weak_ptr &applicationStateChangeCallback); - void DispatchOnAbilityCreate(std::shared_ptr ability); - void DispatchOnAbilityCreate(std::shared_ptr ability); + void DispatchOnAbilityCreate(const AbilityLifecycleCallbackArgs &ability); void DispatchOnAbilityCreate(std::shared_ptr ability); - void DispatchOnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage); - void DispatchOnWindowStageCreate(std::shared_ptr ability, - std::shared_ptr windowStage); + void DispatchOnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); void DispatchOnWindowStageCreate(std::shared_ptr ability, std::shared_ptr windowStage); - void DispatchOnWindowStageDestroy(std::shared_ptr ability, - std::shared_ptr windowStage); - void DispatchOnWindowStageDestroy(std::shared_ptr ability, - std::shared_ptr windowStage); + void DispatchOnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); void DispatchOnWindowStageDestroy(std::shared_ptr ability, std::shared_ptr windowStage); - void DispatchWindowStageFocus(const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void DispatchWindowStageUnfocus(const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void DispatchOnAbilityDestroy(std::shared_ptr ability); - void DispatchOnAbilityDestroy(std::shared_ptr ability); + void DispatchWindowStageFocus(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); + void DispatchWindowStageUnfocus(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); + void DispatchOnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability); void DispatchOnAbilityDestroy(std::shared_ptr ability); - void DispatchOnAbilityForeground(std::shared_ptr ability); - void DispatchOnAbilityForeground(std::shared_ptr ability); + void DispatchOnAbilityForeground(const AbilityLifecycleCallbackArgs &ability); void DispatchOnAbilityForeground(std::shared_ptr ability); - void DispatchOnAbilityBackground(std::shared_ptr ability); - void DispatchOnAbilityBackground(std::shared_ptr ability); + void DispatchOnAbilityBackground(const AbilityLifecycleCallbackArgs &ability); void DispatchOnAbilityBackground(std::shared_ptr ability); - void DispatchOnAbilityContinue(const std::shared_ptr &ability); - void DispatchOnAbilityWillContinue(const std::shared_ptr &ability); - void DispatchOnWindowStageWillRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void DispatchOnWindowStageRestore(const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void DispatchOnAbilityWillSaveState(const std::shared_ptr &ability); - void DispatchOnAbilitySaveState(const std::shared_ptr &ability); + void DispatchOnAbilityContinue(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); + void DispatchOnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); + void DispatchOnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability); void DispatchConfigurationUpdated(const AppExecFwk::Configuration &config); void DispatchMemoryLevel(const int level); void NotifyApplicationForeground(); void NotifyApplicationBackground(); - void DispatchOnWillNewWant(const std::shared_ptr &ability); - void DispatchOnNewWant(const std::shared_ptr &ability); - void DispatchOnAbilityWillCreate(const std::shared_ptr &ability); - void DispatchOnWindowStageWillCreate(const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void DispatchOnWindowStageWillDestroy(const std::shared_ptr &ability, - const std::shared_ptr &windowStage); - void DispatchOnAbilityWillDestroy(const std::shared_ptr &ability); - void DispatchOnAbilityWillForeground(const std::shared_ptr &ability); - void DispatchOnAbilityWillBackground(const std::shared_ptr &ability); + void DispatchOnWillNewWant(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnNewWant(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); + void DispatchOnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage); + void DispatchOnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability); + void DispatchOnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability); std::string GetBundleName() const override; std::shared_ptr CreateBundleContext(const std::string &bundleName) override; diff --git a/interfaces/kits/native/appkit/ability_runtime/context/js_ability_lifecycle_callback.h b/interfaces/kits/native/appkit/ability_runtime/context/js_ability_lifecycle_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..39a104b87af6412416495aa6704572fe16f700d3 --- /dev/null +++ b/interfaces/kits/native/appkit/ability_runtime/context/js_ability_lifecycle_callback.h @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2025 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_CONTEXT_JS_ABILITY_LIFECYCLE_CALLBACK_H +#define OHOS_ABILITY_RUNTIME_CONTEXT_JS_ABILITY_LIFECYCLE_CALLBACK_H + +#include +#include + +#include "ability_lifecycle_callback.h" + +class NativeReference; +typedef struct napi_env__* napi_env; +typedef struct napi_value__* napi_value; + +namespace OHOS { +namespace AbilityRuntime { +class JsAbilityLifecycleCallbackArgs : public AbilityLifecycleCallbackArgs { +public: + explicit JsAbilityLifecycleCallbackArgs(std::shared_ptr ref) : ref_(ref) + { + type_ = AbilityLifecycleCallbackType::JS; + } + bool IsValid() const override { return ref_ != nullptr; } + std::shared_ptr ref_; +}; + +class JsAbilityLifecycleCallback : public AbilityLifecycleCallback, + public std::enable_shared_from_this { +public: + explicit JsAbilityLifecycleCallback(napi_env env); + void OnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageActive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageInactive(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityWillCreate(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageWillCreate(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageWillDestroy(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityWillDestroy(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityWillForeground(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityWillBackground(const AbilityLifecycleCallbackArgs &ability) override; + void OnNewWant(const AbilityLifecycleCallbackArgs &ability) override; + void OnWillNewWant(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityForeground(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityBackground(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilityWillContinue(const AbilityLifecycleCallbackArgs &ability) override; + void OnWindowStageWillRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnWindowStageRestore(const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override; + void OnAbilityWillSaveState(const AbilityLifecycleCallbackArgs &ability) override; + void OnAbilitySaveState(const AbilityLifecycleCallbackArgs &ability) override; + int32_t Register(napi_value jsCallback, bool isSync = false); + bool UnRegister(int32_t callbackId, bool isSync = false); + bool IsEmpty() const; + void OnWillForeground(const AbilityLifecycleCallbackArgs &ability) override; + void OnDidForeground(const AbilityLifecycleCallbackArgs &ability) override; + void OnWillBackground(const AbilityLifecycleCallbackArgs &ability) override; + void OnDidBackground(const AbilityLifecycleCallbackArgs &ability) override; + static int32_t serialNumber_; + +private: + napi_env env_ = nullptr; + std::shared_ptr jsCallback_; + std::map> callbacks_; + std::map> callbacksSync_; + void CallJsMethod(const std::string &methodName, const std::shared_ptr &ability); + void CallWindowStageJsMethod(const std::string &methodName, const std::shared_ptr &ability, + const std::shared_ptr &windowStage); + void CallJsMethodInnerCommon(const std::string &methodName, const std::shared_ptr &ability, + const std::shared_ptr &windowStage, + const std::map> callbacks); +}; +} // namespace AbilityRuntime +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_CONTEXT_JS_ABILITY_LIFECYCLE_CALLBACK_H \ No newline at end of file diff --git a/interfaces/kits/native/appkit/ability_runtime/context/js_application_context_utils.h b/interfaces/kits/native/appkit/ability_runtime/context/js_application_context_utils.h index 51bb24310b90397586787eb411836e1db43de0ee..e7903a2f976b2b3c6a23390aceebdfe796b674d3 100644 --- a/interfaces/kits/native/appkit/ability_runtime/context/js_application_context_utils.h +++ b/interfaces/kits/native/appkit/ability_runtime/context/js_application_context_utils.h @@ -19,10 +19,10 @@ #include #include -#include "ability_lifecycle_callback.h" #include "application_context.h" #include "application_state_change_callback.h" #include "js_ability_auto_startup_callback.h" +#include "js_ability_lifecycle_callback.h" #include "js_interop_ability_lifecycle_callback.h" #include "native_engine/native_engine.h" #include "running_process_info.h" diff --git a/test/fuzztest/registerabilitylifecyclecallback_fuzzer/registerabilitylifecyclecallback_fuzzer.cpp b/test/fuzztest/registerabilitylifecyclecallback_fuzzer/registerabilitylifecyclecallback_fuzzer.cpp index 0f5ca16bd6165c7e29edf9e28eafe25bd4dd4a78..d74e0d745642571479c91a24b40ceb5899397c7d 100644 --- a/test/fuzztest/registerabilitylifecyclecallback_fuzzer/registerabilitylifecyclecallback_fuzzer.cpp +++ b/test/fuzztest/registerabilitylifecyclecallback_fuzzer/registerabilitylifecyclecallback_fuzzer.cpp @@ -35,27 +35,27 @@ public: explicit AbilityLifecycleCallbackFuzz(){}; virtual ~AbilityLifecycleCallbackFuzz(){}; void - OnAbilityCreate(const std::shared_ptr &ability) override{}; + OnAbilityCreate(const AbilityLifecycleCallbackArgs &ability) override{}; void OnWindowStageCreate( - const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override{}; + const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override{}; void OnWindowStageDestroy( - const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override{}; + const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override{}; void OnWindowStageActive( - const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override{}; + const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override{}; void OnWindowStageInactive( - const std::shared_ptr &ability, - const std::shared_ptr &windowStage) override{}; + const AbilityLifecycleCallbackArgs &ability, + const AbilityLifecycleCallbackArgs &windowStage) override{}; void - OnAbilityDestroy(const std::shared_ptr &ability) override{}; + OnAbilityDestroy(const AbilityLifecycleCallbackArgs &ability) override{}; void OnAbilityForeground( - const std::shared_ptr &ability) override{}; + const AbilityLifecycleCallbackArgs &ability) override{}; void OnAbilityBackground( - const std::shared_ptr &ability) override{}; + const AbilityLifecycleCallbackArgs &ability) override{}; void - OnAbilityContinue(const std::shared_ptr &ability) override{}; + OnAbilityContinue(const AbilityLifecycleCallbackArgs &ability) override{}; }; bool DoSomethingInterestingWithMyAPI(const char *data, size_t size) { diff --git a/test/fuzztest/unregisterabilitylifecyclecallback_fuzzer/unregisterabilitylifecyclecallback_fuzzer.cpp b/test/fuzztest/unregisterabilitylifecyclecallback_fuzzer/unregisterabilitylifecyclecallback_fuzzer.cpp index fb5285c92104f86eb913970209e21cfd90edc64f..f49b5eb7ed13e729c732ca9d556ab4941910f786 100644 --- a/test/fuzztest/unregisterabilitylifecyclecallback_fuzzer/unregisterabilitylifecyclecallback_fuzzer.cpp +++ b/test/fuzztest/unregisterabilitylifecyclecallback_fuzzer/unregisterabilitylifecyclecallback_fuzzer.cpp @@ -34,19 +34,19 @@ class AbilityLifecycleCallbackFuzz : public AbilityLifecycleCallback { public: explicit AbilityLifecycleCallbackFuzz() {}; virtual ~AbilityLifecycleCallbackFuzz() {}; - void OnAbilityCreate(const std::shared_ptr& ability) override {}; - void OnWindowStageCreate(const std::shared_ptr& ability, - const std::shared_ptr& windowStage) override {}; - void OnWindowStageDestroy(const std::shared_ptr& ability, - const std::shared_ptr& windowStage) override {}; - void OnWindowStageActive(const std::shared_ptr& ability, - const std::shared_ptr& windowStage) override {}; - void OnWindowStageInactive(const std::shared_ptr& ability, - const std::shared_ptr& windowStage) override {}; - void OnAbilityDestroy(const std::shared_ptr& ability) override {}; - void OnAbilityForeground(const std::shared_ptr& ability) override {}; - void OnAbilityBackground(const std::shared_ptr& ability) override {}; - void OnAbilityContinue(const std::shared_ptr& ability) override {}; + void OnAbilityCreate(const AbilityLifecycleCallbackArgs& ability) override {}; + void OnWindowStageCreate(const AbilityLifecycleCallbackArgs& ability, + const AbilityLifecycleCallbackArgs& windowStage) override {}; + void OnWindowStageDestroy(const AbilityLifecycleCallbackArgs& ability, + const AbilityLifecycleCallbackArgs& windowStage) override {}; + void OnWindowStageActive(const AbilityLifecycleCallbackArgs& ability, + const AbilityLifecycleCallbackArgs& windowStage) override {}; + void OnWindowStageInactive(const AbilityLifecycleCallbackArgs& ability, + const AbilityLifecycleCallbackArgs& windowStage) override {}; + void OnAbilityDestroy(const AbilityLifecycleCallbackArgs& ability) override {}; + void OnAbilityForeground(const AbilityLifecycleCallbackArgs& ability) override {}; + void OnAbilityBackground(const AbilityLifecycleCallbackArgs& ability) override {}; + void OnAbilityContinue(const AbilityLifecycleCallbackArgs& ability) override {}; }; bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) { diff --git a/test/unittest/application_context_test/application_context_test.cpp b/test/unittest/application_context_test/application_context_test.cpp index cbd66252a0da5ec0ba75a68e0d81d994d7ba2e94..679f483a65808156e35aeebc562275a2dc8283ec 100644 --- a/test/unittest/application_context_test/application_context_test.cpp +++ b/test/unittest/application_context_test/application_context_test.cpp @@ -17,6 +17,7 @@ #define private public #include "application_context.h" #undef private +#include "js_ability_lifecycle_callback.h" #include "mock_ability_token.h" #include "mock_application_state_change_callback.h" #include "mock_context_impl.h" @@ -838,7 +839,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityCreate_0100, TestSize.Level1) GTEST_LOG_(INFO) << "DispatchOnAbilityCreate_0100 start"; EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityCreate(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityCreate(abilityArg); GTEST_LOG_(INFO) << "DispatchOnAbilityCreate_0100 end"; } @@ -853,7 +855,9 @@ HWTEST_F(ApplicationContextTest, DispatchOnWindowStageCreate_0100, TestSize.Leve EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; std::shared_ptr windowStage = nullptr; - context_->DispatchOnWindowStageCreate(ability, windowStage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs windowStageArg(windowStage); + context_->DispatchOnWindowStageCreate(abilityArg, windowStageArg); GTEST_LOG_(INFO) << "DispatchOnWindowStageCreate_0100 end"; } @@ -868,7 +872,9 @@ HWTEST_F(ApplicationContextTest, DispatchOnWindowStageDestroy_0100, TestSize.Lev EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; std::shared_ptr windowStage = nullptr; - context_->DispatchOnWindowStageDestroy(ability, windowStage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs windowStageArg(windowStage); + context_->DispatchOnWindowStageDestroy(abilityArg, windowStageArg); GTEST_LOG_(INFO) << "DispatchOnWindowStageDestroy_0100 end"; } @@ -883,7 +889,9 @@ HWTEST_F(ApplicationContextTest, DispatchWindowStageFocus_0100, TestSize.Level1) EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; std::shared_ptr windowStage = nullptr; - context_->DispatchWindowStageFocus(ability, windowStage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs windowStageArg(windowStage); + context_->DispatchWindowStageFocus(abilityArg, windowStageArg); GTEST_LOG_(INFO) << "DispatchWindowStageFocus_0100 end"; } @@ -898,7 +906,9 @@ HWTEST_F(ApplicationContextTest, DispatchWindowStageUnfocus_0100, TestSize.Level EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; std::shared_ptr windowStage = nullptr; - context_->DispatchWindowStageUnfocus(ability, windowStage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs windowStageArg(windowStage); + context_->DispatchWindowStageUnfocus(abilityArg, windowStageArg); GTEST_LOG_(INFO) << "DispatchWindowStageUnfocus_0100 end"; } @@ -912,7 +922,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityDestroy_0100, TestSize.Level1) GTEST_LOG_(INFO) << "DispatchOnAbilityDestroy_0100 start"; EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityDestroy(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityDestroy(abilityArg); GTEST_LOG_(INFO) << "DispatchOnAbilityDestroy_0100 end"; } @@ -926,7 +937,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityForeground_0100, TestSize.Leve GTEST_LOG_(INFO) << "DispatchOnAbilityForeground_0100 start"; EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityForeground(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityForeground(abilityArg); GTEST_LOG_(INFO) << "DispatchOnAbilityForeground_0100 end"; } @@ -940,7 +952,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityBackground_0100, TestSize.Leve GTEST_LOG_(INFO) << "DispatchOnAbilityBackground_0100 start"; EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityBackground(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityBackground(abilityArg); GTEST_LOG_(INFO) << "DispatchOnAbilityBackground_0100 end"; } @@ -954,7 +967,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityContinue_0100, TestSize.Level1 GTEST_LOG_(INFO) << "DispatchOnAbilityContinue_0100 start"; EXPECT_NE(context_, nullptr); std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityContinue(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityContinue(abilityArg); GTEST_LOG_(INFO) << "DispatchOnAbilityContinue_0100 end"; } @@ -1327,7 +1341,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityWillContinue_0100, TestSize.Le { GTEST_LOG_(INFO) << "DispatchOnAbilityWillContinue_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityWillContinue(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityWillContinue(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilityWillContinue_0100 end"; } @@ -1342,7 +1357,9 @@ HWTEST_F(ApplicationContextTest, DispatchOnWindowStageWillRestore_0100, TestSize GTEST_LOG_(INFO) << "DispatchOnWindowStageWillRestore_0100 start"; std::shared_ptr ability = nullptr; std::shared_ptr winstage = nullptr; - context_->DispatchOnWindowStageWillRestore(ability, winstage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs winstageArg(winstage); + context_->DispatchOnWindowStageWillRestore(abilityArg, winstageArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnWindowStageWillRestore_0100 end"; } @@ -1357,7 +1374,9 @@ HWTEST_F(ApplicationContextTest, DispatchOnWindowStageRestore_0100, TestSize.Lev GTEST_LOG_(INFO) << "DispatchOnWindowStageRestore_0100 start"; std::shared_ptr ability = nullptr; std::shared_ptr winstage = nullptr; - context_->DispatchOnWindowStageRestore(ability, winstage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs winstageArg(winstage); + context_->DispatchOnWindowStageRestore(abilityArg, winstageArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnWindowStageRestore_0100 end"; } @@ -1371,7 +1390,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityWillSaveState_0100, TestSize.L { GTEST_LOG_(INFO) << "DispatchOnAbilityWillSaveState_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityWillSaveState(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityWillSaveState(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilityWillSaveState_0100 end"; } @@ -1385,7 +1405,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilitySaveState_0100, TestSize.Level { GTEST_LOG_(INFO) << "DispatchOnAbilitySaveState_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilitySaveState(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilitySaveState(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilitySaveState_0100 end"; } @@ -1399,7 +1420,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnWillNewWant_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "DispatchOnWillNewWant_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnWillNewWant(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnWillNewWant(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnWillNewWant_0100 end"; } @@ -1413,7 +1435,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnNewWant_0100, TestSize.Level1) { GTEST_LOG_(INFO) << "DispatchOnNewWant_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnNewWant(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnNewWant(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnNewWant_0100 end"; } @@ -1427,7 +1450,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityWillCreate_0100, TestSize.Leve { GTEST_LOG_(INFO) << "DispatchOnAbilityWillCreate_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityWillCreate(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityWillCreate(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilityWillCreate_0100 end"; } @@ -1442,7 +1466,9 @@ HWTEST_F(ApplicationContextTest, DispatchOnWindowStageWillCreate_0100, TestSize. GTEST_LOG_(INFO) << "DispatchOnWindowStageWillCreate_0100 start"; std::shared_ptr ability = nullptr; std::shared_ptr winstage = nullptr; - context_->DispatchOnWindowStageWillCreate(ability, winstage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs winstageArg(winstage); + context_->DispatchOnWindowStageWillCreate(abilityArg, winstageArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnWindowStageWillCreate_0100 end"; } @@ -1457,7 +1483,9 @@ HWTEST_F(ApplicationContextTest, DispatchOnWindowStageWillDestroy_0100, TestSize GTEST_LOG_(INFO) << "DispatchOnWindowStageWillDestroy_0100 start"; std::shared_ptr ability = nullptr; std::shared_ptr winstage = nullptr; - context_->DispatchOnWindowStageWillDestroy(ability, winstage); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + JsAbilityLifecycleCallbackArgs winstageArg(winstage); + context_->DispatchOnWindowStageWillDestroy(abilityArg, winstageArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnWindowStageWillDestroy_0100 end"; } @@ -1471,7 +1499,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityWillDestroy_0100, TestSize.Lev { GTEST_LOG_(INFO) << "DispatchOnAbilityWillDestroy_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityWillDestroy(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityWillDestroy(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilityWillDestroy_0100 end"; } @@ -1485,7 +1514,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityWillForeground_0100, TestSize. { GTEST_LOG_(INFO) << "DispatchOnAbilityWillForeground_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityWillForeground(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityWillForeground(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilityWillForeground_0100 end"; } @@ -1499,7 +1529,8 @@ HWTEST_F(ApplicationContextTest, DispatchOnAbilityWillBackground_0100, TestSize. { GTEST_LOG_(INFO) << "DispatchOnAbilityWillBackground_0100 start"; std::shared_ptr ability = nullptr; - context_->DispatchOnAbilityWillBackground(ability); + JsAbilityLifecycleCallbackArgs abilityArg(ability); + context_->DispatchOnAbilityWillBackground(abilityArg); EXPECT_TRUE(context_ != nullptr); GTEST_LOG_(INFO) << "DispatchOnAbilityWillBackground_0100 end"; }