1 /*
2  * Copyright (c) 2023-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_ability_thread.h"
17 
18 #include "ability_context_impl.h"
19 #include "ability_handler.h"
20 #include "ability_loader.h"
21 #include "ability_manager_client.h"
22 #include "freeze_util.h"
23 #include "hilog_tag_wrapper.h"
24 #include "hitrace_meter.h"
25 #include "ui_extension_utils.h"
26 
27 namespace OHOS {
28 namespace AbilityRuntime {
29 using AbilityManagerClient = OHOS::AAFwk::AbilityManagerClient;
30 namespace {
31 #ifdef SUPPORT_GRAPHICS
32 constexpr static char FORM_EXTENSION[] = "FormExtension";
33 constexpr static char UI_EXTENSION[] = "UIExtensionAbility";
34 constexpr static char CUSTOM_EXTENSION[] = "ExtensionAbility";
35 constexpr static char USER_AUTH_EXTENSION[] = "UserAuthExtensionAbility";
36 constexpr static char ACTION_EXTENSION[] = "ActionExtensionAbility";
37 constexpr static char SHARE_EXTENSION[] = "ShareExtensionAbility";
38 constexpr static char AUTO_FILL_EXTENSION[] = "AutoFillExtensionAbility";
39 constexpr static char EMBEDDED_UI_EXTENSION[] = "EmbeddedUIExtensionAbility";
40 constexpr static char PHOTO_EDITOR_EXTENSION[] = "PhotoEditorExtensionAbility";
41 #endif
42 constexpr static char BASE_SERVICE_EXTENSION[] = "ServiceExtension";
43 constexpr static char BASE_DRIVER_EXTENSION[] = "DriverExtension";
44 constexpr static char STATIC_SUBSCRIBER_EXTENSION[] = "StaticSubscriberExtension";
45 constexpr static char DATA_SHARE_EXT_ABILITY[] = "DataShareExtAbility";
46 constexpr static char WORK_SCHEDULER_EXTENSION[] = "WorkSchedulerExtension";
47 constexpr static char ACCESSIBILITY_EXTENSION[] = "AccessibilityExtension";
48 constexpr static char WALLPAPER_EXTENSION[] = "WallpaperExtension";
49 constexpr static char FILEACCESS_EXT_ABILITY[] = "FileAccessExtension";
50 constexpr static char ENTERPRISE_ADMIN_EXTENSION[] = "EnterpriseAdminExtension";
51 constexpr static char INPUTMETHOD_EXTENSION[] = "InputMethodExtensionAbility";
52 constexpr static char APP_ACCOUNT_AUTHORIZATION_EXTENSION[] = "AppAccountAuthorizationExtension";
53 constexpr static char VPN_EXTENSION[] = "VpnExtension";
54 constexpr static char FENCE_EXTENSION[] = "FenceExtension";
55 constexpr static char CALLER_INFO_QUERY_EXTENSION[] = "CallerInfoQueryExtension";
56 }
57 
58 const std::map<AppExecFwk::ExtensionAbilityType, std::string> UI_EXTENSION_NAME_MAP = {
59     { AppExecFwk::ExtensionAbilityType::SHARE, SHARE_EXTENSION },
60     { AppExecFwk::ExtensionAbilityType::ACTION, ACTION_EXTENSION },
61     { AppExecFwk::ExtensionAbilityType::AUTO_FILL_PASSWORD, AUTO_FILL_EXTENSION },
62     { AppExecFwk::ExtensionAbilityType::AUTO_FILL_SMART, AUTO_FILL_EXTENSION },
63     { AppExecFwk::ExtensionAbilityType::EMBEDDED_UI, EMBEDDED_UI_EXTENSION },
64     { AppExecFwk::ExtensionAbilityType::PHOTO_EDITOR, PHOTO_EDITOR_EXTENSION }
65 };
66 
ExtensionAbilityThread()67 ExtensionAbilityThread::ExtensionAbilityThread() : extensionImpl_(nullptr), currentExtension_(nullptr) {}
68 
~ExtensionAbilityThread()69 ExtensionAbilityThread::~ExtensionAbilityThread()
70 {
71     if (currentExtension_ != nullptr) {
72         currentExtension_.reset();
73     }
74 }
75 
CreateAbilityName(const std::shared_ptr<AppExecFwk::AbilityLocalRecord> & abilityRecord,const std::shared_ptr<AppExecFwk::OHOSApplication> & application)76 std::string ExtensionAbilityThread::CreateAbilityName(
77     const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &abilityRecord,
78     const std::shared_ptr<AppExecFwk::OHOSApplication> &application)
79 {
80     std::string abilityName;
81     if (abilityRecord == nullptr || application == nullptr) {
82         TAG_LOGE(AAFwkTag::EXT, "null AbilityRecord or application");
83         return abilityName;
84     }
85 
86     std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo = abilityRecord->GetAbilityInfo();
87     if (abilityInfo == nullptr) {
88         TAG_LOGE(AAFwkTag::EXT, "null abilityInfo");
89         return abilityName;
90     }
91 
92     if (abilityInfo->isNativeAbility || abilityInfo->type != AppExecFwk::AbilityType::EXTENSION) {
93         TAG_LOGD(AAFwkTag::EXT, "Ability info name:%{public}s", abilityInfo->name.c_str());
94         return abilityInfo->name;
95     }
96 
97     application->GetExtensionNameByType(static_cast<int32_t>(abilityInfo->extensionAbilityType), abilityName);
98     if (!abilityName.empty()) {
99         TAG_LOGD(AAFwkTag::EXT, "Get extension name: %{public}s success", abilityName.c_str());
100         return abilityName;
101     }
102 
103     abilityName = BASE_SERVICE_EXTENSION;
104 #ifdef SUPPORT_GRAPHICS
105     if (abilityInfo->formEnabled || abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::FORM) {
106         abilityName = FORM_EXTENSION;
107     }
108 #endif
109     if (AAFwk::UIExtensionUtils::IsUIExtension(abilityInfo->extensionAbilityType)) {
110         auto iter = UI_EXTENSION_NAME_MAP.find(abilityInfo->extensionAbilityType);
111         if (iter != UI_EXTENSION_NAME_MAP.end()) {
112             abilityName = iter->second;
113         } else {
114             abilityName = UI_EXTENSION;
115         }
116     }
117     CreateExtensionAbilityName(abilityInfo, abilityName);
118     TAG_LOGD(AAFwkTag::EXT, "Ability name: %{public}s", abilityName.c_str());
119     return abilityName;
120 }
121 
CreateExtensionAbilityName(const std::shared_ptr<AppExecFwk::AbilityInfo> & abilityInfo,std::string & abilityName)122 void ExtensionAbilityThread::CreateExtensionAbilityName(
123     const std::shared_ptr<AppExecFwk::AbilityInfo> &abilityInfo, std::string &abilityName)
124 {
125     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::STATICSUBSCRIBER) {
126         abilityName = STATIC_SUBSCRIBER_EXTENSION;
127     }
128     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::DRIVER) {
129         abilityName = BASE_DRIVER_EXTENSION;
130     }
131     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::DATASHARE) {
132         abilityName = DATA_SHARE_EXT_ABILITY;
133     }
134     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::WORK_SCHEDULER) {
135         abilityName = WORK_SCHEDULER_EXTENSION;
136     }
137     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::ACCESSIBILITY) {
138         abilityName = ACCESSIBILITY_EXTENSION;
139     }
140     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::WALLPAPER) {
141         abilityName = WALLPAPER_EXTENSION;
142     }
143     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::FILEACCESS_EXTENSION) {
144         abilityName = FILEACCESS_EXT_ABILITY;
145     }
146     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::ENTERPRISE_ADMIN) {
147         abilityName = ENTERPRISE_ADMIN_EXTENSION;
148     }
149     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::INPUTMETHOD) {
150         abilityName = INPUTMETHOD_EXTENSION;
151     }
152     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::APP_ACCOUNT_AUTHORIZATION) {
153         abilityName = APP_ACCOUNT_AUTHORIZATION_EXTENSION;
154     }
155     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::FENCE) {
156         abilityName = FENCE_EXTENSION;
157     }
158     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::CALLER_INFO_QUERY) {
159         abilityName = CALLER_INFO_QUERY_EXTENSION;
160     }
161     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::SYSDIALOG_USERAUTH) {
162         abilityName = USER_AUTH_EXTENSION;
163     }
164     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::VPN) {
165         abilityName = VPN_EXTENSION;
166     }
167     if (abilityInfo->extensionAbilityType == AppExecFwk::ExtensionAbilityType::UNSPECIFIED &&
168         abilityInfo->type == AppExecFwk::AbilityType::EXTENSION) {
169         abilityName = abilityInfo->extensionTypeName + CUSTOM_EXTENSION;
170     }
171 }
172 
173 void ExtensionAbilityThread::Attach(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,
174     const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &abilityRecord,
175     const std::shared_ptr<AppExecFwk::EventRunner> &mainRunner,
176     [[maybe_unused]] const std::shared_ptr<Context> &appContext)
177 {
178     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
179     TAG_LOGD(AAFwkTag::EXT, "Begin");
180     if (application == nullptr || abilityRecord == nullptr || mainRunner == nullptr) {
181         TAG_LOGE(AAFwkTag::EXT, "null application or abilityRecord or mainRunner");
182         return;
183     }
184     HandleAttach(application, abilityRecord, mainRunner);
185     TAG_LOGD(AAFwkTag::EXT, "End");
186 }
187 
188 void ExtensionAbilityThread::Attach(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,
189     const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &abilityRecord,
190     [[maybe_unused]] const std::shared_ptr<Context> &appContext)
191 {
192     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
193     TAG_LOGD(AAFwkTag::EXT, "Begin");
194     if ((application == nullptr) || (abilityRecord == nullptr)) {
195         TAG_LOGE(AAFwkTag::EXT, "null application or abilityRecord");
196         return;
197     }
198     HandleAttach(application, abilityRecord, nullptr);
199     TAG_LOGD(AAFwkTag::EXT, "End");
200 }
201 
HandleAttach(const std::shared_ptr<AppExecFwk::OHOSApplication> & application,const std::shared_ptr<AppExecFwk::AbilityLocalRecord> & abilityRecord,const std::shared_ptr<AppExecFwk::EventRunner> & mainRunner)202 void ExtensionAbilityThread::HandleAttach(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,
203     const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &abilityRecord,
204     const std::shared_ptr<AppExecFwk::EventRunner> &mainRunner)
205 {
206     if (application == nullptr || abilityRecord == nullptr) {
207         TAG_LOGE(AAFwkTag::EXT, "null Application or abilityRecord");
208         return;
209     }
210 
211     // 1.new AbilityHandler
212     std::string abilityName = CreateAbilityName(abilityRecord, application);
213     if (abilityName.empty()) {
214         TAG_LOGE(AAFwkTag::EXT, "empty abilityName");
215         return;
216     }
217 
218     TAG_LOGI(AAFwkTag::EXT, "Begin, extension: %{public}s", abilityName.c_str());
219     if (mainRunner == nullptr) {
220         runner_ = AppExecFwk::EventRunner::Create(abilityName);
221         if (runner_ == nullptr) {
222             TAG_LOGE(AAFwkTag::EXT, "null runner_");
223             return;
224         }
225         abilityHandler_ = std::make_shared<AppExecFwk::AbilityHandler>(runner_);
226         if (abilityHandler_ == nullptr) {
227             TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
228             return;
229         }
230     } else {
231         abilityHandler_ = std::make_shared<AppExecFwk::AbilityHandler>(mainRunner);
232         if (abilityHandler_ == nullptr) {
233             TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
234             return;
235         }
236     }
237 
238     // 2.new ability
239     auto extension = AppExecFwk::AbilityLoader::GetInstance().GetExtensionByName(abilityName);
240     if (extension == nullptr) {
241         TAG_LOGE(AAFwkTag::EXT, "null extension");
242         return;
243     }
244     currentExtension_.reset(extension);
245     token_ = abilityRecord->GetToken();
246     abilityRecord->SetEventHandler(abilityHandler_);
247     mainRunner == nullptr ? abilityRecord->SetEventRunner(runner_) : abilityRecord->SetEventRunner(mainRunner);
248     abilityRecord->SetAbilityThread(this);
249     HandleAttachInner(application, abilityRecord);
250 }
251 
HandleAttachInner(const std::shared_ptr<AppExecFwk::OHOSApplication> & application,const std::shared_ptr<AppExecFwk::AbilityLocalRecord> & abilityRecord)252 void ExtensionAbilityThread::HandleAttachInner(const std::shared_ptr<AppExecFwk::OHOSApplication> &application,
253     const std::shared_ptr<AppExecFwk::AbilityLocalRecord> &abilityRecord)
254 {
255     extensionImpl_ = std::make_shared<ExtensionImpl>();
256     if (extensionImpl_ == nullptr) {
257         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
258         return;
259     }
260 
261     // 3.new init
262     extensionImpl_->Init(application, abilityRecord, currentExtension_, abilityHandler_, token_);
263     // 4.ipc attach init
264     ErrCode err = AbilityManagerClient::GetInstance()->AttachAbilityThread(this, token_);
265     if (err != ERR_OK) {
266         TAG_LOGE(AAFwkTag::EXT, "Attach err: %{public}d", err);
267     }
268     FreezeUtil::GetInstance().DeleteAppLifecycleEvent(0);
269 }
270 
HandleExtensionTransaction(const Want & want,const LifeCycleStateInfo & lifeCycleStateInfo,sptr<AAFwk::SessionInfo> sessionInfo)271 void ExtensionAbilityThread::HandleExtensionTransaction(
272     const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo, sptr<AAFwk::SessionInfo> sessionInfo)
273 {
274     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
275     TAG_LOGD(AAFwkTag::EXT, "%{public}s Begin", __func__);
276     if (extensionImpl_ == nullptr) {
277         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
278         return;
279     }
280     extensionImpl_->HandleExtensionTransaction(want, lifeCycleStateInfo, sessionInfo);
281 }
282 
HandleConnectExtension(const Want & want)283 void ExtensionAbilityThread::HandleConnectExtension(const Want &want)
284 {
285     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
286     TAG_LOGD(AAFwkTag::EXT, "Begin");
287     if (extensionImpl_ == nullptr) {
288         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
289         return;
290     }
291     bool isAsyncCallback = false;
292     sptr<IRemoteObject> service = extensionImpl_->ConnectExtension(want, isAsyncCallback);
293     if (!isAsyncCallback) {
294         extensionImpl_->ConnectExtensionCallback(service);
295     }
296     TAG_LOGD(AAFwkTag::EXT, "End");
297 }
298 
HandleDisconnectExtension(const Want & want)299 void ExtensionAbilityThread::HandleDisconnectExtension(const Want &want)
300 {
301     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
302     TAG_LOGD(AAFwkTag::EXT, "Begin");
303     if (extensionImpl_ == nullptr) {
304         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
305         return;
306     }
307 
308     bool isAsyncCallback = false;
309     extensionImpl_->DisconnectExtension(want, isAsyncCallback);
310     if (!isAsyncCallback) {
311         extensionImpl_->DisconnectExtensionCallback();
312     }
313     TAG_LOGD(AAFwkTag::EXT, "End");
314 }
315 
HandleCommandExtension(const Want & want,bool restart,int32_t startId)316 void ExtensionAbilityThread::HandleCommandExtension(const Want &want, bool restart, int32_t startId)
317 {
318     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
319     TAG_LOGD(AAFwkTag::EXT, "Begin");
320     if (extensionImpl_ == nullptr) {
321         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
322         return;
323     }
324     extensionImpl_->CommandExtension(want, restart, startId);
325     ErrCode err = AbilityManagerClient::GetInstance()->ScheduleCommandAbilityDone(token_);
326     if (err != ERR_OK) {
327         TAG_LOGE(AAFwkTag::EXT, "err: %{public}d", err);
328     }
329     TAG_LOGD(AAFwkTag::EXT, "End");
330 }
331 
HandleInsightIntent(const Want & want)332 void ExtensionAbilityThread::HandleInsightIntent(const Want &want)
333 {
334     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
335     TAG_LOGD(AAFwkTag::EXT, "Begin");
336     if (extensionImpl_ == nullptr) {
337         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
338         return;
339     }
340     auto ret = extensionImpl_->HandleInsightIntent(want);
341     if (!ret) {
342         TAG_LOGE(AAFwkTag::EXT, "HandleInsightIntent failed");
343         return;
344     }
345     TAG_LOGD(AAFwkTag::EXT, "End");
346 }
347 
HandleCommandExtensionWindow(const Want & want,const sptr<AAFwk::SessionInfo> & sessionInfo,AAFwk::WindowCommand winCmd)348 void ExtensionAbilityThread::HandleCommandExtensionWindow(
349     const Want &want, const sptr<AAFwk::SessionInfo> &sessionInfo, AAFwk::WindowCommand winCmd)
350 {
351     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
352     TAG_LOGD(AAFwkTag::EXT, "Begin");
353     if (extensionImpl_ == nullptr) {
354         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
355         return;
356     }
357     extensionImpl_->CommandExtensionWindow(want, sessionInfo, winCmd);
358     TAG_LOGD(AAFwkTag::EXT, "End");
359 }
360 
ScheduleUpdateConfiguration(const AppExecFwk::Configuration & config)361 void ExtensionAbilityThread::ScheduleUpdateConfiguration(const AppExecFwk::Configuration &config)
362 {
363     TAG_LOGD(AAFwkTag::EXT, "Begin");
364     HandleExtensionUpdateConfiguration(config);
365     TAG_LOGD(AAFwkTag::EXT, "End");
366 }
367 
HandleExtensionUpdateConfiguration(const AppExecFwk::Configuration & config)368 void ExtensionAbilityThread::HandleExtensionUpdateConfiguration(const AppExecFwk::Configuration &config)
369 {
370     TAG_LOGD(AAFwkTag::EXT, "Begin");
371     if (extensionImpl_ == nullptr) {
372         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
373         return;
374     }
375     extensionImpl_->ScheduleUpdateConfiguration(config);
376     TAG_LOGD(AAFwkTag::EXT, "End");
377 }
378 
ScheduleAbilityTransaction(const Want & want,const LifeCycleStateInfo & lifeCycleStateInfo,sptr<AAFwk::SessionInfo> sessionInfo)379 bool ExtensionAbilityThread::ScheduleAbilityTransaction(
380     const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo, sptr<AAFwk::SessionInfo> sessionInfo)
381 {
382     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
383     TAG_LOGD(AAFwkTag::EXT, "Name: %{public}s, targeState: %{public}d, isNewWant: %{public}d",
384         want.GetElement().GetAbilityName().c_str(), lifeCycleStateInfo.state, lifeCycleStateInfo.isNewWant);
385     if (token_ == nullptr) {
386         TAG_LOGE(AAFwkTag::EXT, "null token_");
387         return false;
388     }
389     if (abilityHandler_ == nullptr) {
390         TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
391         return false;
392     }
393     wptr<ExtensionAbilityThread> weak = this;
394     auto task = [weak, want, lifeCycleStateInfo, sessionInfo]() {
395         auto abilityThread = weak.promote();
396         if (abilityThread == nullptr) {
397             TAG_LOGE(AAFwkTag::EXT, "null abilityThread");
398             return;
399         }
400         abilityThread->HandleExtensionTransaction(want, lifeCycleStateInfo, sessionInfo);
401     };
402     bool ret = abilityHandler_->PostTask(task);
403     if (!ret) {
404         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
405         return false;
406     }
407     return true;
408 }
409 
ScheduleConnectAbility(const Want & want)410 void ExtensionAbilityThread::ScheduleConnectAbility(const Want &want)
411 {
412     TAG_LOGD(AAFwkTag::EXT, "called");
413     if (abilityHandler_ == nullptr) {
414         TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
415         return;
416     }
417     wptr<ExtensionAbilityThread> weak = this;
418     auto task = [weak, want]() {
419         auto abilityThread = weak.promote();
420         if (abilityThread == nullptr) {
421             TAG_LOGE(AAFwkTag::EXT, "null abilityThread");
422             return;
423         }
424         abilityThread->HandleConnectExtension(want);
425     };
426     bool ret = abilityHandler_->PostTask(task);
427     if (!ret) {
428         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
429     }
430 }
431 
ScheduleDisconnectAbility(const Want & want)432 void ExtensionAbilityThread::ScheduleDisconnectAbility(const Want &want)
433 {
434     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
435     TAG_LOGD(AAFwkTag::EXT, "called");
436     if (abilityHandler_ == nullptr) {
437         TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
438         return;
439     }
440     wptr<ExtensionAbilityThread> weak = this;
441     auto task = [weak, want]() {
442         auto abilityThread = weak.promote();
443         if (abilityThread == nullptr) {
444             TAG_LOGE(AAFwkTag::EXT, "null abilityThread");
445             return;
446         }
447         abilityThread->HandleDisconnectExtension(want);
448     };
449     bool ret = abilityHandler_->PostTask(task);
450     if (!ret) {
451         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
452     }
453 }
454 
ScheduleCommandAbility(const Want & want,bool restart,int32_t startId)455 void ExtensionAbilityThread::ScheduleCommandAbility(const Want &want, bool restart, int32_t startId)
456 {
457     TAG_LOGD(AAFwkTag::EXT, "Begin startId: %{public}d", startId);
458     if (abilityHandler_ == nullptr) {
459         TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
460         return;
461     }
462     ScheduleCommandAbilityInner(want, restart, startId);
463     if (AppExecFwk::InsightIntentExecuteParam::IsInsightIntentExecute(want)) {
464         ScheduleInsightIntentInner(want);
465     }
466     TAG_LOGD(AAFwkTag::EXT, "End");
467 }
468 
ScheduleCommandAbilityInner(const Want & want,bool restart,int32_t startId)469 void ExtensionAbilityThread::ScheduleCommandAbilityInner(const Want &want, bool restart, int32_t startId)
470 {
471     wptr<ExtensionAbilityThread> weak = this;
472     auto task = [weak, want, restart, startId]() {
473         auto abilityThread = weak.promote();
474         if (abilityThread == nullptr) {
475             TAG_LOGE(AAFwkTag::EXT, "null AbilityThread");
476             return;
477         }
478         abilityThread->HandleCommandExtension(want, restart, startId);
479     };
480     bool ret = abilityHandler_->PostTask(task);
481     if (!ret) {
482         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
483     }
484 }
485 
ScheduleInsightIntentInner(const Want & want)486 void ExtensionAbilityThread::ScheduleInsightIntentInner(const Want &want)
487 {
488     wptr<ExtensionAbilityThread> weak = this;
489     auto task = [weak, want]() {
490         auto abilityThread = weak.promote();
491         if (abilityThread == nullptr) {
492             TAG_LOGE(AAFwkTag::EXT, "null AbilityThread");
493             return;
494         }
495         abilityThread->HandleInsightIntent(want);
496     };
497     bool ret = abilityHandler_->PostTask(task);
498     if (!ret) {
499         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
500     }
501 }
502 
ScheduleCommandAbilityWindow(const Want & want,const sptr<AAFwk::SessionInfo> & sessionInfo,AAFwk::WindowCommand winCmd)503 void ExtensionAbilityThread::ScheduleCommandAbilityWindow(
504     const Want &want, const sptr<AAFwk::SessionInfo> &sessionInfo, AAFwk::WindowCommand winCmd)
505 {
506     TAG_LOGD(AAFwkTag::EXT, "Begin, winCmd: %{public}d", winCmd);
507     if (abilityHandler_ == nullptr) {
508         TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_");
509         return;
510     }
511     wptr<ExtensionAbilityThread> weak = this;
512     auto task = [weak, want, sessionInfo, winCmd]() {
513         auto abilityThread = weak.promote();
514         if (abilityThread == nullptr) {
515             TAG_LOGE(AAFwkTag::EXT, "null abilityThread");
516             return;
517         }
518         abilityThread->HandleCommandExtensionWindow(want, sessionInfo, winCmd);
519     };
520     bool ret = abilityHandler_->PostTask(task);
521     if (!ret) {
522         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
523     }
524     TAG_LOGD(AAFwkTag::EXT, "End");
525 }
526 
SendResult(int requestCode,int resultCode,const Want & want)527 void ExtensionAbilityThread::SendResult(int requestCode, int resultCode, const Want &want)
528 {
529     TAG_LOGD(AAFwkTag::EXT, "Begin");
530     if (abilityHandler_ == nullptr || requestCode == -1) {
531         TAG_LOGE(AAFwkTag::EXT, "null abilityHandler_ or requestCode -1");
532         return;
533     }
534 
535     wptr<ExtensionAbilityThread> weak = this;
536     auto task = [weak, requestCode, resultCode, want]() {
537         auto abilityThread = weak.promote();
538         if (abilityThread == nullptr) {
539             TAG_LOGE(AAFwkTag::EXT, "null abilityThread");
540             return;
541         }
542 
543         if (abilityThread->extensionImpl_ == nullptr) {
544             TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
545             return;
546         }
547         abilityThread->extensionImpl_->SendResult(requestCode, resultCode, want);
548     };
549     bool ret = abilityHandler_->PostTask(task);
550     if (!ret) {
551         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
552     }
553     TAG_LOGD(AAFwkTag::EXT, "End");
554 }
555 
NotifyMemoryLevel(int32_t level)556 void ExtensionAbilityThread::NotifyMemoryLevel(int32_t level)
557 {
558     TAG_LOGD(AAFwkTag::EXT, "result: %{public}d", level);
559     if (extensionImpl_ == nullptr) {
560         TAG_LOGE(AAFwkTag::EXT, "null extensionImpl_");
561         return;
562     }
563     extensionImpl_->NotifyMemoryLevel(level);
564 }
565 
DumpAbilityInfo(const std::vector<std::string> & params,std::vector<std::string> & info)566 void ExtensionAbilityThread::DumpAbilityInfo(const std::vector<std::string> &params, std::vector<std::string> &info)
567 {
568     TAG_LOGD(AAFwkTag::EXT, "Begin");
569     if (token_ == nullptr || abilityHandler_ == nullptr) {
570         TAG_LOGE(AAFwkTag::EXT, "null token_ or abilityHandler_");
571         return;
572     }
573     wptr<ExtensionAbilityThread> weak = this;
574     auto task = [weak, params, token = token_]() {
575         auto abilityThread = weak.promote();
576         if (abilityThread == nullptr) {
577             TAG_LOGE(AAFwkTag::EXT, "null abilityThread");
578             return;
579         }
580         std::vector<std::string> dumpInfo;
581         abilityThread->DumpAbilityInfoInner(params, dumpInfo);
582         ErrCode err = AbilityManagerClient::GetInstance()->DumpAbilityInfoDone(dumpInfo, token);
583         if (err != ERR_OK) {
584             TAG_LOGE(AAFwkTag::EXT, "Dump ability info err: %{public}d", err);
585         }
586     };
587     bool ret = abilityHandler_->PostTask(task);
588     if (!ret) {
589         TAG_LOGE(AAFwkTag::EXT, "PostTask error");
590     }
591     TAG_LOGD(AAFwkTag::EXT, "End");
592 }
593 
DumpAbilityInfoInner(const std::vector<std::string> & params,std::vector<std::string> & info)594 void ExtensionAbilityThread::DumpAbilityInfoInner(
595     const std::vector<std::string> &params, std::vector<std::string> &info)
596 {
597     TAG_LOGD(AAFwkTag::EXT, "Begin");
598     if (currentExtension_ == nullptr) {
599         TAG_LOGD(AAFwkTag::EXT, "null currentExtension_");
600         return;
601     }
602     currentExtension_->Dump(params, info);
603 
604 #ifdef SUPPORT_GRAPHICS
605     if (params.empty()) {
606         DumpOtherInfo(info);
607         return;
608     }
609 #else
610     DumpOtherInfo(info);
611 #endif
612     TAG_LOGD(AAFwkTag::EXT, "End");
613 }
614 
DumpOtherInfo(std::vector<std::string> & info)615 void ExtensionAbilityThread::DumpOtherInfo(std::vector<std::string> &info)
616 {
617     std::string dumpInfo = "        event:";
618     info.push_back(dumpInfo);
619     if (abilityHandler_ == nullptr) {
620         TAG_LOGD(AAFwkTag::EXT, "null abilityHandler_");
621         return;
622     }
623     auto runner = abilityHandler_->GetEventRunner();
624     if (runner == nullptr) {
625         TAG_LOGD(AAFwkTag::EXT, "null runner_");
626         return;
627     }
628     dumpInfo = "";
629     runner->DumpRunnerInfo(dumpInfo);
630     info.push_back(dumpInfo);
631 }
632 } // namespace AbilityRuntime
633 } // namespace OHOS
634