1 /*
2  * Copyright (c) 2021 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 "adapter/ohos/entrance/pa_container.h"
17 
18 #include "adapter/ohos/entrance/ace_application_info.h"
19 #include "adapter/ohos/entrance/file_asset_provider_impl.h"
20 #include "adapter/ohos/entrance/hap_asset_provider_impl.h"
21 #include "adapter/ohos/entrance/pa_engine/engine/common/js_backend_engine_loader.h"
22 #include "adapter/ohos/entrance/pa_engine/pa_backend.h"
23 #include "base/log/ace_trace.h"
24 #include "base/log/event_report.h"
25 #include "base/log/log.h"
26 #include "base/subwindow/subwindow_manager.h"
27 #include "base/utils/system_properties.h"
28 #include "base/utils/utils.h"
29 #include "core/common/ace_engine.h"
30 #include "core/common/asset_manager_impl.h"
31 #include "core/common/platform_window.h"
32 #include "core/common/text_field_manager.h"
33 #include "core/common/window.h"
34 
35 namespace OHOS::Ace::Platform {
36 namespace {
37 
38 constexpr char ARK_PA_ENGINE_SHARED_LIB[] = "libace_engine_pa_ark.z.so";
39 
GetPaEngineSharedLibrary()40 const char* GetPaEngineSharedLibrary()
41 {
42     return ARK_PA_ENGINE_SHARED_LIB;
43 }
44 
45 } // namespace
46 
PaContainer(int32_t instanceId,void * paAbility,const PaContainerOptions & options,std::unique_ptr<PlatformEventCallback> callback)47 PaContainer::PaContainer(int32_t instanceId, void* paAbility, const PaContainerOptions& options,
48     std::unique_ptr<PlatformEventCallback> callback)
49     : instanceId_(instanceId), paAbility_(paAbility)
50 {
51     ACE_DCHECK(callback);
52     type_ = options.type;
53     hapPath_ = options.hapPath;
54     workerPath_ =  options.workerPath;
55     InitializeBackend(options.language);
56     platformEventCallback_ = std::move(callback);
57 }
58 
InitializeBackend(SrcLanguage language)59 void PaContainer::InitializeBackend(SrcLanguage language)
60 {
61     // create backend
62     backend_ = Backend::Create();
63     auto paBackend = AceType::DynamicCast<PaBackend>(backend_);
64     CHECK_NULL_VOID(paBackend);
65 
66     // set JS engine, init in JS thread
67     auto& loader = JsBackendEngineLoader::Get(GetPaEngineSharedLibrary());
68     auto jsEngine = loader.CreateJsBackendEngine(instanceId_);
69     jsEngine->AddExtraNativeObject("ability", paAbility_);
70     jsEngine->SetNeedDebugBreakPoint(AceApplicationInfo::GetInstance().IsNeedDebugBreakPoint());
71     jsEngine->SetDebugVersion(AceApplicationInfo::GetInstance().IsDebugVersion());
72     jsEngine->SetHapPath(hapPath_);
73     jsEngine->SetWorkerPath(workerPath_);
74     paBackend->SetJsEngine(jsEngine);
75 
76     ACE_DCHECK(backend_);
77     backend_->Initialize(type_, language);
78 }
79 
GetContainer(int32_t instanceId)80 RefPtr<PaContainer> PaContainer::GetContainer(int32_t instanceId)
81 {
82     auto container = AceEngine::Get().GetContainer(instanceId);
83     return AceType::DynamicCast<PaContainer>(container);
84 }
85 
CreateContainer(int32_t instanceId,void * paAbility,const PaContainerOptions & options,std::unique_ptr<PlatformEventCallback> callback)86 void PaContainer::CreateContainer(int32_t instanceId, void* paAbility, const PaContainerOptions& options,
87     std::unique_ptr<PlatformEventCallback> callback)
88 {
89     auto aceContainer = AceType::MakeRefPtr<PaContainer>(instanceId, paAbility, options, std::move(callback));
90     AceEngine::Get().AddContainer(instanceId, aceContainer);
91 
92     auto back = aceContainer->GetBackend();
93     CHECK_NULL_VOID(back);
94     back->UpdateState(Backend::State::ON_CREATE);
95 }
96 
RunPa(int32_t instanceId,const std::string & content,const OHOS::AAFwk::Want & want)97 bool PaContainer::RunPa(int32_t instanceId, const std::string& content, const OHOS::AAFwk::Want& want)
98 {
99     LOGI("PA: PaContainer RunPa start");
100     auto container = AceEngine::Get().GetContainer(instanceId);
101     CHECK_NULL_RETURN(container, false);
102     ContainerScope scope(instanceId);
103     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
104     CHECK_NULL_RETURN(aceContainer, false);
105     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
106     CHECK_NULL_RETURN(paBackend, false);
107     paBackend->RunPa(content, want);
108     return true;
109 }
110 
OnCreate(int32_t instanceId,const OHOS::AAFwk::Want & want)111 bool PaContainer::OnCreate(int32_t instanceId, const OHOS::AAFwk::Want& want)
112 {
113     LOGI("PA: PaContainer OnCreate start");
114     auto container = AceEngine::Get().GetContainer(instanceId);
115     CHECK_NULL_RETURN(container, false);
116     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
117     CHECK_NULL_RETURN(aceContainer, false);
118     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
119     CHECK_NULL_RETURN(paBackend, false);
120     paBackend->OnCreate(want);
121     return true;
122 }
123 
OnDelete(int32_t instanceId,int64_t formId)124 bool PaContainer::OnDelete(int32_t instanceId, int64_t formId)
125 {
126     LOGI("PA: PaContainer OnDelete start");
127     auto container = AceEngine::Get().GetContainer(instanceId);
128     CHECK_NULL_RETURN(container, false);
129     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
130     CHECK_NULL_RETURN(aceContainer, false);
131     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
132     CHECK_NULL_RETURN(paBackend, false);
133     paBackend->OnDelete(formId);
134     return true;
135 }
136 
OnTriggerEvent(int32_t instanceId,int64_t formId,const std::string & message)137 bool PaContainer::OnTriggerEvent(int32_t instanceId, int64_t formId, const std::string& message)
138 {
139     LOGI("PA: PaContainer OnTriggerEvent start");
140     auto container = AceEngine::Get().GetContainer(instanceId);
141     CHECK_NULL_RETURN(container, false);
142     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
143     CHECK_NULL_RETURN(aceContainer, false);
144     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
145     CHECK_NULL_RETURN(paBackend, false);
146     paBackend->OnTriggerEvent(formId, message);
147     return true;
148 }
149 
OnAcquireFormState(int32_t instanceId,const OHOS::AAFwk::Want & want)150 int32_t PaContainer::OnAcquireFormState(int32_t instanceId, const OHOS::AAFwk::Want& want)
151 {
152     LOGI("PA: PaContainer OnAcquireFormState start");
153     auto container = AceEngine::Get().GetContainer(instanceId);
154     CHECK_NULL_RETURN(container, -1);
155     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
156     CHECK_NULL_RETURN(aceContainer, -1);
157     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
158     CHECK_NULL_RETURN(paBackend, -1);
159     int32_t formState = paBackend->OnAcquireFormState(want);
160     return formState;
161 }
162 
OnUpdate(int32_t instanceId,int64_t formId)163 bool PaContainer::OnUpdate(int32_t instanceId, int64_t formId)
164 {
165     LOGI("PA: PaContainer OnUpdate start");
166     auto container = AceEngine::Get().GetContainer(instanceId);
167     CHECK_NULL_RETURN(container, false);
168     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
169     CHECK_NULL_RETURN(aceContainer, false);
170     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
171     CHECK_NULL_RETURN(paBackend, false);
172     paBackend->OnUpdate(formId);
173     return true;
174 }
175 
OnCastTemptoNormal(int32_t instanceId,int64_t formId)176 bool PaContainer::OnCastTemptoNormal(int32_t instanceId, int64_t formId)
177 {
178     LOGI("PA: PaContainer OnCastTemptoNormal start");
179     auto container = AceEngine::Get().GetContainer(instanceId);
180     CHECK_NULL_RETURN(container, false);
181     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
182     CHECK_NULL_RETURN(aceContainer, false);
183     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
184     CHECK_NULL_RETURN(paBackend, false);
185     paBackend->OnCastTemptoNormal(formId);
186     return true;
187 }
188 
OnVisibilityChanged(int32_t instanceId,const std::map<int64_t,int32_t> & formEventsMap)189 bool PaContainer::OnVisibilityChanged(int32_t instanceId, const std::map<int64_t, int32_t>& formEventsMap)
190 {
191     LOGI("PA: PaContainer OnVisibilityChanged start");
192     auto container = AceEngine::Get().GetContainer(instanceId);
193     CHECK_NULL_RETURN(container, false);
194     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
195     CHECK_NULL_RETURN(aceContainer, false);
196     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
197     CHECK_NULL_RETURN(paBackend, false);
198     paBackend->OnVisibilityChanged(formEventsMap);
199     return true;
200 }
201 
GetFormData(int32_t instanceId)202 AppExecFwk::FormProviderData PaContainer::GetFormData(int32_t instanceId)
203 {
204     LOGI("PA: PaContainer GetFormData start");
205     auto container = AceEngine::Get().GetContainer(instanceId);
206     CHECK_NULL_RETURN(container, AppExecFwk::FormProviderData());
207     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
208     CHECK_NULL_RETURN(aceContainer, AppExecFwk::FormProviderData());
209     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
210     CHECK_NULL_RETURN(paBackend, AppExecFwk::FormProviderData());
211     return paBackend->GetFormData();
212 }
213 
Destroy()214 void PaContainer::Destroy()
215 {
216     RefPtr<Backend> backend;
217     backend_.Swap(backend);
218     CHECK_NULL_VOID(backend);
219     backend->UpdateState(Backend::State::ON_DESTROY);
220 }
221 
DestroyContainer(int32_t instanceId)222 void PaContainer::DestroyContainer(int32_t instanceId)
223 {
224     LOGI("DestroyContainer with id %{private}d", instanceId);
225     SubwindowManager::GetInstance()->CloseDialog(instanceId);
226     auto container = AceEngine::Get().GetContainer(instanceId);
227     CHECK_NULL_VOID(container);
228     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
229     CHECK_NULL_VOID(aceContainer);
230     aceContainer->Destroy();
231 }
232 
AddAssetPath(int32_t instanceId,const std::string & packagePath,const std::string & hapPath,const std::vector<std::string> & paths)233 void PaContainer::AddAssetPath(int32_t instanceId, const std::string& packagePath, const std::string& hapPath,
234     const std::vector<std::string>& paths)
235 {
236     auto container = AceType::DynamicCast<PaContainer>(AceEngine::Get().GetContainer(instanceId));
237     CHECK_NULL_VOID(container);
238     RefPtr<AssetManagerImpl> assetManagerImpl;
239     if (container->assetManager_) {
240         assetManagerImpl = AceType::DynamicCast<AssetManagerImpl>(container->assetManager_);
241     } else {
242         assetManagerImpl = Referenced::MakeRefPtr<AssetManagerImpl>();
243         container->assetManager_ = assetManagerImpl;
244         AceType::DynamicCast<PaBackend>(container->GetBackend())->SetAssetManager(assetManagerImpl);
245     }
246     CHECK_NULL_VOID(assetManagerImpl);
247     if (!hapPath.empty()) {
248         auto assetProvider = AceType::MakeRefPtr<HapAssetProviderImpl>();
249         if (assetProvider->Initialize(hapPath, paths)) {
250             LOGI("Push AssetProvider to queue.");
251             assetManagerImpl->PushBack(std::move(assetProvider));
252         }
253     }
254     if (!packagePath.empty()) {
255         auto assetProvider = AceType::MakeRefPtr<FileAssetProviderImpl>();
256         if (assetProvider->Initialize(packagePath, paths)) {
257             LOGI("Push AssetProvider to queue.");
258             assetManagerImpl->PushBack(std::move(assetProvider));
259         }
260     }
261 }
262 
AddLibPath(int32_t instanceId,const std::vector<std::string> & libPath)263 void PaContainer::AddLibPath(int32_t instanceId, const std::vector<std::string>& libPath)
264 {
265     auto container = AceType::DynamicCast<PaContainer>(AceEngine::Get().GetContainer(instanceId));
266     CHECK_NULL_VOID(container);
267     RefPtr<AssetManager> assetManagerImpl;
268     if (container->assetManager_) {
269         assetManagerImpl = AceType::DynamicCast<AssetManagerImpl>(container->assetManager_);
270     } else {
271         assetManagerImpl = Referenced::MakeRefPtr<AssetManagerImpl>();
272         container->assetManager_ = assetManagerImpl;
273         AceType::DynamicCast<PaBackend>(container->GetBackend())->SetAssetManager(assetManagerImpl);
274     }
275     CHECK_NULL_VOID(assetManagerImpl);
276     assetManagerImpl->SetLibPath("default", libPath);
277 }
278 
Insert(int32_t instanceId,const Uri & uri,const OHOS::NativeRdb::ValuesBucket & value)279 int32_t PaContainer::Insert(int32_t instanceId, const Uri& uri, const OHOS::NativeRdb::ValuesBucket& value)
280 {
281     LOGI("Insert with id %{public}d", instanceId);
282     int32_t ret = 0;
283     auto container = AceEngine::Get().GetContainer(instanceId);
284     CHECK_NULL_RETURN(container, ret);
285     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
286     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
287     CHECK_NULL_RETURN(back, ret);
288     ret = back->Insert(uri, value);
289     return ret;
290 }
291 
Query(int32_t instanceId,const Uri & uri,const std::vector<std::string> & columns,const OHOS::NativeRdb::DataAbilityPredicates & predicates)292 std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> PaContainer::Query(int32_t instanceId, const Uri& uri,
293     const std::vector<std::string>& columns, const OHOS::NativeRdb::DataAbilityPredicates& predicates)
294 {
295     LOGI("Query with id %{public}d", instanceId);
296     std::shared_ptr<OHOS::NativeRdb::AbsSharedResultSet> ret;
297     auto container = AceEngine::Get().GetContainer(instanceId);
298     CHECK_NULL_RETURN(container, ret);
299     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
300     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
301     CHECK_NULL_RETURN(back, ret);
302     ret = back->Query(uri, columns, predicates);
303     return ret;
304 }
305 
Update(int32_t instanceId,const Uri & uri,const OHOS::NativeRdb::ValuesBucket & value,const OHOS::NativeRdb::DataAbilityPredicates & predicates)306 int32_t PaContainer::Update(int32_t instanceId, const Uri& uri, const OHOS::NativeRdb::ValuesBucket& value,
307     const OHOS::NativeRdb::DataAbilityPredicates& predicates)
308 {
309     LOGI("Update with id %{public}d", instanceId);
310     int32_t ret = 0;
311     auto container = AceEngine::Get().GetContainer(instanceId);
312     CHECK_NULL_RETURN(container, ret);
313     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
314     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
315     CHECK_NULL_RETURN(back, ret);
316     ret = back->Update(uri, value, predicates);
317     return ret;
318 }
319 
Delete(int32_t instanceId,const Uri & uri,const OHOS::NativeRdb::DataAbilityPredicates & predicates)320 int32_t PaContainer::Delete(
321     int32_t instanceId, const Uri& uri, const OHOS::NativeRdb::DataAbilityPredicates& predicates)
322 {
323     LOGI("Delete with id %{public}d", instanceId);
324     int32_t ret = 0;
325     auto container = AceEngine::Get().GetContainer(instanceId);
326     CHECK_NULL_RETURN(container, ret);
327     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
328     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
329     CHECK_NULL_RETURN(back, ret);
330     ret = back->Delete(uri, predicates);
331     return ret;
332 }
333 
BatchInsert(int32_t instanceId,const Uri & uri,const std::vector<OHOS::NativeRdb::ValuesBucket> & values)334 int32_t PaContainer::BatchInsert(
335     int32_t instanceId, const Uri& uri, const std::vector<OHOS::NativeRdb::ValuesBucket>& values)
336 {
337     LOGI("BatchInsert with id %{public}d", instanceId);
338     int32_t ret = 0;
339     auto container = AceEngine::Get().GetContainer(instanceId);
340     CHECK_NULL_RETURN(container, ret);
341     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
342     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
343     CHECK_NULL_RETURN(back, ret);
344     ret = back->BatchInsert(uri, values);
345     return ret;
346 }
347 
GetType(int32_t instanceId,const Uri & uri)348 std::string PaContainer::GetType(int32_t instanceId, const Uri& uri)
349 {
350     LOGI("GetType with id %{public}d", instanceId);
351     std::string ret;
352     auto container = AceEngine::Get().GetContainer(instanceId);
353     CHECK_NULL_RETURN(container, ret);
354     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
355     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
356     CHECK_NULL_RETURN(back, ret);
357     ret = back->GetType(uri);
358     return ret;
359 }
360 
GetFileTypes(int32_t instanceId,const Uri & uri,const std::string & mimeTypeFilter)361 std::vector<std::string> PaContainer::GetFileTypes(
362     int32_t instanceId, const Uri& uri, const std::string& mimeTypeFilter)
363 {
364     LOGI("GetFileTypes with id %{public}d", instanceId);
365     std::vector<std::string> ret;
366     auto container = AceEngine::Get().GetContainer(instanceId);
367     CHECK_NULL_RETURN(container, ret);
368     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
369     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
370     CHECK_NULL_RETURN(back, ret);
371     ret = back->GetFileTypes(uri, mimeTypeFilter);
372     return ret;
373 }
374 
OpenFile(int32_t instanceId,const Uri & uri,const std::string & mode)375 int32_t PaContainer::OpenFile(int32_t instanceId, const Uri& uri, const std::string& mode)
376 {
377     LOGI("OpenFile with id %{public}d", instanceId);
378     int32_t ret = 0;
379     auto container = AceEngine::Get().GetContainer(instanceId);
380     CHECK_NULL_RETURN(container, ret);
381     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
382     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
383     CHECK_NULL_RETURN(back, ret);
384     ret = back->OpenFile(uri, mode);
385     return ret;
386 }
387 
OpenRawFile(int32_t instanceId,const Uri & uri,const std::string & mode)388 int32_t PaContainer::OpenRawFile(int32_t instanceId, const Uri& uri, const std::string& mode)
389 {
390     LOGI("OpenRawFile with id %{public}d", instanceId);
391     int32_t ret = 0;
392     auto container = AceEngine::Get().GetContainer(instanceId);
393     CHECK_NULL_RETURN(container, ret);
394     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
395     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
396     CHECK_NULL_RETURN(back, ret);
397     ret = back->OpenRawFile(uri, mode);
398     return ret;
399 }
400 
NormalizeUri(int32_t instanceId,const Uri & uri)401 Uri PaContainer::NormalizeUri(int32_t instanceId, const Uri& uri)
402 {
403     LOGI("NormalizeUri with id %{public}d", instanceId);
404     Uri ret("");
405     auto container = AceEngine::Get().GetContainer(instanceId);
406     CHECK_NULL_RETURN(container, ret);
407     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
408     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
409     CHECK_NULL_RETURN(back, ret);
410     ret = back->NormalizeUri(uri);
411     return ret;
412 }
413 
DenormalizeUri(int32_t instanceId,const Uri & uri)414 Uri PaContainer::DenormalizeUri(int32_t instanceId, const Uri& uri)
415 {
416     LOGI("DenormalizeUri with id %{public}d", instanceId);
417     Uri ret("");
418     auto container = AceEngine::Get().GetContainer(instanceId);
419     CHECK_NULL_RETURN(container, ret);
420     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
421     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
422     CHECK_NULL_RETURN(back, ret);
423     ret = back->DenormalizeUri(uri);
424     return ret;
425 }
426 
OnConnect(int32_t instanceId,const OHOS::AAFwk::Want & want)427 sptr<IRemoteObject> PaContainer::OnConnect(int32_t instanceId, const OHOS::AAFwk::Want& want)
428 {
429     LOGI("OnConnect with id %{private}d", instanceId);
430     auto container = AceEngine::Get().GetContainer(instanceId);
431     CHECK_NULL_RETURN(container, nullptr);
432     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
433     auto back = aceContainer->GetBackend();
434     CHECK_NULL_RETURN(back, nullptr);
435     auto paBackend = AceType::DynamicCast<PaBackend>(back);
436     CHECK_NULL_RETURN(paBackend, nullptr);
437     return paBackend->OnConnect(want);
438     return nullptr;
439 }
440 
OnDisConnect(int32_t instanceId,const OHOS::AAFwk::Want & want)441 void PaContainer::OnDisConnect(int32_t instanceId, const OHOS::AAFwk::Want& want)
442 {
443     LOGI("OnDisConnect with id %{private}d", instanceId);
444     auto container = AceEngine::Get().GetContainer(instanceId);
445     CHECK_NULL_VOID(container);
446     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
447     auto back = aceContainer->GetBackend();
448     CHECK_NULL_VOID(back);
449     auto paBackend = AceType::DynamicCast<PaBackend>(back);
450     CHECK_NULL_VOID(paBackend);
451     paBackend->OnDisConnect(want);
452 }
453 
OnCommand(const OHOS::AAFwk::Want & want,int startId,int32_t instanceId)454 void PaContainer::OnCommand(const OHOS::AAFwk::Want &want, int startId, int32_t instanceId)
455 {
456     LOGI("OnCommand with id %{private}d", instanceId);
457     auto container = AceEngine::Get().GetContainer(instanceId);
458     CHECK_NULL_VOID(container);
459     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
460     auto back = aceContainer->GetBackend();
461     CHECK_NULL_VOID(back);
462     auto paBackend = AceType::DynamicCast<PaBackend>(back);
463     CHECK_NULL_VOID(paBackend);
464     paBackend->OnCommand(want, startId);
465 }
466 
OnShare(int32_t instanceId,int64_t formId,OHOS::AAFwk::WantParams & wantParams)467 bool PaContainer::OnShare(int32_t instanceId, int64_t formId, OHOS::AAFwk::WantParams &wantParams)
468 {
469     auto container = AceEngine::Get().GetContainer(instanceId);
470     CHECK_NULL_RETURN(container, false);
471     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
472     CHECK_NULL_RETURN(aceContainer, false);
473     auto paBackend = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
474     CHECK_NULL_RETURN(paBackend, false);
475     return paBackend->OnShare(formId, wantParams);
476 }
477 
Call(int32_t instanceId,const Uri & uri,const std::string & method,const std::string & arg,const AppExecFwk::PacMap & pacMap)478 std::shared_ptr<AppExecFwk::PacMap> PaContainer::Call(int32_t instanceId, const Uri& uri,
479     const std::string& method, const std::string& arg, const AppExecFwk::PacMap& pacMap)
480 {
481     std::shared_ptr<AppExecFwk::PacMap> ret = nullptr;
482     auto container = AceEngine::Get().GetContainer(instanceId);
483     CHECK_NULL_RETURN(container, ret);
484     auto aceContainer = AceType::DynamicCast<PaContainer>(container);
485     auto back = AceType::DynamicCast<PaBackend>(aceContainer->GetBackend());
486     CHECK_NULL_RETURN(back, ret);
487     ret = back->Call(uri, method, arg, pacMap);
488     return ret;
489 }
490 } // namespace OHOS::Ace::Platform
491