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 AAFwk::UIExtensionUtils::IsUIExtension(extension_->abilityInfo_->extensionAbilityType)) {
194 extension_->OnStart(want, sessionInfo);
195 } else {
196 extension_->OnStart(want);
197 }
198 lifecycleState_ = AAFwk::ABILITY_STATE_INACTIVE;
199 TAG_LOGD(AAFwkTag::EXT, "ok");
200 }
201
202 /**
203 * @brief Toggles the lifecycle status of Extension to AAFwk::ABILITY_STATE_INITIAL. And notifies the application
204 * that it belongs to of the lifecycle status.
205 *
206 */
Stop()207 void ExtensionImpl::Stop()
208 {
209 TAG_LOGD(AAFwkTag::EXT, "call");
210 if (extension_ == nullptr) {
211 TAG_LOGE(AAFwkTag::EXT, "null extension_");
212 return;
213 }
214
215 extension_->OnStop();
216 lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
217 TAG_LOGD(AAFwkTag::EXT, "ok");
218 }
219
Stop(bool & isAsyncCallback,const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)220 void ExtensionImpl::Stop(bool &isAsyncCallback, const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
221 {
222 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
223 TAG_LOGD(AAFwkTag::EXT, "call");
224 if (extension_ == nullptr) {
225 TAG_LOGE(AAFwkTag::EXT, "null extension_");
226 isAsyncCallback = false;
227 return;
228 }
229
230 if (AAFwk::UIExtensionUtils::IsUIExtension(extensionType_) && sessionInfo != nullptr) {
231 CommandExtensionWindow(want, sessionInfo, AAFwk::WIN_CMD_DESTROY);
232 }
233
234 auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<>::Create();
235 if (callbackInfo == nullptr) {
236 extension_->OnStop();
237 lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
238 isAsyncCallback = false;
239 return;
240 }
241 std::weak_ptr<ExtensionImpl> weakPtr = shared_from_this();
242 auto asyncCallback = [ExtensionImplWeakPtr = weakPtr, state = AAFwk::ABILITY_STATE_INITIAL]() {
243 auto extensionImpl = ExtensionImplWeakPtr.lock();
244 if (extensionImpl == nullptr) {
245 TAG_LOGE(AAFwkTag::EXT, "null extensionImpl");
246 return;
247 }
248 extensionImpl->lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
249 extensionImpl->AbilityTransactionCallback(state);
250 };
251 callbackInfo->Push(asyncCallback);
252
253 extension_->OnStop(callbackInfo, isAsyncCallback);
254 if (!isAsyncCallback) {
255 lifecycleState_ = AAFwk::ABILITY_STATE_INITIAL;
256 AppExecFwk::AbilityTransactionCallbackInfo<>::Destroy(callbackInfo);
257 }
258 // else: callbackInfo will be destroyed after the async callback
259 TAG_LOGD(AAFwkTag::EXT, "end");
260 }
261
AbilityTransactionCallback(const AAFwk::AbilityLifeCycleState & state)262 void ExtensionImpl::AbilityTransactionCallback(const AAFwk::AbilityLifeCycleState &state)
263 {
264 TAG_LOGD(AAFwkTag::EXT, "called");
265 AAFwk::PacMap restoreData;
266 AAFwk::AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_, state, restoreData);
267 }
268
269 /**
270 * @brief Connect the extension. and Calling information back to Extension.
271 *
272 * @param want The Want object to connect to.
273 *
274 */
ConnectExtension(const Want & want)275 sptr<IRemoteObject> ExtensionImpl::ConnectExtension(const Want &want)
276 {
277 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
278 TAG_LOGD(AAFwkTag::EXT, "call");
279 if (extension_ == nullptr) {
280 TAG_LOGE(AAFwkTag::EXT, "null extension_");
281 return nullptr;
282 }
283
284 skipCommandExtensionWithIntent_ = true;
285 sptr<IRemoteObject> object = extension_->OnConnect(want);
286 lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
287 TAG_LOGD(AAFwkTag::EXT, "ok");
288
289 return object;
290 }
291
ConnectExtension(const Want & want,bool & isAsyncCallback)292 sptr<IRemoteObject> ExtensionImpl::ConnectExtension(const Want &want, bool &isAsyncCallback)
293 {
294 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
295 TAG_LOGD(AAFwkTag::EXT, "call");
296 if (extension_ == nullptr) {
297 TAG_LOGE(AAFwkTag::EXT, "null extension_");
298 isAsyncCallback = false;
299 return nullptr;
300 }
301
302 skipCommandExtensionWithIntent_ = true;
303 auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<sptr<IRemoteObject>>::Create();
304 if (callbackInfo == nullptr) {
305 sptr<IRemoteObject> object = extension_->OnConnect(want);
306 lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
307 isAsyncCallback = false;
308 TAG_LOGI(AAFwkTag::EXT, "end");
309 return object;
310 }
311
312 std::weak_ptr<ExtensionImpl> weakPtr = shared_from_this();
313 auto asyncCallback = [extensionImplWeakPtr = weakPtr](sptr<IRemoteObject> &service) {
314 auto extensionImpl = extensionImplWeakPtr.lock();
315 if (extensionImpl == nullptr) {
316 TAG_LOGE(AAFwkTag::EXT, "null extensionImpl");
317 return;
318 }
319 extensionImpl->lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
320 extensionImpl->ConnectExtensionCallback(service);
321 };
322 callbackInfo->Push(asyncCallback);
323
324 sptr<IRemoteObject> object = extension_->OnConnect(want, callbackInfo, isAsyncCallback);
325 if (!isAsyncCallback) {
326 lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
327 AppExecFwk::AbilityTransactionCallbackInfo<sptr<IRemoteObject>>::Destroy(callbackInfo);
328 }
329 // else: callbackInfo will be destroyed after the async callback
330 TAG_LOGD(AAFwkTag::EXT, "ok");
331 return object;
332 }
333
ConnectExtensionCallback(sptr<IRemoteObject> & service)334 void ExtensionImpl::ConnectExtensionCallback(sptr<IRemoteObject> &service)
335 {
336 ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->ScheduleConnectAbilityDone(token_, service);
337 if (err != ERR_OK) {
338 TAG_LOGE(AAFwkTag::EXT, "err: %{public}d", err);
339 }
340 }
341
342 /**
343 * @brief Disconnects the connected object.
344 *
345 * @param want The Want object to disconnect to.
346 */
DisconnectExtension(const Want & want)347 void ExtensionImpl::DisconnectExtension(const Want &want)
348 {
349 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
350 TAG_LOGD(AAFwkTag::EXT, "call");
351 if (extension_ == nullptr) {
352 TAG_LOGE(AAFwkTag::EXT, "null extension_");
353 return;
354 }
355
356 extension_->OnDisconnect(want);
357 TAG_LOGD(AAFwkTag::EXT, "ok");
358 }
359
DisconnectExtension(const Want & want,bool & isAsyncCallback)360 void ExtensionImpl::DisconnectExtension(const Want &want, bool &isAsyncCallback)
361 {
362 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
363 TAG_LOGD(AAFwkTag::EXT, "called");
364 if (extension_ == nullptr) {
365 TAG_LOGE(AAFwkTag::EXT, "null extension_");
366 isAsyncCallback = false;
367 return;
368 }
369
370 auto *callbackInfo = AppExecFwk::AbilityTransactionCallbackInfo<>::Create();
371 if (callbackInfo == nullptr) {
372 extension_->OnDisconnect(want);
373 isAsyncCallback = false;
374 return;
375 }
376 std::weak_ptr<ExtensionImpl> weakPtr = shared_from_this();
377 auto asyncCallback = [extensionImplWeakPtr = weakPtr]() {
378 auto extensionImpl = extensionImplWeakPtr.lock();
379 if (extensionImpl == nullptr) {
380 TAG_LOGE(AAFwkTag::EXT, "null extensionImpl");
381 return;
382 }
383 extensionImpl->DisconnectExtensionCallback();
384 };
385 callbackInfo->Push(asyncCallback);
386
387 extension_->OnDisconnect(want, callbackInfo, isAsyncCallback);
388 if (!isAsyncCallback) {
389 AppExecFwk::AbilityTransactionCallbackInfo<>::Destroy(callbackInfo);
390 }
391 // else: callbackInfo will be destroyed after the async callback
392 TAG_LOGD(AAFwkTag::EXT, "end");
393 }
394
DisconnectExtensionCallback()395 void ExtensionImpl::DisconnectExtensionCallback()
396 {
397 ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->ScheduleDisconnectAbilityDone(token_);
398 if (err != ERR_OK) {
399 TAG_LOGE(AAFwkTag::EXT, "err: %{public}d", err);
400 }
401 }
402
403 /**
404 * @brief Command the Extension. and Calling information back to Extension.
405 *
406 * @param want The Want object to command to.
407 *
408 * * @param restart Indicates the startup mode. The value true indicates that Service is restarted after being
409 * destroyed, and the value false indicates a normal startup.
410 *
411 * @param startId Indicates the number of times the Service Extension has been started. The startId is incremented by 1
412 * every time the Extension is started. For example, if the Extension has been started for six times,
413 * the value of startId is 6.
414 */
CommandExtension(const Want & want,bool restart,int startId)415 void ExtensionImpl::CommandExtension(const Want &want, bool restart, int startId)
416 {
417 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
418 TAG_LOGD(AAFwkTag::EXT, "call");
419 if (extension_ == nullptr) {
420 TAG_LOGE(AAFwkTag::EXT, "null extension_");
421 return;
422 }
423 if (!AppExecFwk::InsightIntentExecuteParam::IsInsightIntentExecute(want) || !skipCommandExtensionWithIntent_) {
424 skipCommandExtensionWithIntent_ = true;
425 extension_->OnCommand(want, restart, startId);
426 }
427 lifecycleState_ = AAFwk::ABILITY_STATE_ACTIVE;
428 TAG_LOGD(AAFwkTag::EXT, "ok");
429 }
430
HandleInsightIntent(const Want & want)431 bool ExtensionImpl::HandleInsightIntent(const Want &want)
432 {
433 TAG_LOGD(AAFwkTag::EXT, "call");
434 if (extension_ == nullptr) {
435 TAG_LOGE(AAFwkTag::EXT, "null extension_");
436 return false;
437 }
438 auto ret = extension_->HandleInsightIntent(want);
439 if (!ret) {
440 TAG_LOGE(AAFwkTag::EXT, "handle failed");
441 return false;
442 }
443 TAG_LOGD(AAFwkTag::EXT, "ok");
444 return true;
445 }
446
CommandExtensionWindow(const Want & want,const sptr<AAFwk::SessionInfo> & sessionInfo,AAFwk::WindowCommand winCmd)447 void ExtensionImpl::CommandExtensionWindow(const Want &want, const sptr<AAFwk::SessionInfo> &sessionInfo,
448 AAFwk::WindowCommand winCmd)
449 {
450 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
451 if (extension_ == nullptr || sessionInfo == nullptr) {
452 TAG_LOGE(AAFwkTag::EXT, "null extension_ or sessionInfo");
453 return;
454 }
455
456 TAG_LOGD(AAFwkTag::EXT, "persistentId: %{private}d, componentId: %{public}" PRId64 ", winCmd: %{public}d",
457 sessionInfo->persistentId, sessionInfo->uiExtensionComponentId, winCmd);
458 extension_->OnCommandWindow(want, sessionInfo, winCmd);
459 TAG_LOGD(AAFwkTag::EXT, "ok");
460 }
461
SendResult(int requestCode,int resultCode,const Want & resultData)462 void ExtensionImpl::SendResult(int requestCode, int resultCode, const Want &resultData)
463 {
464 TAG_LOGD(AAFwkTag::EXT, "begin");
465 if (extension_ == nullptr) {
466 TAG_LOGE(AAFwkTag::EXT, "null extension_");
467 return;
468 }
469
470 extension_->OnAbilityResult(requestCode, resultCode, resultData);
471 TAG_LOGD(AAFwkTag::EXT, "end");
472 }
473
SetLaunchParam(const AAFwk::LaunchParam & launchParam)474 void ExtensionImpl::SetLaunchParam(const AAFwk::LaunchParam &launchParam)
475 {
476 TAG_LOGD(AAFwkTag::EXT, "called");
477 if (extension_ == nullptr) {
478 TAG_LOGE(AAFwkTag::EXT, "null extension_");
479 return;
480 }
481
482 extension_->SetLaunchParam(launchParam);
483 }
484
Foreground(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)485 void ExtensionImpl::Foreground(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
486 {
487 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
488 TAG_LOGD(AAFwkTag::EXT, "begin");
489 if (extension_ == nullptr) {
490 TAG_LOGE(AAFwkTag::EXT, "null extension");
491 return;
492 }
493
494 extension_->OnForeground(want, sessionInfo);
495 lifecycleState_ = AAFwk::ABILITY_STATE_FOREGROUND_NEW;
496 }
497
Background(const Want & want,sptr<AAFwk::SessionInfo> sessionInfo)498 void ExtensionImpl::Background(const Want &want, sptr<AAFwk::SessionInfo> sessionInfo)
499 {
500 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
501 TAG_LOGD(AAFwkTag::EXT, "begin");
502 if (extension_ == nullptr) {
503 TAG_LOGE(AAFwkTag::EXT, "null extension_");
504 return;
505 }
506
507 if (AAFwk::UIExtensionUtils::IsUIExtension(extensionType_) && sessionInfo != nullptr) {
508 CommandExtensionWindow(want, sessionInfo, AAFwk::WIN_CMD_BACKGROUND);
509 }
510
511 extension_->OnBackground();
512 lifecycleState_ = AAFwk::ABILITY_STATE_BACKGROUND_NEW;
513 }
514
AfterForeground()515 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterForeground()
516 {
517 TAG_LOGD(AAFwkTag::EXT, "called");
518 }
519
AfterBackground()520 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterBackground()
521 {
522 TAG_LOGD(AAFwkTag::EXT, "called");
523 }
524
AfterActive()525 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterActive()
526 {
527 TAG_LOGD(AAFwkTag::EXT, "called");
528 }
529
AfterInactive()530 void ExtensionImpl::ExtensionWindowLifeCycleImpl::AfterInactive()
531 {
532 TAG_LOGD(AAFwkTag::EXT, "called");
533 }
534 }
535 }
536