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