1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "js_ui_ability.h"
17
18 #include <cstdlib>
19 #include <regex>
20
21 #include "ability_business_error.h"
22 #include "ability_delegator_registry.h"
23 #include "ability_manager_client.h"
24 #include "ability_recovery.h"
25 #include "ability_start_setting.h"
26 #include "app_recovery.h"
27 #include "connection_manager.h"
28 #include "context/application_context.h"
29 #include "context/context.h"
30 #include "display_util.h"
31 #include "hilog_tag_wrapper.h"
32 #include "hitrace_meter.h"
33 #include "if_system_ability_manager.h"
34 #include "insight_intent_executor_info.h"
35 #include "insight_intent_executor_mgr.h"
36 #include "insight_intent_execute_param.h"
37 #include "js_ability_context.h"
38 #include "js_data_struct_converter.h"
39 #include "js_runtime.h"
40 #include "js_runtime_utils.h"
41 #include "js_utils.h"
42 #ifdef SUPPORT_SCREEN
43 #include "distributed_client.h"
44 #include "js_window_stage.h"
45 #include "scene_board_judgement.h"
46 #endif
47 #include "napi_common_configuration.h"
48 #include "napi_common_want.h"
49 #include "napi_remote_object.h"
50 #include "string_wrapper.h"
51 #include "system_ability_definition.h"
52 #include "time_util.h"
53
54 namespace OHOS {
55 namespace AbilityRuntime {
56 namespace {
57 #ifdef SUPPORT_GRAPHICS
58 const std::string PAGE_STACK_PROPERTY_NAME = "pageStack";
59 const std::string SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME = "ohos.extra.param.key.supportContinuePageStack";
60 const std::string METHOD_NAME = "WindowScene::GoForeground";
61 #endif
62 // Numerical base (radix) that determines the valid characters and their interpretation.
63 #ifdef SUPPORT_SCREEN
64 const int32_t BASE_DISPLAY_ID_NUM (10);
65 constexpr const char* IS_CALLING_FROM_DMS = "supportCollaborativeCallingFromDmsInAAFwk";
66 constexpr const char* SUPPORT_COLLABORATE_INDEX = "ohos.extra.param.key.supportCollaborateIndex";
67 constexpr const char* COLLABORATE_KEY = "ohos.dms.collabToken";
68 enum CollaborateResult {
69 ACCEPT = 0,
70 REJECT,
71 };
72 #endif
73 constexpr const int32_t API12 = 12;
74 constexpr const int32_t API_VERSION_MOD = 100;
75 constexpr const int32_t PROMISE_CALLBACK_PARAM_NUM = 2;
76
PromiseCallback(napi_env env,napi_callback_info info)77 napi_value PromiseCallback(napi_env env, napi_callback_info info)
78 {
79 void *data = nullptr;
80 NAPI_CALL_NO_THROW(napi_get_cb_info(env, info, nullptr, nullptr, nullptr, &data), nullptr);
81 auto *callbackInfo = static_cast<AppExecFwk::AbilityTransactionCallbackInfo<> *>(data);
82 callbackInfo->Call();
83 AppExecFwk::AbilityTransactionCallbackInfo<>::Destroy(callbackInfo);
84 data = nullptr;
85 return nullptr;
86 }
87
OnContinuePromiseCallback(napi_env env,napi_callback_info info)88 napi_value OnContinuePromiseCallback(napi_env env, napi_callback_info info)
89 {
90 void *data = nullptr;
91 size_t argc = 1;
92 napi_value argv = {nullptr};
93 NAPI_CALL_NO_THROW(napi_get_cb_info(env, info, &argc, &argv, nullptr, &data), nullptr);
94 int32_t onContinueRes = 0;
95 if (!ConvertFromJsValue(env, argv, onContinueRes)) {
96 TAG_LOGE(AAFwkTag::UIABILITY, "get value failed");
97 onContinueRes = AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
98 }
99 auto *callbackInfo = static_cast<AppExecFwk::AbilityTransactionCallbackInfo<int32_t> *>(data);
100 callbackInfo->Call(onContinueRes);
101 data = nullptr;
102
103 return nullptr;
104 }
105
OnPrepareTerminatePromiseCallback(napi_env env,napi_callback_info info)106 napi_value OnPrepareTerminatePromiseCallback(napi_env env, napi_callback_info info)
107 {
108 TAG_LOGI(AAFwkTag::UIABILITY, "OnPrepareTerminatePromiseCallback begin");
109 void *data = nullptr;
110 size_t argc = ARGC_MAX_COUNT;
111 napi_value argv[ARGC_MAX_COUNT] = {nullptr};
112 NAPI_CALL_NO_THROW(napi_get_cb_info(env, info, &argc, argv, nullptr, &data), nullptr);
113 auto *callbackInfo = static_cast<AppExecFwk::AbilityTransactionCallbackInfo<bool> *>(data);
114 bool prepareTermination = false;
115 if (callbackInfo == nullptr || (argc > 0 && !ConvertFromJsValue(env, argv[0], prepareTermination))) {
116 TAG_LOGE(AAFwkTag::UIABILITY, "null callbackInfo or unwrap prepareTermination result failed");
117 return nullptr;
118 }
119 callbackInfo->Call(prepareTermination);
120 AppExecFwk::AbilityTransactionCallbackInfo<bool>::Destroy(callbackInfo);
121 data = nullptr;
122 TAG_LOGI(AAFwkTag::UIABILITY, "OnPrepareTerminatePromiseCallback end");
123 return nullptr;
124 }
125 } // namespace
126
AttachJsAbilityContext(napi_env env,void * value,void * extValue)127 napi_value AttachJsAbilityContext(napi_env env, void *value, void *extValue)
128 {
129 TAG_LOGD(AAFwkTag::UIABILITY, "called");
130 if (value == nullptr || extValue == nullptr) {
131 TAG_LOGE(AAFwkTag::UIABILITY, "invalid params");
132 return nullptr;
133 }
134 auto ptr = reinterpret_cast<std::weak_ptr<AbilityRuntime::AbilityContext> *>(value)->lock();
135 if (ptr == nullptr) {
136 TAG_LOGE(AAFwkTag::UIABILITY, "null ptr");
137 return nullptr;
138 }
139 std::shared_ptr<NativeReference> systemModule = nullptr;
140 auto screenModePtr = reinterpret_cast<std::weak_ptr<int32_t> *>(extValue)->lock();
141 if (screenModePtr == nullptr) {
142 TAG_LOGE(AAFwkTag::UIABILITY, "null screenModePtr");
143 return nullptr;
144 }
145 if (*screenModePtr == AAFwk::IDLE_SCREEN_MODE) {
146 auto uiAbiObject = CreateJsAbilityContext(env, ptr);
147 CHECK_POINTER_AND_RETURN(uiAbiObject, nullptr);
148 systemModule = std::shared_ptr<NativeReference>(JsRuntime::LoadSystemModuleByEngine(env,
149 "application.AbilityContext", &uiAbiObject, 1).release());
150 } else {
151 auto emUIObject = JsEmbeddableUIAbilityContext::CreateJsEmbeddableUIAbilityContext(env,
152 ptr, nullptr, *screenModePtr);
153 CHECK_POINTER_AND_RETURN(emUIObject, nullptr);
154 systemModule = std::shared_ptr<NativeReference>(JsRuntime::LoadSystemModuleByEngine(env,
155 "application.EmbeddableUIAbilityContext", &emUIObject, 1).release());
156 }
157 CHECK_POINTER_AND_RETURN(systemModule, nullptr);
158 auto contextObj = systemModule->GetNapiValue();
159 napi_coerce_to_native_binding_object(env, contextObj, DetachCallbackFunc, AttachJsAbilityContext, value, extValue);
160 auto workContext = new (std::nothrow) std::weak_ptr<AbilityRuntime::AbilityContext>(ptr);
161 if (workContext != nullptr) {
162 napi_status status = napi_wrap(env, contextObj, workContext,
163 [](napi_env, void* data, void*) {
164 TAG_LOGD(AAFwkTag::UIABILITY, "finalizer for weak_ptr ability context is called");
165 delete static_cast<std::weak_ptr<AbilityRuntime::AbilityContext> *>(data);
166 },
167 nullptr, nullptr);
168 if (status != napi_ok && workContext != nullptr) {
169 TAG_LOGE(AAFwkTag::UIABILITY, "napi_wrap Failed: %{public}d", status);
170 delete workContext;
171 return nullptr;
172 }
173 }
174 return contextObj;
175 }
176
Create(const std::unique_ptr<Runtime> & runtime)177 UIAbility *JsUIAbility::Create(const std::unique_ptr<Runtime> &runtime)
178 {
179 return new (std::nothrow) JsUIAbility(static_cast<JsRuntime &>(*runtime));
180 }
181
JsUIAbility(JsRuntime & jsRuntime)182 JsUIAbility::JsUIAbility(JsRuntime &jsRuntime) : jsRuntime_(jsRuntime)
183 {
184 TAG_LOGD(AAFwkTag::UIABILITY, "called");
185 }
186
~JsUIAbility()187 JsUIAbility::~JsUIAbility()
188 {
189 // maintenance log
190 TAG_LOGI(AAFwkTag::UIABILITY, "called");
191 if (abilityContext_ != nullptr) {
192 abilityContext_->Unbind();
193 }
194
195 jsRuntime_.FreeNativeReference(std::move(jsAbilityObj_));
196 jsRuntime_.FreeNativeReference(std::move(shellContextRef_));
197 #ifdef SUPPORT_SCREEN
198 jsRuntime_.FreeNativeReference(std::move(jsWindowStageObj_));
199 #endif
200 }
201
Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,const std::shared_ptr<OHOSApplication> application,std::shared_ptr<AbilityHandler> & handler,const sptr<IRemoteObject> & token)202 void JsUIAbility::Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,
203 const std::shared_ptr<OHOSApplication> application, std::shared_ptr<AbilityHandler> &handler,
204 const sptr<IRemoteObject> &token)
205 {
206 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
207 if (record == nullptr) {
208 TAG_LOGE(AAFwkTag::UIABILITY, "null localAbilityRecord");
209 return;
210 }
211 auto abilityInfo = record->GetAbilityInfo();
212 if (abilityInfo == nullptr) {
213 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo");
214 return;
215 }
216 UIAbility::Init(record, application, handler, token);
217 #ifdef SUPPORT_GRAPHICS
218 if (abilityContext_ != nullptr) {
219 AppExecFwk::AppRecovery::GetInstance().AddAbility(
220 shared_from_this(), abilityContext_->GetAbilityInfo(), abilityContext_->GetToken());
221 }
222 #endif
223 std::string srcPath(abilityInfo->package);
224 if (!abilityInfo->isModuleJson) {
225 /* temporary compatibility api8 + config.json */
226 srcPath.append("/assets/js/");
227 if (!abilityInfo->srcPath.empty()) {
228 srcPath.append(abilityInfo->srcPath);
229 }
230 srcPath.append("/").append(abilityInfo->name).append(".abc");
231 } else {
232 if (abilityInfo->srcEntrance.empty()) {
233 TAG_LOGE(AAFwkTag::UIABILITY, "empty srcEntrance");
234 return;
235 }
236 srcPath.append("/");
237 srcPath.append(abilityInfo->srcEntrance);
238 srcPath.erase(srcPath.rfind("."));
239 srcPath.append(".abc");
240 TAG_LOGD(AAFwkTag::UIABILITY, "jsAbility srcPath: %{public}s", srcPath.c_str());
241 }
242
243 std::string moduleName(abilityInfo->moduleName);
244 moduleName.append("::").append(abilityInfo->name);
245
246 SetAbilityContext(abilityInfo, record->GetWant(), moduleName, srcPath);
247 }
248
UpdateAbilityObj(std::shared_ptr<AbilityInfo> abilityInfo,const std::string & moduleName,const std::string & srcPath)249 void JsUIAbility::UpdateAbilityObj(std::shared_ptr<AbilityInfo> abilityInfo,
250 const std::string &moduleName, const std::string &srcPath)
251 {
252 std::string key = moduleName + "::" + srcPath;
253 std::unique_ptr<NativeReference> moduleObj = nullptr;
254 jsAbilityObj_ = jsRuntime_.PopPreloadObj(key, moduleObj) ? std::move(moduleObj) : jsRuntime_.LoadModule(
255 moduleName, srcPath, abilityInfo->hapPath, abilityInfo->compileMode == AppExecFwk::CompileMode::ES_MODULE,
256 false, abilityInfo->srcEntrance);
257 }
258
SetAbilityContext(std::shared_ptr<AbilityInfo> abilityInfo,std::shared_ptr<AAFwk::Want> want,const std::string & moduleName,const std::string & srcPath)259 void JsUIAbility::SetAbilityContext(std::shared_ptr<AbilityInfo> abilityInfo,
260 std::shared_ptr<AAFwk::Want> want, const std::string &moduleName, const std::string &srcPath)
261 {
262 TAG_LOGI(AAFwkTag::UIABILITY, "called");
263 HandleScope handleScope(jsRuntime_);
264 auto env = jsRuntime_.GetNapiEnv();
265 UpdateAbilityObj(abilityInfo, moduleName, srcPath);
266 if (jsAbilityObj_ == nullptr || abilityContext_ == nullptr || want == nullptr) {
267 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_ or abilityContext_ or want");
268 return;
269 }
270 napi_value obj = jsAbilityObj_->GetNapiValue();
271 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
272 TAG_LOGE(AAFwkTag::UIABILITY, "check type failed");
273 return;
274 }
275 napi_value contextObj = nullptr;
276 int32_t screenMode = want->GetIntParam(AAFwk::SCREEN_MODE_KEY, AAFwk::ScreenMode::IDLE_SCREEN_MODE);
277 CreateJSContext(env, contextObj, screenMode);
278 CHECK_POINTER(shellContextRef_);
279 contextObj = shellContextRef_->GetNapiValue();
280 if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
281 TAG_LOGE(AAFwkTag::UIABILITY, "get ability native object failed");
282 return;
283 }
284 auto workContext = new (std::nothrow) std::weak_ptr<AbilityRuntime::AbilityContext>(abilityContext_);
285 CHECK_POINTER(workContext);
286 screenModePtr_ = std::make_shared<int32_t>(screenMode);
287 auto workScreenMode = new (std::nothrow) std::weak_ptr<int32_t>(screenModePtr_);
288 if (workScreenMode == nullptr) {
289 TAG_LOGE(AAFwkTag::UIABILITY, "null workScreenMode");
290 delete workContext;
291 return;
292 }
293 napi_coerce_to_native_binding_object(
294 env, contextObj, DetachCallbackFunc, AttachJsAbilityContext, workContext, workScreenMode);
295 abilityContext_->Bind(jsRuntime_, shellContextRef_.get());
296 napi_set_named_property(env, obj, "context", contextObj);
297 TAG_LOGD(AAFwkTag::UIABILITY, "set ability context");
298 if (abilityRecovery_ != nullptr) {
299 abilityRecovery_->SetJsAbility(reinterpret_cast<uintptr_t>(workContext));
300 }
301 napi_status status = napi_wrap(env, contextObj, workContext,
302 [](napi_env, void *data, void *hint) {
303 TAG_LOGD(AAFwkTag::UIABILITY, "finalizer for weak_ptr ability context is called");
304 delete static_cast<std::weak_ptr<AbilityRuntime::AbilityContext> *>(data);
305 delete static_cast<std::weak_ptr<int32_t> *>(hint);
306 }, workScreenMode, nullptr);
307 if (status != napi_ok && workContext != nullptr) {
308 TAG_LOGE(AAFwkTag::UIABILITY, "napi_wrap Failed: %{public}d", status);
309 delete workContext;
310 delete workScreenMode;
311 return;
312 }
313
314 TAG_LOGI(AAFwkTag::UIABILITY, "End");
315 }
316
CreateJSContext(napi_env env,napi_value & contextObj,int32_t screenMode)317 void JsUIAbility::CreateJSContext(napi_env env, napi_value &contextObj, int32_t screenMode)
318 {
319 if (screenMode == AAFwk::IDLE_SCREEN_MODE) {
320 contextObj = CreateJsAbilityContext(env, abilityContext_);
321 CHECK_POINTER(contextObj);
322 shellContextRef_ = std::shared_ptr<NativeReference>(JsRuntime::LoadSystemModuleByEngine(
323 env, "application.AbilityContext", &contextObj, 1).release());
324 } else {
325 contextObj = JsEmbeddableUIAbilityContext::CreateJsEmbeddableUIAbilityContext(env,
326 abilityContext_, nullptr, screenMode);
327 CHECK_POINTER(contextObj);
328 shellContextRef_ = std::shared_ptr<NativeReference>(JsRuntime::LoadSystemModuleByEngine(
329 env, "application.EmbeddableUIAbilityContext", &contextObj, 1).release());
330 }
331 }
332
OnStart(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)333 void JsUIAbility::OnStart(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
334 {
335 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
336 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
337 UIAbility::OnStart(want, sessionInfo);
338
339 if (!jsAbilityObj_) {
340 TAG_LOGE(AAFwkTag::UIABILITY, "not found Ability.js");
341 return;
342 }
343
344 HandleScope handleScope(jsRuntime_);
345 auto env = jsRuntime_.GetNapiEnv();
346
347 napi_value obj = jsAbilityObj_->GetNapiValue();
348 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
349 TAG_LOGE(AAFwkTag::UIABILITY, "get ability object failed");
350 return;
351 }
352
353 napi_value jsWant = OHOS::AppExecFwk::WrapWant(env, want);
354 if (jsWant == nullptr) {
355 TAG_LOGE(AAFwkTag::UIABILITY, "null jsWant");
356 return;
357 }
358
359 napi_set_named_property(env, obj, "launchWant", jsWant);
360 napi_set_named_property(env, obj, "lastRequestWant", jsWant);
361 auto launchParam = GetLaunchParam();
362 if (InsightIntentExecuteParam::IsInsightIntentExecute(want)) {
363 launchParam.launchReason = AAFwk::LaunchReason::LAUNCHREASON_INSIGHT_INTENT;
364 }
365 napi_value argv[] = {
366 jsWant,
367 CreateJsLaunchParam(env, launchParam),
368 };
369 std::string methodName = "OnStart";
370
371 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
372 if (applicationContext != nullptr) {
373 applicationContext->DispatchOnAbilityWillCreate(jsAbilityObj_);
374 }
375
376 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
377 CallObjectMethod("onCreate", argv, ArraySize(argv));
378 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
379
380 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
381 if (delegator) {
382 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformStart");
383 delegator->PostPerformStart(CreateADelegatorAbilityProperty());
384 }
385
386 applicationContext = AbilityRuntime::Context::GetApplicationContext();
387 if (applicationContext != nullptr) {
388 applicationContext->DispatchOnAbilityCreate(jsAbilityObj_);
389 }
390 TAG_LOGD(AAFwkTag::UIABILITY, "end");
391 }
392
AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState state,const std::string & methodName) const393 void JsUIAbility::AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState state, const std::string &methodName) const
394 {
395 auto entry = std::string("JsUIAbility::") + methodName + " begin";
396 FreezeUtil::GetInstance().AddLifecycleEvent(AbilityContext::token_, entry);
397 }
398
AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState state,const std::string & methodName) const399 void JsUIAbility::AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState state, const std::string &methodName) const
400 {
401 auto entry = std::string("JsUIAbility::") + methodName + " end";
402 FreezeUtil::GetInstance().AddLifecycleEvent(AbilityContext::token_, entry);
403 }
404
OnShare(WantParams & wantParam)405 int32_t JsUIAbility::OnShare(WantParams &wantParam)
406 {
407 TAG_LOGD(AAFwkTag::UIABILITY, "called");
408 HandleScope handleScope(jsRuntime_);
409 auto env = jsRuntime_.GetNapiEnv();
410 if (jsAbilityObj_ == nullptr) {
411 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
412 return ERR_INVALID_VALUE;
413 }
414 napi_value obj = jsAbilityObj_->GetNapiValue();
415 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
416 TAG_LOGE(AAFwkTag::UIABILITY, "ability napi value failed");
417 return ERR_INVALID_VALUE;
418 }
419
420 napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParam);
421 napi_value argv[] = {
422 jsWantParams,
423 };
424 CallObjectMethod("onShare", argv, ArraySize(argv));
425 OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParam);
426 TAG_LOGD(AAFwkTag::UIABILITY, "end");
427 return ERR_OK;
428 }
429
OnStop()430 void JsUIAbility::OnStop()
431 {
432 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
433 TAG_LOGD(AAFwkTag::UIABILITY, "called");
434 if (abilityContext_) {
435 TAG_LOGD(AAFwkTag::UIABILITY, "set terminating true");
436 abilityContext_->SetTerminating(true);
437 }
438 UIAbility::OnStop();
439 HandleScope handleScope(jsRuntime_);
440 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
441 if (applicationContext != nullptr) {
442 applicationContext->DispatchOnAbilityWillDestroy(jsAbilityObj_);
443 }
444 CallObjectMethod("onDestroy");
445 OnStopCallback();
446 TAG_LOGD(AAFwkTag::UIABILITY, "end");
447 }
448
OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> * callbackInfo,bool & isAsyncCallback)449 void JsUIAbility::OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callbackInfo, bool &isAsyncCallback)
450 {
451 if (callbackInfo == nullptr) {
452 isAsyncCallback = false;
453 OnStop();
454 return;
455 }
456
457 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
458 TAG_LOGD(AAFwkTag::UIABILITY, "Begin");
459 if (abilityContext_) {
460 TAG_LOGD(AAFwkTag::UIABILITY, "set terminating true");
461 abilityContext_->SetTerminating(true);
462 }
463
464 UIAbility::OnStop();
465
466 HandleScope handleScope(jsRuntime_);
467 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
468 if (applicationContext != nullptr) {
469 applicationContext->DispatchOnAbilityWillDestroy(jsAbilityObj_);
470 }
471 napi_value result = CallObjectMethod("onDestroy", nullptr, 0, true);
472 if (!CheckPromise(result)) {
473 OnStopCallback();
474 isAsyncCallback = false;
475 return;
476 }
477
478 std::weak_ptr<UIAbility> weakPtr = shared_from_this();
479 auto asyncCallback = [abilityWeakPtr = weakPtr]() {
480 auto ability = abilityWeakPtr.lock();
481 if (ability == nullptr) {
482 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
483 return;
484 }
485 ability->OnStopCallback();
486 };
487 callbackInfo->Push(asyncCallback);
488 isAsyncCallback = CallPromise(result, callbackInfo);
489 if (!isAsyncCallback) {
490 TAG_LOGE(AAFwkTag::UIABILITY, "call promise failed");
491 OnStopCallback();
492 }
493 TAG_LOGD(AAFwkTag::UIABILITY, "end");
494 }
495
OnStopCallback()496 void JsUIAbility::OnStopCallback()
497 {
498 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
499 if (delegator) {
500 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformStop");
501 delegator->PostPerformStop(CreateADelegatorAbilityProperty());
502 }
503
504 bool ret = ConnectionManager::GetInstance().DisconnectCaller(AbilityContext::token_);
505 if (ret) {
506 ConnectionManager::GetInstance().ReportConnectionLeakEvent(getpid(), gettid());
507 TAG_LOGD(AAFwkTag::UIABILITY, "the service connection is not disconnected");
508 }
509
510 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
511 if (applicationContext != nullptr) {
512 applicationContext->DispatchOnAbilityDestroy(jsAbilityObj_);
513 }
514 }
515
516 #ifdef SUPPORT_SCREEN
OnSceneCreated()517 void JsUIAbility::OnSceneCreated()
518 {
519 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
520 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
521 UIAbility::OnSceneCreated();
522 auto jsAppWindowStage = CreateAppWindowStage();
523 if (jsAppWindowStage == nullptr) {
524 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAppWindowStage");
525 return;
526 }
527
528 HandleScope handleScope(jsRuntime_);
529 UpdateJsWindowStage(jsAppWindowStage->GetNapiValue());
530 napi_value argv[] = {jsAppWindowStage->GetNapiValue()};
531 jsWindowStageObj_ = std::shared_ptr<NativeReference>(jsAppWindowStage.release());
532 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
533 if (applicationContext != nullptr) {
534 applicationContext->DispatchOnWindowStageWillCreate(jsAbilityObj_, jsWindowStageObj_);
535 }
536 {
537 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "onWindowStageCreate");
538 std::string methodName = "OnSceneCreated";
539 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
540 CallObjectMethod("onWindowStageCreate", argv, ArraySize(argv));
541 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
542 }
543
544 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
545 if (delegator) {
546 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformScenceCreated");
547 delegator->PostPerformScenceCreated(CreateADelegatorAbilityProperty());
548 }
549
550 applicationContext = AbilityRuntime::Context::GetApplicationContext();
551 if (applicationContext != nullptr) {
552 applicationContext->DispatchOnWindowStageCreate(jsAbilityObj_, jsWindowStageObj_);
553 }
554
555 TAG_LOGD(AAFwkTag::UIABILITY, "end");
556 }
557
OnSceneRestored()558 void JsUIAbility::OnSceneRestored()
559 {
560 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
561 UIAbility::OnSceneRestored();
562 TAG_LOGD(AAFwkTag::UIABILITY, "called");
563 HandleScope handleScope(jsRuntime_);
564 auto jsAppWindowStage = CreateAppWindowStage();
565 if (jsAppWindowStage == nullptr) {
566 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAppWindowStage");
567 return;
568 }
569 UpdateJsWindowStage(jsAppWindowStage->GetNapiValue());
570 napi_value argv[] = {jsAppWindowStage->GetNapiValue()};
571 jsWindowStageObj_ = std::shared_ptr<NativeReference>(jsAppWindowStage.release());
572 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
573 if (applicationContext != nullptr) {
574 applicationContext->DispatchOnWindowStageWillRestore(jsAbilityObj_, jsWindowStageObj_);
575 }
576 CallObjectMethod("onWindowStageRestore", argv, ArraySize(argv));
577 if (applicationContext != nullptr) {
578 applicationContext->DispatchOnWindowStageRestore(jsAbilityObj_, jsWindowStageObj_);
579 }
580
581 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
582 if (delegator) {
583 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformScenceRestored");
584 delegator->PostPerformScenceRestored(CreateADelegatorAbilityProperty());
585 }
586 }
587
OnSceneWillDestroy()588 void JsUIAbility::OnSceneWillDestroy()
589 {
590 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
591 HandleScope handleScope(jsRuntime_);
592 if (jsWindowStageObj_ == nullptr) {
593 TAG_LOGE(AAFwkTag::UIABILITY, "null jsWindowStageObj_");
594 return;
595 }
596 napi_value argv[] = {jsWindowStageObj_->GetNapiValue()};
597 {
598 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "onWindowStageWillDestroy");
599 std::string methodName = "onWindowStageWillDestroy";
600 CallObjectMethod("onWindowStageWillDestroy", argv, ArraySize(argv));
601 }
602 }
603
onSceneDestroyed()604 void JsUIAbility::onSceneDestroyed()
605 {
606 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
607 UIAbility::onSceneDestroyed();
608
609 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
610 if (applicationContext != nullptr) {
611 applicationContext->DispatchOnWindowStageWillDestroy(jsAbilityObj_, jsWindowStageObj_);
612 }
613 HandleScope handleScope(jsRuntime_);
614 UpdateJsWindowStage(nullptr);
615 CallObjectMethod("onWindowStageDestroy");
616
617 if (scene_ != nullptr) {
618 auto window = scene_->GetMainWindow();
619 if (window != nullptr) {
620 TAG_LOGD(AAFwkTag::UIABILITY, "unRegisterDisplaymovelistener");
621 window->UnregisterDisplayMoveListener(abilityDisplayMoveListener_);
622 }
623 }
624
625 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
626 if (delegator) {
627 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformScenceDestroyed");
628 delegator->PostPerformScenceDestroyed(CreateADelegatorAbilityProperty());
629 }
630
631 applicationContext = AbilityRuntime::Context::GetApplicationContext();
632 if (applicationContext != nullptr) {
633 applicationContext->DispatchOnWindowStageDestroy(jsAbilityObj_, jsWindowStageObj_);
634 }
635 TAG_LOGD(AAFwkTag::UIABILITY, "end");
636 }
637
OnForeground(const Want & want)638 void JsUIAbility::OnForeground(const Want &want)
639 {
640 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
641 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
642 if (abilityInfo_) {
643 jsRuntime_.UpdateModuleNameAndAssetPath(abilityInfo_->moduleName);
644 }
645
646 UIAbility::OnForeground(want);
647 HandleCollaboration(want);
648
649 if (CheckIsSilentForeground()) {
650 TAG_LOGD(AAFwkTag::UIABILITY, "silent foreground, do not call 'onForeground'");
651 return;
652 }
653 CallOnForegroundFunc(want);
654 }
655
CallOnForegroundFunc(const Want & want)656 void JsUIAbility::CallOnForegroundFunc(const Want &want)
657 {
658 HandleScope handleScope(jsRuntime_);
659 auto env = jsRuntime_.GetNapiEnv();
660 if (jsAbilityObj_ == nullptr) {
661 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
662 return;
663 }
664 napi_value obj = jsAbilityObj_->GetNapiValue();
665 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
666 TAG_LOGE(AAFwkTag::UIABILITY, "get Ability object failed");
667 return;
668 }
669
670 napi_value jsWant = OHOS::AppExecFwk::WrapWant(env, want);
671 if (jsWant == nullptr) {
672 TAG_LOGE(AAFwkTag::UIABILITY, "null jsWant");
673 return;
674 }
675
676 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
677 if (applicationContext != nullptr) {
678 applicationContext->DispatchOnAbilityWillForeground(jsAbilityObj_);
679 }
680
681 napi_set_named_property(env, obj, "lastRequestWant", jsWant);
682 std::string methodName = "OnForeground";
683 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
684 CallObjectMethod("onForeground", &jsWant, 1);
685 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
686
687 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
688 if (delegator) {
689 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformForeground");
690 delegator->PostPerformForeground(CreateADelegatorAbilityProperty());
691 }
692
693 applicationContext = AbilityRuntime::Context::GetApplicationContext();
694 if (applicationContext != nullptr) {
695 applicationContext->DispatchOnAbilityForeground(jsAbilityObj_);
696 }
697 TAG_LOGD(AAFwkTag::UIABILITY, "end");
698 }
699
OnBackground()700 void JsUIAbility::OnBackground()
701 {
702 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
703 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
704 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
705 if (applicationContext != nullptr) {
706 applicationContext->DispatchOnAbilityWillBackground(jsAbilityObj_);
707 }
708 std::string methodName = "OnBackground";
709 HandleScope handleScope(jsRuntime_);
710 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
711 CallObjectMethod("onBackground");
712 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
713
714 UIAbility::OnBackground();
715
716 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator();
717 if (delegator) {
718 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformBackground");
719 delegator->PostPerformBackground(CreateADelegatorAbilityProperty());
720 }
721
722 applicationContext = AbilityRuntime::Context::GetApplicationContext();
723 if (applicationContext != nullptr) {
724 applicationContext->DispatchOnAbilityBackground(jsAbilityObj_);
725 }
726 auto want = GetWant();
727 if (want != nullptr) {
728 HandleCollaboration(*want);
729 }
730 TAG_LOGD(AAFwkTag::UIABILITY, "end");
731 }
732
OnWillForeground()733 void JsUIAbility::OnWillForeground()
734 {
735 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
736 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
737 UIAbility::OnWillForeground();
738
739 std::string methodName = "OnWillForeground";
740 HandleScope handleScope(jsRuntime_);
741 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
742 CallObjectMethod("onWillForeground");
743 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
744
745 TAG_LOGD(AAFwkTag::UIABILITY, "end");
746 }
747
OnDidForeground()748 void JsUIAbility::OnDidForeground()
749 {
750 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
751 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
752 UIAbility::OnDidForeground();
753
754 std::string methodName = "OnDidForeground";
755 HandleScope handleScope(jsRuntime_);
756 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
757 CallObjectMethod("onDidForeground");
758 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
759
760 if (scene_ != nullptr) {
761 scene_->GoResume();
762 }
763 TAG_LOGD(AAFwkTag::UIABILITY, "end");
764 }
765
OnWillBackground()766 void JsUIAbility::OnWillBackground()
767 {
768 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
769 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
770 UIAbility::OnWillBackground();
771
772 std::string methodName = "OnWillBackground";
773 HandleScope handleScope(jsRuntime_);
774 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
775 CallObjectMethod("onWillBackground");
776 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
777
778 TAG_LOGD(AAFwkTag::UIABILITY, "end");
779 }
780
OnDidBackground()781 void JsUIAbility::OnDidBackground()
782 {
783 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
784 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
785 UIAbility::OnDidBackground();
786
787 std::string methodName = "OnDidBackground";
788 HandleScope handleScope(jsRuntime_);
789 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
790 CallObjectMethod("onDidBackground");
791 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
792
793 TAG_LOGD(AAFwkTag::UIABILITY, "end");
794 }
795
OnBackPress()796 bool JsUIAbility::OnBackPress()
797 {
798 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
799 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
800 UIAbility::OnBackPress();
801 HandleScope handleScope(jsRuntime_);
802 auto env = jsRuntime_.GetNapiEnv();
803 napi_value jsValue = CallObjectMethod("onBackPressed", nullptr, 0, true, false);
804 bool defaultRet = BackPressDefaultValue();
805 if (jsValue == nullptr) {
806 TAG_LOGD(AAFwkTag::UIABILITY, "null jsValue, return defaultRet %{public}d", defaultRet);
807 return defaultRet;
808 }
809 bool ret = defaultRet;
810 if (!ConvertFromJsValue(env, jsValue, ret)) {
811 TAG_LOGE(AAFwkTag::UIABILITY, "get js value failed");
812 return defaultRet;
813 }
814 TAG_LOGD(AAFwkTag::UIABILITY, "end ret: %{public}d", ret);
815 return ret;
816 }
817
OnPrepareTerminate(AppExecFwk::AbilityTransactionCallbackInfo<bool> * callbackInfo,bool & isAsync)818 void JsUIAbility::OnPrepareTerminate(AppExecFwk::AbilityTransactionCallbackInfo<bool> *callbackInfo,
819 bool &isAsync)
820 {
821 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
822 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
823 UIAbility::OnPrepareTerminate(callbackInfo, isAsync);
824 HandleScope handleScope(jsRuntime_);
825 auto env = jsRuntime_.GetNapiEnv();
826 napi_value onPrepareToTerminateAsyncResult = nullptr;
827 napi_value onPrepareToTerminateResult = nullptr;
828 onPrepareToTerminateAsyncResult = CallObjectMethod("onPrepareToTerminateAsync", nullptr, 0, true);
829 if (onPrepareToTerminateAsyncResult == nullptr) {
830 TAG_LOGI(AAFwkTag::UIABILITY, "onPrepareToTerminateAsync not implemented, call onPrepareToTerminate");
831 onPrepareToTerminateResult = CallObjectMethod("onPrepareToTerminate", nullptr, 0, true);
832 }
833
834 if (onPrepareToTerminateAsyncResult == nullptr && onPrepareToTerminateResult == nullptr) {
835 TAG_LOGW(AAFwkTag::UIABILITY, "neither is implemented");
836 return;
837 }
838 if (onPrepareToTerminateResult != nullptr) {
839 TAG_LOGI(AAFwkTag::UIABILITY, "sync call");
840 bool isTerminate = false;
841 if (!ConvertFromJsValue(env, onPrepareToTerminateResult, isTerminate)) {
842 TAG_LOGE(AAFwkTag::UIABILITY, "get js value failed");
843 }
844 callbackInfo->Call(isTerminate);
845 return;
846 }
847 TAG_LOGI(AAFwkTag::UIABILITY, "async call");
848 if (!CheckPromise(onPrepareToTerminateAsyncResult) ||
849 !CallPromise(onPrepareToTerminateAsyncResult, callbackInfo)) {
850 TAG_LOGE(AAFwkTag::APPKIT, "check or call promise error");
851 return;
852 }
853 isAsync = true;
854 }
855
CreateAppWindowStage()856 std::unique_ptr<NativeReference> JsUIAbility::CreateAppWindowStage()
857 {
858 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
859 HandleScope handleScope(jsRuntime_);
860 auto env = jsRuntime_.GetNapiEnv();
861 napi_value jsWindowStage = Rosen::CreateJsWindowStage(env, GetScene());
862 if (jsWindowStage == nullptr) {
863 TAG_LOGE(AAFwkTag::UIABILITY, "null jsWindowStage");
864 return nullptr;
865 }
866 return JsRuntime::LoadSystemModuleByEngine(env, "application.WindowStage", &jsWindowStage, 1);
867 }
868
GetPageStackFromWant(const Want & want,std::string & pageStack)869 void JsUIAbility::GetPageStackFromWant(const Want &want, std::string &pageStack)
870 {
871 auto stringObj = AAFwk::IString::Query(want.GetParams().GetParam(PAGE_STACK_PROPERTY_NAME));
872 if (stringObj != nullptr) {
873 pageStack = AAFwk::String::Unbox(stringObj);
874 }
875 }
876
IsRestorePageStack(const Want & want)877 bool JsUIAbility::IsRestorePageStack(const Want &want)
878 {
879 return want.GetBoolParam(SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME, true);
880 }
881
RestorePageStack(const Want & want)882 void JsUIAbility::RestorePageStack(const Want &want)
883 {
884 if (IsRestorePageStack(want)) {
885 std::string pageStack;
886 GetPageStackFromWant(want, pageStack);
887 HandleScope handleScope(jsRuntime_);
888 auto env = jsRuntime_.GetNapiEnv();
889 if (abilityContext_->GetContentStorage()) {
890 scene_->GetMainWindow()->NapiSetUIContent(pageStack, env,
891 abilityContext_->GetContentStorage()->GetNapiValue(), Rosen::BackupAndRestoreType::CONTINUATION);
892 } else {
893 TAG_LOGE(AAFwkTag::UIABILITY, "null content storage");
894 }
895 }
896 }
897
AbilityContinuationOrRecover(const Want & want)898 void JsUIAbility::AbilityContinuationOrRecover(const Want &want)
899 {
900 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
901 // multi-instance ability continuation
902 TAG_LOGD(AAFwkTag::UIABILITY, "launch reason: %{public}d, last exit reasion: %{public}d",
903 launchParam_.launchReason, launchParam_.lastExitReason);
904 if (IsRestoredInContinuation()) {
905 RestorePageStack(want);
906 OnSceneRestored();
907 NotifyContinuationResult(want, true);
908 } else if (ShouldRecoverState(want)) {
909 std::string pageStack = abilityRecovery_->GetSavedPageStack(AppExecFwk::StateReason::DEVELOPER_REQUEST);
910 HandleScope handleScope(jsRuntime_);
911 auto env = jsRuntime_.GetNapiEnv();
912 auto mainWindow = scene_->GetMainWindow();
913 if (mainWindow != nullptr) {
914 mainWindow->NapiSetUIContent(pageStack, env, abilityContext_->GetContentStorage()->GetNapiValue(),
915 Rosen::BackupAndRestoreType::APP_RECOVERY);
916 } else {
917 TAG_LOGE(AAFwkTag::UIABILITY, "null mainWindow");
918 }
919 OnSceneRestored();
920 } else {
921 if (ShouldDefaultRecoverState(want) && abilityRecovery_ != nullptr && scene_ != nullptr) {
922 TAG_LOGD(AAFwkTag::UIABILITY, "need restore");
923 std::string pageStack = abilityRecovery_->GetSavedPageStack(AppExecFwk::StateReason::DEVELOPER_REQUEST);
924 auto mainWindow = scene_->GetMainWindow();
925 if (!pageStack.empty() && mainWindow != nullptr) {
926 mainWindow->SetRestoredRouterStack(pageStack);
927 }
928 }
929 OnSceneCreated();
930 }
931 }
932
DoOnForeground(const Want & want)933 void JsUIAbility::DoOnForeground(const Want &want)
934 {
935 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
936 if (scene_ == nullptr) {
937 if ((abilityContext_ == nullptr) || (sceneListener_ == nullptr)) {
938 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext or sceneListener_");
939 return;
940 }
941 DoOnForegroundForSceneIsNull(want);
942 } else {
943 auto window = scene_->GetMainWindow();
944 if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) {
945 auto windowMode = want.GetIntParam(
946 Want::PARAM_RESV_WINDOW_MODE, AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
947 window->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
948 windowMode_ = windowMode;
949 TAG_LOGD(AAFwkTag::UIABILITY, "set window mode: %{public}d", windowMode);
950 }
951 }
952
953 auto window = scene_->GetMainWindow();
954 if (window != nullptr && securityFlag_) {
955 window->SetSystemPrivacyMode(true);
956 }
957
958 if (CheckIsSilentForeground()) {
959 TAG_LOGI(AAFwkTag::UIABILITY, "silent foreground, do not show window");
960 return;
961 }
962
963 OnWillForeground();
964
965 TAG_LOGD(AAFwkTag::UIABILITY, "move scene to foreground, sceneFlag_: %{public}d", UIAbility::sceneFlag_);
966 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, METHOD_NAME);
967 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "scene_->GoForeground");
968 scene_->GoForeground(UIAbility::sceneFlag_);
969 TAG_LOGD(AAFwkTag::UIABILITY, "end");
970 }
971
DoOnForegroundForSceneIsNull(const Want & want)972 void JsUIAbility::DoOnForegroundForSceneIsNull(const Want &want)
973 {
974 scene_ = std::make_shared<Rosen::WindowScene>();
975 int32_t displayId = AAFwk::DisplayUtil::GetDefaultDisplayId();
976 if (setting_ != nullptr) {
977 std::string strDisplayId = setting_->GetProperty(OHOS::AppExecFwk::AbilityStartSetting::WINDOW_DISPLAY_ID_KEY);
978 std::regex formatRegex("[0-9]{0,9}$");
979 std::smatch sm;
980 bool flag = std::regex_match(strDisplayId, sm, formatRegex);
981 if (flag && !strDisplayId.empty()) {
982 displayId = strtol(strDisplayId.c_str(), nullptr, BASE_DISPLAY_ID_NUM);
983 TAG_LOGD(AAFwkTag::UIABILITY, "displayId: %{public}d", displayId);
984 } else {
985 TAG_LOGW(AAFwkTag::UIABILITY, "formatRegex: [%{public}s] failed", strDisplayId.c_str());
986 }
987 }
988 auto option = GetWindowOption(want);
989 Rosen::WMError ret = Rosen::WMError::WM_OK;
990 auto sessionToken = GetSessionToken();
991 auto identityToken = GetIdentityToken();
992 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "scene_->Init");
993 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled() && sessionToken != nullptr) {
994 abilityContext_->SetWeakSessionToken(sessionToken);
995 ret = scene_->Init(displayId, abilityContext_, sceneListener_, option, sessionToken, identityToken);
996 } else {
997 ret = scene_->Init(displayId, abilityContext_, sceneListener_, option);
998 }
999 if (ret != Rosen::WMError::WM_OK) {
1000 TAG_LOGE(AAFwkTag::UIABILITY, "init window scene failed");
1001 FreezeUtil::GetInstance().AppendLifecycleEvent(AbilityContext::token_,
1002 std::string("JsUIAbility::DoOnForegroundForSceneIsNull; error ") + std::to_string(static_cast<int>(ret)));
1003 return;
1004 }
1005
1006 AbilityContinuationOrRecover(want);
1007 auto window = scene_->GetMainWindow();
1008 if (window) {
1009 TAG_LOGD(AAFwkTag::UIABILITY, "registerDisplayMoveListener, windowId: %{public}d", window->GetWindowId());
1010 abilityDisplayMoveListener_ = new AbilityDisplayMoveListener(weak_from_this());
1011 if (abilityDisplayMoveListener_ == nullptr) {
1012 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityDisplayMoveListener_");
1013 return;
1014 }
1015 window->RegisterDisplayMoveListener(abilityDisplayMoveListener_);
1016 }
1017 }
1018
RequestFocus(const Want & want)1019 void JsUIAbility::RequestFocus(const Want &want)
1020 {
1021 TAG_LOGI(AAFwkTag::UIABILITY, "called");
1022 if (scene_ == nullptr) {
1023 TAG_LOGE(AAFwkTag::UIABILITY, "null scene_");
1024 return;
1025 }
1026 auto window = scene_->GetMainWindow();
1027 if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) {
1028 auto windowMode = want.GetIntParam(
1029 Want::PARAM_RESV_WINDOW_MODE, AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
1030 window->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
1031 TAG_LOGD(AAFwkTag::UIABILITY, "set window mode: %{public}d", windowMode);
1032 }
1033 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, METHOD_NAME);
1034 scene_->GoForeground(UIAbility::sceneFlag_);
1035 TAG_LOGI(AAFwkTag::UIABILITY, "end");
1036 }
1037
ContinuationRestore(const Want & want)1038 void JsUIAbility::ContinuationRestore(const Want &want)
1039 {
1040 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1041 if (!IsRestoredInContinuation()) {
1042 TAG_LOGE(AAFwkTag::UIABILITY, "not in continuation");
1043 return;
1044 }
1045 if (scene_ == nullptr) {
1046 TAG_LOGE(AAFwkTag::UIABILITY, "null scene_");
1047 return;
1048 }
1049 RestorePageStack(want);
1050 OnSceneRestored();
1051 NotifyContinuationResult(want, true);
1052 }
1053
GetJsWindowStage()1054 std::shared_ptr<NativeReference> JsUIAbility::GetJsWindowStage()
1055 {
1056 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1057 if (jsWindowStageObj_ == nullptr) {
1058 TAG_LOGE(AAFwkTag::UIABILITY, "null jsWindowStageObj_");
1059 }
1060 return jsWindowStageObj_;
1061 }
1062
GetJsRuntime()1063 const JsRuntime &JsUIAbility::GetJsRuntime()
1064 {
1065 return jsRuntime_;
1066 }
1067
ExecuteInsightIntentRepeateForeground(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)1068 void JsUIAbility::ExecuteInsightIntentRepeateForeground(const Want &want,
1069 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1070 std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
1071 {
1072 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1073 if (executeParam == nullptr) {
1074 TAG_LOGW(AAFwkTag::UIABILITY, "null executeParam");
1075 RequestFocus(want);
1076 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback), ERR_OK);
1077 return;
1078 }
1079
1080 auto asyncCallback = [weak = weak_from_this(), want](InsightIntentExecuteResult result) {
1081 TAG_LOGD(AAFwkTag::UIABILITY, "request focus");
1082 auto ability = weak.lock();
1083 if (ability == nullptr) {
1084 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
1085 return;
1086 }
1087 ability->RequestFocus(want);
1088 };
1089 callback->Push(asyncCallback);
1090
1091 InsightIntentExecutorInfo executeInfo;
1092 auto ret = GetInsightIntentExecutorInfo(want, executeParam, executeInfo);
1093 if (!ret) {
1094 TAG_LOGE(AAFwkTag::UIABILITY, "get intentExecutor failed");
1095 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback),
1096 static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INVALID_PARAM));
1097 return;
1098 }
1099
1100 ret = DelayedSingleton<InsightIntentExecutorMgr>::GetInstance()->ExecuteInsightIntent(
1101 jsRuntime_, executeInfo, std::move(callback));
1102 if (!ret) {
1103 // callback has removed, release in insight intent executor.
1104 TAG_LOGE(AAFwkTag::UIABILITY, "execute insightIntent failed");
1105 }
1106 }
1107
ExecuteInsightIntentMoveToForeground(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)1108 void JsUIAbility::ExecuteInsightIntentMoveToForeground(const Want &want,
1109 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1110 std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
1111 {
1112 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1113 if (executeParam == nullptr) {
1114 TAG_LOGW(AAFwkTag::UIABILITY, "null executeParam");
1115 OnForeground(want);
1116 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback), ERR_OK);
1117 return;
1118 }
1119
1120 if (abilityInfo_) {
1121 jsRuntime_.UpdateModuleNameAndAssetPath(abilityInfo_->moduleName);
1122 }
1123 UIAbility::OnForeground(want);
1124
1125 auto asyncCallback = [weak = weak_from_this(), want](InsightIntentExecuteResult result) {
1126 TAG_LOGD(AAFwkTag::UIABILITY, "begin call onForeground");
1127 auto ability = weak.lock();
1128 if (ability == nullptr) {
1129 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
1130 return;
1131 }
1132 ability->CallOnForegroundFunc(want);
1133 };
1134 callback->Push(asyncCallback);
1135
1136 InsightIntentExecutorInfo executeInfo;
1137 auto ret = GetInsightIntentExecutorInfo(want, executeParam, executeInfo);
1138 if (!ret) {
1139 TAG_LOGE(AAFwkTag::UIABILITY, "get intentExecutor failed");
1140 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback),
1141 static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INVALID_PARAM));
1142 return;
1143 }
1144
1145 ret = DelayedSingleton<InsightIntentExecutorMgr>::GetInstance()->ExecuteInsightIntent(
1146 jsRuntime_, executeInfo, std::move(callback));
1147 if (!ret) {
1148 // callback has removed, release in insight intent executor.
1149 TAG_LOGE(AAFwkTag::UIABILITY, "execute insightIntent failed");
1150 }
1151 }
1152
ExecuteInsightIntentBackground(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)1153 void JsUIAbility::ExecuteInsightIntentBackground(const Want &want,
1154 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1155 std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
1156 {
1157 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1158 if (executeParam == nullptr) {
1159 TAG_LOGW(AAFwkTag::UIABILITY, "null executeParam");
1160 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback), ERR_OK);
1161 return;
1162 }
1163
1164 if (abilityInfo_) {
1165 jsRuntime_.UpdateModuleNameAndAssetPath(abilityInfo_->moduleName);
1166 }
1167
1168 InsightIntentExecutorInfo executeInfo;
1169 auto ret = GetInsightIntentExecutorInfo(want, executeParam, executeInfo);
1170 if (!ret) {
1171 TAG_LOGE(AAFwkTag::UIABILITY, "get intentExecutor failed");
1172 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback),
1173 static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INVALID_PARAM));
1174 return;
1175 }
1176
1177 ret = DelayedSingleton<InsightIntentExecutorMgr>::GetInstance()->ExecuteInsightIntent(
1178 jsRuntime_, executeInfo, std::move(callback));
1179 if (!ret) {
1180 // callback has removed, release in insight intent executor.
1181 TAG_LOGE(AAFwkTag::UIABILITY, "execute insightIntent failed");
1182 }
1183 }
1184
GetInsightIntentExecutorInfo(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,InsightIntentExecutorInfo & executeInfo)1185 bool JsUIAbility::GetInsightIntentExecutorInfo(const Want &want,
1186 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1187 InsightIntentExecutorInfo& executeInfo)
1188 {
1189 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1190
1191 auto context = GetAbilityContext();
1192 if (executeParam == nullptr || context == nullptr || abilityInfo_ == nullptr) {
1193 TAG_LOGE(AAFwkTag::UIABILITY, "param invalid");
1194 return false;
1195 }
1196
1197 if (executeParam->executeMode_ == AppExecFwk::ExecuteMode::UI_ABILITY_FOREGROUND
1198 && jsWindowStageObj_ == nullptr) {
1199 TAG_LOGE(AAFwkTag::UIABILITY, "param invalid");
1200 return false;
1201 }
1202
1203 const WantParams &wantParams = want.GetParams();
1204 executeInfo.srcEntry = wantParams.GetStringParam("ohos.insightIntent.srcEntry");
1205 executeInfo.hapPath = abilityInfo_->hapPath;
1206 executeInfo.esmodule = abilityInfo_->compileMode == AppExecFwk::CompileMode::ES_MODULE;
1207 executeInfo.windowMode = windowMode_;
1208 executeInfo.token = context->GetToken();
1209 if (jsWindowStageObj_ != nullptr) {
1210 executeInfo.pageLoader = jsWindowStageObj_;
1211 }
1212 executeInfo.executeParam = executeParam;
1213 return true;
1214 }
1215
OnCollaborate(WantParams & wantParam)1216 int32_t JsUIAbility::OnCollaborate(WantParams &wantParam)
1217 {
1218 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1219 TAG_LOGD(AAFwkTag::UIABILITY, "OnCollaborate: %{public}s", GetAbilityName().c_str());
1220 int32_t ret = CollaborateResult::REJECT;
1221 HandleScope handleScope(jsRuntime_);
1222 auto env = jsRuntime_.GetNapiEnv();
1223
1224 if (jsAbilityObj_ == nullptr) {
1225 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
1226 return ret;
1227 }
1228 napi_value obj = jsAbilityObj_->GetNapiValue();
1229 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1230 TAG_LOGE(AAFwkTag::UIABILITY, "get ability object fail");
1231 return ret;
1232 }
1233
1234 napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParam);
1235 napi_value argv[] = {
1236 jsWantParams,
1237 };
1238 auto result = CallObjectMethod("onCollaborate", argv, ArraySize(argv), true);
1239 OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParam);
1240
1241 if (!ConvertFromJsValue(env, result, ret)) {
1242 TAG_LOGE(AAFwkTag::UIABILITY, "get js value failed");
1243 return ret;
1244 }
1245 ret = (ret == CollaborateResult::ACCEPT) ? CollaborateResult::ACCEPT : CollaborateResult::REJECT;
1246 return ret;
1247 }
1248
HandleCollaboration(const Want & want)1249 void JsUIAbility::HandleCollaboration(const Want &want)
1250 {
1251 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1252 if (abilityInfo_ == nullptr) {
1253 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo_");
1254 return;
1255 }
1256 if (want.GetBoolParam(IS_CALLING_FROM_DMS, false) &&
1257 (abilityInfo_->launchMode != AppExecFwk::LaunchMode::SPECIFIED)) {
1258 (const_cast<Want &>(want)).RemoveParam(IS_CALLING_FROM_DMS);
1259 SetWant(want);
1260 OHOS::AAFwk::WantParams wantParams = want.GetParams();
1261 int32_t resultCode = OnCollaborate(wantParams);
1262 auto abilityContext = GetAbilityContext();
1263 if (abilityContext == nullptr) {
1264 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
1265 return;
1266 }
1267 OHOS::AAFwk::WantParams param = want.GetParams().GetWantParams(SUPPORT_COLLABORATE_INDEX);
1268 auto collabToken = param.GetStringParam(COLLABORATE_KEY);
1269 auto uid = abilityInfo_->uid;
1270 auto callerPid = getpid();
1271 auto accessTokenId = abilityInfo_->applicationInfo.accessTokenId;
1272 AAFwk::DistributedClient dmsClient;
1273 dmsClient.OnCollaborateDone(collabToken, resultCode, callerPid, uid, accessTokenId);
1274 }
1275 }
1276 #endif
1277
OnContinue(WantParams & wantParams,bool & isAsyncOnContinue,const AppExecFwk::AbilityInfo & abilityInfo)1278 int32_t JsUIAbility::OnContinue(WantParams &wantParams, bool &isAsyncOnContinue,
1279 const AppExecFwk::AbilityInfo &abilityInfo)
1280 {
1281 TAG_LOGI(AAFwkTag::UIABILITY, "called");
1282 HandleScope handleScope(jsRuntime_);
1283 auto env = jsRuntime_.GetNapiEnv();
1284 if (jsAbilityObj_ == nullptr) {
1285 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
1286 return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
1287 }
1288 napi_value obj = jsAbilityObj_->GetNapiValue();
1289 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1290 TAG_LOGE(AAFwkTag::UIABILITY, "failed get ability");
1291 return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
1292 }
1293 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
1294 if (applicationContext != nullptr) {
1295 applicationContext->DispatchOnAbilityWillContinue(jsAbilityObj_);
1296 }
1297 napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParams);
1298 napi_value result = CallObjectMethod("onContinue", &jsWantParams, 1, true);
1299 int32_t onContinueRes = 0;
1300 if (!CheckPromise(result)) {
1301 return OnContinueSyncCB(result, wantParams, jsWantParams);
1302 }
1303 auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<int32_t>::Create();
1304 if (callbackInfo == nullptr) {
1305 TAG_LOGE(AAFwkTag::UIABILITY, "null callbackInfo");
1306 return OnContinueSyncCB(result, wantParams, jsWantParams);
1307 }
1308 std::weak_ptr<UIAbility> weakPtr = shared_from_this();
1309 napi_ref jsWantParamsRef;
1310 napi_create_reference(env, jsWantParams, 1, &jsWantParamsRef);
1311 ReleaseOnContinueAsset(env, result, jsWantParamsRef, callbackInfo);
1312 auto asyncCallback = [jsWantParamsRef, abilityWeakPtr = weakPtr, abilityInfo](int32_t status) {
1313 auto ability = abilityWeakPtr.lock();
1314 if (ability == nullptr) {
1315 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
1316 return;
1317 }
1318 ability->OnContinueAsyncCB(jsWantParamsRef, status, abilityInfo);
1319 };
1320 callbackInfo->Push(asyncCallback);
1321 if (!CallPromise(result, callbackInfo)) {
1322 TAG_LOGE(AAFwkTag::UIABILITY, "call promise failed");
1323 return OnContinueSyncCB(result, wantParams, jsWantParams);
1324 }
1325 isAsyncOnContinue = true;
1326 TAG_LOGI(AAFwkTag::UIABILITY, "end");
1327 return onContinueRes;
1328 }
1329
ReleaseOnContinueAsset(const napi_env env,napi_value & promise,napi_ref & jsWantParamsRef,AppExecFwk::AbilityTransactionCallbackInfo<int32_t> * callbackInfo)1330 void JsUIAbility::ReleaseOnContinueAsset(const napi_env env, napi_value &promise,
1331 napi_ref &jsWantParamsRef, AppExecFwk::AbilityTransactionCallbackInfo<int32_t> *callbackInfo)
1332 {
1333 napi_add_finalizer(env, promise, jsWantParamsRef, [](napi_env env, void *context, void *) {
1334 TAG_LOGI(AAFwkTag::UIABILITY, "Release jsWantParamsRef");
1335 auto contextRef = reinterpret_cast<napi_ref>(context);
1336 if (contextRef != nullptr) {
1337 napi_delete_reference(env, contextRef);
1338 contextRef = nullptr;
1339 }
1340 }, nullptr, nullptr);
1341 napi_add_finalizer(env, promise, callbackInfo, [](napi_env env, void *context, void *) {
1342 TAG_LOGI(AAFwkTag::UIABILITY, "Release callbackInfo");
1343 auto contextRef = reinterpret_cast<AppExecFwk::AbilityTransactionCallbackInfo<int32_t> *>(context);
1344 if (contextRef != nullptr) {
1345 AppExecFwk::AbilityTransactionCallbackInfo<int32_t>::Destroy(contextRef);
1346 contextRef = nullptr;
1347 }
1348 }, nullptr, nullptr);
1349 }
1350
OnContinueAsyncCB(napi_ref jsWantParamsRef,int32_t status,const AppExecFwk::AbilityInfo & abilityInfo)1351 int32_t JsUIAbility::OnContinueAsyncCB(napi_ref jsWantParamsRef, int32_t status,
1352 const AppExecFwk::AbilityInfo &abilityInfo)
1353 {
1354 TAG_LOGI(AAFwkTag::UIABILITY, "call");
1355 HandleScope handleScope(jsRuntime_);
1356 auto env = jsRuntime_.GetNapiEnv();
1357 WantParams wantParams;
1358 napi_value jsWantParams;
1359 napi_get_reference_value(env, jsWantParamsRef, &jsWantParams);
1360 OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams);
1361 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
1362 if (applicationContext != nullptr) {
1363 applicationContext->DispatchOnAbilityContinue(jsAbilityObj_);
1364 }
1365
1366 Want want;
1367 want.SetParams(wantParams);
1368 want.AddFlags(want.FLAG_ABILITY_CONTINUATION);
1369 want.SetElementName(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name,
1370 abilityInfo.moduleName);
1371 int result = AAFwk::AbilityManagerClient::GetInstance()->StartContinuation(want, token_, status);
1372 if (result != ERR_OK) {
1373 TAG_LOGE(AAFwkTag::CONTINUATION, "StartContinuation failed: %{public}d", result);
1374 }
1375 TAG_LOGI(AAFwkTag::UIABILITY, "end");
1376 return result;
1377 }
1378
OnContinueSyncCB(napi_value result,WantParams & wantParams,napi_value jsWantParams)1379 int32_t JsUIAbility::OnContinueSyncCB(napi_value result, WantParams &wantParams, napi_value jsWantParams)
1380 {
1381 TAG_LOGI(AAFwkTag::UIABILITY, "call");
1382 HandleScope handleScope(jsRuntime_);
1383 auto env = jsRuntime_.GetNapiEnv();
1384 int32_t onContinueRes = 0;
1385 if (!ConvertFromJsValue(env, result, onContinueRes)) {
1386 TAG_LOGE(AAFwkTag::UIABILITY, "'onContinue' is not implemented");
1387 return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
1388 }
1389 OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams);
1390 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
1391 if (applicationContext != nullptr) {
1392 applicationContext->DispatchOnAbilityContinue(jsAbilityObj_);
1393 }
1394 TAG_LOGI(AAFwkTag::UIABILITY, "end");
1395 return onContinueRes;
1396 }
1397
OnSaveState(int32_t reason,WantParams & wantParams)1398 int32_t JsUIAbility::OnSaveState(int32_t reason, WantParams &wantParams)
1399 {
1400 HandleScope handleScope(jsRuntime_);
1401 auto env = jsRuntime_.GetNapiEnv();
1402 if (jsAbilityObj_ == nullptr) {
1403 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
1404 return -1;
1405 }
1406 napi_value obj = jsAbilityObj_->GetNapiValue();
1407 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1408 TAG_LOGE(AAFwkTag::UIABILITY, "get ability object failed");
1409 return -1;
1410 }
1411
1412 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
1413 if (applicationContext != nullptr) {
1414 applicationContext->DispatchOnAbilityWillSaveState(jsAbilityObj_);
1415 }
1416
1417 napi_value methodOnSaveState = nullptr;
1418 napi_get_named_property(env, obj, "onSaveState", &methodOnSaveState);
1419 if (methodOnSaveState == nullptr) {
1420 TAG_LOGE(AAFwkTag::UIABILITY, "null methodOnSaveState");
1421 return -1;
1422 }
1423
1424 napi_value jsWantParams = OHOS::AppExecFwk::WrapWantParams(env, wantParams);
1425 napi_value jsReason = CreateJsValue(env, reason);
1426 napi_value args[] = { jsReason, jsWantParams };
1427 napi_value result = nullptr;
1428 napi_call_function(env, obj, methodOnSaveState, 2, args, &result); // 2:args size
1429 OHOS::AppExecFwk::UnwrapWantParams(env, jsWantParams, wantParams);
1430
1431 int32_t numberResult = 0;
1432 if (!ConvertFromJsValue(env, result, numberResult)) {
1433 TAG_LOGE(AAFwkTag::UIABILITY, "no result return from onSaveState");
1434 return -1;
1435 }
1436
1437 if (applicationContext != nullptr) {
1438 applicationContext->DispatchOnAbilitySaveState(jsAbilityObj_);
1439 }
1440
1441 return numberResult;
1442 }
1443
OnConfigurationUpdated(const Configuration & configuration)1444 void JsUIAbility::OnConfigurationUpdated(const Configuration &configuration)
1445 {
1446 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1447 UIAbility::OnConfigurationUpdated(configuration);
1448 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1449 if (abilityContext_ == nullptr) {
1450 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
1451 return;
1452 }
1453
1454 HandleScope handleScope(jsRuntime_);
1455 auto env = jsRuntime_.GetNapiEnv();
1456 auto abilityConfig = abilityContext_->GetAbilityConfiguration();
1457 auto fullConfig = abilityContext_->GetConfiguration();
1458 if (fullConfig == nullptr) {
1459 TAG_LOGE(AAFwkTag::UIABILITY, "null fullConfig");
1460 return;
1461 }
1462
1463 auto realConfig = AppExecFwk::Configuration(*fullConfig);
1464
1465 if (abilityConfig != nullptr) {
1466 std::vector<std::string> changeKeyV;
1467 realConfig.CompareDifferent(changeKeyV, *abilityConfig);
1468 if (!changeKeyV.empty()) {
1469 realConfig.Merge(changeKeyV, *abilityConfig);
1470 }
1471 }
1472
1473 TAG_LOGD(AAFwkTag::UIABILITY, "realConfig: %{public}s", realConfig.GetName().c_str());
1474 napi_value napiConfiguration = OHOS::AppExecFwk::WrapConfiguration(env, realConfig);
1475
1476 CallObjectMethod("onConfigurationUpdated", &napiConfiguration, 1);
1477 CallObjectMethod("onConfigurationUpdate", &napiConfiguration, 1);
1478 auto realConfigPtr = std::make_shared<Configuration>(realConfig);
1479 JsAbilityContext::ConfigurationUpdated(env, shellContextRef_, realConfigPtr);
1480 }
1481
OnMemoryLevel(int level)1482 void JsUIAbility::OnMemoryLevel(int level)
1483 {
1484 UIAbility::OnMemoryLevel(level);
1485 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1486
1487 HandleScope handleScope(jsRuntime_);
1488 auto env = jsRuntime_.GetNapiEnv();
1489 if (jsAbilityObj_ == nullptr) {
1490 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
1491 return;
1492 }
1493 napi_value obj = jsAbilityObj_->GetNapiValue();
1494 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1495 TAG_LOGE(AAFwkTag::UIABILITY, "get ability object failed");
1496 return;
1497 }
1498
1499 napi_value jslevel = CreateJsValue(env, level);
1500 napi_value argv[] = { jslevel };
1501 CallObjectMethod("onMemoryLevel", argv, ArraySize(argv));
1502 }
1503
UpdateContextConfiguration()1504 void JsUIAbility::UpdateContextConfiguration()
1505 {
1506 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1507 if (abilityContext_ == nullptr) {
1508 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
1509 return;
1510 }
1511 HandleScope handleScope(jsRuntime_);
1512 auto env = jsRuntime_.GetNapiEnv();
1513 JsAbilityContext::ConfigurationUpdated(env, shellContextRef_, abilityContext_->GetConfiguration());
1514 }
1515
OnNewWant(const Want & want)1516 void JsUIAbility::OnNewWant(const Want &want)
1517 {
1518 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1519 UIAbility::OnNewWant(want);
1520
1521 #ifdef SUPPORT_SCREEN
1522 if (scene_) {
1523 scene_->OnNewWant(want);
1524 }
1525 HandleCollaboration(want);
1526 #endif
1527
1528 HandleScope handleScope(jsRuntime_);
1529 auto env = jsRuntime_.GetNapiEnv();
1530 if (jsAbilityObj_ == nullptr) {
1531 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
1532 return;
1533 }
1534 napi_value obj = jsAbilityObj_->GetNapiValue();
1535 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1536 TAG_LOGE(AAFwkTag::UIABILITY, "ability object failed");
1537 return;
1538 }
1539
1540 napi_value jsWant = OHOS::AppExecFwk::WrapWant(env, want);
1541 if (jsWant == nullptr) {
1542 TAG_LOGE(AAFwkTag::UIABILITY, "null want");
1543 return;
1544 }
1545
1546 auto applicationContext = AbilityRuntime::Context::GetApplicationContext();
1547 if (applicationContext != nullptr) {
1548 applicationContext->DispatchOnWillNewWant(jsAbilityObj_);
1549 }
1550
1551 napi_set_named_property(env, obj, "lastRequestWant", jsWant);
1552 auto launchParam = GetLaunchParam();
1553 if (InsightIntentExecuteParam::IsInsightIntentExecute(want)) {
1554 launchParam.launchReason = AAFwk::LaunchReason::LAUNCHREASON_INSIGHT_INTENT;
1555 }
1556 napi_value argv[] = {
1557 jsWant,
1558 CreateJsLaunchParam(env, launchParam),
1559 };
1560 std::string methodName = "OnNewWant";
1561 AddLifecycleEventBeforeJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
1562 CallObjectMethod("onNewWant", argv, ArraySize(argv));
1563 AddLifecycleEventAfterJSCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
1564
1565 applicationContext = AbilityRuntime::Context::GetApplicationContext();
1566 if (applicationContext != nullptr) {
1567 applicationContext->DispatchOnNewWant(jsAbilityObj_);
1568 }
1569 TAG_LOGD(AAFwkTag::UIABILITY, "end");
1570 }
1571
OnAbilityResult(int requestCode,int resultCode,const Want & resultData)1572 void JsUIAbility::OnAbilityResult(int requestCode, int resultCode, const Want &resultData)
1573 {
1574 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1575 UIAbility::OnAbilityResult(requestCode, resultCode, resultData);
1576 if (abilityContext_ == nullptr) {
1577 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
1578 return;
1579 }
1580 abilityContext_->OnAbilityResult(requestCode, resultCode, resultData);
1581 TAG_LOGD(AAFwkTag::UIABILITY, "end");
1582 }
1583
CallRequest()1584 sptr<IRemoteObject> JsUIAbility::CallRequest()
1585 {
1586 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1587 if (jsAbilityObj_ == nullptr) {
1588 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
1589 return nullptr;
1590 }
1591
1592 if (remoteCallee_ != nullptr) {
1593 TAG_LOGE(AAFwkTag::UIABILITY, "remoteCallee_ is exist");
1594 return remoteCallee_;
1595 }
1596
1597 HandleScope handleScope(jsRuntime_);
1598 auto env = jsRuntime_.GetNapiEnv();
1599 auto obj = jsAbilityObj_->GetNapiValue();
1600 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1601 TAG_LOGE(AAFwkTag::UIABILITY, "null value");
1602 return nullptr;
1603 }
1604
1605 napi_value method = nullptr;
1606 napi_get_named_property(env, obj, "onCallRequest", &method);
1607 bool isCallable = false;
1608 napi_is_callable(env, method, &isCallable);
1609 if (!isCallable) {
1610 TAG_LOGE(AAFwkTag::UIABILITY, "method: %{public}s", method == nullptr ? "nullptr" : "not func");
1611 return nullptr;
1612 }
1613
1614 napi_value remoteJsObj = nullptr;
1615 napi_call_function(env, obj, method, 0, nullptr, &remoteJsObj);
1616 if (remoteJsObj == nullptr) {
1617 TAG_LOGE(AAFwkTag::UIABILITY, "null remoteJsObj");
1618 return nullptr;
1619 }
1620
1621 remoteCallee_ = SetNewRuleFlagToCallee(env, remoteJsObj);
1622 TAG_LOGD(AAFwkTag::UIABILITY, "end");
1623 return remoteCallee_;
1624 }
1625
CallObjectMethod(const char * name,napi_value const * argv,size_t argc,bool withResult,bool showMethodNotFoundLog)1626 napi_value JsUIAbility::CallObjectMethod(const char *name, napi_value const *argv, size_t argc, bool withResult,
1627 bool showMethodNotFoundLog)
1628 {
1629 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, std::string("CallObjectMethod:") + name);
1630 TAG_LOGI(AAFwkTag::UIABILITY, "JsUIAbility call js, name: %{public}s", name);
1631 if (jsAbilityObj_ == nullptr) {
1632 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj");
1633 return nullptr;
1634 }
1635
1636 HandleEscape handleEscape(jsRuntime_);
1637 auto env = jsRuntime_.GetNapiEnv();
1638
1639 napi_value obj = jsAbilityObj_->GetNapiValue();
1640 if (!CheckTypeForNapiValue(env, obj, napi_object)) {
1641 TAG_LOGE(AAFwkTag::UIABILITY, "get ability object failed");
1642 return nullptr;
1643 }
1644
1645 napi_value methodOnCreate = nullptr;
1646 napi_get_named_property(env, obj, name, &methodOnCreate);
1647 if (methodOnCreate == nullptr) {
1648 if (showMethodNotFoundLog) {
1649 TAG_LOGE(AAFwkTag::UIABILITY, "get '%{public}s' from ability object failed", name);
1650 }
1651 return nullptr;
1652 }
1653 TryCatch tryCatch(env);
1654 if (withResult) {
1655 napi_value result = nullptr;
1656 napi_status withResultStatus = napi_call_function(env, obj, methodOnCreate, argc, argv, &result);
1657 if (withResultStatus != napi_ok) {
1658 TAG_LOGE(AAFwkTag::UIABILITY, "JsUIAbility call js, withResult failed: %{public}d", withResultStatus);
1659 }
1660 if (tryCatch.HasCaught()) {
1661 reinterpret_cast<NativeEngine*>(env)->HandleUncaughtException();
1662 }
1663 return handleEscape.Escape(result);
1664 }
1665 int64_t timeStart = AbilityRuntime::TimeUtil::SystemTimeMillisecond();
1666 napi_status status = napi_call_function(env, obj, methodOnCreate, argc, argv, nullptr);
1667 if (status != napi_ok) {
1668 TAG_LOGE(AAFwkTag::UIABILITY, "JsUIAbility call js, failed: %{public}d", status);
1669 }
1670 int64_t timeEnd = AbilityRuntime::TimeUtil::SystemTimeMillisecond();
1671 if (tryCatch.HasCaught()) {
1672 reinterpret_cast<NativeEngine*>(env)->HandleUncaughtException();
1673 }
1674 TAG_LOGI(AAFwkTag::UIABILITY, "end, name: %{public}s, time: %{public}s",
1675 name, std::to_string(timeEnd - timeStart).c_str());
1676 return nullptr;
1677 }
1678
CheckPromise(napi_value result)1679 bool JsUIAbility::CheckPromise(napi_value result)
1680 {
1681 if (result == nullptr) {
1682 TAG_LOGE(AAFwkTag::UIABILITY, "null result");
1683 return false;
1684 }
1685 auto env = jsRuntime_.GetNapiEnv();
1686 bool isPromise = false;
1687 napi_is_promise(env, result, &isPromise);
1688 if (!isPromise) {
1689 TAG_LOGD(AAFwkTag::UIABILITY, "result is not promise");
1690 return false;
1691 }
1692 return true;
1693 }
1694
CallPromise(napi_value result,AppExecFwk::AbilityTransactionCallbackInfo<> * callbackInfo)1695 bool JsUIAbility::CallPromise(napi_value result, AppExecFwk::AbilityTransactionCallbackInfo<> *callbackInfo)
1696 {
1697 auto env = jsRuntime_.GetNapiEnv();
1698 if (!CheckTypeForNapiValue(env, result, napi_object)) {
1699 TAG_LOGE(AAFwkTag::UIABILITY, "convert failed");
1700 return false;
1701 }
1702 napi_value then = nullptr;
1703 napi_get_named_property(env, result, "then", &then);
1704 if (then == nullptr) {
1705 TAG_LOGE(AAFwkTag::UIABILITY, "null then");
1706 return false;
1707 }
1708 bool isCallable = false;
1709 napi_is_callable(env, then, &isCallable);
1710 if (!isCallable) {
1711 TAG_LOGE(AAFwkTag::UIABILITY, "not callable");
1712 return false;
1713 }
1714 HandleScope handleScope(jsRuntime_);
1715 napi_value promiseCallback = nullptr;
1716 napi_create_function(env, "promiseCallback", strlen("promiseCallback"), PromiseCallback,
1717 callbackInfo, &promiseCallback);
1718 napi_value argv[1] = { promiseCallback };
1719 napi_call_function(env, result, then, 1, argv, nullptr);
1720 TAG_LOGD(AAFwkTag::UIABILITY, "end");
1721 return true;
1722 }
1723
CallPromise(napi_value result,AppExecFwk::AbilityTransactionCallbackInfo<int32_t> * callbackInfo)1724 bool JsUIAbility::CallPromise(napi_value result, AppExecFwk::AbilityTransactionCallbackInfo<int32_t> *callbackInfo)
1725 {
1726 TAG_LOGI(AAFwkTag::UIABILITY, "called");
1727 auto env = jsRuntime_.GetNapiEnv();
1728 if (!CheckTypeForNapiValue(env, result, napi_object)) {
1729 TAG_LOGE(AAFwkTag::UIABILITY, "convert error");
1730 return false;
1731 }
1732 napi_value then = nullptr;
1733 napi_get_named_property(env, result, "then", &then);
1734 if (then == nullptr) {
1735 TAG_LOGE(AAFwkTag::UIABILITY, "null then");
1736 return false;
1737 }
1738 bool isCallable = false;
1739 napi_is_callable(env, then, &isCallable);
1740 if (!isCallable) {
1741 TAG_LOGE(AAFwkTag::UIABILITY, "not callable");
1742 return false;
1743 }
1744 HandleScope handleScope(jsRuntime_);
1745 napi_value promiseCallback = nullptr;
1746 napi_create_function(env, nullptr, NAPI_AUTO_LENGTH, OnContinuePromiseCallback,
1747 callbackInfo, &promiseCallback);
1748 napi_value argv[2] = { promiseCallback, promiseCallback };
1749 napi_call_function(env, result, then, PROMISE_CALLBACK_PARAM_NUM, argv, nullptr);
1750 TAG_LOGI(AAFwkTag::UIABILITY, "end");
1751 return true;
1752 }
1753
CallPromise(napi_value result,AppExecFwk::AbilityTransactionCallbackInfo<bool> * callbackInfo)1754 bool JsUIAbility::CallPromise(napi_value result, AppExecFwk::AbilityTransactionCallbackInfo<bool> *callbackInfo)
1755 {
1756 TAG_LOGI(AAFwkTag::UIABILITY, "called");
1757 auto env = jsRuntime_.GetNapiEnv();
1758 if (!CheckTypeForNapiValue(env, result, napi_object)) {
1759 TAG_LOGE(AAFwkTag::UIABILITY, "convert error");
1760 return false;
1761 }
1762 napi_value then = nullptr;
1763 napi_get_named_property(env, result, "then", &then);
1764 if (then == nullptr) {
1765 TAG_LOGE(AAFwkTag::UIABILITY, "null then");
1766 return false;
1767 }
1768 bool isCallable = false;
1769 napi_is_callable(env, then, &isCallable);
1770 if (!isCallable) {
1771 TAG_LOGE(AAFwkTag::UIABILITY, "not callable");
1772 return false;
1773 }
1774 HandleScope handleScope(jsRuntime_);
1775 napi_value promiseCallback = nullptr;
1776 napi_create_function(env, "promiseCallback", strlen("promiseCallback"),
1777 OnPrepareTerminatePromiseCallback, callbackInfo, &promiseCallback);
1778 napi_value argv[1] = { promiseCallback };
1779 napi_call_function(env, result, then, 1, argv, nullptr);
1780 TAG_LOGI(AAFwkTag::UIABILITY, "end");
1781 return true;
1782 }
1783
CreateADelegatorAbilityProperty()1784 std::shared_ptr<AppExecFwk::ADelegatorAbilityProperty> JsUIAbility::CreateADelegatorAbilityProperty()
1785 {
1786 if (abilityContext_ == nullptr) {
1787 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
1788 return nullptr;
1789 }
1790 auto property = std::make_shared<AppExecFwk::ADelegatorAbilityProperty>();
1791 property->token_ = abilityContext_->GetToken();
1792 property->name_ = GetAbilityName();
1793 property->moduleName_ = GetModuleName();
1794 if (GetApplicationInfo() == nullptr || GetApplicationInfo()->bundleName.empty()) {
1795 property->fullName_ = GetAbilityName();
1796 } else {
1797 std::string::size_type pos = GetAbilityName().find(GetApplicationInfo()->bundleName);
1798 if (pos == std::string::npos || pos != 0) {
1799 property->fullName_ = GetApplicationInfo()->bundleName + "." + GetAbilityName();
1800 } else {
1801 property->fullName_ = GetAbilityName();
1802 }
1803 }
1804 property->lifecycleState_ = GetState();
1805 property->object_ = jsAbilityObj_;
1806 return property;
1807 }
1808
Dump(const std::vector<std::string> & params,std::vector<std::string> & info)1809 void JsUIAbility::Dump(const std::vector<std::string> ¶ms, std::vector<std::string> &info)
1810 {
1811 UIAbility::Dump(params, info);
1812 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1813 HandleScope handleScope(jsRuntime_);
1814 auto env = jsRuntime_.GetNapiEnv();
1815 // create js array object of params
1816 napi_value argv[] = { CreateNativeArray(env, params) };
1817 napi_value dumpInfo = CallObjectMethod("dump", argv, ArraySize(argv), true);
1818 napi_value onDumpInfo = CallObjectMethod("onDump", argv, ArraySize(argv), true);
1819
1820 GetDumpInfo(env, dumpInfo, onDumpInfo, info);
1821 TAG_LOGD(AAFwkTag::UIABILITY, "dump info size: %{public}zu", info.size());
1822 }
1823
GetDumpInfo(napi_env env,napi_value dumpInfo,napi_value onDumpInfo,std::vector<std::string> & info)1824 void JsUIAbility::GetDumpInfo(
1825 napi_env env, napi_value dumpInfo, napi_value onDumpInfo, std::vector<std::string> &info)
1826 {
1827 if (dumpInfo != nullptr) {
1828 uint32_t len = 0;
1829 napi_get_array_length(env, dumpInfo, &len);
1830 for (uint32_t i = 0; i < len; i++) {
1831 std::string dumpInfoStr;
1832 napi_value element = nullptr;
1833 napi_get_element(env, dumpInfo, i, &element);
1834 if (!ConvertFromJsValue(env, element, dumpInfoStr)) {
1835 TAG_LOGE(AAFwkTag::UIABILITY, "parse dumpInfoStr failed");
1836 return;
1837 }
1838 info.push_back(dumpInfoStr);
1839 }
1840 }
1841
1842 if (onDumpInfo != nullptr) {
1843 uint32_t len = 0;
1844 napi_get_array_length(env, onDumpInfo, &len);
1845 for (uint32_t i = 0; i < len; i++) {
1846 std::string dumpInfoStr;
1847 napi_value element = nullptr;
1848 napi_get_element(env, onDumpInfo, i, &element);
1849 if (!ConvertFromJsValue(env, element, dumpInfoStr)) {
1850 TAG_LOGE(AAFwkTag::UIABILITY, "invalid dumpInfoStr from onDumpInfoNative");
1851 return;
1852 }
1853 info.push_back(dumpInfoStr);
1854 }
1855 }
1856 }
1857
GetJsAbility()1858 std::shared_ptr<NativeReference> JsUIAbility::GetJsAbility()
1859 {
1860 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1861 if (jsAbilityObj_ == nullptr) {
1862 TAG_LOGE(AAFwkTag::UIABILITY, "null jsAbilityObj_");
1863 }
1864 return jsAbilityObj_;
1865 }
1866
SetNewRuleFlagToCallee(napi_env env,napi_value remoteJsObj)1867 sptr<IRemoteObject> JsUIAbility::SetNewRuleFlagToCallee(napi_env env, napi_value remoteJsObj)
1868 {
1869 if (!CheckTypeForNapiValue(env, remoteJsObj, napi_object)) {
1870 TAG_LOGE(AAFwkTag::UIABILITY, "null callee");
1871 return nullptr;
1872 }
1873 napi_value setFlagMethod = nullptr;
1874 napi_get_named_property(env, remoteJsObj, "setNewRuleFlag", &setFlagMethod);
1875 bool isCallable = false;
1876 napi_is_callable(env, setFlagMethod, &isCallable);
1877 if (!isCallable) {
1878 TAG_LOGE(AAFwkTag::UIABILITY, "setFlagMethod: %{public}s", setFlagMethod == nullptr ? "nullptr" : "not func");
1879 return nullptr;
1880 }
1881 auto flag = CreateJsValue(env, IsUseNewStartUpRule());
1882 napi_value argv[1] = { flag };
1883 napi_call_function(env, remoteJsObj, setFlagMethod, 1, argv, nullptr);
1884
1885 auto remoteObj = NAPI_ohos_rpc_getNativeRemoteObject(env, remoteJsObj);
1886 if (remoteObj == nullptr) {
1887 TAG_LOGE(AAFwkTag::UIABILITY, "null remoteObj");
1888 return nullptr;
1889 }
1890 return remoteObj;
1891 }
1892 #ifdef SUPPORT_SCREEN
UpdateJsWindowStage(napi_value windowStage)1893 void JsUIAbility::UpdateJsWindowStage(napi_value windowStage)
1894 {
1895 TAG_LOGD(AAFwkTag::UIABILITY, "called");
1896 if (shellContextRef_ == nullptr) {
1897 TAG_LOGE(AAFwkTag::UIABILITY, "null shellContextRef_");
1898 return;
1899 }
1900 napi_value contextObj = shellContextRef_->GetNapiValue();
1901 napi_env env = jsRuntime_.GetNapiEnv();
1902 if (!CheckTypeForNapiValue(env, contextObj, napi_object)) {
1903 TAG_LOGE(AAFwkTag::UIABILITY, "get native context obj failed");
1904 return;
1905 }
1906 if (windowStage == nullptr) {
1907 TAG_LOGE(AAFwkTag::UIABILITY, "null windowStage");
1908 napi_set_named_property(env, contextObj, "windowStage", CreateJsUndefined(env));
1909 return;
1910 }
1911 TAG_LOGD(AAFwkTag::UIABILITY, "set context windowStage");
1912 napi_set_named_property(env, contextObj, "windowStage", windowStage);
1913 }
1914 #endif
CheckSatisfyTargetAPIVersion(int32_t version)1915 bool JsUIAbility::CheckSatisfyTargetAPIVersion(int32_t version)
1916 {
1917 auto applicationInfo = GetApplicationInfo();
1918 if (!applicationInfo) {
1919 TAG_LOGE(AAFwkTag::UIABILITY, "null targetAPIVersion");
1920 return false;
1921 }
1922 TAG_LOGD(AAFwkTag::UIABILITY, "targetAPIVersion: %{public}d", applicationInfo->apiTargetVersion);
1923 return applicationInfo->apiTargetVersion % API_VERSION_MOD >= version;
1924 }
1925
BackPressDefaultValue()1926 bool JsUIAbility::BackPressDefaultValue()
1927 {
1928 return CheckSatisfyTargetAPIVersion(API12) ? true : false;
1929 }
1930
OnAfterFocusedCommon(bool isFocused)1931 void JsUIAbility::OnAfterFocusedCommon(bool isFocused)
1932 {
1933 auto abilityContext = GetAbilityContext();
1934 if (abilityContext == nullptr) {
1935 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
1936 return;
1937 }
1938 auto applicationContext = abilityContext->GetApplicationContext();
1939 if (applicationContext == nullptr || applicationContext->IsAbilityLifecycleCallbackEmpty()) {
1940 TAG_LOGD(AAFwkTag::UIABILITY, "null applicationContext or lifecycleCallback");
1941 return;
1942 }
1943 if (isFocused) {
1944 applicationContext->DispatchWindowStageFocus(GetJsAbility(), GetJsWindowStage());
1945 } else {
1946 applicationContext->DispatchWindowStageUnfocus(GetJsAbility(), GetJsWindowStage());
1947 }
1948 }
1949
SetContinueState(int32_t state)1950 void JsUIAbility::SetContinueState(int32_t state)
1951 {
1952 if (scene_ == nullptr) {
1953 TAG_LOGE(AAFwkTag::UIABILITY, "windowScene is nullptr.");
1954 return;
1955 }
1956 auto window = scene_->GetMainWindow();
1957 if (window == nullptr) {
1958 TAG_LOGE(AAFwkTag::UIABILITY, "window is nullptr.");
1959 return;
1960 }
1961 window->SetContinueState(state);
1962 TAG_LOGI(AAFwkTag::UIABILITY, "window SetContinueState, state: %{public}d.", state);
1963 }
1964 } // namespace AbilityRuntime
1965 } // namespace OHOS
1966