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 "ui_ability.h"
17 
18 #include "ability_lifecycle.h"
19 #include "ability_recovery.h"
20 #include "configuration_convertor.h"
21 #include "event_report.h"
22 #include "hilog_tag_wrapper.h"
23 #include "hitrace_meter.h"
24 #include "js_ui_ability.h"
25 #ifdef CJ_FRONTEND
26 #include "cj_ui_ability.h"
27 #endif
28 #include "ohos_application.h"
29 #include "reverse_continuation_scheduler_primary_stage.h"
30 #include "runtime.h"
31 #include "resource_config_helper.h"
32 #ifdef SUPPORT_GRAPHICS
33 #include "wm_common.h"
34 #endif
35 
36 namespace OHOS {
37 namespace AbilityRuntime {
38 namespace {
39 constexpr char DMS_SESSION_ID[] = "sessionId";
40 constexpr char DMS_ORIGIN_DEVICE_ID[] = "deviceId";
41 constexpr int32_t DEFAULT_DMS_SESSION_ID = 0;
42 constexpr char LAUNCHER_BUNDLE_NAME[] = "com.ohos.launcher";
43 constexpr char LAUNCHER_ABILITY_NAME[] = "com.ohos.launcher.MainAbility";
44 constexpr char SHOW_ON_LOCK_SCREEN[] = "ShowOnLockScreen";
45 
46 #ifdef WITH_DLP
47 constexpr char DLP_PARAMS_SECURITY_FLAG[] = "ohos.dlp.params.securityFlag";
48 #endif // WITH_DLP
49 constexpr char COMPONENT_STARTUP_NEW_RULES[] = "component.startup.newRules";
50 constexpr int32_t ERR_INVALID_VALUE = -1;
51 }
Create(const std::unique_ptr<Runtime> & runtime)52 UIAbility *UIAbility::Create(const std::unique_ptr<Runtime> &runtime)
53 {
54     if (!runtime) {
55         return new (std::nothrow) UIAbility;
56     }
57 
58     switch (runtime->GetLanguage()) {
59         case Runtime::Language::JS:
60             return JsUIAbility::Create(runtime);
61 #ifdef CJ_FRONTEND
62         case Runtime::Language::CJ:
63             return CJUIAbility::Create(runtime);
64 #endif
65         default:
66             return new (std::nothrow) UIAbility();
67     }
68 }
69 
Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,const std::shared_ptr<AppExecFwk::OHOSApplication> application,std::shared_ptr<AppExecFwk::AbilityHandler> & handler,const sptr<IRemoteObject> & token)70 void UIAbility::Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,
71     const std::shared_ptr<AppExecFwk::OHOSApplication> application,
72     std::shared_ptr<AppExecFwk::AbilityHandler> &handler, const sptr<IRemoteObject> &token)
73 {
74     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
75     TAG_LOGD(AAFwkTag::UIABILITY, "called");
76     if (record == nullptr) {
77         TAG_LOGE(AAFwkTag::UIABILITY, "null localRecord");
78         return;
79     }
80     application_ = application;
81     abilityInfo_ = record->GetAbilityInfo();
82     handler_ = handler;
83     token_ = token;
84 #ifdef SUPPORT_GRAPHICS
85     continuationManager_ = std::make_shared<AppExecFwk::ContinuationManagerStage>();
86     std::weak_ptr<AppExecFwk::ContinuationManagerStage> continuationManager = continuationManager_;
87     continuationHandler_ =
88         std::make_shared<AppExecFwk::ContinuationHandlerStage>(continuationManager, weak_from_this());
89     if (!continuationManager_->Init(shared_from_this(), GetToken(), GetAbilityInfo(), continuationHandler_)) {
90         continuationManager_.reset();
91     } else {
92         std::weak_ptr<AppExecFwk::ContinuationHandlerStage> continuationHandler = continuationHandler_;
93         sptr<AppExecFwk::ReverseContinuationSchedulerPrimaryStage> primary =
94             new (std::nothrow) AppExecFwk::ReverseContinuationSchedulerPrimaryStage(continuationHandler, handler_);
95         if (primary == nullptr) {
96             TAG_LOGE(AAFwkTag::UIABILITY, "null primary");
97         } else {
98             continuationHandler_->SetPrimaryStub(primary);
99             continuationHandler_->SetAbilityInfo(abilityInfo_);
100         }
101     }
102     // register displayid change callback
103     TAG_LOGD(AAFwkTag::UIABILITY, "registerDisplayListener");
104     abilityDisplayListener_ = new (std::nothrow) UIAbilityDisplayListener(weak_from_this());
105     if (abilityDisplayListener_ == nullptr) {
106         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityDisplayListener_");
107         return;
108     }
109     TAG_LOGD(AAFwkTag::UIABILITY, "end register");
110     Rosen::WindowManager::GetInstance().RegisterDisplayInfoChangedListener(token_, abilityDisplayListener_);
111 #endif
112     lifecycle_ = std::make_shared<AppExecFwk::LifeCycle>();
113     abilityLifecycleExecutor_ = std::make_shared<AppExecFwk::AbilityLifecycleExecutor>();
114     abilityLifecycleExecutor_->DispatchLifecycleState(AppExecFwk::AbilityLifecycleExecutor::LifecycleState::INITIAL);
115     if (abilityContext_ != nullptr) {
116         abilityContext_->RegisterAbilityCallback(weak_from_this());
117     }
118     TAG_LOGD(AAFwkTag::UIABILITY, "end");
119 }
120 
GetLifecycle()121 std::shared_ptr<OHOS::AppExecFwk::LifeCycle> UIAbility::GetLifecycle()
122 {
123     TAG_LOGD(AAFwkTag::UIABILITY, "called");
124     return lifecycle_;
125 }
126 
RegisterAbilityLifecycleObserver(const std::shared_ptr<AppExecFwk::ILifecycleObserver> & observer)127 void UIAbility::RegisterAbilityLifecycleObserver(const std::shared_ptr<AppExecFwk::ILifecycleObserver> &observer)
128 {
129     TAG_LOGD(AAFwkTag::UIABILITY, "called");
130     if (observer == nullptr) {
131         TAG_LOGE(AAFwkTag::UIABILITY, "null observer");
132         return;
133     }
134     if (lifecycle_ == nullptr) {
135         TAG_LOGE(AAFwkTag::UIABILITY, "null lifecycle_");
136         return;
137     }
138     lifecycle_->AddObserver(observer);
139 }
140 
UnregisterAbilityLifecycleObserver(const std::shared_ptr<AppExecFwk::ILifecycleObserver> & observer)141 void UIAbility::UnregisterAbilityLifecycleObserver(const std::shared_ptr<AppExecFwk::ILifecycleObserver> &observer)
142 {
143     TAG_LOGD(AAFwkTag::UIABILITY, "called");
144     if (observer == nullptr) {
145         TAG_LOGE(AAFwkTag::UIABILITY, "null observer");
146         return;
147     }
148     if (lifecycle_ == nullptr) {
149         TAG_LOGE(AAFwkTag::UIABILITY, "null lifecycle_");
150         return;
151     }
152     lifecycle_->RemoveObserver(observer);
153 }
154 
AttachAbilityContext(const std::shared_ptr<AbilityRuntime::AbilityContext> & abilityContext)155 void UIAbility::AttachAbilityContext(const std::shared_ptr<AbilityRuntime::AbilityContext> &abilityContext)
156 {
157     abilityContext_ = abilityContext;
158 }
159 
OnStart(const AAFwk::Want & want,sptr<AAFwk::SessionInfo> sessionInfo)160 void UIAbility::OnStart(const AAFwk::Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
161 {
162     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
163     if (abilityInfo_ == nullptr) {
164         TAG_LOGE(AAFwkTag::UIABILITY, "null AbilityInfo_");
165         return;
166     }
167 
168 #ifdef WITH_DLP
169     securityFlag_ = want.GetBoolParam(DLP_PARAMS_SECURITY_FLAG, false);
170     (const_cast<AAFwk::Want &>(want)).RemoveParam(DLP_PARAMS_SECURITY_FLAG);
171 #endif // WITH_DLP
172     SetWant(want);
173     TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s.", abilityInfo_->name.c_str());
174 #ifdef SUPPORT_GRAPHICS
175     if (sessionInfo != nullptr) {
176         SetSessionToken(sessionInfo->sessionToken);
177         SetIdentityToken(sessionInfo->identityToken);
178     }
179     OnStartForSupportGraphics(want);
180 #endif
181     if (abilityLifecycleExecutor_ == nullptr) {
182         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityLifecycleExecutor_");
183         return;
184     }
185     abilityLifecycleExecutor_->DispatchLifecycleState(
186         AppExecFwk::AbilityLifecycleExecutor::LifecycleState::STARTED_NEW);
187 
188     if (lifecycle_ == nullptr) {
189         TAG_LOGE(AAFwkTag::UIABILITY, "null lifecycle_");
190         return;
191     }
192     lifecycle_->DispatchLifecycle(AppExecFwk::LifeCycle::Event::ON_START, want);
193     TAG_LOGD(AAFwkTag::UIABILITY, "end");
194 }
195 
OnStop()196 void UIAbility::OnStop()
197 {
198     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
199     TAG_LOGD(AAFwkTag::UIABILITY, "called");
200 #ifdef SUPPORT_GRAPHICS
201     TAG_LOGI(AAFwkTag::UIABILITY, "UnregisterDisplayInfoChangedListener.");
202     (void)Rosen::WindowManager::GetInstance().UnregisterDisplayInfoChangedListener(token_, abilityDisplayListener_);
203     auto &&window = GetWindow();
204     if (window != nullptr) {
205         TAG_LOGD(AAFwkTag::UIABILITY, "UnregisterDisplayMoveListener");
206         window->UnregisterDisplayMoveListener(abilityDisplayMoveListener_);
207     }
208     // Call JS Func(onWindowStageDestroy) and Release the scene.
209     if (scene_ != nullptr) {
210         OnSceneWillDestroy();
211         scene_->GoDestroy();
212         onSceneDestroyed();
213     }
214 #endif
215     if (abilityLifecycleExecutor_ == nullptr) {
216         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityLifecycleExecutor_");
217         return;
218     }
219     abilityLifecycleExecutor_->DispatchLifecycleState(AppExecFwk::AbilityLifecycleExecutor::LifecycleState::INITIAL);
220 
221     if (lifecycle_ == nullptr) {
222         TAG_LOGE(AAFwkTag::UIABILITY, "null lifecycle_");
223         return;
224     }
225     lifecycle_->DispatchLifecycle(AppExecFwk::LifeCycle::Event::ON_STOP);
226 #ifdef SUPPORT_SCREEN
227     Rosen::DisplayManager::GetInstance().RemoveDisplayIdFromAms(token_);
228 #endif
229     TAG_LOGD(AAFwkTag::UIABILITY, "end");
230 }
231 
OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> * callbackInfo,bool & isAsyncCallback)232 void UIAbility::OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callbackInfo, bool &isAsyncCallback)
233 {
234     isAsyncCallback = false;
235     OnStop();
236 }
237 
OnStopCallback()238 void UIAbility::OnStopCallback()
239 {
240     TAG_LOGD(AAFwkTag::UIABILITY, "called");
241 }
242 
DestroyInstance()243 void UIAbility::DestroyInstance()
244 {
245     TAG_LOGD(AAFwkTag::UIABILITY, "called");
246 }
247 
IsRestoredInContinuation() const248 bool UIAbility::IsRestoredInContinuation() const
249 {
250     if (abilityContext_ == nullptr) {
251         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
252         return false;
253     }
254 
255     if (launchParam_.launchReason != AAFwk::LaunchReason::LAUNCHREASON_CONTINUATION) {
256         TAG_LOGD(AAFwkTag::UIABILITY, "launchReason: %{public}d", launchParam_.launchReason);
257         return false;
258     }
259 
260     return true;
261 }
262 
ShouldRecoverState(const AAFwk::Want & want)263 bool UIAbility::ShouldRecoverState(const AAFwk::Want &want)
264 {
265     if (!want.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false)) {
266         TAG_LOGE(AAFwkTag::UIABILITY, "appRecovery not recovery restart");
267         return false;
268     }
269 
270     if (abilityRecovery_ == nullptr) {
271         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityRecovery_");
272         return false;
273     }
274 
275     if (abilityContext_ == nullptr) {
276         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
277         return false;
278     }
279 
280     if (abilityContext_->GetContentStorage() == nullptr) {
281         TAG_LOGE(AAFwkTag::UIABILITY, "get content failed");
282         return false;
283     }
284     return true;
285 }
286 
ShouldDefaultRecoverState(const AAFwk::Want & want)287 bool UIAbility::ShouldDefaultRecoverState(const AAFwk::Want &want)
288 {
289     auto launchParam = GetLaunchParam();
290     if (CheckDefaultRecoveryEnabled() && IsStartByScb() &&
291         want.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false) &&
292         (launchParam.lastExitReason == AAFwk::LastExitReason::LASTEXITREASON_PERFORMANCE_CONTROL ||
293         launchParam.lastExitReason == AAFwk::LastExitReason::LASTEXITREASON_RESOURCE_CONTROL)) {
294         return true;
295     }
296     return false;
297 }
298 
NotifyContinuationResult(const AAFwk::Want & want,bool success)299 void UIAbility::NotifyContinuationResult(const AAFwk::Want &want, bool success)
300 {
301     TAG_LOGD(AAFwkTag::UIABILITY, "called");
302     int sessionId = want.GetIntParam(DMS_SESSION_ID, DEFAULT_DMS_SESSION_ID);
303     std::string originDeviceId = want.GetStringParam(DMS_ORIGIN_DEVICE_ID);
304 
305     if (continuationManager_ == nullptr) {
306         TAG_LOGE(AAFwkTag::UIABILITY, "null continuationManager_");
307         return;
308     }
309     continuationManager_->NotifyCompleteContinuation(
310         originDeviceId, sessionId, success, reverseContinuationSchedulerReplica_);
311 }
312 
OnConfigurationUpdatedNotify(const AppExecFwk::Configuration & configuration)313 void UIAbility::OnConfigurationUpdatedNotify(const AppExecFwk::Configuration &configuration)
314 {
315     TAG_LOGD(AAFwkTag::UIABILITY, "begin");
316     ResourceConfigHelper resourceConfig;
317     InitConfigurationProperties(configuration, resourceConfig);
318     auto resourceManager = GetResourceManager();
319     resourceConfig.UpdateResConfig(configuration, resourceManager);
320 
321     if (abilityContext_ != nullptr && application_ != nullptr) {
322         abilityContext_->SetConfiguration(application_->GetConfiguration());
323     }
324     // Notify Ability Subclass
325     OnConfigurationUpdated(configuration);
326     TAG_LOGD(AAFwkTag::UIABILITY, "end");
327 }
328 
InitConfigurationProperties(const AppExecFwk::Configuration & changeConfiguration,ResourceConfigHelper & resourceConfig)329 void UIAbility::InitConfigurationProperties(const AppExecFwk::Configuration &changeConfiguration,
330     ResourceConfigHelper &resourceConfig)
331 {
332     resourceConfig.SetMcc(changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MCC));
333     resourceConfig.SetMnc(changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_MNC));
334     if (setting_) {
335         auto displayId =
336             std::atoi(setting_->GetProperty(AppExecFwk::AbilityStartSetting::WINDOW_DISPLAY_ID_KEY).c_str());
337         resourceConfig.SetLanguage(changeConfiguration.GetItem(displayId,
338             AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE));
339         resourceConfig.SetColormode(changeConfiguration.GetItem(displayId,
340             AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE));
341         resourceConfig.SetHasPointerDevice(changeConfiguration.GetItem(displayId,
342             AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE));
343         TAG_LOGD(AAFwkTag::UIABILITY, "displayId: [%{public}d], language: [%{public}s], colormode: [%{public}s], "
344             "hasPointerDevice: [%{public}s] mcc: [%{public}s], mnc: [%{public}s]", displayId,
345             resourceConfig.GetLanguage().c_str(), resourceConfig.GetColormode().c_str(),
346             resourceConfig.GetHasPointerDevice().c_str(), resourceConfig.GetMcc().c_str(),
347             resourceConfig.GetMnc().c_str());
348     } else {
349         resourceConfig.SetLanguage(changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE));
350         resourceConfig.SetColormode(changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE));
351         resourceConfig.SetHasPointerDevice(changeConfiguration.GetItem(
352             AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE));
353         TAG_LOGD(AAFwkTag::UIABILITY,
354             "language: [%{public}s], colormode: [%{public}s], hasPointerDevice: [%{public}s] "
355             "mcc: [%{public}s], mnc: [%{public}s]",
356             resourceConfig.GetLanguage().c_str(), resourceConfig.GetColormode().c_str(),
357             resourceConfig.GetHasPointerDevice().c_str(), resourceConfig.GetMcc().c_str(),
358             resourceConfig.GetMnc().c_str());
359     }
360 }
361 
OnMemoryLevel(int level)362 void UIAbility::OnMemoryLevel(int level)
363 {
364     TAG_LOGD(AAFwkTag::UIABILITY, "called");
365     if (scene_ == nullptr) {
366         TAG_LOGE(AAFwkTag::UIABILITY, "null scene");
367         return;
368     }
369     scene_->NotifyMemoryLevel(level);
370 }
371 
GetAbilityName()372 std::string UIAbility::GetAbilityName()
373 {
374     if (abilityInfo_ == nullptr) {
375         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo_");
376         return "";
377     }
378     return abilityInfo_->name;
379 }
380 
GetModuleName()381 std::string UIAbility::GetModuleName()
382 {
383     if (abilityInfo_ == nullptr) {
384         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo_");
385         return "";
386     }
387 
388     return abilityInfo_->moduleName;
389 }
390 
OnAbilityResult(int requestCode,int resultCode,const AAFwk::Want & want)391 void UIAbility::OnAbilityResult(int requestCode, int resultCode, const AAFwk::Want &want)
392 {
393     TAG_LOGD(AAFwkTag::UIABILITY, "called");
394 }
395 
OnNewWant(const AAFwk::Want & want)396 void UIAbility::OnNewWant(const AAFwk::Want &want)
397 {
398     TAG_LOGD(AAFwkTag::UIABILITY, "called");
399 }
400 
OnRestoreAbilityState(const AppExecFwk::PacMap & inState)401 void UIAbility::OnRestoreAbilityState(const AppExecFwk::PacMap &inState)
402 {
403     TAG_LOGD(AAFwkTag::UIABILITY, "called");
404 }
405 
SetWant(const AAFwk::Want & want)406 void UIAbility::SetWant(const AAFwk::Want &want)
407 {
408     std::lock_guard<std::mutex> lock(wantMutexlock_);
409     setWant_ = std::make_shared<AAFwk::Want>(want);
410 }
411 
GetWant()412 std::shared_ptr<AAFwk::Want> UIAbility::GetWant()
413 {
414     std::lock_guard<std::mutex> lock(wantMutexlock_);
415     return setWant_;
416 }
417 
OnConfigurationUpdated(const AppExecFwk::Configuration & configuration)418 void UIAbility::OnConfigurationUpdated(const AppExecFwk::Configuration &configuration)
419 {
420     TAG_LOGD(AAFwkTag::UIABILITY, "called");
421 }
422 
Dump(const std::vector<std::string> & params,std::vector<std::string> & info)423 void UIAbility::Dump(const std::vector<std::string> &params, std::vector<std::string> &info)
424 {
425     TAG_LOGD(AAFwkTag::UIABILITY, "called");
426 }
427 
GetState()428 AppExecFwk::AbilityLifecycleExecutor::LifecycleState UIAbility::GetState()
429 {
430     TAG_LOGD(AAFwkTag::UIABILITY, "called");
431     if (abilityLifecycleExecutor_ == nullptr) {
432         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityLifecycleExecutor_");
433         return AppExecFwk::AbilityLifecycleExecutor::LifecycleState::UNINITIALIZED;
434     }
435     return static_cast<AppExecFwk::AbilityLifecycleExecutor::LifecycleState>(abilityLifecycleExecutor_->GetState());
436 }
437 
OnContinue(AAFwk::WantParams & wantParams)438 int32_t UIAbility::OnContinue(AAFwk::WantParams &wantParams)
439 {
440     return AppExecFwk::ContinuationManagerStage::OnContinueResult::REJECT;
441 }
442 
ContinueAbilityWithStack(const std::string & deviceId,uint32_t versionCode)443 void UIAbility::ContinueAbilityWithStack(const std::string &deviceId, uint32_t versionCode)
444 {
445     if (deviceId.empty()) {
446         TAG_LOGE(AAFwkTag::UIABILITY, "empty deviceId");
447         return;
448     }
449 
450     if (continuationManager_ == nullptr) {
451         TAG_LOGE(AAFwkTag::UIABILITY, "null continuationManager_");
452         return;
453     }
454     continuationManager_->ContinueAbilityWithStack(deviceId, versionCode);
455 }
456 
OnStartContinuation()457 bool UIAbility::OnStartContinuation()
458 {
459     return false;
460 }
461 
OnSaveData(AAFwk::WantParams & saveData)462 bool UIAbility::OnSaveData(AAFwk::WantParams &saveData)
463 {
464     return false;
465 }
466 
OnRestoreData(AAFwk::WantParams & restoreData)467 bool UIAbility::OnRestoreData(AAFwk::WantParams &restoreData)
468 {
469     return false;
470 }
471 
OnSaveState(int32_t reason,AAFwk::WantParams & wantParams)472 int32_t UIAbility::OnSaveState(int32_t reason, AAFwk::WantParams &wantParams)
473 {
474     return ERR_OK;
475 }
476 
OnCompleteContinuation(int result)477 void UIAbility::OnCompleteContinuation(int result)
478 {
479     TAG_LOGD(AAFwkTag::UIABILITY, "called");
480     if (continuationManager_ == nullptr) {
481         TAG_LOGE(AAFwkTag::UIABILITY, "null continuationManager_");
482         return;
483     }
484 
485     continuationManager_->ChangeProcessStateToInit();
486 }
487 
OnRemoteTerminated()488 void UIAbility::OnRemoteTerminated()
489 {
490     TAG_LOGD(AAFwkTag::UIABILITY, "called");
491 }
492 
DispatchLifecycleOnForeground(const AAFwk::Want & want)493 void UIAbility::DispatchLifecycleOnForeground(const AAFwk::Want &want)
494 {
495     if (abilityLifecycleExecutor_ == nullptr) {
496         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityLifecycleExecutor_");
497         return;
498     }
499     abilityLifecycleExecutor_->DispatchLifecycleState(
500         AppExecFwk::AbilityLifecycleExecutor::LifecycleState::FOREGROUND_NEW);
501 
502     if (lifecycle_ == nullptr) {
503         TAG_LOGE(AAFwkTag::UIABILITY, "null lifecycle_");
504         return;
505     }
506     lifecycle_->DispatchLifecycle(AppExecFwk::LifeCycle::Event::ON_FOREGROUND, want);
507 }
508 
HandleCreateAsRecovery(const AAFwk::Want & want)509 void UIAbility::HandleCreateAsRecovery(const AAFwk::Want &want)
510 {
511     if (!want.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false)) {
512         TAG_LOGE(AAFwkTag::UIABILITY, "appRecovery not recovery restart");
513         return;
514     }
515 
516     if (abilityRecovery_ != nullptr) {
517         abilityRecovery_->ScheduleRestoreAbilityState(AppExecFwk::StateReason::DEVELOPER_REQUEST, want);
518     }
519 }
520 
SetStartAbilitySetting(std::shared_ptr<AppExecFwk::AbilityStartSetting> setting)521 void UIAbility::SetStartAbilitySetting(std::shared_ptr<AppExecFwk::AbilityStartSetting> setting)
522 {
523     TAG_LOGD(AAFwkTag::UIABILITY, "called");
524     setting_ = setting;
525 }
526 
SetLaunchParam(const AAFwk::LaunchParam & launchParam)527 void UIAbility::SetLaunchParam(const AAFwk::LaunchParam &launchParam)
528 {
529     TAG_LOGD(AAFwkTag::UIABILITY, "called");
530     launchParam_ = launchParam;
531 }
532 
GetLaunchParam() const533 const AAFwk::LaunchParam &UIAbility::GetLaunchParam() const
534 {
535     return launchParam_;
536 }
537 
GetAbilityContext()538 std::shared_ptr<AbilityRuntime::AbilityContext> UIAbility::GetAbilityContext()
539 {
540     return abilityContext_;
541 }
542 
CallRequest()543 sptr<IRemoteObject> UIAbility::CallRequest()
544 {
545     return nullptr;
546 }
547 
IsUseNewStartUpRule()548 bool UIAbility::IsUseNewStartUpRule()
549 {
550     std::lock_guard<std::mutex> lock(wantMutexlock_);
551     if (!isNewRuleFlagSetted_ && setWant_) {
552         startUpNewRule_ = setWant_->GetBoolParam(COMPONENT_STARTUP_NEW_RULES, false);
553         isNewRuleFlagSetted_ = true;
554     }
555     return startUpNewRule_;
556 }
557 
EnableAbilityRecovery(const std::shared_ptr<AppExecFwk::AbilityRecovery> & abilityRecovery,bool useAppSettedRecoveryValue)558 void UIAbility::EnableAbilityRecovery(const std::shared_ptr<AppExecFwk::AbilityRecovery> &abilityRecovery,
559     bool useAppSettedRecoveryValue)
560 {
561     abilityRecovery_ = abilityRecovery;
562     useAppSettedRecoveryValue_.store(useAppSettedRecoveryValue);
563 }
564 
OnShare(AAFwk::WantParams & wantParams)565 int32_t UIAbility::OnShare(AAFwk::WantParams &wantParams)
566 {
567     return ERR_OK;
568 }
569 
CheckIsSilentForeground() const570 bool UIAbility::CheckIsSilentForeground() const
571 {
572     return isSilentForeground_;
573 }
574 
SetIsSilentForeground(bool isSilentForeground)575 void UIAbility::SetIsSilentForeground(bool isSilentForeground)
576 {
577     isSilentForeground_ = isSilentForeground;
578 }
579 
580 #ifdef SUPPORT_GRAPHICS
OnSceneCreated()581 void UIAbility::OnSceneCreated()
582 {
583     TAG_LOGD(AAFwkTag::UIABILITY, "called");
584 }
585 
OnSceneRestored()586 void UIAbility::OnSceneRestored()
587 {
588     TAG_LOGD(AAFwkTag::UIABILITY, "called");
589 }
590 
OnSceneWillDestroy()591 void UIAbility::OnSceneWillDestroy()
592 {
593     TAG_LOGD(AAFwkTag::UIABILITY, "called");
594 }
595 
onSceneDestroyed()596 void UIAbility::onSceneDestroyed()
597 {
598     TAG_LOGD(AAFwkTag::UIABILITY, "called");
599 }
600 
OnForeground(const AAFwk::Want & want)601 void UIAbility::OnForeground(const AAFwk::Want &want)
602 {
603     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
604     TAG_LOGD(AAFwkTag::UIABILITY, "called");
605     DoOnForeground(want);
606     if (isSilentForeground_) {
607         TAG_LOGD(AAFwkTag::UIABILITY, "silent foreground, return");
608         return;
609     }
610     DispatchLifecycleOnForeground(want);
611     AAFwk::EventInfo eventInfo;
612     eventInfo.bundleName = want.GetElement().GetBundleName();
613     eventInfo.moduleName = want.GetElement().GetModuleName();
614     eventInfo.abilityName = want.GetElement().GetAbilityName();
615     eventInfo.callerBundleName = want.GetStringParam(Want::PARAM_RESV_CALLER_BUNDLE_NAME);
616     if (abilityInfo_ != nullptr) {
617         eventInfo.bundleType = static_cast<int32_t>(abilityInfo_->applicationInfo.bundleType);
618     } else {
619         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo_");
620     }
621     AAFwk::EventReport::SendAbilityEvent(AAFwk::EventName::ABILITY_ONFOREGROUND, HiSysEventType::BEHAVIOR, eventInfo);
622 }
623 
OnBackground()624 void UIAbility::OnBackground()
625 {
626     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
627     TAG_LOGD(AAFwkTag::UIABILITY, "called");
628     if (abilityInfo_ == nullptr) {
629         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo_");
630         return;
631     }
632 
633     if (scene_ != nullptr) {
634         TAG_LOGD(AAFwkTag::UIABILITY, "goBackground sceneFlag: %{public}d", sceneFlag_);
635         scene_->GoBackground(sceneFlag_);
636     }
637 
638     if (abilityRecovery_ != nullptr && abilityContext_ != nullptr && abilityContext_->GetRestoreEnabled() &&
639         CheckRecoveryEnabled()) {
640         abilityRecovery_->ScheduleSaveAbilityState(AppExecFwk::StateReason::LIFECYCLE);
641     }
642 
643     if (abilityLifecycleExecutor_ == nullptr) {
644         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityLifecycleExecutor_");
645         return;
646     }
647     abilityLifecycleExecutor_->DispatchLifecycleState(
648         AppExecFwk::AbilityLifecycleExecutor::LifecycleState::BACKGROUND_NEW);
649 
650     if (lifecycle_ == nullptr) {
651         TAG_LOGE(AAFwkTag::UIABILITY, "null lifecycle_");
652         return;
653     }
654     lifecycle_->DispatchLifecycle(AppExecFwk::LifeCycle::Event::ON_BACKGROUND);
655     AAFwk::EventInfo eventInfo;
656     eventInfo.bundleName = abilityInfo_->bundleName;
657     eventInfo.moduleName = abilityInfo_->moduleName;
658     eventInfo.abilityName = abilityInfo_->name;
659     eventInfo.bundleType = static_cast<int32_t>(abilityInfo_->applicationInfo.bundleType);
660     AAFwk::EventReport::SendAbilityEvent(AAFwk::EventName::ABILITY_ONBACKGROUND, HiSysEventType::BEHAVIOR, eventInfo);
661 }
662 
OnPrepareTerminate()663 bool UIAbility::OnPrepareTerminate()
664 {
665     TAG_LOGD(AAFwkTag::UIABILITY, "called");
666     return false;
667 }
668 
GetWindow()669 const sptr<Rosen::Window> UIAbility::GetWindow()
670 {
671     TAG_LOGD(AAFwkTag::UIABILITY, "called");
672     return nullptr;
673 }
674 
GetScene()675 std::shared_ptr<Rosen::WindowScene> UIAbility::GetScene()
676 {
677     return scene_;
678 }
679 
OnLeaveForeground()680 void UIAbility::OnLeaveForeground()
681 {
682     TAG_LOGD(AAFwkTag::UIABILITY, "called");
683 }
684 
GetContentInfo()685 std::string UIAbility::GetContentInfo()
686 {
687     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
688     if (scene_ == nullptr) {
689         TAG_LOGE(AAFwkTag::UIABILITY, "null scene");
690         return "";
691     }
692     return scene_->GetContentInfo(Rosen::BackupAndRestoreType::CONTINUATION);
693 }
694 
GetContentInfoForRecovery()695 std::string UIAbility::GetContentInfoForRecovery()
696 {
697     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
698     if (scene_ == nullptr) {
699         TAG_LOGE(AAFwkTag::UIABILITY, "Scene invalid.");
700         return "";
701     }
702     return scene_->GetContentInfo(Rosen::BackupAndRestoreType::APP_RECOVERY);
703 }
704 
GetContentInfoForDefaultRecovery()705 std::string UIAbility::GetContentInfoForDefaultRecovery()
706 {
707     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
708     if (scene_ == nullptr) {
709         TAG_LOGE(AAFwkTag::UIABILITY, "Scene invalid.");
710         return "";
711     }
712     return scene_->GetContentInfo(Rosen::BackupAndRestoreType::RESOURCESCHEDULE_RECOVERY);
713 }
714 
SetSceneListener(const sptr<Rosen::IWindowLifeCycle> & listener)715 void UIAbility::SetSceneListener(const sptr<Rosen::IWindowLifeCycle> &listener)
716 {
717     sceneListener_ = listener;
718 }
719 
DoOnForeground(const AAFwk::Want & want)720 void UIAbility::DoOnForeground(const AAFwk::Want &want)
721 {
722     TAG_LOGD(AAFwkTag::UIABILITY, "called");
723 }
724 
GetCurrentWindowMode()725 int32_t UIAbility::GetCurrentWindowMode()
726 {
727     TAG_LOGD(AAFwkTag::UIABILITY, "called");
728     auto windowMode = static_cast<int>(Rosen::WindowMode::WINDOW_MODE_UNDEFINED);
729     if (scene_ == nullptr) {
730         return windowMode;
731     }
732     auto window = scene_->GetMainWindow();
733     if (window != nullptr) {
734         windowMode = static_cast<int>(window->GetMode());
735     }
736     return windowMode;
737 }
738 
SetMissionLabel(const std::string & label)739 ErrCode UIAbility::SetMissionLabel(const std::string &label)
740 {
741     TAG_LOGD(AAFwkTag::UIABILITY, "called");
742     if (!abilityInfo_ || abilityInfo_->type != AppExecFwk::AbilityType::PAGE) {
743         TAG_LOGE(AAFwkTag::UIABILITY, "invalid ability info");
744         return ERR_INVALID_VALUE;
745     }
746 
747     if (scene_ == nullptr) {
748         TAG_LOGE(AAFwkTag::UIABILITY, "null scene");
749         return ERR_INVALID_VALUE;
750     }
751     auto window = scene_->GetMainWindow();
752     if (window == nullptr) {
753         TAG_LOGE(AAFwkTag::UIABILITY, "get window scene failed");
754         return ERR_INVALID_VALUE;
755     }
756 
757     if (window->SetAPPWindowLabel(label) != OHOS::Rosen::WMError::WM_OK) {
758         TAG_LOGE(AAFwkTag::UIABILITY, "setAPPWindowLabel failed");
759         return ERR_INVALID_VALUE;
760     }
761     return ERR_OK;
762 }
763 
SetMissionIcon(const std::shared_ptr<OHOS::Media::PixelMap> & icon)764 ErrCode UIAbility::SetMissionIcon(const std::shared_ptr<OHOS::Media::PixelMap> &icon)
765 {
766     TAG_LOGD(AAFwkTag::UIABILITY, "called");
767     if (!abilityInfo_ || abilityInfo_->type != AppExecFwk::AbilityType::PAGE) {
768         TAG_LOGE(AAFwkTag::UIABILITY, "abilityInfo_ is nullptr or not page type");
769         return ERR_INVALID_VALUE;
770     }
771 
772     if (scene_ == nullptr) {
773         TAG_LOGE(AAFwkTag::UIABILITY, "null scene_");
774         return ERR_INVALID_VALUE;
775     }
776     auto window = scene_->GetMainWindow();
777     if (window == nullptr) {
778         TAG_LOGE(AAFwkTag::UIABILITY, "null window");
779         return ERR_INVALID_VALUE;
780     }
781 
782     if (window->SetAPPWindowIcon(icon) != OHOS::Rosen::WMError::WM_OK) {
783         TAG_LOGE(AAFwkTag::UIABILITY, "setAPPWindowIcon failed");
784         return ERR_INVALID_VALUE;
785     }
786     return ERR_OK;
787 }
788 
GetWindowRect(int32_t & left,int32_t & top,int32_t & width,int32_t & height)789 void UIAbility::GetWindowRect(int32_t &left, int32_t &top, int32_t &width, int32_t &height)
790 {
791     TAG_LOGD(AAFwkTag::UIABILITY, "called");
792     if (scene_ == nullptr) {
793         TAG_LOGE(AAFwkTag::UIABILITY, "null scene");
794         return;
795     }
796     auto window = scene_->GetMainWindow();
797     if (window == nullptr) {
798         TAG_LOGE(AAFwkTag::UIABILITY, "null window");
799         return;
800     }
801     left = window->GetRect().posX_;
802     top = window->GetRect().posY_;
803     width = static_cast<int32_t>(window->GetRect().width_);
804     height = static_cast<int32_t>(window->GetRect().height_);
805     TAG_LOGD(AAFwkTag::UIABILITY, "left: %{public}d, top: %{public}d, width: %{public}d, height: %{public}d",
806         left, top, width, height);
807 }
808 
GetUIContent()809 Ace::UIContent *UIAbility::GetUIContent()
810 {
811     TAG_LOGD(AAFwkTag::UIABILITY, "called");
812     if (scene_ == nullptr) {
813         TAG_LOGE(AAFwkTag::UIABILITY, "null scene_");
814         return nullptr;
815     }
816     auto window = scene_->GetMainWindow();
817     if (window == nullptr) {
818         TAG_LOGE(AAFwkTag::UIABILITY, "null window");
819         return nullptr;
820     }
821     return window->GetUIContent();
822 }
823 
OnCreate(Rosen::DisplayId displayId)824 void UIAbility::OnCreate(Rosen::DisplayId displayId)
825 {
826     TAG_LOGD(AAFwkTag::UIABILITY, "called");
827 }
828 
OnDestroy(Rosen::DisplayId displayId)829 void UIAbility::OnDestroy(Rosen::DisplayId displayId)
830 {
831     TAG_LOGD(AAFwkTag::UIABILITY, "called");
832 }
833 
OnDisplayInfoChange(const sptr<IRemoteObject> & token,Rosen::DisplayId displayId,float density,Rosen::DisplayOrientation orientation)834 void UIAbility::OnDisplayInfoChange(const sptr<IRemoteObject>& token, Rosen::DisplayId displayId, float density,
835     Rosen::DisplayOrientation orientation)
836 {
837     TAG_LOGD(AAFwkTag::UIABILITY, "displayId: %{public}" PRIu64, displayId);
838     // Get display
839     auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId);
840     if (!display) {
841         TAG_LOGE(AAFwkTag::UIABILITY, "get display by displayId %{public}" PRIu64 " failed", displayId);
842         return;
843     }
844 
845     // Notify ResourceManager
846     int32_t width = display->GetWidth();
847     int32_t height = display->GetHeight();
848     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
849     if (resConfig != nullptr) {
850         auto resourceManager = GetResourceManager();
851         if (resourceManager != nullptr) {
852             resourceManager->GetResConfig(*resConfig);
853             resConfig->SetScreenDensity(density);
854             resConfig->SetDirection(AppExecFwk::ConvertDirection(height, width));
855             resourceManager->UpdateResConfig(*resConfig);
856             TAG_LOGD(AAFwkTag::UIABILITY, "notify resourceManager, density: %{public}f, direction: %{public}d",
857                 resConfig->GetScreenDensity(), resConfig->GetDirection());
858         }
859     }
860 
861     // Notify ability
862     Configuration newConfig;
863     newConfig.AddItem(
864         displayId, AppExecFwk::ConfigurationInner::APPLICATION_DIRECTION, AppExecFwk::GetDirectionStr(height, width));
865     newConfig.AddItem(
866         displayId, AppExecFwk::ConfigurationInner::APPLICATION_DENSITYDPI, AppExecFwk::GetDensityStr(density));
867 
868     if (application_ == nullptr) {
869         TAG_LOGE(AAFwkTag::UIABILITY, "null application_");
870         return;
871     }
872 
873     OnChangeForUpdateConfiguration(newConfig);
874     TAG_LOGD(AAFwkTag::UIABILITY, "end");
875 }
876 
OnChange(Rosen::DisplayId displayId)877 void UIAbility::OnChange(Rosen::DisplayId displayId)
878 {
879     TAG_LOGD(AAFwkTag::UIABILITY, "displayId: %{public}" PRIu64 "", displayId);
880     // Get display
881     auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId);
882     if (!display) {
883         TAG_LOGE(AAFwkTag::UIABILITY, "get display by displayId %{public}" PRIu64 " failed", displayId);
884         return;
885     }
886 
887     // Notify ResourceManager
888     float density = display->GetVirtualPixelRatio();
889     int32_t width = display->GetWidth();
890     int32_t height = display->GetHeight();
891     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
892     if (resConfig != nullptr) {
893         auto resourceManager = GetResourceManager();
894         if (resourceManager != nullptr) {
895             resourceManager->GetResConfig(*resConfig);
896             resConfig->SetScreenDensity(density);
897             resConfig->SetDirection(AppExecFwk::ConvertDirection(height, width));
898             resourceManager->UpdateResConfig(*resConfig);
899             TAG_LOGD(AAFwkTag::UIABILITY, "notify ResourceManager, density: %{public}f, direction: %{public}d",
900                 resConfig->GetScreenDensity(), resConfig->GetDirection());
901         }
902     }
903 
904     // Notify ability
905     Configuration newConfig;
906     newConfig.AddItem(
907         displayId, AppExecFwk::ConfigurationInner::APPLICATION_DIRECTION, AppExecFwk::GetDirectionStr(height, width));
908     newConfig.AddItem(
909         displayId, AppExecFwk::ConfigurationInner::APPLICATION_DENSITYDPI, AppExecFwk::GetDensityStr(density));
910 
911     if (application_ == nullptr) {
912         TAG_LOGE(AAFwkTag::UIABILITY, "null application_");
913         return;
914     }
915 
916     OnChangeForUpdateConfiguration(newConfig);
917     TAG_LOGD(AAFwkTag::UIABILITY, "end");
918 }
919 
OnDisplayMove(Rosen::DisplayId from,Rosen::DisplayId to)920 void UIAbility::OnDisplayMove(Rosen::DisplayId from, Rosen::DisplayId to)
921 {
922     TAG_LOGD(AAFwkTag::UIABILITY, "from displayId %{public}" PRIu64 " to %{public}" PRIu64 "", from, to);
923     auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(to);
924     if (!display) {
925         TAG_LOGE(AAFwkTag::UIABILITY, "get display by displayId %{public}" PRIu64 " failed", to);
926         return;
927     }
928     // Get new display config
929     float density = display->GetVirtualPixelRatio();
930     int32_t width = display->GetWidth();
931     int32_t height = display->GetHeight();
932     std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
933     if (resConfig != nullptr) {
934         auto resourceManager = GetResourceManager();
935         if (resourceManager != nullptr) {
936             resourceManager->GetResConfig(*resConfig);
937             resConfig->SetScreenDensity(density);
938             resConfig->SetDirection(AppExecFwk::ConvertDirection(height, width));
939             resourceManager->UpdateResConfig(*resConfig);
940             TAG_LOGD(AAFwkTag::UIABILITY,
941                 "Density: %{public}f, direction: %{public}d", resConfig->GetScreenDensity(), resConfig->GetDirection());
942         }
943     }
944         UpdateConfiguration(to, density, width, height);
945 }
946 
UpdateConfiguration(Rosen::DisplayId to,float density,int32_t width,int32_t height)947 void UIAbility::UpdateConfiguration(Rosen::DisplayId to, float density, int32_t width, int32_t height)
948 {
949     AppExecFwk::Configuration newConfig;
950     newConfig.AddItem(AppExecFwk::ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(to));
951     newConfig.AddItem(
952         to, AppExecFwk::ConfigurationInner::APPLICATION_DIRECTION, AppExecFwk::GetDirectionStr(height, width));
953     newConfig.AddItem(to, AppExecFwk::ConfigurationInner::APPLICATION_DENSITYDPI, AppExecFwk::GetDensityStr(density));
954     if (application_ == nullptr || handler_ == nullptr) {
955         TAG_LOGE(AAFwkTag::UIABILITY, "null application_ or handler_");
956         return;
957     }
958     std::vector<std::string> changeKeyV;
959     auto configuration = application_->GetConfiguration();
960     if (!configuration) {
961         TAG_LOGE(AAFwkTag::UIABILITY, "null configuration");
962         return;
963     }
964 
965     configuration->CompareDifferent(changeKeyV, newConfig);
966     TAG_LOGD(AAFwkTag::UIABILITY, "changeKeyV size: %{public}zu", changeKeyV.size());
967     if (!changeKeyV.empty()) {
968         configuration->Merge(changeKeyV, newConfig);
969         auto task = [abilityWptr = weak_from_this(), configuration = *configuration]() {
970             auto ability = abilityWptr.lock();
971             if (ability == nullptr) {
972                 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
973                 return;
974             }
975             ability->OnConfigurationUpdated(configuration);
976         };
977         handler_->PostTask(task);
978     }
979 }
980 
RequestFocus(const AAFwk::Want & want)981 void UIAbility::RequestFocus(const AAFwk::Want &want)
982 {
983     TAG_LOGD(AAFwkTag::UIABILITY, "called");
984 }
985 
InitWindow(int32_t displayId,sptr<Rosen::WindowOption> option)986 void UIAbility::InitWindow(int32_t displayId, sptr<Rosen::WindowOption> option)
987 {
988     TAG_LOGD(AAFwkTag::UIABILITY, "called");
989 }
990 
GetWindowOption(const AAFwk::Want & want)991 sptr<Rosen::WindowOption> UIAbility::GetWindowOption(const AAFwk::Want &want)
992 {
993     auto option = sptr<Rosen::WindowOption>::MakeSptr();
994     if (option == nullptr) {
995         TAG_LOGE(AAFwkTag::UIABILITY, "null option");
996         return nullptr;
997     }
998     auto windowMode = want.GetIntParam(
999         AAFwk::Want::PARAM_RESV_WINDOW_MODE, AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
1000     TAG_LOGD(AAFwkTag::UIABILITY, "window mode: %{public}d", windowMode);
1001     option->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
1002     bool showOnLockScreen = false;
1003     if (abilityInfo_) {
1004         std::vector<AppExecFwk::CustomizeData> datas = abilityInfo_->metaData.customizeData;
1005         for (AppExecFwk::CustomizeData data : datas) {
1006             if (data.name == SHOW_ON_LOCK_SCREEN) {
1007                 showOnLockScreen = true;
1008             }
1009         }
1010     }
1011     if (showOnLockScreen_ || showOnLockScreen) {
1012         TAG_LOGD(AAFwkTag::UIABILITY, "add window flag WINDOW_FLAG_SHOW_WHEN_LOCKED");
1013         option->AddWindowFlag(Rosen::WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
1014     }
1015 
1016     if (want.GetElement().GetBundleName() == LAUNCHER_BUNDLE_NAME &&
1017         want.GetElement().GetAbilityName() == LAUNCHER_ABILITY_NAME) {
1018         TAG_LOGD(AAFwkTag::UIABILITY, "set window type for launcher");
1019         option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_DESKTOP);
1020     }
1021     return option;
1022 }
1023 
ContinuationRestore(const AAFwk::Want & want)1024 void UIAbility::ContinuationRestore(const AAFwk::Want &want)
1025 {
1026     TAG_LOGD(AAFwkTag::UIABILITY, "called");
1027 }
1028 
OnStartForSupportGraphics(const AAFwk::Want & want)1029 void UIAbility::OnStartForSupportGraphics(const AAFwk::Want &want)
1030 {
1031     if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) {
1032         int32_t defualtDisplayId = static_cast<int32_t>(Rosen::DisplayManager::GetInstance().GetDefaultDisplayId());
1033         int32_t displayId = want.GetIntParam(AAFwk::Want::PARAM_RESV_DISPLAY_ID, defualtDisplayId);
1034         TAG_LOGD(AAFwkTag::UIABILITY, "abilityName: %{public}s, displayId: %{public}d",
1035             abilityInfo_->name.c_str(), displayId);
1036 #ifdef SUPPORT_SCREEN
1037         Rosen::DisplayManager::GetInstance().AddDisplayIdFromAms(displayId, token_);
1038 #endif
1039         auto option = GetWindowOption(want);
1040         InitWindow(displayId, option);
1041 
1042         // Update resMgr, Configuration
1043         TAG_LOGD(AAFwkTag::UIABILITY, "displayId: %{public}d", displayId);
1044         auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId);
1045         if (display) {
1046             float density = display->GetVirtualPixelRatio();
1047             int32_t width = display->GetWidth();
1048             int32_t height = display->GetHeight();
1049             std::shared_ptr<AppExecFwk::Configuration> configuration = nullptr;
1050             if (application_) {
1051                 configuration = application_->GetConfiguration();
1052             }
1053             if (configuration) {
1054                 std::string direction = AppExecFwk::GetDirectionStr(height, width);
1055                 configuration->AddItem(displayId, AppExecFwk::ConfigurationInner::APPLICATION_DIRECTION, direction);
1056                 configuration->AddItem(displayId, AppExecFwk::ConfigurationInner::APPLICATION_DENSITYDPI,
1057                     AppExecFwk::GetDensityStr(density));
1058                 configuration->AddItem(
1059                     AppExecFwk::ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(displayId));
1060                 UpdateContextConfiguration();
1061             }
1062 
1063             std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
1064             if (resConfig == nullptr) {
1065                 TAG_LOGE(AAFwkTag::UIABILITY, "null resConfig");
1066                 return;
1067             }
1068             auto resourceManager = GetResourceManager();
1069             if (resourceManager != nullptr) {
1070                 resourceManager->GetResConfig(*resConfig);
1071                 resConfig->SetScreenDensity(density);
1072                 resConfig->SetDirection(AppExecFwk::ConvertDirection(height, width));
1073                 resourceManager->UpdateResConfig(*resConfig);
1074                 TAG_LOGD(AAFwkTag::UIABILITY, "density: %{public}f, direction: %{public}d",
1075                     resConfig->GetScreenDensity(), resConfig->GetDirection());
1076             }
1077         }
1078     }
1079 }
1080 
OnChangeForUpdateConfiguration(const AppExecFwk::Configuration & newConfig)1081 void UIAbility::OnChangeForUpdateConfiguration(const AppExecFwk::Configuration &newConfig)
1082 {
1083     if (application_ == nullptr || handler_ == nullptr) {
1084         TAG_LOGE(AAFwkTag::UIABILITY, "null application_ or handler_");
1085         return;
1086     }
1087     auto configuration = application_->GetConfiguration();
1088     if (!configuration) {
1089         TAG_LOGE(AAFwkTag::UIABILITY, "null configuration");
1090         return;
1091     }
1092 
1093     std::vector<std::string> changeKeyV;
1094     configuration->CompareDifferent(changeKeyV, newConfig);
1095     TAG_LOGD(AAFwkTag::UIABILITY, "changeKeyV size: %{public}zu", changeKeyV.size());
1096     if (!changeKeyV.empty()) {
1097         configuration->Merge(changeKeyV, newConfig);
1098         auto task = [abilityWptr = weak_from_this(), configuration = *configuration]() {
1099             auto ability = abilityWptr.lock();
1100             if (ability == nullptr) {
1101                 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
1102                 return;
1103             }
1104             ability->OnConfigurationUpdated(configuration);
1105         };
1106         handler_->PostTask(task);
1107     }
1108 }
1109 
CallOnForegroundFunc(const AAFwk::Want & want)1110 void UIAbility::CallOnForegroundFunc(const AAFwk::Want &want)
1111 {
1112     TAG_LOGD(AAFwkTag::UIABILITY, "called");
1113 }
1114 
ExecuteInsightIntentRepeateForeground(const AAFwk::Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)1115 void UIAbility::ExecuteInsightIntentRepeateForeground(const AAFwk::Want &want,
1116     const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1117     std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
1118 {
1119     TAG_LOGD(AAFwkTag::UIABILITY, "called");
1120 }
1121 
ExecuteInsightIntentMoveToForeground(const AAFwk::Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)1122 void UIAbility::ExecuteInsightIntentMoveToForeground(const AAFwk::Want &want,
1123     const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1124     std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
1125 {
1126     TAG_LOGD(AAFwkTag::UIABILITY, "called");
1127 }
1128 
ExecuteInsightIntentBackground(const AAFwk::Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)1129 void UIAbility::ExecuteInsightIntentBackground(const AAFwk::Want &want,
1130     const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
1131     std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
1132 {
1133     TAG_LOGD(AAFwkTag::UIABILITY, "called");
1134 }
1135 
CreateModalUIExtension(const AAFwk::Want & want)1136 int UIAbility::CreateModalUIExtension(const AAFwk::Want &want)
1137 {
1138     TAG_LOGD(AAFwkTag::UIABILITY, "call");
1139     auto abilityContextImpl = GetAbilityContext();
1140     if (abilityContextImpl == nullptr) {
1141         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
1142         return ERR_INVALID_VALUE;
1143     }
1144     return abilityContextImpl->CreateModalUIExtensionWithApp(want);
1145 }
1146 
SetSessionToken(sptr<IRemoteObject> sessionToken)1147 void UIAbility::SetSessionToken(sptr<IRemoteObject> sessionToken)
1148 {
1149     std::lock_guard lock(sessionTokenMutex_);
1150     sessionToken_ = sessionToken;
1151     auto abilityContextImpl = GetAbilityContext();
1152     if (abilityContextImpl == nullptr) {
1153         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
1154         return;
1155     }
1156     abilityContextImpl->SetWeakSessionToken(sessionToken);
1157 }
1158 
UpdateSessionToken(sptr<IRemoteObject> sessionToken)1159 void UIAbility::UpdateSessionToken(sptr<IRemoteObject> sessionToken)
1160 {
1161     SetSessionToken(sessionToken);
1162 }
1163 
EraseUIExtension(int32_t sessionId)1164 void UIAbility::EraseUIExtension(int32_t sessionId)
1165 {
1166     TAG_LOGD(AAFwkTag::UIABILITY, "call");
1167     auto abilityContextImpl = GetAbilityContext();
1168     if (abilityContextImpl == nullptr) {
1169         TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext");
1170         return;
1171     }
1172     abilityContextImpl->EraseUIExtension(sessionId);
1173 }
1174 
SetIdentityToken(const std::string & identityToken)1175 void UIAbility::SetIdentityToken(const std::string &identityToken)
1176 {
1177     identityToken_ = identityToken;
1178 }
1179 
GetIdentityToken() const1180 std::string UIAbility::GetIdentityToken() const
1181 {
1182     return identityToken_;
1183 }
1184 
CheckRecoveryEnabled()1185 bool UIAbility::CheckRecoveryEnabled()
1186 {
1187     if (useAppSettedRecoveryValue_.load()) {
1188         TAG_LOGD(AAFwkTag::UIABILITY, "Use app setted value.");
1189         // Check in app recovery, here return true.
1190         return true;
1191     }
1192 
1193     return CheckDefaultRecoveryEnabled();
1194 }
1195 
CheckDefaultRecoveryEnabled()1196 bool UIAbility::CheckDefaultRecoveryEnabled()
1197 {
1198     if (abilityContext_ == nullptr) {
1199         TAG_LOGW(AAFwkTag::UIABILITY, "context invalid");
1200         return false;
1201     }
1202 
1203     return abilityContext_->GetRestoreEnabled();
1204 }
1205 
IsStartByScb()1206 bool UIAbility::IsStartByScb()
1207 {
1208     if (setting_ == nullptr) {
1209         TAG_LOGW(AAFwkTag::UIABILITY, "setting is nullptr.");
1210         return false;
1211     }
1212 
1213     auto value = setting_->GetProperty(AppExecFwk::AbilityStartSetting::IS_START_BY_SCB_KEY);
1214     if (value == "true") {
1215         TAG_LOGD(AAFwkTag::UIABILITY, "Start by scb.");
1216         return true;
1217     }
1218 
1219     return false;
1220 }
1221 #endif
1222 } // namespace AbilityRuntime
1223 } // namespace OHOS
1224