1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cj_ui_ability.h"
17
18 #include <dlfcn.h>
19 #include <regex>
20 #include <cstdlib>
21
22 #include "ability_business_error.h"
23 #include "ability_delegator_registry.h"
24 #include "ability_recovery.h"
25 #include "ability_start_setting.h"
26 #include "app_recovery.h"
27 #include "context/application_context.h"
28 #include "connection_manager.h"
29 #include "context/context.h"
30 #include "display_util.h"
31 #include "hilog_tag_wrapper.h"
32 #include "hitrace_meter.h"
33 #include "if_system_ability_manager.h"
34 #include "insight_intent_executor_info.h"
35 #include "insight_intent_executor_mgr.h"
36 #include "insight_intent_execute_param.h"
37 #include "cj_runtime.h"
38 #include "cj_ability_object.h"
39 #include "cj_ability_context.h"
40 #include "time_util.h"
41 #ifdef SUPPORT_SCREEN
42 #include "scene_board_judgement.h"
43 #endif
44 #include "string_wrapper.h"
45 #include "system_ability_definition.h"
46
47 namespace OHOS {
48 namespace AbilityRuntime {
49 namespace {
50 #ifdef SUPPORT_GRAPHICS
51 const std::string PAGE_STACK_PROPERTY_NAME = "pageStack";
52 const std::string METHOD_NAME = "WindowScene::GoForeground";
53 const std::string SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME = "ohos.extra.param.key.supportContinuePageStack";
54 #endif
55 #ifdef SUPPORT_SCREEN
56 // Numerical base (radix) that determines the valid characters and their interpretation.
57 const int32_t BASE_DISPLAY_ID_NUM (10);
58 #endif
59 const char* CJWINDOW_FFI_LIBNAME = "libcj_window_ffi.z.so";
60 const char* FUNC_CREATE_CJWINDOWSTAGE = "OHOS_CreateCJWindowStage";
61 constexpr const int32_t API12 = 12;
62 constexpr const int32_t API_VERSION_MOD = 100;
63 using CFFICreateCJWindowStage = int64_t (*)(std::shared_ptr<Rosen::WindowScene>&);
64
65 const char* CJ_ABILITY_LIBNAME = "libcj_ability_ffi.z.so";
66 const char* CJ_APP_CTX_FUNC = "OHOS_CjAppCtxFunc";
67 const char* CJ_APP_CTX_WINDOW_FUNC = "OHOS_CjAppCtxWindowFunc";
68
69 const char* CJ_IPC_LIBNAME = "libcj_ipc_ffi.z.so";
70 const char* FUNC_GET_NATIVE_REMOTEOBJECT = "OHOS_CallGetNativeRemoteObject";
71
CreateCJWindowStage(std::shared_ptr<Rosen::WindowScene> windowScene)72 sptr<Rosen::CJWindowStageImpl> CreateCJWindowStage(std::shared_ptr<Rosen::WindowScene> windowScene)
73 {
74 static void* handle = nullptr;
75 if (handle == nullptr) {
76 handle = dlopen(CJWINDOW_FFI_LIBNAME, RTLD_LAZY);
77 if (handle == nullptr) {
78 TAG_LOGE(AAFwkTag::UIABILITY, "null handle");
79 return nullptr;
80 }
81 }
82 // get function
83 auto func = reinterpret_cast<CFFICreateCJWindowStage>(dlsym(handle, FUNC_CREATE_CJWINDOWSTAGE));
84 if (func == nullptr) {
85 TAG_LOGE(AAFwkTag::UIABILITY, "null func");
86 dlclose(handle);
87 handle = nullptr;
88 return nullptr;
89 }
90 auto id = func(windowScene);
91 return OHOS::FFI::FFIData::GetData<Rosen::CJWindowStageImpl>(id);
92 }
93 }
94
Create(const std::unique_ptr<Runtime> & runtime)95 UIAbility *CJUIAbility::Create(const std::unique_ptr<Runtime> &runtime)
96 {
97 return new (std::nothrow) CJUIAbility(static_cast<CJRuntime &>(*runtime));
98 }
99
CJUIAbility(CJRuntime & cjRuntime)100 CJUIAbility::CJUIAbility(CJRuntime &cjRuntime) : cjRuntime_(cjRuntime)
101 {
102 TAG_LOGD(AAFwkTag::UIABILITY, "called");
103 }
104
~CJUIAbility()105 CJUIAbility::~CJUIAbility()
106 {
107 TAG_LOGD(AAFwkTag::UIABILITY, "called");
108 if (abilityContext_ != nullptr) {
109 abilityContext_->Unbind();
110 }
111 if (cjAppHandle_) {
112 dlclose(cjAppHandle_);
113 }
114 }
115
Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,const std::shared_ptr<OHOSApplication> application,std::shared_ptr<AbilityHandler> & handler,const sptr<IRemoteObject> & token)116 void CJUIAbility::Init(std::shared_ptr<AppExecFwk::AbilityLocalRecord> record,
117 const std::shared_ptr<OHOSApplication> application, std::shared_ptr<AbilityHandler> &handler,
118 const sptr<IRemoteObject> &token)
119 {
120 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
121 if (record == nullptr) {
122 TAG_LOGE(AAFwkTag::UIABILITY, "null record");
123 return;
124 }
125 auto abilityInfo = record->GetAbilityInfo();
126 if (abilityInfo == nullptr) {
127 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo");
128 return;
129 }
130 UIAbility::Init(record, application, handler, token);
131
132 #ifdef SUPPORT_GRAPHICS
133 if (abilityContext_ != nullptr) {
134 AppExecFwk::AppRecovery::GetInstance().AddAbility(
135 shared_from_this(), abilityContext_->GetAbilityInfo(), abilityContext_->GetToken());
136 }
137 #endif
138 SetAbilityContext(abilityInfo);
139 cjAppHandle_ = dlopen(CJ_ABILITY_LIBNAME, RTLD_LAZY);
140 if (cjAppHandle_ == nullptr) {
141 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAppHandle");
142 return;
143 }
144 }
145
SetAbilityContext(const std::shared_ptr<AbilityInfo> & abilityInfo)146 void CJUIAbility::SetAbilityContext(
147 const std::shared_ptr<AbilityInfo> &abilityInfo)
148 {
149 if (!abilityInfo) {
150 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityInfo");
151 return;
152 }
153 cjAbilityObj_ = CJAbilityObject::LoadModule(abilityInfo->name);
154 if (!cjAbilityObj_) {
155 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
156 return;
157 }
158 cjAbilityObj_->Init(this);
159 if (abilityRecovery_ != nullptr) {
160 abilityRecovery_->SetJsAbility(reinterpret_cast<uintptr_t>(abilityContext_.get()));
161 }
162 }
163
CallAppCtxFunc(CjAppCtxFuncType type,int64_t id)164 void CJUIAbility::CallAppCtxFunc(CjAppCtxFuncType type, int64_t id)
165 {
166 if (cjAppHandle_ != nullptr) {
167 auto symbol = dlsym(cjAppHandle_, CJ_APP_CTX_FUNC);
168 if (symbol == nullptr) {
169 TAG_LOGE(AAFwkTag::UIABILITY, "dlsym failed %{public}s, %{public}s", CJ_APP_CTX_FUNC, dlerror());
170 return;
171 }
172 auto func = reinterpret_cast<void (*)(int32_t, int64_t)>(symbol);
173 func(static_cast<int32_t>(type), id);
174 }
175 }
176
CallAppCtxWindowFunc(CjAppCtxFuncType type,int64_t id,sptr<Rosen::CJWindowStageImpl> window)177 void CJUIAbility::CallAppCtxWindowFunc(CjAppCtxFuncType type, int64_t id, sptr<Rosen::CJWindowStageImpl> window)
178 {
179 if (cjAppHandle_ != nullptr) {
180 WindowStagePtr windowStage = reinterpret_cast<WindowStagePtr>(window.GetRefPtr());
181 auto symbol = dlsym(cjAppHandle_, CJ_APP_CTX_WINDOW_FUNC);
182 if (symbol == nullptr) {
183 TAG_LOGE(AAFwkTag::UIABILITY, "dlsym failed %{public}s, %{public}s", CJ_APP_CTX_WINDOW_FUNC, dlerror());
184 return;
185 }
186 auto func = reinterpret_cast<void (*)(int32_t, int64_t, void*)>(symbol);
187 func(static_cast<int32_t>(type), id, windowStage);
188 }
189 }
190
OnStart(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)191 void CJUIAbility::OnStart(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
192 {
193 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
194 TAG_LOGD(AAFwkTag::UIABILITY, "ability is %{public}s", GetAbilityName().c_str());
195 UIAbility::OnStart(want, sessionInfo);
196
197 if (!cjAbilityObj_) {
198 TAG_LOGE(AAFwkTag::UIABILITY, "null cJAbility");
199 return;
200 }
201 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_CREATE, cjAbilityObj_->GetId());
202 std::string methodName = "OnStart";
203 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
204 cjAbilityObj_->OnStart(want, GetLaunchParam());
205 AddLifecycleEventAfterCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
206
207 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
208 if (delegator) {
209 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformStart");
210 delegator->PostPerformStart(CreateADelegatorAbilityProperty());
211 }
212 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_CREATE, cjAbilityObj_->GetId());
213 }
214
AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState state,const std::string & methodName) const215 void CJUIAbility::AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState state, const std::string &methodName) const
216 {
217 auto entry = std::string("CJUIAbility::") + methodName + " begin";
218 FreezeUtil::GetInstance().AddLifecycleEvent(AbilityContext::token_, entry);
219 }
220
AddLifecycleEventAfterCall(FreezeUtil::TimeoutState state,const std::string & methodName) const221 void CJUIAbility::AddLifecycleEventAfterCall(FreezeUtil::TimeoutState state, const std::string &methodName) const
222 {
223 auto entry = std::string("CJUIAbility::") + methodName + " end";
224 FreezeUtil::GetInstance().AddLifecycleEvent(AbilityContext::token_, entry);
225 }
226
OnShare(WantParams & wantParams)227 int32_t CJUIAbility::OnShare(WantParams &wantParams)
228 {
229 TAG_LOGD(AAFwkTag::UIABILITY, "called");
230 if (!cjAbilityObj_) {
231 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
232 return ERR_INVALID_VALUE;
233 }
234 return cjAbilityObj_->OnShare(wantParams);
235 }
236
OnStop()237 void CJUIAbility::OnStop()
238 {
239 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
240 TAG_LOGD(AAFwkTag::UIABILITY, "called");
241 if (abilityContext_) {
242 TAG_LOGD(AAFwkTag::UIABILITY, "set terminating true");
243 abilityContext_->SetTerminating(true);
244 }
245 UIAbility::OnStop();
246 if (!cjAbilityObj_) {
247 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
248 return;
249 }
250 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_DESTROY, cjAbilityObj_->GetId());
251 cjAbilityObj_->OnStop();
252 CJUIAbility::OnStopCallback();
253 TAG_LOGD(AAFwkTag::UIABILITY, "end");
254 }
255
OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> * callbackInfo,bool & isAsyncCallback)256 void CJUIAbility::OnStop(AppExecFwk::AbilityTransactionCallbackInfo<> *callbackInfo, bool &isAsyncCallback)
257 {
258 if (callbackInfo == nullptr) {
259 isAsyncCallback = false;
260 OnStop();
261 return;
262 }
263
264 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
265 TAG_LOGD(AAFwkTag::UIABILITY, "Begin");
266 if (abilityContext_) {
267 TAG_LOGD(AAFwkTag::UIABILITY, "set terminating true");
268 abilityContext_->SetTerminating(true);
269 }
270
271 UIAbility::OnStop();
272 if (cjAbilityObj_ != nullptr) {
273 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_DESTROY, cjAbilityObj_->GetId());
274 cjAbilityObj_->OnStop();
275 }
276 OnStopCallback();
277 TAG_LOGD(AAFwkTag::UIABILITY, "end");
278 }
279
OnStopCallback()280 void CJUIAbility::OnStopCallback()
281 {
282 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
283 if (delegator) {
284 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformStop");
285 delegator->PostPerformStop(CreateADelegatorAbilityProperty());
286 }
287
288 bool ret = ConnectionManager::GetInstance().DisconnectCaller(AbilityContext::token_);
289 if (!ret) {
290 TAG_LOGE(AAFwkTag::UIABILITY, "service connection disconnected");
291 }
292 ConnectionManager::GetInstance().ReportConnectionLeakEvent(getpid(), gettid());
293 if (cjAbilityObj_ != nullptr) {
294 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_DESTROY, cjAbilityObj_->GetId());
295 }
296 TAG_LOGD(AAFwkTag::UIABILITY, "end");
297 }
298
299 #ifdef SUPPORT_GRAPHICS
300 #ifdef SUPPORT_SCREEN
OnSceneCreated()301 void CJUIAbility::OnSceneCreated()
302 {
303 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
304 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
305 UIAbility::OnSceneCreated();
306
307 if (!cjAbilityObj_) {
308 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
309 return;
310 }
311 cjWindowStage_ = CreateCJWindowStage(GetScene());
312 if (!cjWindowStage_) {
313 TAG_LOGE(AAFwkTag::UIABILITY, "null cjWindowStage");
314 return;
315 }
316 CallAppCtxWindowFunc(CjAppCtxFuncType::ON_WINDOWSTAGE_WILL_CREATE, cjAbilityObj_->GetId(), cjWindowStage_);
317 {
318 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "onWindowStageCreate");
319 std::string methodName = "OnSceneCreated";
320 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
321 cjAbilityObj_->OnSceneCreated(cjWindowStage_.GetRefPtr());
322 AddLifecycleEventAfterCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
323 }
324
325 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
326 if (delegator) {
327 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformScenceCreated");
328 delegator->PostPerformScenceCreated(CreateADelegatorAbilityProperty());
329 }
330 CallAppCtxWindowFunc(CjAppCtxFuncType::ON_WINDOWSTAGE_CREATE, cjAbilityObj_->GetId(), cjWindowStage_);
331 TAG_LOGD(AAFwkTag::UIABILITY, "end");
332 }
333
OnSceneRestored()334 void CJUIAbility::OnSceneRestored()
335 {
336 UIAbility::OnSceneRestored();
337 TAG_LOGD(AAFwkTag::UIABILITY, "called");
338
339 if (!cjAbilityObj_) {
340 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
341 return;
342 }
343
344 if (!cjWindowStage_) {
345 cjWindowStage_ = CreateCJWindowStage(scene_);
346 if (!cjWindowStage_) {
347 TAG_LOGE(AAFwkTag::UIABILITY, "null cjWindowStage");
348 return;
349 }
350 }
351 CallAppCtxWindowFunc(CjAppCtxFuncType::ON_WINDOWSTAGE_WILL_RESTORE, cjAbilityObj_->GetId(), cjWindowStage_);
352 cjAbilityObj_->OnSceneRestored(cjWindowStage_.GetRefPtr());
353 CallAppCtxWindowFunc(CjAppCtxFuncType::ON_WINDOWSTAGE_RESTORE, cjAbilityObj_->GetId(), cjWindowStage_);
354
355 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
356 if (delegator) {
357 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformScenceRestored");
358 delegator->PostPerformScenceRestored(CreateADelegatorAbilityProperty());
359 }
360 }
361
OnSceneWillDestroy()362 void CJUIAbility::OnSceneWillDestroy()
363 {
364 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
365 if (!cjAbilityObj_) {
366 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
367 return;
368 }
369 if (!cjWindowStage_) {
370 TAG_LOGE(AAFwkTag::UIABILITY, "null cjWindowStage");
371 return;
372 }
373 cjAbilityObj_->OnSceneWillDestroy(cjWindowStage_.GetRefPtr());
374 }
375
onSceneDestroyed()376 void CJUIAbility::onSceneDestroyed()
377 {
378 TAG_LOGD(AAFwkTag::UIABILITY, "ability is %{public}s", GetAbilityName().c_str());
379 UIAbility::onSceneDestroyed();
380
381 if (!cjAbilityObj_) {
382 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
383 return;
384 }
385 CallAppCtxWindowFunc(CjAppCtxFuncType::ON_WINDOWSTAGE_WILL_DESTROY, cjAbilityObj_->GetId(), cjWindowStage_);
386 cjAbilityObj_->OnSceneDestroyed();
387
388 if (scene_ != nullptr) {
389 auto window = scene_->GetMainWindow();
390 if (window != nullptr) {
391 TAG_LOGD(AAFwkTag::UIABILITY, "window UnregisterDisplayMoveListener");
392 window->UnregisterDisplayMoveListener(abilityDisplayMoveListener_);
393 }
394 }
395
396 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
397 if (delegator) {
398 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformScenceDestroyed");
399 delegator->PostPerformScenceDestroyed(CreateADelegatorAbilityProperty());
400 }
401 CallAppCtxWindowFunc(CjAppCtxFuncType::ON_WINDOWSTAGE_DESTROY, cjAbilityObj_->GetId(), cjWindowStage_);
402 TAG_LOGD(AAFwkTag::UIABILITY, "end");
403 }
404
OnForeground(const Want & want)405 void CJUIAbility::OnForeground(const Want &want)
406 {
407 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
408 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
409
410 UIAbility::OnForeground(want);
411 CallOnForegroundFunc(want);
412 }
413
CallOnForegroundFunc(const Want & want)414 void CJUIAbility::CallOnForegroundFunc(const Want &want)
415 {
416 if (!cjAbilityObj_) {
417 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
418 return;
419 }
420 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_FOREGROUND, cjAbilityObj_->GetId());
421 std::string methodName = "OnForeground";
422 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
423 cjAbilityObj_->OnForeground(want);
424 AddLifecycleEventAfterCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
425
426 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
427 if (delegator) {
428 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformForeground");
429 delegator->PostPerformForeground(CreateADelegatorAbilityProperty());
430 }
431 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_FOREGROUND, cjAbilityObj_->GetId());
432 TAG_LOGD(AAFwkTag::UIABILITY, "end");
433 }
434
OnBackground()435 void CJUIAbility::OnBackground()
436 {
437 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
438 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
439
440 if (cjAbilityObj_ != nullptr) {
441 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_BACKGROUND, cjAbilityObj_->GetId());
442 }
443
444 UIAbility::OnBackground();
445
446 if (!cjAbilityObj_) {
447 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
448 return;
449 }
450 std::string methodName = "OnBackground";
451 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
452 cjAbilityObj_->OnBackground();
453 AddLifecycleEventAfterCall(FreezeUtil::TimeoutState::BACKGROUND, methodName);
454
455 auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetCJAbilityDelegator();
456 if (delegator) {
457 TAG_LOGD(AAFwkTag::UIABILITY, "call PostPerformBackground");
458 delegator->PostPerformBackground(CreateADelegatorAbilityProperty());
459 }
460
461 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_BACKGROUND, cjAbilityObj_->GetId());
462 TAG_LOGD(AAFwkTag::UIABILITY, "end");
463 }
464
OnAfterFocusedCommon(bool isFocused)465 void CJUIAbility::OnAfterFocusedCommon(bool isFocused)
466 {
467 if (!cjAbilityObj_) {
468 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
469 return;
470 }
471
472 if (isFocused) {
473 CallAppCtxWindowFunc(CjAppCtxFuncType::WINDOWSTAGE_FOCUS, cjAbilityObj_->GetId(), cjWindowStage_);
474 } else {
475 CallAppCtxWindowFunc(CjAppCtxFuncType::WINDOWSTAGE_UNFOCUS, cjAbilityObj_->GetId(), cjWindowStage_);
476 }
477 }
478
OnBackPress()479 bool CJUIAbility::OnBackPress()
480 {
481 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
482 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
483 UIAbility::OnBackPress();
484 bool defaultRet = BackPressDefaultValue();
485 if (!cjAbilityObj_) {
486 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
487 return defaultRet;
488 }
489 bool ret = cjAbilityObj_->OnBackPress(defaultRet);
490 TAG_LOGD(AAFwkTag::UIABILITY, "end ret: %{public}d", ret);
491 return ret;
492 }
493
OnPrepareTerminate()494 bool CJUIAbility::OnPrepareTerminate()
495 {
496 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
497 TAG_LOGD(AAFwkTag::UIABILITY, "ability: %{public}s", GetAbilityName().c_str());
498 UIAbility::OnPrepareTerminate();
499 if (!cjAbilityObj_) {
500 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj");
501 return false;
502 }
503 bool ret = cjAbilityObj_->OnPrepareTerminate();
504 TAG_LOGD(AAFwkTag::UIABILITY, "end ret: %{public}d", ret);
505 return ret;
506 }
507
GetPageStackFromWant(const Want & want,std::string & pageStack)508 void CJUIAbility::GetPageStackFromWant(const Want &want, std::string &pageStack)
509 {
510 auto stringObj = AAFwk::IString::Query(want.GetParams().GetParam(PAGE_STACK_PROPERTY_NAME));
511 if (stringObj != nullptr) {
512 pageStack = AAFwk::String::Unbox(stringObj);
513 }
514 }
515
IsRestorePageStack(const Want & want)516 bool CJUIAbility::IsRestorePageStack(const Want &want)
517 {
518 return want.GetBoolParam(SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME, true);
519 }
520
RestorePageStack(const Want & want)521 void CJUIAbility::RestorePageStack(const Want &want)
522 {
523 if (IsRestorePageStack(want)) {
524 std::string pageStack;
525 GetPageStackFromWant(want, pageStack);
526 }
527 }
528
AbilityContinuationOrRecover(const Want & want)529 void CJUIAbility::AbilityContinuationOrRecover(const Want &want)
530 {
531 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
532 // multi-instance ability continuation
533 TAG_LOGD(AAFwkTag::UIABILITY, "launch reason: %{public}d", launchParam_.launchReason);
534 if (IsRestoredInContinuation()) {
535 RestorePageStack(want);
536 OnSceneRestored();
537 NotifyContinuationResult(want, true);
538 } else if (ShouldRecoverState(want)) {
539 std::string pageStack = abilityRecovery_->GetSavedPageStack(AppExecFwk::StateReason::DEVELOPER_REQUEST);
540 OnSceneRestored();
541 } else {
542 OnSceneCreated();
543 }
544 }
545
DoOnForeground(const Want & want)546 void CJUIAbility::DoOnForeground(const Want &want)
547 {
548 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
549 if (scene_ == nullptr) {
550 if ((abilityContext_ == nullptr) || (sceneListener_ == nullptr)) {
551 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext or sceneListener");
552 return;
553 }
554 scene_ = std::make_shared<Rosen::WindowScene>();
555 InitSceneDoOnForeground(scene_, want);
556 } else {
557 auto window = scene_->GetMainWindow();
558 if (window == nullptr) {
559 TAG_LOGE(AAFwkTag::UIABILITY, "null window");
560 return;
561 }
562 if (want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) {
563 TAG_LOGI(AAFwkTag::UIABILITY, "recv window mode");
564 auto windowMode = want.GetIntParam(
565 Want::PARAM_RESV_WINDOW_MODE, AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
566 window->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
567 windowMode_ = windowMode;
568 TAG_LOGD(AAFwkTag::UIABILITY, "set window mode: %{public}d", windowMode);
569 }
570 }
571
572 auto window = scene_->GetMainWindow();
573 if (window == nullptr) {
574 TAG_LOGE(AAFwkTag::UIABILITY, "null window");
575 return;
576 }
577 if (securityFlag_) {
578 window->SetSystemPrivacyMode(true);
579 }
580
581 TAG_LOGD(AAFwkTag::UIABILITY, "move scene to foreground, sceneFlag_: %{public}d", UIAbility::sceneFlag_);
582 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::FOREGROUND, METHOD_NAME);
583 scene_->GoForeground(UIAbility::sceneFlag_);
584 }
585
InitSceneDoOnForeground(std::shared_ptr<Rosen::WindowScene> scene,const Want & want)586 void CJUIAbility::InitSceneDoOnForeground(std::shared_ptr<Rosen::WindowScene> scene, const Want &want)
587 {
588 int32_t displayId = AAFwk::DisplayUtil::GetDefaultDisplayId();
589 if (setting_ != nullptr) {
590 std::string strDisplayId = setting_->GetProperty(OHOS::AppExecFwk::AbilityStartSetting::WINDOW_DISPLAY_ID_KEY);
591 std::regex formatRegex("[0-9]{0,9}$");
592 std::smatch sm;
593 bool flag = std::regex_match(strDisplayId, sm, formatRegex);
594 if (flag && !strDisplayId.empty()) {
595 displayId = strtol(strDisplayId.c_str(), nullptr, BASE_DISPLAY_ID_NUM);
596 TAG_LOGD(AAFwkTag::UIABILITY, "displayId: %{public}d", displayId);
597 } else {
598 TAG_LOGE(AAFwkTag::UIABILITY, "formatRegex: [%{public}s] failed", strDisplayId.c_str());
599 }
600 }
601 Rosen::WMError ret = Rosen::WMError::WM_OK;
602 auto option = GetWindowOption(want);
603 auto sessionToken = GetSessionToken();
604 if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled() && sessionToken != nullptr) {
605 abilityContext_->SetWeakSessionToken(sessionToken);
606 ret = scene_->Init(displayId, abilityContext_, sceneListener_, option, sessionToken);
607 } else {
608 ret = scene_->Init(displayId, abilityContext_, sceneListener_, option);
609 }
610 if (ret != Rosen::WMError::WM_OK) {
611 TAG_LOGE(AAFwkTag::UIABILITY, "init window scene failed");
612 return;
613 }
614
615 AbilityContinuationOrRecover(want);
616 auto window = scene_->GetMainWindow();
617 if (window) {
618 TAG_LOGD(AAFwkTag::UIABILITY,
619 "call RegisterDisplayMoveListener, windowId: %{public}d", window->GetWindowId());
620 abilityDisplayMoveListener_ = new AbilityDisplayMoveListener(weak_from_this());
621 if (abilityDisplayMoveListener_ == nullptr) {
622 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityDisplayMoveListener_");
623 return;
624 }
625 window->RegisterDisplayMoveListener(abilityDisplayMoveListener_);
626 }
627 }
628
RequestFocus(const Want & want)629 void CJUIAbility::RequestFocus(const Want &want)
630 {
631 TAG_LOGD(AAFwkTag::UIABILITY, "called");
632 if (scene_ == nullptr) {
633 TAG_LOGE(AAFwkTag::UIABILITY, "null scene_");
634 return;
635 }
636 auto window = scene_->GetMainWindow();
637 if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) {
638 auto windowMode = want.GetIntParam(
639 Want::PARAM_RESV_WINDOW_MODE, AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED);
640 window->SetWindowMode(static_cast<Rosen::WindowMode>(windowMode));
641 TAG_LOGD(AAFwkTag::UIABILITY, "set window mode: %{public}d", windowMode);
642 }
643 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::FOREGROUND, METHOD_NAME);
644 scene_->GoForeground(UIAbility::sceneFlag_);
645 TAG_LOGD(AAFwkTag::UIABILITY, "end");
646 }
647
ContinuationRestore(const Want & want)648 void CJUIAbility::ContinuationRestore(const Want &want)
649 {
650 TAG_LOGD(AAFwkTag::UIABILITY, "called");
651 if (!IsRestoredInContinuation() || scene_ == nullptr) {
652 TAG_LOGE(AAFwkTag::UIABILITY, "is not in continuation or null scene_");
653 return;
654 }
655 RestorePageStack(want);
656 OnSceneRestored();
657 NotifyContinuationResult(want, true);
658 }
659
GetCJRuntime()660 const CJRuntime &CJUIAbility::GetCJRuntime()
661 {
662 return cjRuntime_;
663 }
664
ExecuteInsightIntentRepeateForeground(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)665 void CJUIAbility::ExecuteInsightIntentRepeateForeground(const Want &want,
666 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
667 std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
668 {
669 TAG_LOGD(AAFwkTag::UIABILITY, "called");
670 if (executeParam == nullptr) {
671 TAG_LOGW(AAFwkTag::UIABILITY, "invalid param");
672 RequestFocus(want);
673 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback), ERR_OK);
674 return;
675 }
676
677 auto asyncCallback = [weak = weak_from_this(), want](InsightIntentExecuteResult result) {
678 TAG_LOGD(AAFwkTag::UIABILITY, "begin request focus");
679 auto ability = weak.lock();
680 if (ability == nullptr) {
681 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
682 return;
683 }
684 ability->RequestFocus(want);
685 };
686 callback->Push(asyncCallback);
687
688 InsightIntentExecutorInfo executeInfo;
689 auto ret = GetInsightIntentExecutorInfo(want, executeParam, executeInfo);
690 if (!ret) {
691 TAG_LOGE(AAFwkTag::UIABILITY, "get intention executor failed");
692 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback),
693 static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INVALID_PARAM));
694 return;
695 }
696 }
697
ExecuteInsightIntentMoveToForeground(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)698 void CJUIAbility::ExecuteInsightIntentMoveToForeground(const Want &want,
699 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
700 std::unique_ptr<InsightIntentExecutorAsyncCallback> callback)
701 {
702 TAG_LOGD(AAFwkTag::UIABILITY, "called");
703 if (executeParam == nullptr) {
704 TAG_LOGW(AAFwkTag::UIABILITY, "param invalid");
705 OnForeground(want);
706 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback), ERR_OK);
707 return;
708 }
709
710 UIAbility::OnForeground(want);
711
712 auto asyncCallback = [weak = weak_from_this(), want](InsightIntentExecuteResult result) {
713 TAG_LOGD(AAFwkTag::UIABILITY, "begin call onForeground");
714 auto ability = weak.lock();
715 if (ability == nullptr) {
716 TAG_LOGE(AAFwkTag::UIABILITY, "null ability");
717 return;
718 }
719 ability->CallOnForegroundFunc(want);
720 };
721 callback->Push(asyncCallback);
722
723 InsightIntentExecutorInfo executeInfo;
724 auto ret = GetInsightIntentExecutorInfo(want, executeParam, executeInfo);
725 if (!ret) {
726 TAG_LOGE(AAFwkTag::UIABILITY, "get Intention executor failed");
727 InsightIntentExecutorMgr::TriggerCallbackInner(std::move(callback),
728 static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INVALID_PARAM));
729 return;
730 }
731 }
732
GetInsightIntentExecutorInfo(const Want & want,const std::shared_ptr<InsightIntentExecuteParam> & executeParam,InsightIntentExecutorInfo & executeInfo)733 bool CJUIAbility::GetInsightIntentExecutorInfo(const Want &want,
734 const std::shared_ptr<InsightIntentExecuteParam> &executeParam,
735 InsightIntentExecutorInfo& executeInfo)
736 {
737 TAG_LOGD(AAFwkTag::UIABILITY, "called");
738 auto context = GetAbilityContext();
739 if (executeParam == nullptr || context == nullptr || abilityInfo_ == nullptr || cjWindowStage_ == nullptr) {
740 TAG_LOGE(AAFwkTag::UIABILITY, "invalid param");
741 return false;
742 }
743
744 const WantParams &wantParams = want.GetParams();
745 executeInfo.srcEntry = wantParams.GetStringParam("ohos.insightIntent.srcEntry");
746 executeInfo.hapPath = abilityInfo_->hapPath;
747 executeInfo.esmodule = abilityInfo_->compileMode == AppExecFwk::CompileMode::ES_MODULE;
748 executeInfo.windowMode = windowMode_;
749 executeInfo.token = context->GetToken();
750 executeInfo.executeParam = executeParam;
751 return true;
752 }
753 #endif
754 #endif
OnContinue(WantParams & wantParams,bool & isAsyncOnContinue,const AppExecFwk::AbilityInfo & abilityInfo)755 int32_t CJUIAbility::OnContinue(WantParams &wantParams, bool &isAsyncOnContinue,
756 const AppExecFwk::AbilityInfo &abilityInfo)
757 {
758 if (!cjAbilityObj_) {
759 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
760 return AppExecFwk::ContinuationManagerStage::OnContinueResult::ON_CONTINUE_ERR;
761 }
762
763 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_CONTINUE, cjAbilityObj_->GetId());
764 auto res = cjAbilityObj_->OnContinue(wantParams);
765 TAG_LOGD(AAFwkTag::UIABILITY, "end, value: %{public}d", res);
766
767 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_CONTINUE, cjAbilityObj_->GetId());
768 return res;
769 }
770
OnSaveState(int32_t reason,WantParams & wantParams)771 int32_t CJUIAbility::OnSaveState(int32_t reason, WantParams &wantParams)
772 {
773 if (!cjAbilityObj_) {
774 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
775 return -1;
776 }
777
778 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_WILL_SAVE_STATE, cjAbilityObj_->GetId());
779 int32_t numberResult = cjAbilityObj_->OnSaveState(reason, wantParams);
780
781 CallAppCtxFunc(CjAppCtxFuncType::ON_ABILITY_SAVE_STATE, cjAbilityObj_->GetId());
782 return numberResult;
783 }
784
OnConfigurationUpdated(const Configuration & configuration)785 void CJUIAbility::OnConfigurationUpdated(const Configuration &configuration)
786 {
787 UIAbility::OnConfigurationUpdated(configuration);
788 TAG_LOGD(AAFwkTag::UIABILITY, "called");
789 auto fullConfig = GetAbilityContext()->GetConfiguration();
790 if (!fullConfig) {
791 TAG_LOGE(AAFwkTag::UIABILITY, "null fullConfig");
792 return;
793 }
794
795 if (!cjAbilityObj_) {
796 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
797 return;
798 }
799
800 cjAbilityObj_->OnConfigurationUpdated(fullConfig);
801 TAG_LOGD(AAFwkTag::UIABILITY, "end");
802 }
803
OnMemoryLevel(int level)804 void CJUIAbility::OnMemoryLevel(int level)
805 {
806 UIAbility::OnMemoryLevel(level);
807 TAG_LOGD(AAFwkTag::UIABILITY, "called");
808 if (!cjAbilityObj_) {
809 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
810 return;
811 }
812 auto memLevel = static_cast<int32_t>(level);
813 cjAbilityObj_->OnMemoryLevel(memLevel);
814 TAG_LOGD(AAFwkTag::UIABILITY, "end");
815 }
816
UpdateContextConfiguration()817 void CJUIAbility::UpdateContextConfiguration()
818 {
819 TAG_LOGD(AAFwkTag::UIABILITY, "called");
820 }
821
OnNewWant(const Want & want)822 void CJUIAbility::OnNewWant(const Want &want)
823 {
824 TAG_LOGD(AAFwkTag::UIABILITY, "called");
825 UIAbility::OnNewWant(want);
826
827 #ifdef SUPPORT_GRAPHICS
828 #ifdef SUPPORT_SCREEN
829 if (scene_) {
830 scene_->OnNewWant(want);
831 }
832 #endif
833 #endif
834 if (!cjAbilityObj_) {
835 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
836 return;
837 }
838
839 CallAppCtxFunc(CjAppCtxFuncType::ON_WILL_NEW_WANT, cjAbilityObj_->GetId());
840 std::string methodName = "OnNewWant";
841 AddLifecycleEventBeforeCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
842 cjAbilityObj_->OnNewWant(want, GetLaunchParam());
843 AddLifecycleEventAfterCall(FreezeUtil::TimeoutState::FOREGROUND, methodName);
844
845 CallAppCtxFunc(CjAppCtxFuncType::ON_NEW_WANT, cjAbilityObj_->GetId());
846 TAG_LOGD(AAFwkTag::UIABILITY, "end");
847 }
848
OnAbilityResult(int requestCode,int resultCode,const Want & resultData)849 void CJUIAbility::OnAbilityResult(int requestCode, int resultCode, const Want &resultData)
850 {
851 TAG_LOGD(AAFwkTag::UIABILITY, "called");
852 UIAbility::OnAbilityResult(requestCode, resultCode, resultData);
853 if (abilityContext_ == nullptr) {
854 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
855 return;
856 }
857 abilityContext_->OnAbilityResult(requestCode, resultCode, resultData);
858 TAG_LOGD(AAFwkTag::UIABILITY, "end");
859 }
860
CallRequest()861 sptr<IRemoteObject> CJUIAbility::CallRequest()
862 {
863 TAG_LOGD(AAFwkTag::UIABILITY, "called");
864 if (cjAbilityObj_ == nullptr) {
865 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
866 return nullptr;
867 }
868 if (remoteCallee_ != nullptr) {
869 TAG_LOGD(AAFwkTag::UIABILITY, "some remoteCallee_");
870 return remoteCallee_;
871 }
872 int64_t ret = cjAbilityObj_->OnCallRequest();
873 if (ret <= 0) {
874 TAG_LOGE(AAFwkTag::UIABILITY, "invalid callee");
875 return nullptr;
876 }
877 remoteCallee_ = SetNewRuleFlagToCallee(ret);
878 TAG_LOGD(AAFwkTag::UIABILITY, "end");
879 return remoteCallee_;
880 }
881
CreateADelegatorAbilityProperty()882 std::shared_ptr<AppExecFwk::ACJDelegatorAbilityProperty> CJUIAbility::CreateADelegatorAbilityProperty()
883 {
884 if (abilityContext_ == nullptr) {
885 TAG_LOGE(AAFwkTag::UIABILITY, "null abilityContext_");
886 return nullptr;
887 }
888 auto property = std::make_shared<AppExecFwk::ACJDelegatorAbilityProperty>();
889 property->token_ = abilityContext_->GetToken();
890 property->name_ = GetAbilityName();
891 property->moduleName_ = GetModuleName();
892 if (GetApplicationInfo() == nullptr || GetApplicationInfo()->bundleName.empty()) {
893 property->fullName_ = GetAbilityName();
894 } else {
895 std::string::size_type pos = GetAbilityName().find(GetApplicationInfo()->bundleName);
896 if (pos == std::string::npos || pos != 0) {
897 property->fullName_ = GetApplicationInfo()->bundleName + "." + GetAbilityName();
898 } else {
899 property->fullName_ = GetAbilityName();
900 }
901 }
902 property->lifecycleState_ = GetState();
903 property->cjObject_ = cjAbilityObj_->GetId();
904 return property;
905 }
906
Dump(const std::vector<std::string> & params,std::vector<std::string> & info)907 void CJUIAbility::Dump(const std::vector<std::string> ¶ms, std::vector<std::string> &info)
908 {
909 UIAbility::Dump(params, info);
910 TAG_LOGD(AAFwkTag::UIABILITY, "called");
911 if (!cjAbilityObj_) {
912 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
913 return;
914 }
915 cjAbilityObj_->Dump(params, info);
916 TAG_LOGD(AAFwkTag::UIABILITY, "dump, size: %{public}zu", info.size());
917 }
918
GetCJAbility()919 std::shared_ptr<CJAbilityObject> CJUIAbility::GetCJAbility()
920 {
921 TAG_LOGD(AAFwkTag::UIABILITY, "called");
922 if (cjAbilityObj_ == nullptr) {
923 TAG_LOGE(AAFwkTag::UIABILITY, "null cjAbilityObj_");
924 }
925 return cjAbilityObj_;
926 }
927
CallGetNativeRemoteObject(int64_t remoteCjObjId)928 sptr<IRemoteObject> CallGetNativeRemoteObject(int64_t remoteCjObjId)
929 {
930 void* handle = dlopen(CJ_IPC_LIBNAME, RTLD_LAZY);
931 if (handle == nullptr) {
932 TAG_LOGE(AAFwkTag::CONTEXT, "null handle");
933 return nullptr;
934 }
935 using GetNativeRemoteObjectFunc = void (*)(int64_t, void*);
936 auto func = reinterpret_cast<GetNativeRemoteObjectFunc>(dlsym(handle, FUNC_GET_NATIVE_REMOTEOBJECT));
937 if (func == nullptr) {
938 TAG_LOGE(AAFwkTag::CONTEXT, "null func");
939 dlclose(handle);
940 return nullptr;
941 }
942 sptr<IRemoteObject> remoteObject = nullptr;
943 func(remoteCjObjId, &remoteObject);
944 dlclose(handle);
945 return remoteObject;
946 }
947
SetNewRuleFlagToCallee(int64_t remoteCjObjId)948 sptr<IRemoteObject> CJUIAbility::SetNewRuleFlagToCallee(int64_t remoteCjObjId)
949 {
950 if (remoteCjObjId <= 0) {
951 TAG_LOGE(AAFwkTag::UIABILITY, "null callee");
952 return nullptr;
953 }
954 auto flag = IsUseNewStartUpRule();
955 cjAbilityObj_->OnSetCalleeFlag(flag);
956 auto remoteObj = CallGetNativeRemoteObject(remoteCjObjId);
957 if (remoteObj == nullptr) {
958 TAG_LOGE(AAFwkTag::UIABILITY, "null remoteObj");
959 }
960 return remoteObj;
961 }
962
CheckSatisfyTargetAPIVersion(int32_t version)963 bool CJUIAbility::CheckSatisfyTargetAPIVersion(int32_t version)
964 {
965 auto applicationInfo = GetApplicationInfo();
966 if (!applicationInfo) {
967 TAG_LOGE(AAFwkTag::UIABILITY, "null applicationInfo");
968 return false;
969 }
970 TAG_LOGD(AAFwkTag::UIABILITY, "targetAPIVersion: %{public}d", applicationInfo->apiTargetVersion);
971 return applicationInfo->apiTargetVersion % API_VERSION_MOD >= version;
972 }
973
BackPressDefaultValue()974 bool CJUIAbility::BackPressDefaultValue()
975 {
976 return CheckSatisfyTargetAPIVersion(API12) ? true : false;
977 }
978 } // namespace AbilityRuntime
979 } // namespace OHOS
980