1 /*
2 * Copyright (c) 2021-2022 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 "ability.h"
17
18 #include <cinttypes>
19 #include <thread>
20
21 #include "ability_impl.h"
22 #include "ability_loader.h"
23 #include "ability_post_event_timeout.h"
24 #include "ability_recovery.h"
25 #include "ability_runtime/js_ability.h"
26 #include "abs_shared_result_set.h"
27 #include "app_recovery.h"
28 #include "hitrace_meter.h"
29 #include "configuration_convertor.h"
30 #include "connection_manager.h"
31 #include "context_impl.h"
32 #include "continuation_manager.h"
33 #include "continuation_register_manager.h"
34 #include "continuation_register_manager_proxy.h"
35 #include "data_ability_operation.h"
36 #include "data_ability_predicates.h"
37 #include "data_ability_result.h"
38 #include "data_uri_utils.h"
39 #include "hilog_wrapper.h"
40 #include "if_system_ability_manager.h"
41 #include "ipc_skeleton.h"
42 #include "iservice_registry.h"
43 #include "ohos_application.h"
44 #include "reverse_continuation_scheduler_primary.h"
45 #include "reverse_continuation_scheduler_replica.h"
46 #include "reverse_continuation_scheduler_replica_handler_interface.h"
47 #include "runtime.h"
48 #include "string_wrapper.h"
49 #include "system_ability_definition.h"
50 #include "task_handler_client.h"
51 #include "values_bucket.h"
52 #include "event_report.h"
53
54 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
55 #include "background_task_mgr_helper.h"
56 #include "continuous_task_param.h"
57 #endif
58
59 #ifdef SUPPORT_GRAPHICS
60 #include "display_type.h"
61 #include "form_host_client.h"
62 #include "form_mgr.h"
63 #include "form_mgr_errors.h"
64 #include "form_provider_client.h"
65 #include "key_event.h"
66 #endif
67
68 namespace OHOS {
69 namespace AppExecFwk {
70 // REGISTER_AA(Ability)
71 const std::string Ability::SYSTEM_UI("com.ohos.systemui");
72 const std::string Ability::STATUS_BAR("com.ohos.systemui.statusbar.MainAbility");
73 const std::string Ability::NAVIGATION_BAR("com.ohos.systemui.navigationbar.MainAbility");
74 const std::string Ability::KEYGUARD("com.ohos.screenlock");
75 const std::string DEVICE_MANAGER_BUNDLE_NAME = "com.ohos.devicemanagerui";
76 const std::string DEVICE_MANAGER_NAME = "com.ohos.devicemanagerui.MainAbility";
77 const std::string Ability::DMS_SESSION_ID("sessionId");
78 const std::string Ability::DMS_ORIGIN_DEVICE_ID("deviceId");
79 const int Ability::DEFAULT_DMS_SESSION_ID(0);
80 const std::string PERMISSION_REQUIRE_FORM = "ohos.permission.REQUIRE_FORM";
81 const std::string LAUNCHER_BUNDLE_NAME = "com.ohos.launcher";
82 const std::string LAUNCHER_ABILITY_NAME = "com.ohos.launcher.MainAbility";
83 const std::string SHOW_ON_LOCK_SCREEN = "ShowOnLockScreen";
84 const std::string DLP_INDEX = "ohos.dlp.params.index";
85 const std::string DLP_PARAMS_SECURITY_FLAG = "ohos.dlp.params.securityFlag";
86 const std::string COMPONENT_STARTUP_NEW_RULES = "component.startup.newRules";
87
Create(const std::unique_ptr<AbilityRuntime::Runtime> & runtime)88 Ability* Ability::Create(const std::unique_ptr<AbilityRuntime::Runtime>& runtime)
89 {
90 if (!runtime) {
91 return new Ability;
92 }
93
94 switch (runtime->GetLanguage()) {
95 case AbilityRuntime::Runtime::Language::JS:
96 return AbilityRuntime::JsAbility::Create(runtime);
97
98 default:
99 return new Ability();
100 }
101 }
102
Init(const std::shared_ptr<AbilityInfo> & abilityInfo,const std::shared_ptr<OHOSApplication> application,std::shared_ptr<AbilityHandler> & handler,const sptr<IRemoteObject> & token)103 void Ability::Init(const std::shared_ptr<AbilityInfo> &abilityInfo, const std::shared_ptr<OHOSApplication> application,
104 std::shared_ptr<AbilityHandler> &handler, const sptr<IRemoteObject> &token)
105 {
106 HILOG_DEBUG("%{public}s begin.", __func__);
107 application_ = application;
108 abilityInfo_ = abilityInfo;
109 handler_ = handler;
110 AbilityContext::token_ = token;
111
112 #ifdef SUPPORT_GRAPHICS
113 // page ability only.
114 if (abilityInfo_->type == AbilityType::PAGE) {
115 if (!abilityInfo_->isStageBasedModel) {
116 abilityWindow_ = std::make_shared<AbilityWindow>();
117 abilityWindow_->Init(handler_, shared_from_this());
118 } else {
119 AppRecovery::GetInstance().AddAbility(shared_from_this(), GetAbilityInfo(), GetToken());
120 }
121 continuationManager_ = std::make_shared<ContinuationManager>();
122 std::weak_ptr<Ability> ability = shared_from_this();
123 std::weak_ptr<ContinuationManager> continuationManager = continuationManager_;
124 continuationHandler_ = std::make_shared<ContinuationHandler>(continuationManager, ability);
125 if (!continuationManager_->Init(shared_from_this(), GetToken(), GetAbilityInfo(), continuationHandler_)) {
126 continuationManager_.reset();
127 } else {
128 std::weak_ptr<ContinuationHandler> continuationHandler = continuationHandler_;
129 sptr<ReverseContinuationSchedulerPrimary> primary = sptr<ReverseContinuationSchedulerPrimary>(
130 new (std::nothrow) ReverseContinuationSchedulerPrimary(continuationHandler, handler_));
131 if (primary == nullptr) {
132 HILOG_ERROR("Ability::Init failed,primary create failed");
133 } else {
134 continuationHandler_->SetPrimaryStub(primary);
135 continuationHandler_->SetAbilityInfo(abilityInfo_);
136 }
137 }
138
139 // register displayid change callback
140 HILOG_DEBUG("Ability::Init call RegisterDisplayListener");
141 abilityDisplayListener_ = new AbilityDisplayListener(ability);
142 Rosen::DisplayManager::GetInstance().RegisterDisplayListener(abilityDisplayListener_);
143 }
144 #endif
145 lifecycle_ = std::make_shared<LifeCycle>();
146 abilityLifecycleExecutor_ = std::make_shared<AbilityLifecycleExecutor>();
147 if (abilityLifecycleExecutor_ != nullptr) {
148 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::INITIAL);
149 } else {
150 HILOG_ERROR("%{public}s abilityLifecycleExecutor_ make failed.", __func__);
151 }
152
153 if (abilityContext_ != nullptr) {
154 abilityContext_->RegisterAbilityCallback(weak_from_this());
155 }
156 HILOG_DEBUG("%{public}s end.", __func__);
157 }
158
AttachAbilityContext(const std::shared_ptr<AbilityRuntime::AbilityContext> & abilityContext)159 void Ability::AttachAbilityContext(const std::shared_ptr<AbilityRuntime::AbilityContext> &abilityContext)
160 {
161 abilityContext_ = abilityContext;
162 }
163
GetResourceManager() const164 std::shared_ptr<Global::Resource::ResourceManager> Ability::GetResourceManager() const
165 {
166 return AbilityContext::GetResourceManager();
167 }
168
IsUpdatingConfigurations()169 bool Ability::IsUpdatingConfigurations()
170 {
171 return AbilityContext::IsUpdatingConfigurations();
172 }
173
OnStart(const Want & want)174 void Ability::OnStart(const Want &want)
175 {
176 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
177 if (abilityInfo_ == nullptr) {
178 HILOG_ERROR("Ability::OnStart failed abilityInfo_ is nullptr.");
179 return;
180 }
181
182 appIndex_ = want.GetIntParam(DLP_INDEX, 0);
183 (const_cast<Want &>(want)).RemoveParam(DLP_INDEX);
184 securityFlag_ = want.GetBoolParam(DLP_PARAMS_SECURITY_FLAG, false);
185 (const_cast<Want &>(want)).RemoveParam(DLP_PARAMS_SECURITY_FLAG);
186 SetWant(want);
187 HILOG_INFO("%{public}s begin, ability is %{public}s.", __func__, abilityInfo_->name.c_str());
188 #ifdef SUPPORT_GRAPHICS
189 if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) {
190 int defualtDisplayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID;
191 int displayId = want.GetIntParam(Want::PARAM_RESV_DISPLAY_ID, defualtDisplayId);
192 HILOG_DEBUG("abilityName:%{public}s, displayId:%{public}d", abilityInfo_->name.c_str(), displayId);
193 auto option = GetWindowOption(want);
194 InitWindow(displayId, option);
195
196 if (abilityWindow_ != nullptr) {
197 HILOG_DEBUG("%{public}s get window from abilityWindow.", __func__);
198 auto window = abilityWindow_->GetWindow();
199 if (window) {
200 HILOG_DEBUG("Call RegisterDisplayMoveListener, windowId: %{public}d", window->GetWindowId());
201 abilityDisplayMoveListener_ = new AbilityDisplayMoveListener(weak_from_this());
202 window->RegisterDisplayMoveListener(abilityDisplayMoveListener_);
203 }
204 }
205
206 // Update resMgr, Configuration
207 HILOG_DEBUG("%{public}s get display by displayId %{public}d.", __func__, displayId);
208 auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId);
209 if (display) {
210 float density = display->GetVirtualPixelRatio();
211 int32_t width = display->GetWidth();
212 int32_t height = display->GetHeight();
213 std::shared_ptr<Configuration> configuration = nullptr;
214 if (application_) {
215 configuration = application_->GetConfiguration();
216 }
217 if (configuration) {
218 std::string direction = GetDirectionStr(height, width);
219 configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DIRECTION, direction);
220 configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI, GetDensityStr(density));
221 configuration->AddItem(ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(displayId));
222 UpdateContextConfiguration();
223 }
224
225 std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
226 if (resConfig == nullptr) {
227 HILOG_ERROR("%{public}s error, resConfig is nullptr.", __func__);
228 return;
229 }
230 auto resourceManager = GetResourceManager();
231 if (resourceManager != nullptr) {
232 resourceManager->GetResConfig(*resConfig);
233 resConfig->SetScreenDensity(density);
234 resConfig->SetDirection(ConvertDirection(height, width));
235 resourceManager->UpdateResConfig(*resConfig);
236 HILOG_DEBUG("%{public}s Notify ResourceManager, Density: %{public}f, Direction: %{public}d.", __func__,
237 resConfig->GetScreenDensity(), resConfig->GetDirection());
238 }
239 }
240 }
241 #endif
242 if (abilityLifecycleExecutor_ == nullptr) {
243 HILOG_ERROR("Ability::OnStart error. abilityLifecycleExecutor_ == nullptr.");
244 return;
245 }
246 if (!abilityInfo_->isStageBasedModel) {
247 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::INACTIVE);
248 } else {
249 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::STARTED_NEW);
250 }
251
252 if (lifecycle_ == nullptr) {
253 HILOG_ERROR("Ability::OnStart error. lifecycle_ == nullptr.");
254 return;
255 }
256 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_START, want);
257 HILOG_DEBUG("%{public}s end", __func__);
258 }
259
OnStop()260 void Ability::OnStop()
261 {
262 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
263 HILOG_DEBUG("%{public}s begin", __func__);
264 if (abilityRecovery_ != nullptr) {
265 abilityRecovery_->ScheduleSaveAbilityState(StateReason::LIFECYCLE);
266 }
267 #ifdef SUPPORT_GRAPHICS
268 (void)Rosen::DisplayManager::GetInstance().UnregisterDisplayListener(abilityDisplayListener_);
269 auto && window = GetWindow();
270 if (window != nullptr) {
271 HILOG_DEBUG("Call UnregisterDisplayMoveListener");
272 window->UnregisterDisplayMoveListener(abilityDisplayMoveListener_);
273 }
274 // Call JS Func(onWindowStageDestroy) and Release the scene.
275 if (scene_ != nullptr) {
276 scene_->GoDestroy();
277 onSceneDestroyed();
278 }
279 #endif
280 if (abilityLifecycleExecutor_ == nullptr) {
281 HILOG_ERROR("Ability::OnStop error. abilityLifecycleExecutor_ == nullptr.");
282 return;
283 }
284 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::INITIAL);
285 if (lifecycle_ == nullptr) {
286 HILOG_ERROR("Ability::OnStop error. lifecycle_ == nullptr.");
287 return;
288 }
289 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_STOP);
290 HILOG_DEBUG("%{public}s end", __func__);
291 }
292
OnStop(AbilityTransactionCallbackInfo<> * callbackInfo,bool & isAsyncCallback)293 void Ability::OnStop(AbilityTransactionCallbackInfo<> *callbackInfo, bool &isAsyncCallback)
294 {
295 isAsyncCallback = false;
296 OnStop();
297 }
298
OnStopCallback()299 void Ability::OnStopCallback()
300 {
301 }
302
DestroyInstance()303 void Ability::DestroyInstance()
304 {
305 HILOG_DEBUG("%{public}s begin", __func__);
306 #ifdef SUPPORT_GRAPHICS
307 // Release the window.
308 if (abilityWindow_ != nullptr && abilityInfo_->type == AppExecFwk::AbilityType::PAGE) {
309 abilityWindow_->OnPostAbilityStop(); // Ability instance will been released when window destroy.
310 }
311 #endif
312 HILOG_DEBUG("%{public}s end", __func__);
313 }
314
OnActive()315 void Ability::OnActive()
316 {
317 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
318 HILOG_DEBUG("%{public}s begin.", __func__);
319 #ifdef SUPPORT_GRAPHICS
320 bWindowFocus_ = true;
321 #endif
322 if (abilityLifecycleExecutor_ == nullptr) {
323 HILOG_ERROR("Ability::OnActive error. abilityLifecycleExecutor_ == nullptr.");
324 return;
325 }
326 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::ACTIVE);
327
328 if (lifecycle_ == nullptr) {
329 HILOG_ERROR("Ability::OnActive error. lifecycle_ == nullptr.");
330 return;
331 }
332 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_ACTIVE);
333 AAFwk::EventInfo eventInfo;
334 eventInfo.bundleName = abilityInfo_->bundleName;
335 eventInfo.moduleName = abilityInfo_->moduleName;
336 eventInfo.abilityName = abilityInfo_->name;
337 eventInfo.abilityType = static_cast<int32_t>(abilityInfo_->type);
338 AAFwk::EventReport::SendAbilityEvent(AAFwk::EventName::ABILITY_ONACTIVE,
339 HiSysEventType::BEHAVIOR, eventInfo);
340 HILOG_DEBUG("%{public}s end.", __func__);
341 }
342
OnInactive()343 void Ability::OnInactive()
344 {
345 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
346 HILOG_DEBUG("%{public}s begin", __func__);
347 #ifdef SUPPORT_GRAPHICS
348 bWindowFocus_ = false;
349 #endif
350 if (abilityLifecycleExecutor_ == nullptr) {
351 HILOG_ERROR("Ability::OnInactive error. abilityLifecycleExecutor_ == nullptr.");
352 return;
353 }
354 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::INACTIVE);
355
356 if (lifecycle_ == nullptr) {
357 HILOG_ERROR("Ability::OnInactive error. lifecycle_ == nullptr.");
358 return;
359 }
360 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_INACTIVE);
361 AAFwk::EventInfo eventInfo;
362 eventInfo.bundleName = abilityInfo_->bundleName;
363 eventInfo.moduleName = abilityInfo_->moduleName;
364 eventInfo.abilityName = abilityInfo_->name;
365 AAFwk::EventReport::SendAbilityEvent(AAFwk::EventName::ABILITY_ONINACTIVE,
366 HiSysEventType::BEHAVIOR, eventInfo);
367 HILOG_DEBUG("%{public}s end", __func__);
368 }
369
IsRestoredInContinuation() const370 bool Ability::IsRestoredInContinuation() const
371 {
372 if (abilityContext_ == nullptr) {
373 HILOG_ERROR("abilityContext_ is null");
374 return false;
375 }
376
377 if (launchParam_.launchReason != LaunchReason::LAUNCHREASON_CONTINUATION) {
378 HILOG_DEBUG("launchReason is %{public}d", launchParam_.launchReason);
379 return false;
380 }
381
382 if (abilityContext_->GetContentStorage() == nullptr) {
383 HILOG_DEBUG("not Restored In Continuation");
384 return false;
385 }
386
387 HILOG_DEBUG("Is Restored In Continuation");
388 return true;
389 }
390
ShouldRecoverState(const Want & want)391 bool Ability::ShouldRecoverState(const Want& want)
392 {
393 if (abilityRecovery_ == nullptr) {
394 HILOG_ERROR("AppRecovery Not enable");
395 return false;
396 }
397
398 if (abilityContext_ == nullptr) {
399 HILOG_ERROR("AppRecovery abilityContext_ is null");
400 return false;
401 }
402
403 if (abilityContext_->GetContentStorage() == nullptr) {
404 HILOG_ERROR("AppRecovery abilityContext_ GetContentStorage is null");
405 return false;
406 }
407
408 if (!want.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false)) {
409 HILOG_ERROR("AppRecovery not recovery restart");
410 return false;
411 }
412
413 return true;
414 }
415
NotifyContinuationResult(const Want & want,bool success)416 void Ability::NotifyContinuationResult(const Want& want, bool success)
417 {
418 HILOG_INFO("NotifyContinuationResult begin");
419
420 int sessionId = want.GetIntParam(DMS_SESSION_ID, DEFAULT_DMS_SESSION_ID);
421 std::string originDeviceId = want.GetStringParam(DMS_ORIGIN_DEVICE_ID);
422 HILOG_DEBUG("Ability::NotifyContinuationComplete");
423 continuationManager_->NotifyCompleteContinuation(
424 originDeviceId, sessionId, success, reverseContinuationSchedulerReplica_);
425 }
426
OnConnect(const Want & want)427 sptr<IRemoteObject> Ability::OnConnect(const Want &want)
428 {
429 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
430 HILOG_DEBUG("%{public}s begin", __func__);
431 if (abilityLifecycleExecutor_ == nullptr) {
432 HILOG_ERROR("Ability::OnConnect error. abilityLifecycleExecutor_ == nullptr.");
433 return nullptr;
434 }
435 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::ACTIVE);
436
437 if (lifecycle_ == nullptr) {
438 HILOG_ERROR("Ability::OnConnect error. lifecycle_ == nullptr.");
439 return nullptr;
440 }
441 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_ACTIVE);
442 HILOG_DEBUG("%{public}s end", __func__);
443 return nullptr;
444 }
445
OnDisconnect(const Want & want)446 void Ability::OnDisconnect(const Want &want)
447 {
448 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
449 HILOG_DEBUG("%{public}s come", __func__);
450 }
451
StartAbilityForResult(const Want & want,int requestCode)452 ErrCode Ability::StartAbilityForResult(const Want &want, int requestCode)
453 {
454 HILOG_DEBUG("%{public}s begin.", __func__);
455 if (abilityInfo_ == nullptr) {
456 HILOG_ERROR("Ability::StartAbilityForResult abilityInfo_ == nullptr");
457 return ERR_NULL_OBJECT;
458 }
459 HILOG_DEBUG("Ability::StartAbilityForResult called type = %{public}d", abilityInfo_->type);
460 if (abilityInfo_->type != AppExecFwk::AbilityType::PAGE) {
461 HILOG_ERROR("Ability::StartAbility ability type: %{public}d", abilityInfo_->type);
462 return ERR_INVALID_VALUE;
463 }
464 ErrCode err = AbilityContext::StartAbility(want, requestCode);
465 HILOG_DEBUG("%{public}s end.", __func__);
466 return err;
467 }
468
StartAbilityForResult(const Want & want,int requestCode,AbilityStartSetting abilityStartSetting)469 ErrCode Ability::StartAbilityForResult(const Want &want, int requestCode, AbilityStartSetting abilityStartSetting)
470 {
471 HILOG_DEBUG("%{public}s begin.", __func__);
472 if (abilityInfo_ == nullptr) {
473 HILOG_ERROR("Ability::StartAbilityForResult abilityInfo_ == nullptr");
474 return ERR_NULL_OBJECT;
475 }
476 HILOG_DEBUG("Ability::StartAbilityForResult called type = %{public}d", abilityInfo_->type);
477 if (abilityInfo_->type != AppExecFwk::AbilityType::PAGE) {
478 HILOG_ERROR("Ability::StartAbility ability type: %{public}d", abilityInfo_->type);
479 return ERR_INVALID_VALUE;
480 }
481 ErrCode err = AbilityContext::StartAbility(want, requestCode, abilityStartSetting);
482 HILOG_DEBUG("%{public}s end.", __func__);
483 return err;
484 }
485
StartAbility(const Want & want,AbilityStartSetting abilityStartSetting)486 ErrCode Ability::StartAbility(const Want &want, AbilityStartSetting abilityStartSetting)
487 {
488 HILOG_DEBUG("%{public}s beign.", __func__);
489 if (abilityInfo_ == nullptr) {
490 HILOG_ERROR("Ability::StartAbility abilityInfo_ == nullptr");
491 return ERR_NULL_OBJECT;
492 }
493 HILOG_DEBUG("Ability::StartAbility called type = %{public}d", abilityInfo_->type);
494 if (abilityInfo_->type != AppExecFwk::AbilityType::PAGE && abilityInfo_->type != AppExecFwk::AbilityType::SERVICE) {
495 HILOG_ERROR("Ability::StartAbility ability type: %{public}d", abilityInfo_->type);
496 return ERR_INVALID_VALUE;
497 }
498 ErrCode err = AbilityContext::StartAbility(want, -1, abilityStartSetting);
499 HILOG_DEBUG("%{public}s end.", __func__);
500 return err;
501 }
502
GetType(const Uri & uri)503 std::string Ability::GetType(const Uri &uri)
504 {
505 return "";
506 }
507
Insert(const Uri & uri,const NativeRdb::ValuesBucket & value)508 int Ability::Insert(const Uri &uri, const NativeRdb::ValuesBucket &value)
509 {
510 return 0;
511 }
512
Call(const Uri & uri,const std::string & method,const std::string & arg,const AppExecFwk::PacMap & pacMap)513 std::shared_ptr<AppExecFwk::PacMap> Ability::Call(
514 const Uri &uri, const std::string &method, const std::string &arg, const AppExecFwk::PacMap &pacMap)
515 {
516 return nullptr;
517 }
518
OnConfigurationUpdated(const Configuration & configuration)519 void Ability::OnConfigurationUpdated(const Configuration &configuration)
520 {
521 HILOG_DEBUG("%{public}s called.", __func__);
522 }
523
OnConfigurationUpdatedNotify(const Configuration & configuration)524 void Ability::OnConfigurationUpdatedNotify(const Configuration &configuration)
525 {
526 HILOG_DEBUG("%{public}s begin.", __func__);
527
528 std::string language;
529 std::string colormode;
530 std::string hasPointerDevice;
531 InitConfigurationProperties(configuration, language, colormode, hasPointerDevice);
532 // Notify ResourceManager
533 std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
534 if (resConfig == nullptr) {
535 HILOG_ERROR("Create res config failed.");
536 return;
537 }
538 auto resourceManager = GetResourceManager();
539 if (resourceManager != nullptr) {
540 resourceManager->GetResConfig(*resConfig);
541 #ifdef SUPPORT_GRAPHICS
542 if (!language.empty()) {
543 UErrorCode status = U_ZERO_ERROR;
544 icu::Locale locale = icu::Locale::forLanguageTag(language, status);
545 HILOG_DEBUG("get Locale::forLanguageTag return[%{public}d].", static_cast<int>(status));
546 if (status == U_ZERO_ERROR) {
547 resConfig->SetLocaleInfo(locale);
548 }
549 }
550 #endif
551 if (!colormode.empty()) {
552 resConfig->SetColorMode(ConvertColorMode(colormode));
553 }
554 if (!hasPointerDevice.empty()) {
555 resConfig->SetInputDevice(ConvertHasPointerDevice(hasPointerDevice));
556 }
557 resourceManager->UpdateResConfig(*resConfig);
558 HILOG_INFO("Notify ResourceManager, current colorMode: %{public}d, hasPointerDevice: %{publis}d.",
559 resConfig->GetColorMode(), resConfig->GetInputDevice());
560 }
561
562 if (abilityContext_ != nullptr && application_ != nullptr) {
563 abilityContext_->SetConfiguration(application_->GetConfiguration());
564 }
565 // Notify Ability Subclass
566 OnConfigurationUpdated(configuration);
567 HILOG_DEBUG("%{public}s Notify Ability Subclass.", __func__);
568 }
569
InitConfigurationProperties(const Configuration & changeConfiguration,std::string & language,std::string & colormode,std::string & hasPointerDevice)570 void Ability::InitConfigurationProperties(const Configuration& changeConfiguration, std::string& language,
571 std::string& colormode, std::string& hasPointerDevice)
572 {
573 if (setting_) {
574 auto displayId = std::atoi(setting_->GetProperty(AbilityStartSetting::WINDOW_DISPLAY_ID_KEY).c_str());
575 language = changeConfiguration.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
576 colormode = changeConfiguration.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
577 hasPointerDevice = changeConfiguration.GetItem(displayId, AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE);
578 HILOG_INFO("displayId: [%{public}d], language: [%{public}s], colormode: [%{public}s], "
579 "hasPointerDevice: [%{public}s]", displayId, language.c_str(), colormode.c_str(), hasPointerDevice.c_str());
580 } else {
581 language = changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
582 colormode = changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
583 hasPointerDevice = changeConfiguration.GetItem(AAFwk::GlobalConfigurationKey::INPUT_POINTER_DEVICE);
584 HILOG_INFO("language: [%{public}s], colormode: [%{public}s], hasPointerDevice: [%{public}s]",
585 language.c_str(), colormode.c_str(), hasPointerDevice.c_str());
586 }
587 }
588
OnMemoryLevel(int level)589 void Ability::OnMemoryLevel(int level)
590 {
591 HILOG_INFO("%{public}s start.", __func__);
592 if (scene_ == nullptr) {
593 HILOG_DEBUG("WindowScene is null");
594 return;
595 }
596 scene_->NotifyMemoryLevel(level);
597 }
598
OpenRawFile(const Uri & uri,const std::string & mode)599 int Ability::OpenRawFile(const Uri &uri, const std::string &mode)
600 {
601 return -1;
602 }
603
Update(const Uri & uri,const NativeRdb::ValuesBucket & value,const NativeRdb::DataAbilityPredicates & predicates)604 int Ability::Update(
605 const Uri &uri, const NativeRdb::ValuesBucket &value, const NativeRdb::DataAbilityPredicates &predicates)
606 {
607 return 0;
608 }
609
GetApplication()610 std::shared_ptr<OHOSApplication> Ability::GetApplication()
611 {
612 HILOG_DEBUG("%{public}s begin.", __func__);
613 if (application_ == nullptr) {
614 HILOG_ERROR("Ability::GetApplication error. application_ == nullptr.");
615 return nullptr;
616 }
617 HILOG_DEBUG("%{public}s end.", __func__);
618 return application_;
619 }
620
GetAbilityName()621 std::string Ability::GetAbilityName()
622 {
623 if (abilityInfo_ == nullptr) {
624 HILOG_ERROR("Ability::GetAbilityName abilityInfo_ is nullptr");
625 return "";
626 }
627
628 return abilityInfo_->name;
629 }
630
IsTerminating()631 bool Ability::IsTerminating()
632 {
633 return false;
634 }
635
OnAbilityResult(int requestCode,int resultCode,const Want & want)636 void Ability::OnAbilityResult(int requestCode, int resultCode, const Want &want)
637 {}
638
OnBackPressed()639 void Ability::OnBackPressed()
640 {
641 HILOG_DEBUG("%{public}s begin.", __func__);
642 if (abilityInfo_ == nullptr) {
643 HILOG_ERROR("Ability::OnBackPressed abilityInfo_ is nullptr");
644 return;
645 }
646
647 if (abilityInfo_->isLauncherAbility == false) {
648 HILOG_DEBUG("Ability::OnBackPressed the ability is not Launcher");
649 TerminateAbility();
650 }
651 HILOG_DEBUG("%{public}s end.", __func__);
652 }
653
OnNewWant(const Want & want)654 void Ability::OnNewWant(const Want &want)
655 {
656 HILOG_DEBUG("Ability::OnNewWant called");
657 }
658
OnRestoreAbilityState(const PacMap & inState)659 void Ability::OnRestoreAbilityState(const PacMap &inState)
660 {
661 HILOG_DEBUG("Ability::OnRestoreAbilityState called");
662 }
663
OnSaveAbilityState(PacMap & outState)664 void Ability::OnSaveAbilityState(PacMap &outState)
665 {
666 HILOG_DEBUG("Ability::OnSaveAbilityState called");
667 }
668
OnEventDispatch()669 void Ability::OnEventDispatch()
670 {}
671
SetWant(const AAFwk::Want & want)672 void Ability::SetWant(const AAFwk::Want &want)
673 {
674 setWant_ = std::make_shared<AAFwk::Want>(want);
675 }
676
GetWant()677 std::shared_ptr<AAFwk::Want> Ability::GetWant()
678 {
679 return setWant_;
680 }
681
SetResult(int resultCode,const Want & resultData)682 void Ability::SetResult(int resultCode, const Want &resultData)
683 {
684 HILOG_DEBUG("%{public}s begin.", __func__);
685 if (abilityInfo_ == nullptr) {
686 HILOG_ERROR("Ability::SetResult abilityInfo_ == nullptr");
687 return;
688 }
689 HILOG_DEBUG("Ability::SetResult called type = %{public}d", abilityInfo_->type);
690 if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) {
691 AbilityContext::resultWant_ = resultData;
692 AbilityContext::resultCode_ = resultCode;
693 }
694 HILOG_DEBUG("%{public}s end.", __func__);
695 }
696
OnCommand(const AAFwk::Want & want,bool restart,int startId)697 void Ability::OnCommand(const AAFwk::Want &want, bool restart, int startId)
698 {
699 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
700 HILOG_INFO(
701 "%{public}s begin restart=%{public}s,startId=%{public}d.", __func__, restart ? "true" : "false", startId);
702 if (abilityLifecycleExecutor_ == nullptr) {
703 HILOG_ERROR("Ability::OnCommand error. abilityLifecycleExecutor_ == nullptr.");
704 return;
705 }
706 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::ACTIVE);
707
708 if (lifecycle_ == nullptr) {
709 HILOG_ERROR("Ability::OnCommand error. lifecycle_ == nullptr.");
710 return;
711 }
712 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_ACTIVE);
713 HILOG_DEBUG("%{public}s end.", __func__);
714 }
715
Dump(const std::string & extra)716 void Ability::Dump(const std::string &extra)
717 {
718 HILOG_DEBUG("Ability::Dump called");
719 // abilityInfo
720 HILOG_DEBUG("==============AbilityInfo==============");
721 if (abilityInfo_ != nullptr) {
722 HILOG_DEBUG("abilityInfo: package: %{public}s", abilityInfo_->package.c_str());
723 HILOG_DEBUG("abilityInfo: name: %{public}s", abilityInfo_->name.c_str());
724 HILOG_DEBUG("abilityInfo: label: %{public}s", abilityInfo_->label.c_str());
725 HILOG_DEBUG("abilityInfo: description: %{public}s", abilityInfo_->description.c_str());
726 HILOG_DEBUG("abilityInfo: iconPath: %{public}s", abilityInfo_->iconPath.c_str());
727 HILOG_DEBUG("abilityInfo: visible: %{public}d", abilityInfo_->visible);
728 HILOG_DEBUG("abilityInfo: kind: %{public}s", abilityInfo_->kind.c_str());
729 HILOG_DEBUG("abilityInfo: type: %{public}d", abilityInfo_->type);
730 HILOG_DEBUG("abilityInfo: orientation: %{public}d", abilityInfo_->orientation);
731 HILOG_DEBUG("abilityInfo: launchMode: %{public}d", abilityInfo_->launchMode);
732 for (auto permission : abilityInfo_->permissions) {
733 HILOG_DEBUG("abilityInfo: permission: %{public}s", permission.c_str());
734 }
735 HILOG_DEBUG("abilityInfo: bundleName: %{public}s", abilityInfo_->bundleName.c_str());
736 HILOG_DEBUG("abilityInfo: applicationName: %{public}s", abilityInfo_->applicationName.c_str());
737 } else {
738 HILOG_DEBUG("abilityInfo is nullptr");
739 }
740
741 // lifecycle_Event
742 HILOG_DEBUG("==============lifecycle_Event==============");
743 if (lifecycle_ != nullptr) {
744 HILOG_DEBUG("lifecycle_Event: launchMode: %{public}d", lifecycle_->GetLifecycleState());
745 } else {
746 HILOG_DEBUG("lifecycle is nullptr");
747 }
748
749 // lifecycle_State
750 HILOG_DEBUG("==============lifecycle_State==============");
751 if (abilityLifecycleExecutor_ != nullptr) {
752 HILOG_DEBUG("lifecycle_State: launchMode: %{public}d", abilityLifecycleExecutor_->GetState());
753 } else {
754 HILOG_DEBUG("abilityLifecycleExecutor is nullptr");
755 }
756
757 // applicationInfo
758 HILOG_DEBUG("==============applicationInfo==============");
759 std::shared_ptr<ApplicationInfo> ApplicationInfoPtr = GetApplicationInfo();
760 if (ApplicationInfoPtr != nullptr) {
761 HILOG_DEBUG("applicationInfo: name: %{public}s", ApplicationInfoPtr->name.c_str());
762 HILOG_DEBUG("applicationInfo: bundleName: %{public}s", ApplicationInfoPtr->bundleName.c_str());
763 } else {
764 HILOG_DEBUG("ApplicationInfoPtr is nullptr");
765 }
766 }
767
Dump(const std::vector<std::string> & params,std::vector<std::string> & info)768 void Ability::Dump(const std::vector<std::string> ¶ms, std::vector<std::string> &info)
769 {}
770
KeepBackgroundRunning(int id,const NotificationRequest & notificationRequest)771 void Ability::KeepBackgroundRunning(int id, const NotificationRequest ¬ificationRequest)
772 {}
773
CancelBackgroundRunning()774 void Ability::CancelBackgroundRunning()
775 {}
776
NormalizeUri(const Uri & uri)777 Uri Ability::NormalizeUri(const Uri &uri)
778 {
779 return uri;
780 }
781
Delete(const Uri & uri,const NativeRdb::DataAbilityPredicates & predicates)782 int Ability::Delete(const Uri &uri, const NativeRdb::DataAbilityPredicates &predicates)
783 {
784 return 0;
785 }
786
GetFileTypes(const Uri & uri,const std::string & mimeTypeFilter)787 std::vector<std::string> Ability::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
788 {
789 return types_;
790 }
791
OpenFile(const Uri & uri,const std::string & mode)792 int Ability::OpenFile(const Uri &uri, const std::string &mode)
793 {
794 return -1;
795 }
796
Query(const Uri & uri,const std::vector<std::string> & columns,const NativeRdb::DataAbilityPredicates & predicates)797 std::shared_ptr<NativeRdb::AbsSharedResultSet> Ability::Query(
798 const Uri &uri, const std::vector<std::string> &columns, const NativeRdb::DataAbilityPredicates &predicates)
799 {
800 return nullptr;
801 }
802
Reload(const Uri & uri,const PacMap & extras)803 bool Ability::Reload(const Uri &uri, const PacMap &extras)
804 {
805 return false;
806 }
807
BatchInsert(const Uri & uri,const std::vector<NativeRdb::ValuesBucket> & values)808 int Ability::BatchInsert(const Uri &uri, const std::vector<NativeRdb::ValuesBucket> &values)
809 {
810 HILOG_DEBUG("%{public}s begin.", __func__);
811 int amount = 0;
812 for (auto it = values.begin(); it != values.end(); it++) {
813 if (Insert(uri, *it) >= 0) {
814 amount++;
815 }
816 }
817 HILOG_DEBUG("%{public}s end, amount=%{public}d", __func__, amount);
818 return amount;
819 }
820
ContinueAbilityReversibly(const std::string & deviceId)821 void Ability::ContinueAbilityReversibly(const std::string &deviceId)
822 {
823 if (!VerifySupportForContinuation()) {
824 HILOG_ERROR("Ability::ContinueAbilityReversibly(deviceId) failed. VerifySupportForContinuation faled");
825 return;
826 }
827 continuationManager_->ContinueAbility(true, deviceId);
828 }
829
GetOriginalDeviceId()830 std::string Ability::GetOriginalDeviceId()
831 {
832 return "";
833 }
834
GetContinuationState()835 ContinuationState Ability::GetContinuationState()
836 {
837 if (!VerifySupportForContinuation()) {
838 HILOG_ERROR("Ability::GetContinuationState failed. VerifySupportForContinuation faled");
839 return ContinuationState::LOCAL_RUNNING;
840 }
841 return continuationManager_->GetContinuationState();
842 }
843
DenormalizeUri(const Uri & uri)844 Uri Ability::DenormalizeUri(const Uri &uri)
845 {
846 return uri;
847 }
848
GetLifecycle()849 std::shared_ptr<LifeCycle> Ability::GetLifecycle()
850 {
851 HILOG_DEBUG("Ability::GetLifecycle called");
852 return lifecycle_;
853 }
854
GetState()855 AbilityLifecycleExecutor::LifecycleState Ability::GetState()
856 {
857 HILOG_DEBUG("Ability::GetState called");
858
859 if (abilityLifecycleExecutor_ == nullptr) {
860 HILOG_ERROR("Ability::GetState error. abilityLifecycleExecutor_ == nullptr.");
861 return AbilityLifecycleExecutor::LifecycleState::UNINITIALIZED;
862 }
863
864 return (AbilityLifecycleExecutor::LifecycleState)abilityLifecycleExecutor_->GetState();
865 }
866
StartAbility(const Want & want)867 ErrCode Ability::StartAbility(const Want &want)
868 {
869 HILOG_DEBUG("%{public}s begin Ability::StartAbility", __func__);
870 return AbilityContext::StartAbility(want, -1);
871 }
872
PostTask(std::function<void ()> task,long delayTime)873 void Ability::PostTask(std::function<void()> task, long delayTime)
874 {
875 HILOG_DEBUG("%{public}s begin.", __func__);
876 TaskHandlerClient::GetInstance()->PostTask(task, delayTime);
877 HILOG_DEBUG("%{public}s end.", __func__);
878 }
879
GetContinuationRegisterManager()880 std::weak_ptr<IContinuationRegisterManager> Ability::GetContinuationRegisterManager()
881 {
882 if (abilityInfo_ != nullptr) {
883 if ((abilityInfo_->type == AbilityType::PAGE) && (continuationRegisterManager_ == nullptr)) {
884 std::weak_ptr<Context> context = shared_from_this();
885 std::shared_ptr<ContinuationRegisterManagerProxy> continuationRegisterManagerProxy =
886 std::make_shared<ContinuationRegisterManagerProxy>(context);
887 continuationRegisterManager_ = std::make_shared<ContinuationRegisterManager>();
888 continuationRegisterManager_->Init(continuationRegisterManagerProxy);
889 }
890 }
891 std::weak_ptr<IContinuationRegisterManager> continuationRegisterManager =
892 std::weak_ptr<IContinuationRegisterManager>(continuationRegisterManager_);
893 return continuationRegisterManager;
894 }
895
OnContinue(WantParams & wantParams)896 int32_t Ability::OnContinue(WantParams &wantParams)
897 {
898 return ContinuationManager::OnContinueResult::Reject;
899 }
900
ContinueAbilityWithStack(const std::string & deviceId,uint32_t versionCode)901 void Ability::ContinueAbilityWithStack(const std::string &deviceId, uint32_t versionCode)
902 {
903 if (deviceId.empty()) {
904 HILOG_ERROR("ContinueAbilityWithStack(deviceId) failed. deviceId is empty");
905 return;
906 }
907
908 if (!VerifySupportForContinuation()) {
909 HILOG_ERROR("ContinueAbilityWithStack(deviceId) failed. VerifySupportForContinuation failed");
910 return;
911 }
912 continuationManager_->ContinueAbilityWithStack(deviceId, versionCode);
913 }
914
ContinueAbility(const std::string & deviceId)915 void Ability::ContinueAbility(const std::string &deviceId)
916 {
917 if (deviceId.empty()) {
918 HILOG_ERROR("Ability::ContinueAbility(deviceId) failed. deviceId is empty");
919 return;
920 }
921
922 if (!VerifySupportForContinuation()) {
923 HILOG_ERROR("Ability::ContinueAbility(deviceId) failed. VerifySupportForContinuation failed");
924 return;
925 }
926 continuationManager_->ContinueAbility(false, deviceId);
927 }
928
OnStartContinuation()929 bool Ability::OnStartContinuation()
930 {
931 return false;
932 }
933
OnSaveData(WantParams & saveData)934 bool Ability::OnSaveData(WantParams &saveData)
935 {
936 return false;
937 }
938
OnRestoreData(WantParams & restoreData)939 bool Ability::OnRestoreData(WantParams &restoreData)
940 {
941 return false;
942 }
943
OnSaveState(int32_t reason,WantParams & wantParams)944 int32_t Ability::OnSaveState(int32_t reason, WantParams &wantParams)
945 {
946 return 0;
947 }
948
OnCompleteContinuation(int result)949 void Ability::OnCompleteContinuation(int result)
950 {
951 HILOG_DEBUG("Ability::OnCompleteContinuation change continuation state to initial");
952 if (continuationManager_ == nullptr) {
953 HILOG_ERROR("Continuation manager is nullptr.");
954 return;
955 }
956
957 continuationManager_->ChangeProcessStateToInit();
958 }
959
OnRemoteTerminated()960 void Ability::OnRemoteTerminated()
961 {}
962
DispatchLifecycleOnForeground(const Want & want)963 void Ability::DispatchLifecycleOnForeground(const Want &want)
964 {
965 if (abilityLifecycleExecutor_ == nullptr) {
966 HILOG_ERROR("Ability::OnForeground error. abilityLifecycleExecutor_ == nullptr.");
967 return;
968 }
969 if (abilityInfo_ != nullptr && abilityInfo_->isStageBasedModel) {
970 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::FOREGROUND_NEW);
971 } else {
972 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::INACTIVE);
973 }
974 if (lifecycle_ == nullptr) {
975 HILOG_ERROR("Ability::OnForeground error. lifecycle_ == nullptr.");
976 return;
977 }
978 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_FOREGROUND, want);
979 }
980
VerifySupportForContinuation()981 bool Ability::VerifySupportForContinuation()
982 {
983 if (continuationManager_ == nullptr) {
984 HILOG_ERROR("Ability::VerifySupportForContinuation failed. continuationManager_ is nullptr");
985 return false;
986 }
987 return true;
988 }
989
HandleCreateAsContinuation(const Want & want)990 void Ability::HandleCreateAsContinuation(const Want &want)
991 {
992 if (!IsFlagExists(Want::FLAG_ABILITY_CONTINUATION, want.GetFlags())) {
993 HILOG_DEBUG("Ability::HandleCreateAsContinuation return. This not continuated ability");
994 return;
995 }
996
997 // check whether it needs reversible
998 bool reversible = false;
999 reversible = IsFlagExists(Want::FLAG_ABILITY_CONTINUATION_REVERSIBLE, want.GetFlags());
1000 if (!VerifySupportForContinuation()) {
1001 HILOG_ERROR("Ability::HandleCreateAsContinuation failed. VerifySupportForContinuation failed");
1002 return;
1003 }
1004 bool success = continuationManager_->RestoreData(
1005 want.GetParams(), reversible, want.GetStringParam(ContinuationHandler::ORIGINAL_DEVICE_ID));
1006 if (success && reversible) {
1007 // Register this ability to receive reverse continuation callback.
1008 std::weak_ptr<IReverseContinuationSchedulerReplicaHandler> ReplicaHandler = continuationHandler_;
1009 reverseContinuationSchedulerReplica_ = sptr<ReverseContinuationSchedulerReplica>(
1010 new (std::nothrow) ReverseContinuationSchedulerReplica(handler_, ReplicaHandler));
1011
1012 if (reverseContinuationSchedulerReplica_ == nullptr) {
1013 HILOG_ERROR(
1014 "Ability::HandleCreateAsContinuation failed, create reverseContinuationSchedulerReplica failed");
1015 return;
1016 }
1017 }
1018
1019 int sessionId = want.GetIntParam(DMS_SESSION_ID, DEFAULT_DMS_SESSION_ID);
1020 std::string originDeviceId = want.GetStringParam(DMS_ORIGIN_DEVICE_ID);
1021 HILOG_DEBUG("Ability::HandleCreateAsContinuation");
1022 continuationManager_->NotifyCompleteContinuation(
1023 originDeviceId, sessionId, success, reverseContinuationSchedulerReplica_);
1024 }
1025
HandleCreateAsRecovery(const Want & want)1026 void Ability::HandleCreateAsRecovery(const Want &want)
1027 {
1028 if (!want.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false)) {
1029 HILOG_ERROR("AppRecovery not recovery restart");
1030 return;
1031 }
1032
1033 if (abilityRecovery_ != nullptr) {
1034 abilityRecovery_->ScheduleRestoreAbilityState(StateReason::DEVELOPER_REQUEST, want);
1035 }
1036 }
1037
IsFlagExists(unsigned int flag,unsigned int flagSet)1038 bool Ability::IsFlagExists(unsigned int flag, unsigned int flagSet)
1039 {
1040 return (flag & flagSet) == flag;
1041 }
1042
OnSetCaller()1043 Uri Ability::OnSetCaller()
1044 {
1045 return Uri("");
1046 }
1047
CreatePostEventTimeouter(std::string taskstr)1048 std::shared_ptr<AbilityPostEventTimeout> Ability::CreatePostEventTimeouter(std::string taskstr)
1049 {
1050 return std::make_shared<AbilityPostEventTimeout>(taskstr, handler_);
1051 }
1052
StartBackgroundRunning(const AbilityRuntime::WantAgent::WantAgent & wantAgent)1053 int Ability::StartBackgroundRunning(const AbilityRuntime::WantAgent::WantAgent &wantAgent)
1054 {
1055 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
1056 auto bundleMgr = GetBundleMgr();
1057 if (bundleMgr == nullptr) {
1058 HILOG_ERROR("Ability::GetBundleMgr failed");
1059 return ERR_NULL_OBJECT;
1060 }
1061 if (abilityInfo_ == nullptr) {
1062 HILOG_ERROR("ability info is null");
1063 return ERR_INVALID_VALUE;
1064 }
1065 Want want;
1066 want.SetAction("action.system.home");
1067 want.AddEntity("entity.system.home");
1068 want.SetElementName("", abilityInfo_->bundleName, "", "");
1069 AppExecFwk::AbilityInfo abilityInfo;
1070 bundleMgr->QueryAbilityInfo(want, abilityInfo);
1071 std::string appName = bundleMgr->GetAbilityLabel(abilityInfo_->bundleName, abilityInfo.name);
1072 uint32_t defaultBgMode = 0;
1073 BackgroundTaskMgr::ContinuousTaskParam taskParam = BackgroundTaskMgr::ContinuousTaskParam(false, defaultBgMode,
1074 std::make_shared<AbilityRuntime::WantAgent::WantAgent>(wantAgent), abilityInfo_->name, GetToken(), appName);
1075 return BackgroundTaskMgr::BackgroundTaskMgrHelper::RequestStartBackgroundRunning(taskParam);
1076 #else
1077 return ERR_INVALID_OPERATION;
1078 #endif
1079 }
1080
StopBackgroundRunning()1081 int Ability::StopBackgroundRunning()
1082 {
1083 #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE
1084 return BackgroundTaskMgr::BackgroundTaskMgrHelper::RequestStopBackgroundRunning(abilityInfo_->name, GetToken());
1085 #else
1086 return ERR_INVALID_OPERATION;
1087 #endif
1088 }
1089
GetBundleMgr()1090 sptr<IBundleMgr> Ability::GetBundleMgr()
1091 {
1092 HILOG_DEBUG("%{public}s called.", __func__);
1093 if (iBundleMgr_ == nullptr) {
1094 sptr<ISystemAbilityManager> systemAbilityManager =
1095 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1096 auto remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
1097 if (remoteObject == nullptr) {
1098 HILOG_ERROR("%{public}s error, failed to get bundle manager service.", __func__);
1099 return nullptr;
1100 }
1101
1102 iBundleMgr_ = iface_cast<IBundleMgr>(remoteObject);
1103 if (iBundleMgr_ == nullptr) {
1104 HILOG_ERROR("%{public}s error, failed to get bundle manager service", __func__);
1105 return nullptr;
1106 }
1107 }
1108
1109 return iBundleMgr_;
1110 }
1111
SetBundleManager(const sptr<IBundleMgr> & bundleManager)1112 void Ability::SetBundleManager(const sptr<IBundleMgr> &bundleManager)
1113 {
1114 HILOG_DEBUG("%{public}s called.", __func__);
1115
1116 iBundleMgr_ = bundleManager;
1117 }
1118
SetStartAbilitySetting(std::shared_ptr<AbilityStartSetting> setting)1119 void Ability::SetStartAbilitySetting(std::shared_ptr<AbilityStartSetting> setting)
1120 {
1121 HILOG_DEBUG("%{public}s called.", __func__);
1122 setting_ = setting;
1123 }
1124
SetLaunchParam(const AAFwk::LaunchParam & launchParam)1125 void Ability::SetLaunchParam(const AAFwk::LaunchParam &launchParam)
1126 {
1127 HILOG_DEBUG("%{public}s called.", __func__);
1128 launchParam_ = launchParam;
1129 }
1130
GetLaunchParam() const1131 const AAFwk::LaunchParam& Ability::GetLaunchParam() const
1132 {
1133 return launchParam_;
1134 }
1135
ExecuteBatch(const std::vector<std::shared_ptr<DataAbilityOperation>> & operations)1136 std::vector<std::shared_ptr<DataAbilityResult>> Ability::ExecuteBatch(
1137 const std::vector<std::shared_ptr<DataAbilityOperation>> &operations)
1138 {
1139 HILOG_DEBUG("start");
1140 std::vector<std::shared_ptr<DataAbilityResult>> results;
1141 if (abilityInfo_ == nullptr) {
1142 HILOG_ERROR("abilityInfo is nullptr");
1143 return results;
1144 }
1145 if (abilityInfo_->type != AppExecFwk::AbilityType::DATA) {
1146 HILOG_ERROR("data ability type failed, current type: %{public}d", abilityInfo_->type);
1147 return results;
1148 }
1149 size_t len = operations.size();
1150 HILOG_DEBUG("operation is nullptr, len %{public}zu", len);
1151 for (size_t i = 0; i < len; i++) {
1152 std::shared_ptr<DataAbilityOperation> operation = operations[i];
1153 if (operation == nullptr) {
1154 HILOG_DEBUG("operation is nullptr, create DataAbilityResult");
1155 results.push_back(std::make_shared<DataAbilityResult>(0));
1156 continue;
1157 }
1158 ExecuteOperation(operation, results, i);
1159 }
1160 HILOG_DEBUG("end, %{public}zu", results.size());
1161 return results;
1162 }
ExecuteOperation(std::shared_ptr<DataAbilityOperation> & operation,std::vector<std::shared_ptr<DataAbilityResult>> & results,int index)1163 void Ability::ExecuteOperation(std::shared_ptr<DataAbilityOperation> &operation,
1164 std::vector<std::shared_ptr<DataAbilityResult>> &results, int index)
1165 {
1166 HILOG_DEBUG("exec start, index=%{public}d", index);
1167 if (abilityInfo_->type != AppExecFwk::AbilityType::DATA) {
1168 HILOG_ERROR("exec data ability type failed, current type: %{public}d", abilityInfo_->type);
1169 return;
1170 }
1171 if (index < 0) {
1172 HILOG_ERROR(
1173 "exec operation result index should not below zero, current index: %{public}d", index);
1174 return;
1175 }
1176 if (operation == nullptr) {
1177 HILOG_WARN("exec operation is nullptr, create DataAbilityResult");
1178 results.push_back(std::make_shared<DataAbilityResult>(0));
1179 return;
1180 }
1181
1182 int numRows = 0;
1183 std::shared_ptr<NativeRdb::ValuesBucket> valuesBucket = ParseValuesBucketReference(results, operation, index);
1184 std::shared_ptr<NativeRdb::DataAbilityPredicates> predicates =
1185 ParsePredictionArgsReference(results, operation, index);
1186 if (operation->IsInsertOperation()) {
1187 HILOG_DEBUG("exec IsInsertOperation");
1188 numRows = Insert(*(operation->GetUri().get()), *valuesBucket);
1189 } else if (operation->IsDeleteOperation() && predicates) {
1190 HILOG_DEBUG("exec IsDeleteOperation");
1191 numRows = Delete(*(operation->GetUri().get()), *predicates);
1192 } else if (operation->IsUpdateOperation() && predicates) {
1193 HILOG_DEBUG("exec IsUpdateOperation");
1194 numRows = Update(*(operation->GetUri().get()), *valuesBucket, *predicates);
1195 } else if (operation->IsAssertOperation() && predicates) {
1196 HILOG_DEBUG("exec IsAssertOperation");
1197 std::vector<std::string> columns;
1198 std::shared_ptr<NativeRdb::AbsSharedResultSet> queryResult =
1199 Query(*(operation->GetUri().get()), columns, *predicates);
1200 if (queryResult == nullptr) {
1201 HILOG_ERROR("exec Query retval is nullptr");
1202 results.push_back(std::make_shared<DataAbilityResult>(0));
1203 return;
1204 }
1205 if (queryResult->GetRowCount(numRows) != 0) {
1206 HILOG_ERROR("exec queryResult->GetRowCount(numRows) != E_OK");
1207 }
1208 if (!CheckAssertQueryResult(queryResult, operation->GetValuesBucket())) {
1209 if (queryResult != nullptr) {
1210 queryResult->Close();
1211 }
1212 HILOG_ERROR("Query Result is not equal to expected value.");
1213 }
1214
1215 if (queryResult != nullptr) {
1216 queryResult->Close();
1217 }
1218 } else {
1219 HILOG_ERROR("exec Expected bad type %{public}d", operation->GetType());
1220 }
1221 if (operation->GetExpectedCount() != numRows) {
1222 HILOG_ERROR("exec Expected %{public}d rows but actual %{public}d",
1223 operation->GetExpectedCount(),
1224 numRows);
1225 } else {
1226 if (operation->GetUri() != nullptr) {
1227 results.push_back(std::make_shared<DataAbilityResult>(*operation->GetUri(), numRows));
1228 } else {
1229 results.push_back(std::make_shared<DataAbilityResult>(Uri(std::string("")), numRows));
1230 }
1231 }
1232 }
1233
ParsePredictionArgsReference(std::vector<std::shared_ptr<DataAbilityResult>> & results,std::shared_ptr<DataAbilityOperation> & operation,int numRefs)1234 std::shared_ptr<NativeRdb::DataAbilityPredicates> Ability::ParsePredictionArgsReference(
1235 std::vector<std::shared_ptr<DataAbilityResult>> &results, std::shared_ptr<DataAbilityOperation> &operation,
1236 int numRefs)
1237 {
1238 if (operation == nullptr) {
1239 HILOG_ERROR("intput is nullptr");
1240 return nullptr;
1241 }
1242
1243 std::map<int, int> predicatesBackReferencesMap = operation->GetDataAbilityPredicatesBackReferences();
1244 if (predicatesBackReferencesMap.empty()) {
1245 return operation->GetDataAbilityPredicates();
1246 }
1247
1248 std::vector<std::string> strPredicatesList;
1249 strPredicatesList.clear();
1250 std::shared_ptr<NativeRdb::DataAbilityPredicates> predicates = operation->GetDataAbilityPredicates();
1251 if (predicates == nullptr) {
1252 HILOG_DEBUG("operation->GetDataAbilityPredicates is nullptr");
1253 } else {
1254 HILOG_DEBUG("operation->GetDataAbilityPredicates isn`t nullptr");
1255 strPredicatesList = predicates->GetWhereArgs();
1256 }
1257
1258 if (strPredicatesList.empty()) {
1259 HILOG_ERROR("operation->GetDataAbilityPredicates()->GetWhereArgs()"
1260 "error strList is empty()");
1261 }
1262
1263 for (auto iterMap : predicatesBackReferencesMap) {
1264 HILOG_DEBUG("predicatesBackReferencesMap first:%{public}d second:%{public}d",
1265 iterMap.first,
1266 iterMap.second);
1267 int tempCount = ChangeRef2Value(results, numRefs, iterMap.second);
1268 if (tempCount < 0) {
1269 HILOG_ERROR("tempCount:%{public}d", tempCount);
1270 continue;
1271 }
1272 std::string strPredicates = std::to_string(tempCount);
1273 strPredicatesList.push_back(strPredicates);
1274 }
1275
1276 if (predicates) {
1277 predicates->SetWhereArgs(strPredicatesList);
1278 }
1279
1280 return predicates;
1281 }
1282
ParseValuesBucketReference(std::vector<std::shared_ptr<DataAbilityResult>> & results,std::shared_ptr<DataAbilityOperation> & operation,int numRefs)1283 std::shared_ptr<NativeRdb::ValuesBucket> Ability::ParseValuesBucketReference(
1284 std::vector<std::shared_ptr<DataAbilityResult>> &results, std::shared_ptr<DataAbilityOperation> &operation,
1285 int numRefs)
1286 {
1287 NativeRdb::ValuesBucket retValueBucket;
1288 if (operation == nullptr) {
1289 HILOG_ERROR("intput is nullptr");
1290 return nullptr;
1291 }
1292
1293 if (operation->GetValuesBucketReferences() == nullptr) {
1294 return operation->GetValuesBucket();
1295 }
1296
1297 retValueBucket.Clear();
1298 if (operation->GetValuesBucket() == nullptr) {
1299 HILOG_DEBUG("operation->GetValuesBucket is nullptr");
1300 } else {
1301 HILOG_DEBUG("operation->GetValuesBucket is nullptr");
1302 retValueBucket = *operation->GetValuesBucket();
1303 }
1304
1305 std::map<std::string, NativeRdb::ValueObject> valuesMapReferences;
1306 operation->GetValuesBucketReferences()->GetAll(valuesMapReferences);
1307
1308 for (auto itermap : valuesMapReferences) {
1309 std::string key = itermap.first;
1310 NativeRdb::ValueObject obj;
1311 if (!operation->GetValuesBucketReferences()->GetObject(key, obj)) {
1312 HILOG_ERROR("operation->GetValuesBucketReferences()->GetObject error");
1313 continue;
1314 }
1315 switch (obj.GetType()) {
1316 case NativeRdb::ValueObjectType::TYPE_INT: {
1317 int val = 0;
1318 if (obj.GetInt(val) != 0) {
1319 HILOG_ERROR("ValueObject->GetInt() error");
1320 break;
1321 }
1322 HILOG_DEBUG("retValueBucket->PutInt(%{public}s, %{public}d)",
1323 key.c_str(),
1324 val);
1325 retValueBucket.PutInt(key, val);
1326 } break;
1327 case NativeRdb::ValueObjectType::TYPE_DOUBLE: {
1328 double val = 0.0;
1329 if (obj.GetDouble(val) != 0) {
1330 HILOG_ERROR("ValueObject->GetDouble() error");
1331 break;
1332 }
1333 HILOG_DEBUG("retValueBucket->PutDouble(%{public}s, %{public}f)",
1334 key.c_str(),
1335 val);
1336 retValueBucket.PutDouble(key, val);
1337 } break;
1338 case NativeRdb::ValueObjectType::TYPE_STRING: {
1339 std::string val = "";
1340 if (obj.GetString(val) != 0) {
1341 HILOG_ERROR("ValueObject->GetString() error");
1342 break;
1343 }
1344 HILOG_DEBUG("retValueBucket->PutString(%{public}s, %{public}s)",
1345 key.c_str(),
1346 val.c_str());
1347 retValueBucket.PutString(key, val);
1348 } break;
1349 case NativeRdb::ValueObjectType::TYPE_BLOB: {
1350 std::vector<uint8_t> val;
1351 if (obj.GetBlob(val) != 0) {
1352 HILOG_ERROR("ValueObject->GetBlob() error");
1353 break;
1354 }
1355 HILOG_DEBUG("retValueBucket->PutBlob(%{public}s, %{public}zu)",
1356 key.c_str(),
1357 val.size());
1358 retValueBucket.PutBlob(key, val);
1359 } break;
1360 case NativeRdb::ValueObjectType::TYPE_BOOL: {
1361 bool val = false;
1362 if (obj.GetBool(val) != 0) {
1363 HILOG_ERROR("ValueObject->GetBool() error");
1364 break;
1365 }
1366 HILOG_DEBUG("retValueBucket->PutBool(%{public}s, %{public}s)",
1367 key.c_str(),
1368 val ? "true" : "false");
1369 retValueBucket.PutBool(key, val);
1370 } break;
1371 default: {
1372 HILOG_DEBUG("retValueBucket->PutNull(%{public}s)", key.c_str());
1373 retValueBucket.PutNull(key);
1374 } break;
1375 }
1376 }
1377
1378 std::map<std::string, NativeRdb::ValueObject> valuesMap;
1379 retValueBucket.GetAll(valuesMap);
1380
1381 return std::make_shared<NativeRdb::ValuesBucket>(valuesMap);
1382 }
1383
ChangeRef2Value(std::vector<std::shared_ptr<DataAbilityResult>> & results,int numRefs,int index)1384 int Ability::ChangeRef2Value(std::vector<std::shared_ptr<DataAbilityResult>> &results, int numRefs, int index)
1385 {
1386 int retval = -1;
1387 if (index >= numRefs) {
1388 HILOG_ERROR("Ability::ChangeRef2Value index >= numRefs");
1389 return retval;
1390 }
1391
1392 if (index >= static_cast<int>(results.size())) {
1393 HILOG_ERROR("Ability::ChangeRef2Value index:%{public}d >= results.size():%{public}zu", index, results.size());
1394 return retval;
1395 }
1396
1397 std::shared_ptr<DataAbilityResult> refResult = results[index];
1398 if (refResult == nullptr) {
1399 HILOG_ERROR("Ability::ChangeRef2Value No.%{public}d refResult is null", index);
1400 return retval;
1401 }
1402
1403 if (refResult->GetUri().ToString().empty()) {
1404 retval = refResult->GetCount();
1405 } else {
1406 retval = DataUriUtils::GetId(refResult->GetUri());
1407 }
1408
1409 return retval;
1410 }
1411
CheckAssertQueryResult(std::shared_ptr<NativeRdb::AbsSharedResultSet> & queryResult,std::shared_ptr<NativeRdb::ValuesBucket> && valuesBucket)1412 bool Ability::CheckAssertQueryResult(std::shared_ptr<NativeRdb::AbsSharedResultSet> &queryResult,
1413 std::shared_ptr<NativeRdb::ValuesBucket> &&valuesBucket)
1414 {
1415 if (queryResult == nullptr) {
1416 HILOG_ERROR("Ability::CheckAssertQueryResult intput queryResult is null");
1417 return true;
1418 }
1419
1420 if (valuesBucket == nullptr) {
1421 HILOG_ERROR("Ability::CheckAssertQueryResult intput valuesBucket is null");
1422 return true;
1423 }
1424
1425 std::map<std::string, NativeRdb::ValueObject> valuesMap;
1426 valuesBucket->GetAll(valuesMap);
1427 if (valuesMap.empty()) {
1428 HILOG_ERROR("Ability::CheckAssertQueryResult valuesMap is empty");
1429 return true;
1430 }
1431 int count = 0;
1432 if (queryResult->GetRowCount(count) != 0) {
1433 HILOG_ERROR("Ability::CheckAssertQueryResult GetRowCount is 0");
1434 return true;
1435 }
1436
1437 for (auto iterMap : valuesMap) {
1438 std::string strObject;
1439 if (iterMap.second.GetString(strObject) != 0) {
1440 HILOG_ERROR("Ability::CheckAssertQueryResult GetString strObject is error");
1441 continue;
1442 }
1443 if (strObject.empty()) {
1444 HILOG_ERROR("Ability::CheckAssertQueryResult strObject is empty");
1445 continue;
1446 }
1447 for (int i = 0; i < count; ++i) {
1448 std::string strName;
1449 if (queryResult->GetString(i, strName) != 0) {
1450 HILOG_ERROR("Ability::CheckAssertQueryResult GetString strName is error");
1451 continue;
1452 }
1453 if (strName.empty()) {
1454 HILOG_ERROR("Ability::CheckAssertQueryResult strName is empty");
1455 continue;
1456 }
1457 if (strName == strObject) {
1458 HILOG_ERROR("Ability::CheckAssertQueryResult strName same to strObject");
1459 continue;
1460 }
1461
1462 return false;
1463 }
1464 }
1465
1466 return true;
1467 }
1468
CallRequest()1469 sptr<IRemoteObject> Ability::CallRequest()
1470 {
1471 return nullptr;
1472 }
1473
StartFeatureAbilityForResult(const Want & want,int requestCode,FeatureAbilityTask && task)1474 ErrCode Ability::StartFeatureAbilityForResult(const Want &want, int requestCode, FeatureAbilityTask &&task)
1475 {
1476 HILOG_DEBUG("%{public}s begin.", __func__);
1477 resultCallbacks_.insert(make_pair(requestCode, std::move(task)));
1478 ErrCode err = StartAbilityForResult(want, requestCode);
1479 HILOG_DEBUG("%{public}s end. ret=%{public}d", __func__, err);
1480 return err;
1481 }
1482
OnFeatureAbilityResult(int requestCode,int resultCode,const Want & want)1483 void Ability::OnFeatureAbilityResult(int requestCode, int resultCode, const Want &want)
1484 {
1485 HILOG_DEBUG("%{public}s begin.", __func__);
1486 auto callback = resultCallbacks_.find(requestCode);
1487 if (callback != resultCallbacks_.end()) {
1488 if (callback->second) {
1489 callback->second(resultCode, want);
1490 }
1491 resultCallbacks_.erase(requestCode);
1492 }
1493 HILOG_DEBUG("%{public}s end.", __func__);
1494 }
1495
IsUseNewStartUpRule()1496 bool Ability::IsUseNewStartUpRule()
1497 {
1498 if (!isNewRuleFlagSetted_ && setWant_) {
1499 startUpNewRule_ = setWant_->GetBoolParam(COMPONENT_STARTUP_NEW_RULES, false);
1500 isNewRuleFlagSetted_ = true;
1501 }
1502 return startUpNewRule_;
1503 }
1504
EnableAbilityRecovery(const std::shared_ptr<AbilityRecovery> & abilityRecovery)1505 void Ability::EnableAbilityRecovery(const std::shared_ptr<AbilityRecovery>& abilityRecovery)
1506 {
1507 abilityRecovery_ = abilityRecovery;
1508 }
1509
1510 #ifdef SUPPORT_GRAPHICS
PrintDrawnCompleted()1511 bool Ability::PrintDrawnCompleted()
1512 {
1513 return AbilityContext::PrintDrawnCompleted();
1514 }
1515
OnSceneCreated()1516 void Ability::OnSceneCreated()
1517 {
1518 HILOG_DEBUG("%{public}s called.", __func__);
1519 }
1520
OnSceneRestored()1521 void Ability::OnSceneRestored()
1522 {
1523 HILOG_DEBUG("%{public}s called.", __func__);
1524 }
1525
onSceneDestroyed()1526 void Ability::onSceneDestroyed()
1527 {
1528 HILOG_DEBUG("%{public}s called.", __func__);
1529 }
1530
OnForeground(const Want & want)1531 void Ability::OnForeground(const Want &want)
1532 {
1533 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1534 HILOG_DEBUG("%{public}s begin.", __func__);
1535 DoOnForeground(want);
1536 DispatchLifecycleOnForeground(want);
1537 HILOG_DEBUG("%{public}s end.", __func__);
1538 AAFwk::EventInfo eventInfo;
1539 eventInfo.bundleName = want.GetElement().GetBundleName();
1540 eventInfo.moduleName = want.GetElement().GetModuleName();
1541 eventInfo.abilityName = want.GetElement().GetAbilityName();
1542 AAFwk::EventReport::SendAbilityEvent(AAFwk::EventName::ABILITY_ONFOREGROUND,
1543 HiSysEventType::BEHAVIOR, eventInfo);
1544 }
1545
OnBackground()1546 void Ability::OnBackground()
1547 {
1548 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1549 HILOG_DEBUG("%{public}s begin.", __func__);
1550 if (abilityInfo_ == nullptr) {
1551 HILOG_ERROR("abilityInfo_ is nullptr.");
1552 return;
1553 }
1554 if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) {
1555 if (abilityInfo_->isStageBasedModel) {
1556 if (scene_ == nullptr) {
1557 HILOG_ERROR("Ability::OnBackground error. scene_ == nullptr.");
1558 return;
1559 }
1560 HILOG_DEBUG("GoBackground sceneFlag:%{public}d.", sceneFlag_);
1561 scene_->GoBackground(sceneFlag_);
1562 if (abilityRecovery_ != nullptr) {
1563 abilityRecovery_->ScheduleSaveAbilityState(StateReason::LIFECYCLE);
1564 }
1565 } else {
1566 if (abilityWindow_ == nullptr) {
1567 HILOG_ERROR("Ability::OnBackground error. abilityWindow_ == nullptr.");
1568 return;
1569 }
1570 HILOG_DEBUG("OnPostAbilityBackground sceneFlag:%{public}d.", sceneFlag_);
1571 abilityWindow_->OnPostAbilityBackground(sceneFlag_);
1572 }
1573 }
1574
1575 if (abilityLifecycleExecutor_ == nullptr) {
1576 HILOG_ERROR("Ability::OnBackground error. abilityLifecycleExecutor_ == nullptr.");
1577 return;
1578 }
1579
1580 if (abilityInfo_->isStageBasedModel) {
1581 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::BACKGROUND_NEW);
1582 } else {
1583 abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::BACKGROUND);
1584 }
1585
1586 if (lifecycle_ == nullptr) {
1587 HILOG_ERROR("Ability::OnBackground error. lifecycle_ == nullptr.");
1588 return;
1589 }
1590 lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_BACKGROUND);
1591 HILOG_DEBUG("%{public}s end", __func__);
1592 AAFwk::EventInfo eventInfo;
1593 eventInfo.bundleName = abilityInfo_->bundleName;
1594 eventInfo.moduleName = abilityInfo_->moduleName;
1595 eventInfo.abilityName = abilityInfo_->name;
1596 AAFwk::EventReport::SendAbilityEvent(AAFwk::EventName::ABILITY_ONBACKGROUND,
1597 HiSysEventType::BEHAVIOR, eventInfo);
1598 }
1599
OnKeyDown(const std::shared_ptr<MMI::KeyEvent> & keyEvent)1600 void Ability::OnKeyDown(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
1601 {
1602 HILOG_DEBUG("Ability::OnKeyDown called");
1603 }
1604
OnKeyUp(const std::shared_ptr<MMI::KeyEvent> & keyEvent)1605 void Ability::OnKeyUp(const std::shared_ptr<MMI::KeyEvent>& keyEvent)
1606 {
1607 HILOG_DEBUG("Ability::OnKeyUp called");
1608 auto code = keyEvent->GetKeyCode();
1609 if (code == MMI::KeyEvent::KEYCODE_BACK) {
1610 HILOG_DEBUG("Ability::OnKey Back key pressed.");
1611 OnBackPressed();
1612 }
1613 }
1614
OnPointerEvent(std::shared_ptr<MMI::PointerEvent> & pointerEvent)1615 void Ability::OnPointerEvent(std::shared_ptr<MMI::PointerEvent>& pointerEvent)
1616 {
1617 HILOG_DEBUG("Ability::OnTouchEvent called");
1618 }
1619
SetUIContent(const ComponentContainer & componentContainer)1620 void Ability::SetUIContent(const ComponentContainer &componentContainer)
1621 {}
1622
SetUIContent(int layoutRes)1623 void Ability::SetUIContent(int layoutRes)
1624 {}
1625
SetUIContent(const ComponentContainer & componentContainer,std::shared_ptr<Context> & context,int typeFlag)1626 void Ability::SetUIContent(
1627 const ComponentContainer &componentContainer, std::shared_ptr<Context> &context, int typeFlag)
1628 {}
1629
SetUIContent(int layoutRes,std::shared_ptr<Context> & context,int typeFlag)1630 void Ability::SetUIContent(int layoutRes, std::shared_ptr<Context> &context, int typeFlag)
1631 {}
1632
InitWindow(int32_t displayId,sptr<Rosen::WindowOption> option)1633 void Ability::InitWindow(int32_t displayId, sptr<Rosen::WindowOption> option)
1634 {
1635 if (abilityWindow_ == nullptr) {
1636 HILOG_ERROR("Ability::InitWindow abilityWindow_ is nullptr");
1637 return;
1638 }
1639 abilityWindow_->InitWindow(abilityContext_, sceneListener_, displayId, option, securityFlag_);
1640 }
1641
GetWindow()1642 const sptr<Rosen::Window> Ability::GetWindow()
1643 {
1644 if (abilityWindow_ != nullptr) {
1645 return abilityWindow_->GetWindow();
1646 } else {
1647 HILOG_DEBUG("%{public}s abilityWindow_ is nullptr.", __func__);
1648 return nullptr;
1649 }
1650 }
1651
GetScene()1652 std::shared_ptr<Rosen::WindowScene> Ability::GetScene()
1653 {
1654 return scene_;
1655 }
1656
GetVolumeTypeAdjustedByKey()1657 int Ability::GetVolumeTypeAdjustedByKey()
1658 {
1659 return 0;
1660 }
1661
HasWindowFocus()1662 bool Ability::HasWindowFocus()
1663 {
1664 if (abilityInfo_ == nullptr) {
1665 HILOG_ERROR("Ability::HasWindowFocus abilityInfo_ == nullptr");
1666 return false;
1667 }
1668
1669 if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) {
1670 return bWindowFocus_;
1671 }
1672
1673 return false;
1674 }
1675
SetShowOnLockScreen(bool showOnLockScreen)1676 void Ability::SetShowOnLockScreen(bool showOnLockScreen)
1677 {
1678 HILOG_DEBUG("SetShowOnLockScreen come, showOnLockScreen is %{public}d", showOnLockScreen);
1679 showOnLockScreen_ = showOnLockScreen;
1680 sptr<Rosen::Window> window = nullptr;
1681 if (abilityWindow_ == nullptr || (window = abilityWindow_->GetWindow()) == nullptr) {
1682 HILOG_ERROR("SetShowOnLockScreen come, window is null");
1683 return;
1684 }
1685 HILOG_DEBUG("SetShowOnLockScreen come, addWindowFlag, showOnLockScreen is %{public}d", showOnLockScreen);
1686 if (showOnLockScreen) {
1687 window->AddWindowFlag(Rosen::WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
1688 } else {
1689 window->RemoveWindowFlag(Rosen::WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
1690 }
1691 }
1692
OnKeyPressAndHold(int keyCode,const std::shared_ptr<KeyEvent> & keyEvent)1693 bool Ability::OnKeyPressAndHold(int keyCode, const std::shared_ptr<KeyEvent> &keyEvent)
1694 {
1695 return false;
1696 }
1697
OnLeaveForeground()1698 void Ability::OnLeaveForeground()
1699 {}
1700
SetVolumeTypeAdjustedByKey(int volumeType)1701 void Ability::SetVolumeTypeAdjustedByKey(int volumeType)
1702 {}
1703
SetWindowBackgroundColor(int red,int green,int blue)1704 int Ability::SetWindowBackgroundColor(int red, int green, int blue)
1705 {
1706 return -1;
1707 }
1708
GetContentInfo()1709 std::string Ability::GetContentInfo()
1710 {
1711 if (scene_ == nullptr) {
1712 return "";
1713 }
1714 return scene_->GetContentInfo();
1715 }
1716
OnWindowFocusChanged(bool hasFocus)1717 void Ability::OnWindowFocusChanged(bool hasFocus)
1718 {}
1719
OnTopActiveAbilityChanged(bool topActive)1720 void Ability::OnTopActiveAbilityChanged(bool topActive)
1721 {}
1722
OnCreate(const Want & want)1723 FormProviderInfo Ability::OnCreate(const Want &want)
1724 {
1725 HILOG_DEBUG("%{public}s called.", __func__);
1726 FormProviderInfo formProviderInfo;
1727 return formProviderInfo;
1728 }
1729
OnShare(int64_t formId,AAFwk::WantParams & wantParams)1730 bool Ability::OnShare(int64_t formId, AAFwk::WantParams &wantParams)
1731 {
1732 HILOG_DEBUG("%{public}s called.", __func__);
1733 return false;
1734 }
1735
OnDelete(const int64_t formId)1736 void Ability::OnDelete(const int64_t formId)
1737 {}
1738
OnUpdate(const int64_t formId)1739 void Ability::OnUpdate(const int64_t formId)
1740 {}
1741
OnCastTemptoNormal(const int64_t formId)1742 void Ability::OnCastTemptoNormal(const int64_t formId)
1743 {}
1744
OnVisibilityChanged(const std::map<int64_t,int32_t> & formEventsMap)1745 void Ability::OnVisibilityChanged(const std::map<int64_t, int32_t> &formEventsMap)
1746 {}
1747
OnTriggerEvent(const int64_t formId,const std::string & message)1748 void Ability::OnTriggerEvent(const int64_t formId, const std::string &message)
1749 {}
1750
OnAcquireFormState(const Want & want)1751 FormState Ability::OnAcquireFormState(const Want &want)
1752 {
1753 return FormState::DEFAULT;
1754 }
1755
GetFormRemoteObject()1756 sptr<IRemoteObject> Ability::GetFormRemoteObject()
1757 {
1758 HILOG_DEBUG("%{public}s start", __func__);
1759 if (providerRemoteObject_ == nullptr) {
1760 sptr<FormProviderClient> providerClient = new (std::nothrow) FormProviderClient();
1761 std::shared_ptr<Ability> thisAbility = this->shared_from_this();
1762 if (thisAbility == nullptr) {
1763 HILOG_ERROR("%{public}s failed, thisAbility is nullptr", __func__);
1764 }
1765 providerClient->SetOwner(thisAbility);
1766 providerRemoteObject_ = providerClient->AsObject();
1767 }
1768 HILOG_DEBUG("%{public}s end", __func__);
1769 return providerRemoteObject_;
1770 }
1771
SetSceneListener(const sptr<Rosen::IWindowLifeCycle> & listener)1772 void Ability::SetSceneListener(const sptr<Rosen::IWindowLifeCycle> &listener)
1773 {
1774 sceneListener_ = listener;
1775 }
1776
GetWindowOption(const Want & want)1777 sptr<Rosen::WindowOption> Ability::GetWindowOption(const Want &want)
1778 {
1779 sptr<Rosen::WindowOption> option = new Rosen::WindowOption();
1780 if (option == nullptr) {
1781 HILOG_ERROR("Ability::GetWindowOption option is null.");
1782 return nullptr;
1783 }
1784 auto windowMode = want.GetIntParam(Want::PARAM_RESV_WINDOW_MODE,
1785 AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
1786 HILOG_DEBUG("Ability::GetWindowOption window mode is %{public}d.", windowMode);
1787 option->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
1788 bool showOnLockScreen = false;
1789 if (abilityInfo_) {
1790 std::vector<CustomizeData> datas = abilityInfo_->metaData.customizeData;
1791 for (CustomizeData data : datas) {
1792 if (data.name == SHOW_ON_LOCK_SCREEN) {
1793 showOnLockScreen = true;
1794 }
1795 }
1796 }
1797 if (showOnLockScreen_ || showOnLockScreen) {
1798 HILOG_DEBUG("Ability::GetWindowOption come, add window flag WINDOW_FLAG_SHOW_WHEN_LOCKED.");
1799 option->AddWindowFlag(Rosen::WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED);
1800 }
1801
1802 if (want.GetElement().GetBundleName() == LAUNCHER_BUNDLE_NAME &&
1803 want.GetElement().GetAbilityName() == LAUNCHER_ABILITY_NAME) {
1804 HILOG_DEBUG("Set window type for launcher");
1805 option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_DESKTOP);
1806 }
1807 return option;
1808 }
1809
DoOnForeground(const Want & want)1810 void Ability::DoOnForeground(const Want& want)
1811 {
1812 if (abilityWindow_ != nullptr) {
1813 HILOG_DEBUG("%{public}s begin abilityWindow_->OnPostAbilityForeground, sceneFlag:%{public}d.",
1814 __func__, sceneFlag_);
1815 auto window = abilityWindow_->GetWindow();
1816 if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) {
1817 auto windowMode = want.GetIntParam(Want::PARAM_RESV_WINDOW_MODE,
1818 AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
1819 window->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
1820 HILOG_DEBUG("set window mode = %{public}d.", windowMode);
1821 }
1822 abilityWindow_->OnPostAbilityForeground(sceneFlag_);
1823 HILOG_DEBUG("%{public}s end abilityWindow_->OnPostAbilityForeground.", __func__);
1824 } else {
1825 HILOG_DEBUG("abilityWindow_ != nullptr");
1826 }
1827 }
1828
GetCurrentWindowMode()1829 int Ability::GetCurrentWindowMode()
1830 {
1831 HILOG_DEBUG("%{public}s start", __func__);
1832 auto windowMode = static_cast<int>(Rosen::WindowMode::WINDOW_MODE_UNDEFINED);
1833 if (scene_ == nullptr) {
1834 return windowMode;
1835 }
1836 auto window = scene_->GetMainWindow();
1837 if (window != nullptr) {
1838 windowMode = static_cast<int>(window->GetMode());
1839 }
1840 return windowMode;
1841 }
1842
SetMissionLabel(const std::string & label)1843 ErrCode Ability::SetMissionLabel(const std::string &label)
1844 {
1845 HILOG_DEBUG("%{public}s start", __func__);
1846 if (!abilityInfo_ || abilityInfo_->type != AppExecFwk::AbilityType::PAGE) {
1847 HILOG_ERROR("invalid ability info.");
1848 return -1;
1849 }
1850
1851 // stage mode
1852 if (abilityInfo_->isStageBasedModel) {
1853 if (scene_ == nullptr) {
1854 HILOG_ERROR("get window scene failed.");
1855 return -1;
1856 }
1857 auto window = scene_->GetMainWindow();
1858 if (window == nullptr) {
1859 HILOG_ERROR("get window scene failed.");
1860 return -1;
1861 }
1862
1863 if (window->SetAPPWindowLabel(label) != OHOS::Rosen::WMError::WM_OK) {
1864 HILOG_ERROR("SetAPPWindowLabel failed.");
1865 return -1;
1866 }
1867 return ERR_OK;
1868 }
1869
1870 // fa mode
1871 if (abilityWindow_ == nullptr) {
1872 HILOG_ERROR("abilityWindow is nullptr.");
1873 return -1;
1874 }
1875 return abilityWindow_->SetMissionLabel(label);
1876 }
1877
SetMissionIcon(const std::shared_ptr<OHOS::Media::PixelMap> & icon)1878 ErrCode Ability::SetMissionIcon(const std::shared_ptr<OHOS::Media::PixelMap> &icon)
1879 {
1880 HILOG_DEBUG("%{public}s start", __func__);
1881 if (!abilityInfo_ || abilityInfo_->type != AppExecFwk::AbilityType::PAGE) {
1882 HILOG_ERROR("invalid ability info, can not set mission icon.");
1883 return -1;
1884 }
1885
1886 // stage mode
1887 if (abilityInfo_->isStageBasedModel) {
1888 if (scene_ == nullptr) {
1889 HILOG_ERROR("get window scene failed, can not set mission icon.");
1890 return -1;
1891 }
1892 auto window = scene_->GetMainWindow();
1893 if (window == nullptr) {
1894 HILOG_ERROR("get window scene failed, can not set mission icon.");
1895 return -1;
1896 }
1897
1898 if (window->SetAPPWindowIcon(icon) != OHOS::Rosen::WMError::WM_OK) {
1899 HILOG_ERROR("SetAPPWindowIcon failed.");
1900 return -1;
1901 }
1902 return ERR_OK;
1903 }
1904
1905 // fa mode
1906 if (abilityWindow_ == nullptr) {
1907 HILOG_ERROR("abilityWindow is nullptr, can not set mission icon.");
1908 return -1;
1909 }
1910 return abilityWindow_->SetMissionIcon(icon);
1911 }
1912
OnCreate(Rosen::DisplayId displayId)1913 void Ability::OnCreate(Rosen::DisplayId displayId)
1914 {
1915 HILOG_DEBUG("%{public}s called.", __func__);
1916 }
1917
OnDestroy(Rosen::DisplayId displayId)1918 void Ability::OnDestroy(Rosen::DisplayId displayId)
1919 {
1920 HILOG_DEBUG("%{public}s called.", __func__);
1921 }
1922
OnChange(Rosen::DisplayId displayId)1923 void Ability::OnChange(Rosen::DisplayId displayId)
1924 {
1925 HILOG_DEBUG("%{public}s start, displayId: %{public}" PRIu64"", __func__,
1926 displayId);
1927
1928 // Get display
1929 auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId);
1930 if (!display) {
1931 HILOG_ERROR("Get display by displayId %{public}" PRIu64" failed.", displayId);
1932 return;
1933 }
1934
1935 // Notify ResourceManager
1936 float density = display->GetVirtualPixelRatio();
1937 int32_t width = display->GetWidth();
1938 int32_t height = display->GetHeight();
1939 std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
1940 if (resConfig != nullptr) {
1941 auto resourceManager = GetResourceManager();
1942 if (resourceManager != nullptr) {
1943 resourceManager->GetResConfig(*resConfig);
1944 resConfig->SetScreenDensity(density);
1945 resConfig->SetDirection(ConvertDirection(height, width));
1946 resourceManager->UpdateResConfig(*resConfig);
1947 HILOG_INFO("%{public}s Notify ResourceManager, Density: %{public}f, Direction: %{public}d.", __func__,
1948 resConfig->GetScreenDensity(), resConfig->GetDirection());
1949 }
1950 }
1951
1952 // Notify ability
1953 Configuration newConfig;
1954 newConfig.AddItem(displayId, ConfigurationInner::APPLICATION_DIRECTION, GetDirectionStr(height, width));
1955 newConfig.AddItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI, GetDensityStr(density));
1956
1957 if (application_ == nullptr) {
1958 HILOG_ERROR("application_ is nullptr.");
1959 return;
1960 }
1961
1962 auto configuration = application_->GetConfiguration();
1963 if (!configuration) {
1964 HILOG_ERROR("configuration is nullptr.");
1965 return;
1966 }
1967
1968 std::vector<std::string> changeKeyV;
1969 configuration->CompareDifferent(changeKeyV, newConfig);
1970 HILOG_DEBUG("changeKeyV size :%{public}zu", changeKeyV.size());
1971 if (!changeKeyV.empty()) {
1972 configuration->Merge(changeKeyV, newConfig);
1973 auto task = [ability = shared_from_this(), configuration = *configuration]() {
1974 ability->OnConfigurationUpdated(configuration);
1975 };
1976 handler_->PostTask(task);
1977 }
1978
1979 HILOG_DEBUG("%{public}s end", __func__);
1980 }
1981
OnDisplayMove(Rosen::DisplayId from,Rosen::DisplayId to)1982 void Ability::OnDisplayMove(Rosen::DisplayId from, Rosen::DisplayId to)
1983 {
1984 HILOG_INFO("%{public}s called, from displayId %{public}" PRIu64" to %{public}" PRIu64".", __func__, from, to);
1985
1986 auto display = Rosen::DisplayManager::GetInstance().GetDisplayById(to);
1987 if (!display) {
1988 HILOG_ERROR("Get display by displayId %{public}" PRIu64" failed.", to);
1989 return;
1990 }
1991
1992 // Get new display config
1993 float density = display->GetVirtualPixelRatio();
1994 int32_t width = display->GetWidth();
1995 int32_t height = display->GetHeight();
1996 std::unique_ptr<Global::Resource::ResConfig> resConfig(Global::Resource::CreateResConfig());
1997 if (resConfig != nullptr) {
1998 auto resourceManager = GetResourceManager();
1999 if (resourceManager != nullptr) {
2000 resourceManager->GetResConfig(*resConfig);
2001 resConfig->SetScreenDensity(density);
2002 resConfig->SetDirection(ConvertDirection(height, width));
2003 resourceManager->UpdateResConfig(*resConfig);
2004 HILOG_INFO("%{public}s Notify ResourceManager, Density: %{public}f, Direction: %{public}d.", __func__,
2005 resConfig->GetScreenDensity(), resConfig->GetDirection());
2006 }
2007 }
2008
2009 Configuration newConfig;
2010 newConfig.AddItem(ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(to));
2011 newConfig.AddItem(to, ConfigurationInner::APPLICATION_DIRECTION, GetDirectionStr(height, width));
2012 newConfig.AddItem(to, ConfigurationInner::APPLICATION_DENSITYDPI, GetDensityStr(density));
2013
2014 if (application_ == nullptr) {
2015 HILOG_ERROR("application_ is nullptr.");
2016 return;
2017 }
2018
2019 std::vector<std::string> changeKeyV;
2020 auto configuration = application_->GetConfiguration();
2021 if (!configuration) {
2022 HILOG_ERROR("configuration is nullptr.");
2023 return;
2024 }
2025
2026 configuration->CompareDifferent(changeKeyV, newConfig);
2027 HILOG_DEBUG("changeKeyV size :%{public}zu", changeKeyV.size());
2028 if (!changeKeyV.empty()) {
2029 configuration->Merge(changeKeyV, newConfig);
2030 auto task = [ability = shared_from_this(), configuration = *configuration]() {
2031 ability->OnConfigurationUpdated(configuration);
2032 };
2033 handler_->PostTask(task);
2034 }
2035 }
2036
RequestFocus(const Want & want)2037 void Ability::RequestFocus(const Want &want)
2038 {
2039 HILOG_DEBUG("%{public}s called.", __func__);
2040 if (abilityWindow_ == nullptr) {
2041 return;
2042 }
2043 auto window = abilityWindow_->GetWindow();
2044 if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) {
2045 auto windowMode = want.GetIntParam(Want::PARAM_RESV_WINDOW_MODE,
2046 AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
2047 window->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
2048 HILOG_DEBUG("set window mode = %{public}d.", windowMode);
2049 }
2050 abilityWindow_->OnPostAbilityForeground(sceneFlag_);
2051 }
2052
SetWakeUpScreen(bool wakeUp)2053 void Ability::SetWakeUpScreen(bool wakeUp)
2054 {
2055 HILOG_DEBUG("FA mode::SetWakeUpScreen wakeUp:%{public}d.", wakeUp);
2056 if (abilityWindow_ == nullptr) {
2057 HILOG_ERROR("SetWakeUpScreen error. abilityWindow_ == nullptr.");
2058 return;
2059 }
2060 auto window = abilityWindow_->GetWindow();
2061 if (window == nullptr) {
2062 HILOG_ERROR("window nullptr.");
2063 return;
2064 }
2065 window->SetTurnScreenOn(wakeUp);
2066 }
2067
SetDisplayOrientation(int orientation)2068 void Ability::SetDisplayOrientation(int orientation)
2069 {
2070 HILOG_DEBUG("FA mode::%{public}s called, orientation: %{public}d", __func__, orientation);
2071 if (abilityWindow_ == nullptr) {
2072 HILOG_ERROR("Ability::SetDisplayOrientation error. abilityWindow_ == nullptr.");
2073 return;
2074 }
2075 auto window = abilityWindow_->GetWindow();
2076 if (window == nullptr) {
2077 HILOG_ERROR("window is nullptr.");
2078 return;
2079 }
2080 if (orientation == static_cast<int>(DisplayOrientation::FOLLOWRECENT)) {
2081 int defaultOrientation = 0;
2082 if (setWant_) {
2083 orientation = setWant_->GetIntParam("ohos.aafwk.Orientation", defaultOrientation);
2084 } else {
2085 orientation = defaultOrientation;
2086 }
2087 }
2088 if (orientation == static_cast<int>(DisplayOrientation::LANDSCAPE)) {
2089 HILOG_DEBUG("%{public}s, to set LANDSCAPE", __func__);
2090 window->SetRequestedOrientation(Rosen::Orientation::HORIZONTAL);
2091 } else if (orientation == static_cast<int>(DisplayOrientation::PORTRAIT)) {
2092 HILOG_DEBUG("%{public}s, to set PORTRAIT", __func__);
2093 window->SetRequestedOrientation(Rosen::Orientation::VERTICAL);
2094 } else {
2095 HILOG_DEBUG("%{public}s, to set UNSPECIFIED", __func__);
2096 window->SetRequestedOrientation(Rosen::Orientation::UNSPECIFIED);
2097 }
2098 }
2099
GetDisplayOrientation()2100 int Ability::GetDisplayOrientation()
2101 {
2102 HILOG_DEBUG("%{public}s called.", __func__);
2103 if (abilityWindow_ == nullptr) {
2104 HILOG_ERROR("Ability::GetDisplayOrientation error. abilityWindow_ == nullptr.");
2105 return -1;
2106 }
2107 HILOG_DEBUG("FA mode");
2108 auto window = abilityWindow_->GetWindow();
2109 if (window == nullptr) {
2110 HILOG_ERROR("window is nullptr.");
2111 return -1;
2112 }
2113 auto orientation = window->GetRequestedOrientation();
2114 if (orientation == Rosen::Orientation::HORIZONTAL) {
2115 HILOG_DEBUG("%{public}s, get window orientation: LANDSCAPE", __func__);
2116 return static_cast<int>(DisplayOrientation::LANDSCAPE);
2117 }
2118 if (orientation == Rosen::Orientation::VERTICAL) {
2119 HILOG_DEBUG("%{public}s, get window orientation: PORTRAIT", __func__);
2120 return static_cast<int>(DisplayOrientation::PORTRAIT);
2121 }
2122 HILOG_DEBUG("%{public}s, get window orientation: UNSPECIFIED", __func__);
2123 return 0;
2124 }
2125
ContinuationRestore(const Want & want)2126 void Ability::ContinuationRestore(const Want &want)
2127 {
2128 HILOG_DEBUG("%{public}s called.", __func__);
2129 }
2130 #endif
2131 } // namespace AppExecFwk
2132 } // namespace OHOS
2133