1 /*
2  * Copyright (c) 2021-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 "extension_impl.h"
17 
18 #include "ability_manager_client.h"
19 #include "ability_local_record.h"
20 #include "ability_transaction_callback_info.h"
21 #include "hitrace_meter.h"
22 #include "ipc_object_proxy.h"
23 #include "extension_context.h"
24 #include "hilog_tag_wrapper.h"
25 #include "ui_extension_utils.h"
26 
27 
28 namespace OHOS {
29 namespace AbilityRuntime {
~ExtensionImpl()30 ExtensionImpl::~ExtensionImpl()
31 {
32     TAG_LOGI(AAFwkTag::EXT, "~ExtensionImpl");
33 }
34 
Init(const std::shared_ptr<AppExecFwk::OHOSApplication> & application,const std::shared_ptr<AppExecFwk::AbilityLocalRecord> & record,std::shared_ptr<Extension> & extension,std::shared_ptr<AppExecFwk::AbilityHandler> & handler,const sptr<IRemoteObject> & token)35 void ExtensionImpl::Init(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,
36     const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &record,
37     std::shared_ptr<Extension> &extension,
38     std::shared_ptr<AppExecFwk::AbilityHandler> &handler,
39     const sptr<IRemoteObject> &token)
40 {
41     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
42     TAG_LOGD(AAFwkTag::EXT, "call");
43     if ((token == nullptr) || (application == nullptr) || (handler == nullptr) || (record == nullptr) ||
44         extension == nullptr) {
45         TAG_LOGE(AAFwkTag::EXT, "init failed, some obj null");
46         return;
47     }
48 
49     token_ = record->GetToken();
50     extension_ = extension;
51     if (record->GetAbilityInfo() != nullptr) {
52         extensionType_ = record->GetAbilityInfo()->extensionAbilityType;
53         if (AAFwk::UIExtensionUtils::IsUIExtension(extensionType_)) {
54             extension_->SetExtensionWindowLifeCycleListener(
55                 sptr<ExtensionWindowLifeCycleImpl>(new ExtensionWindowLifeCycleImpl(token_, shared_from_this())));
56         }
57         if (record->GetAbilityInfo()->name == "com.ohos.callui.ServiceAbility") {
58             PrintTokenInfo();
59         }
60     }
61     extension_->Init(record, application, handler, token);
62     lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
63     skipCommandExtensionWithIntent_ = false;
64 }
65 
PrintTokenInfo() const66 void ExtensionImpl::PrintTokenInfo() const
67 {
68     if (token_ == nullptr) {
69         TAG_LOGI(AAFwkTag::EXT, "null token");
70         return;
71     }
72     if (!token_->IsProxyObject()) {
73         TAG_LOGI(AAFwkTag::EXT, "token not proxy");
74         return;
75     }
76     IPCObjectProxy *tokenProxyObject = reinterpret_cast<IPCObjectProxy *>(token_.GetRefPtr());
77     if (tokenProxyObject != nullptr) {
78         std::string remoteDescriptor = Str16ToStr8(tokenProxyObject->GetInterfaceDescriptor());
79         TAG_LOGI(AAFwkTag::EXT, "handle: %{public}d, descriptor: %{public}s",
80             tokenProxyObject->GetHandle(), remoteDescriptor.c_str());
81     }
82 }
83 
84 /**
85  * @brief Handling the life cycle switching of Extension.
86  *
87  * @param want Indicates the structure containing information about the extension.
88  * @param targetState The life cycle state to switch to.
89  * @param sessionInfo  Indicates the sessionInfo.
90  *
91  */
HandleExtensionTransaction(const Want & want,const AAFwk::LifeCycleStateInfo & targetState,sptr<AAFwk::SessionInfo> sessionInfo)92 void ExtensionImpl::HandleExtensionTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState,
93     sptr<AAFwk::SessionInfo> sessionInfo)
94 {
95     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
96     TAG_LOGI(AAFwkTag::EXT, "%{public}s;sourceState:%{public}d;targetState:%{public}d;isNewWant:%{public}d",
97         want.GetElement().GetAbilityName().c_str(), lifecycleState_, targetState.state, targetState.isNewWant);
98     if (lifecycleState_ == targetState.state) {
99         TAG_LOGE(AAFwkTag::EXT, "lifecycle state equal");
100         return;
101     }
102     SetLaunchParam(targetState.launchParam);
103     bool ret = true;
104     switch (targetState.state) {
105         case AAFwk::ABILITY_STATE_INITIAL: {
106             bool isAsyncCallback = false;
107             if (lifecycleState_ != AAFwk::ABILITY_STATE_INITIAL) {
108                 Stop(isAsyncCallback, want, sessionInfo);
109             }
110             if (isAsyncCallback) {
111                 ret = false;
112             }
113             break;
114         }
115         case AAFwk::ABILITY_STATE_INACTIVE: {
116             if (lifecycleState_ == AAFwk::ABILITY_STATE_INITIAL) {
117                 Start(want, sessionInfo);
118             }
119             break;
120         }
121         case AAFwk::ABILITY_STATE_FOREGROUND_NEW: {
122             if (lifecycleState_ == AAFwk::ABILITY_STATE_INITIAL) {
123                 Start(want, sessionInfo);
124             }
125             Foreground(want, sessionInfo);
126             break;
127         }
128         case AAFwk::ABILITY_STATE_BACKGROUND_NEW: {
129             Background(want, sessionInfo);
130             break;
131         }
132         default: {
133             ret = false;
134             TAG_LOGE(AAFwkTag::EXT, "error state");
135             break;
136         }
137     }
138     if (ret && !UIExtensionAbilityExecuteInsightIntent(want)) {
139         TAG_LOGD(AAFwkTag::EXT, "call abilityms");
140         AAFwk::PacMap restoreData;
141         AAFwk::AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_, targetState.state, restoreData);
142     }
143 }
144 
UIExtensionAbilityExecuteInsightIntent(const Want & want)145 bool ExtensionImpl::UIExtensionAbilityExecuteInsightIntent(const Want &want)
146 {
147     return AAFwk::UIExtensionUtils::IsUIExtension(extensionType_) &&
148         AppExecFwk::InsightIntentExecuteParam::IsInsightIntentExecute(want);
149 }
150 
ScheduleUpdateConfiguration(const AppExecFwk::Configuration & config)151 void ExtensionImpl::ScheduleUpdateConfiguration(const AppExecFwk::Configuration &config)
152 {
153     TAG_LOGD(AAFwkTag::EXT, "call");
154     if (extension_ == nullptr) {
155         TAG_LOGE(AAFwkTag::EXT, "null extension_");
156         return;
157     }
158 
159     extension_->OnConfigurationUpdated(config);
160 }
161 
NotifyMemoryLevel(int level)162 void ExtensionImpl::NotifyMemoryLevel(int level)
163 {
164     TAG_LOGD(AAFwkTag::EXT, "call");
165     if (extension_ == nullptr) {
166         TAG_LOGE(AAFwkTag::EXT, "null extension_");
167         return;
168     }
169 
170     if (lifecycleState_ != AAFwk::ABILITY_STATE_INITIAL) {
171         extension_->OnMemoryLevel(level);
172     }
173 }
174 
175 /**
176  * @brief Toggles the lifecycle status of Extension to AAFwk::ABILITY_STATE_INACTIVE. And notifies the application
177  * that it belongs to of the lifecycle status.
178  *
179  * @param want  The Want object to switch the life cycle.
180  * @param sessionInfo  Indicates the sessionInfo.
181  */
Start(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)182 void ExtensionImpl::Start(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
183 {
184     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
185     TAG_LOGD(AAFwkTag::EXT, "call");
186     if (extension_ == nullptr) {
187         TAG_LOGE(AAFwkTag::EXT, "null extension_");
188         return;
189     }
190 
191     TAG_LOGD(AAFwkTag::EXT, "called");
192     if (extension_->abilityInfo_->extensionAbilityType == AppExecFwk::ExtensionAbilityType::WINDOW) {
193         extension_->OnStart(want, sessionInfo);
194     } else {
195         extension_->OnStart(want);
196     }
197     lifecycleState_ = AAFwk::ABILITY_STATE_INACTIVE;
198     TAG_LOGD(AAFwkTag::EXT, "ok");
199 }
200 
201 /**
202  * @brief Toggles the lifecycle status of Extension to AAFwk::ABILITY_STATE_INITIAL. And notifies the application
203  * that it belongs to of the lifecycle status.
204  *
205  */
Stop()206 void ExtensionImpl::Stop()
207 {
208     TAG_LOGD(AAFwkTag::EXT, "call");
209     if (extension_ == nullptr) {
210         TAG_LOGE(AAFwkTag::EXT, "null extension_");
211         return;
212     }
213 
214     extension_->OnStop();
215     lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
216     TAG_LOGD(AAFwkTag::EXT, "ok");
217 }
218 
Stop(bool & isAsyncCallback,const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)219 void ExtensionImpl::Stop(bool &isAsyncCallback, const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
220 {
221     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
222     TAG_LOGD(AAFwkTag::EXT, "call");
223     if (extension_ == nullptr) {
224         TAG_LOGE(AAFwkTag::EXT, "null extension_");
225         isAsyncCallback = false;
226         return;
227     }
228 
229     if (AAFwk::UIExtensionUtils::IsUIExtension(extensionType_) && sessionInfo != nullptr) {
230         CommandExtensionWindow(want, sessionInfo, AAFwk::WIN_CMD_DESTROY);
231     }
232 
233     auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<>::Create();
234     if (callbackInfo == nullptr) {
235         extension_->OnStop();
236         lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
237         isAsyncCallback = false;
238         return;
239     }
240     std::weak_ptr<ExtensionImpl> weakPtr = shared_from_this();
241     auto asyncCallback = [ExtensionImplWeakPtr = weakPtr, state = AAFwk::ABILITY_STATE_INITIAL]() {
242         auto extensionImpl = ExtensionImplWeakPtr.lock();
243         if (extensionImpl == nullptr) {
244             TAG_LOGE(AAFwkTag::EXT, "null extensionImpl");
245             return;
246         }
247         extensionImpl->lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
248         extensionImpl->AbilityTransactionCallback(state);
249     };
250     callbackInfo->Push(asyncCallback);
251 
252     extension_->OnStop(callbackInfo, isAsyncCallback);
253     if (!isAsyncCallback) {
254         lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
255         AppExecFwk::AbilityTransactionCallbackInfo<>::Destroy(callbackInfo);
256     }
257     // else: callbackInfo will be destroyed after the async callback
258     TAG_LOGD(AAFwkTag::EXT, "end");
259 }
260 
AbilityTransactionCallback(const AAFwk::AbilityLifeCycleState & state)261 void ExtensionImpl::AbilityTransactionCallback(const AAFwk::AbilityLifeCycleState &state)
262 {
263     TAG_LOGD(AAFwkTag::EXT, "called");
264     AAFwk::PacMap restoreData;
265     AAFwk::AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_, state, restoreData);
266 }
267 
268 /**
269  * @brief Connect the extension. and Calling information back to Extension.
270  *
271  * @param want The Want object to connect to.
272  *
273  */
ConnectExtension(const Want & want)274 sptr<IRemoteObject> ExtensionImpl::ConnectExtension(const Want &want)
275 {
276     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
277     TAG_LOGD(AAFwkTag::EXT, "call");
278     if (extension_ == nullptr) {
279         TAG_LOGE(AAFwkTag::EXT, "null extension_");
280         return nullptr;
281     }
282 
283     skipCommandExtensionWithIntent_ = true;
284     sptr<IRemoteObject> object = extension_->OnConnect(want);
285     lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
286     TAG_LOGD(AAFwkTag::EXT, "ok");
287 
288     return object;
289 }
290 
ConnectExtension(const Want & want,bool & isAsyncCallback)291 sptr<IRemoteObject> ExtensionImpl::ConnectExtension(const Want &want, bool &isAsyncCallback)
292 {
293     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
294     TAG_LOGD(AAFwkTag::EXT, "call");
295     if (extension_ == nullptr) {
296         TAG_LOGE(AAFwkTag::EXT, "null extension_");
297         isAsyncCallback = false;
298         return nullptr;
299     }
300 
301     skipCommandExtensionWithIntent_ = true;
302     auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<sptr<IRemoteObject>>::Create();
303     if (callbackInfo == nullptr) {
304         sptr<IRemoteObject> object = extension_->OnConnect(want);
305         lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
306         isAsyncCallback = false;
307         TAG_LOGI(AAFwkTag::EXT, "end");
308         return object;
309     }
310 
311     std::weak_ptr<ExtensionImpl> weakPtr = shared_from_this();
312     auto asyncCallback = [extensionImplWeakPtr = weakPtr](sptr<IRemoteObject> &service) {
313         auto extensionImpl = extensionImplWeakPtr.lock();
314         if (extensionImpl == nullptr) {
315             TAG_LOGE(AAFwkTag::EXT, "null extensionImpl");
316             return;
317         }
318         extensionImpl->lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
319         extensionImpl->ConnectExtensionCallback(service);
320     };
321     callbackInfo->Push(asyncCallback);
322 
323     sptr<IRemoteObject> object = extension_->OnConnect(want, callbackInfo, isAsyncCallback);
324     if (!isAsyncCallback) {
325         lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
326         AppExecFwk::AbilityTransactionCallbackInfo<sptr<IRemoteObject>>::Destroy(callbackInfo);
327     }
328     // else: callbackInfo will be destroyed after the async callback
329     TAG_LOGD(AAFwkTag::EXT, "ok");
330     return object;
331 }
332 
ConnectExtensionCallback(sptr<IRemoteObject> & service)333 void ExtensionImpl::ConnectExtensionCallback(sptr<IRemoteObject> &service)
334 {
335     ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->ScheduleConnectAbilityDone(token_, service);
336     if (err != ERR_OK) {
337         TAG_LOGE(AAFwkTag::EXT, "err: %{public}d", err);
338     }
339 }
340 
341 /**
342  * @brief Disconnects the connected object.
343  *
344  * @param want The Want object to disconnect to.
345  */
DisconnectExtension(const Want & want)346 void ExtensionImpl::DisconnectExtension(const Want &want)
347 {
348     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
349     TAG_LOGD(AAFwkTag::EXT, "call");
350     if (extension_ == nullptr) {
351         TAG_LOGE(AAFwkTag::EXT, "null extension_");
352         return;
353     }
354 
355     extension_->OnDisconnect(want);
356     TAG_LOGD(AAFwkTag::EXT, "ok");
357 }
358 
DisconnectExtension(const Want & want,bool & isAsyncCallback)359 void ExtensionImpl::DisconnectExtension(const Want &want, bool &isAsyncCallback)
360 {
361     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
362     TAG_LOGD(AAFwkTag::EXT, "called");
363     if (extension_ == nullptr) {
364         TAG_LOGE(AAFwkTag::EXT, "null extension_");
365         isAsyncCallback = false;
366         return;
367     }
368 
369     auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<>::Create();
370     if (callbackInfo == nullptr) {
371         extension_->OnDisconnect(want);
372         isAsyncCallback = false;
373         return;
374     }
375     std::weak_ptr<ExtensionImpl> weakPtr = shared_from_this();
376     auto asyncCallback = [extensionImplWeakPtr = weakPtr]() {
377         auto extensionImpl = extensionImplWeakPtr.lock();
378         if (extensionImpl == nullptr) {
379             TAG_LOGE(AAFwkTag::EXT, "null extensionImpl");
380             return;
381         }
382         extensionImpl->DisconnectExtensionCallback();
383     };
384     callbackInfo->Push(asyncCallback);
385 
386     extension_->OnDisconnect(want, callbackInfo, isAsyncCallback);
387     if (!isAsyncCallback) {
388         AppExecFwk::AbilityTransactionCallbackInfo<>::Destroy(callbackInfo);
389     }
390     // else: callbackInfo will be destroyed after the async callback
391     TAG_LOGD(AAFwkTag::EXT, "end");
392 }
393 
DisconnectExtensionCallback()394 void ExtensionImpl::DisconnectExtensionCallback()
395 {
396     ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->ScheduleDisconnectAbilityDone(token_);
397     if (err != ERR_OK) {
398         TAG_LOGE(AAFwkTag::EXT, "err: %{public}d", err);
399     }
400 }
401 
402 /**
403  * @brief Command the Extension. and Calling information back to Extension.
404  *
405  * @param want The Want object to command to.
406  *
407  * * @param restart Indicates the startup mode. The value true indicates that Service is restarted after being
408  * destroyed, and the value false indicates a normal startup.
409  *
410  * @param startId Indicates the number of times the Service Extension has been started. The startId is incremented by 1
411  * every time the Extension is started. For example, if the Extension has been started for six times,
412  * the value of startId is 6.
413  */
CommandExtension(const Want & want,bool restart,int startId)414 void ExtensionImpl::CommandExtension(const Want &want, bool restart, int startId)
415 {
416     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
417     TAG_LOGD(AAFwkTag::EXT, "call");
418     if (extension_ == nullptr) {
419         TAG_LOGE(AAFwkTag::EXT, "null extension_");
420         return;
421     }
422     if (!AppExecFwk::InsightIntentExecuteParam::IsInsightIntentExecute(want) || !skipCommandExtensionWithIntent_) {
423         skipCommandExtensionWithIntent_ = true;
424         extension_->OnCommand(want, restart, startId);
425     }
426     lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
427     TAG_LOGD(AAFwkTag::EXT, "ok");
428 }
429 
HandleInsightIntent(const Want & want)430 bool ExtensionImpl::HandleInsightIntent(const Want &want)
431 {
432     TAG_LOGD(AAFwkTag::EXT, "call");
433     if (extension_ == nullptr) {
434         TAG_LOGE(AAFwkTag::EXT, "null extension_");
435         return false;
436     }
437     auto ret = extension_->HandleInsightIntent(want);
438     if (!ret) {
439         TAG_LOGE(AAFwkTag::EXT, "handle failed");
440         return false;
441     }
442     TAG_LOGD(AAFwkTag::EXT, "ok");
443     return true;
444 }
445 
CommandExtensionWindow(const Want & want,const sptr<AAFwk::SessionInfo> & sessionInfo,AAFwk::WindowCommand winCmd)446 void ExtensionImpl::CommandExtensionWindow(const Want &want, const sptr<AAFwk::SessionInfo> &sessionInfo,
447     AAFwk::WindowCommand winCmd)
448 {
449     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
450     if (extension_ == nullptr || sessionInfo == nullptr) {
451         TAG_LOGE(AAFwkTag::EXT, "null extension_ or sessionInfo");
452         return;
453     }
454 
455     TAG_LOGD(AAFwkTag::EXT, "persistentId: %{private}d, componentId: %{public}" PRId64 ", winCmd: %{public}d",
456         sessionInfo->persistentId, sessionInfo->uiExtensionComponentId, winCmd);
457     extension_->OnCommandWindow(want, sessionInfo, winCmd);
458     TAG_LOGD(AAFwkTag::EXT, "ok");
459 }
460 
SendResult(int requestCode,int resultCode,const Want & resultData)461 void ExtensionImpl::SendResult(int requestCode, int resultCode, const Want &resultData)
462 {
463     TAG_LOGD(AAFwkTag::EXT, "begin");
464     if (extension_ == nullptr) {
465         TAG_LOGE(AAFwkTag::EXT, "null extension_");
466         return;
467     }
468 
469     extension_->OnAbilityResult(requestCode, resultCode, resultData);
470     TAG_LOGD(AAFwkTag::EXT, "end");
471 }
472 
SetLaunchParam(const AAFwk::LaunchParam & launchParam)473 void ExtensionImpl::SetLaunchParam(const AAFwk::LaunchParam &launchParam)
474 {
475     TAG_LOGD(AAFwkTag::EXT, "called");
476     if (extension_ == nullptr) {
477         TAG_LOGE(AAFwkTag::EXT, "null extension_");
478         return;
479     }
480 
481     extension_->SetLaunchParam(launchParam);
482 }
483 
Foreground(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)484 void ExtensionImpl::Foreground(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
485 {
486     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
487     TAG_LOGD(AAFwkTag::EXT, "begin");
488     if (extension_ == nullptr) {
489         TAG_LOGE(AAFwkTag::EXT, "null extension");
490         return;
491     }
492 
493     extension_->OnForeground(want, sessionInfo);
494     lifecycleState_ = AAFwk::ABILITY_STATE_FOREGROUND_NEW;
495 }
496 
Background(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)497 void ExtensionImpl::Background(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
498 {
499     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
500     TAG_LOGD(AAFwkTag::EXT, "begin");
501     if (extension_ == nullptr) {
502         TAG_LOGE(AAFwkTag::EXT, "null extension_");
503         return;
504     }
505 
506     if (AAFwk::UIExtensionUtils::IsUIExtension(extensionType_) && sessionInfo != nullptr) {
507         CommandExtensionWindow(want, sessionInfo, AAFwk::WIN_CMD_BACKGROUND);
508     }
509 
510     extension_->OnBackground();
511     lifecycleState_ = AAFwk::ABILITY_STATE_BACKGROUND_NEW;
512 }
513 
AfterForeground()514 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterForeground()
515 {
516     TAG_LOGD(AAFwkTag::EXT, "called");
517 }
518 
AfterBackground()519 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterBackground()
520 {
521     TAG_LOGD(AAFwkTag::EXT, "called");
522 }
523 
AfterActive()524 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterActive()
525 {
526     TAG_LOGD(AAFwkTag::EXT, "called");
527 }
528 
AfterInactive()529 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterInactive()
530 {
531     TAG_LOGD(AAFwkTag::EXT, "called");
532 }
533 }
534 }
535