1 /*
2  * Copyright (c) 2021-2022 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 #ifndef FOUNDATION_ACE_FRAMEWORKS_BRIDGE_CARD_FRONTEND_CARD_FRONTEND_H
17 #define FOUNDATION_ACE_FRAMEWORKS_BRIDGE_CARD_FRONTEND_CARD_FRONTEND_H
18 
19 #include <memory>
20 
21 #include "base/memory/ace_type.h"
22 #include "core/common/ace_page.h"
23 #include "core/common/frontend.h"
24 #include "frameworks/bridge/card_frontend/card_frontend_delegate.h"
25 #include "frameworks/bridge/card_frontend/js_card_parser.h"
26 #include "frameworks/bridge/common/accessibility/accessibility_node_manager.h"
27 #include "frameworks/bridge/common/manifest/manifest_parser.h"
28 #include "frameworks/bridge/common/utils/page_id_pool.h"
29 #include "frameworks/bridge/js_frontend/frontend_delegate_impl.h"
30 
31 namespace OHOS::Ace {
32 class ACE_EXPORT CardFrontend : public Frontend {
33     DECLARE_ACE_TYPE(CardFrontend, Frontend);
34 
35 public:
36     using OnFormVisibleCallback = std::function<void()>;
37 
38     CardFrontend() = default;
39     ~CardFrontend() override;
40 
SetLoadCardCallBack(WeakPtr<PipelineBase> outSidePipelineContext)41     virtual void SetLoadCardCallBack(WeakPtr<PipelineBase> outSidePipelineContext) {}
42     virtual void UpdateData(const std::string& dataList);
43     virtual void OnPageLoaded(const RefPtr<Framework::JsAcePage>& page);
44     virtual void HandleSurfaceChanged(int32_t width, int32_t height);
45     virtual void UpdatePageData(const std::string& dataList);
46     virtual void OnMediaFeatureUpdate();
47     std::string GetFormSrcPath(const std::string& uri, const std::string& suffix) const;
48 
49     bool Initialize(FrontendType type, const RefPtr<TaskExecutor>& taskExecutor) override;
50 
51     void Destroy() override;
52 
53     void AttachPipelineContext(const RefPtr<PipelineBase>& context) override;
54     void SetAssetManager(const RefPtr<AssetManager>& assetManager) override;
55 
56     UIContentErrorCode RunPage(const std::string& url, const std::string& params) override;
57     void ReplacePage(const std::string& url, const std::string& params) override {}
58     void PushPage(const std::string& url, const std::string& params) override {}
59     void AddPage(const RefPtr<AcePage>& page) override {}
60     RefPtr<AcePage> GetPage(int32_t pageId) const override;
61     void TriggerGarbageCollection() override {}
62 
63     void SendCallbackMessage(const std::string& callbackId, const std::string& data) const override {}
64     // platform channel.
65     void SetJsMessageDispatcher(const RefPtr<JsMessageDispatcher>& dispatcher) const override {}
66     void TransferComponentResponseData(int32_t callbackId, int32_t code, std::vector<uint8_t>&& data) const override {}
67     void TransferJsResponseData(int32_t callbackId, int32_t code, std::vector<uint8_t>&& data) const override {}
68     void TransferJsEventData(int32_t callbackId, int32_t code, std::vector<uint8_t>&& data) const override {}
69     void TransferJsPluginGetError(int32_t callbackId, int32_t errorCode, std::string&& errorMessage) const override {}
70 
71     void LoadPluginJsCode(std::string&& jsCode) const override {}
72     void LoadPluginJsByteCode(std::vector<uint8_t>&& jsCode, std::vector<int32_t>&& jsCodeLen) const override {}
73 
74     // application lifecycle.
75     void UpdateState(Frontend::State state) override {}
76 
77     // page lifecycle.
78     bool OnBackPressed() override
79     {
80         return false;
81     }
82 
83     void OnSaveAbilityState(std::string& data) override {}
84 
85     void OnRestoreAbilityState(const std::string& data) override {}
86 
87     void OnShow() override
88     {
89         foregroundFrontend_ = true;
90     }
91     void OnHide() override
92     {
93         foregroundFrontend_ = false;
94     }
95 
96     void OnActive() override {}
97     void OnInactive() override {}
98     bool OnStartContinuation() override
99     {
100         return false;
101     }
102     void OnCompleteContinuation(int32_t code) override {}
103     void OnMemoryLevel(const int32_t level) override {}
104     void OnSaveData(std::string& data) override {}
105     bool OnRestoreData(const std::string& data) override
106     {
107         return false;
108     }
109     void OnRemoteTerminated() override {}
110     void OnNewRequest(const std::string& data) override {}
111     void OnNewWant(const std::string& data) override {}
112     void CallRouterBack() override {}
113     void OnSurfaceChanged(int32_t width, int32_t height) override;
114     void OnLayoutCompleted(const std::string& componentId) override {}
115     void OnDrawCompleted(const std::string& componentId) override {}
116     void DumpFrontend() const override {}
117     std::string GetPagePath() const override
118     {
119         return "";
120     }
121     WindowConfig& GetWindowConfig() override;
122     void SetColorMode(ColorMode colorMode) override;
123     void RebuildAllPages() override;
124 
125     RefPtr<AceEventHandler> GetEventHandler() override
126     {
127         return eventHandler_;
128     }
129 
130     // judge frontend is foreground frontend.
131     bool IsForeground() override
132     {
133         return foregroundFrontend_;
134     }
135 
136     RefPtr<AccessibilityManager> GetAccessibilityManager() const override
137     {
138         if (!delegate_) {
139             return nullptr;
140         }
141         return delegate_->GetJsAccessibilityManager();
142     }
143 
SetDensity(double density)144     void SetDensity(double density)
145     {
146         density_ = density;
147     }
148 
ResetPageLoadState()149     void ResetPageLoadState()
150     {
151         pageLoaded_ = false;
152     }
153 
SetCardHapPath(const std::string& path)154     void SetCardHapPath(const std::string& path)
155     {
156         cardHapPath_ = path;
157     }
158 
GetFormSrc() const159     std::string GetFormSrc() const
160     {
161         return formSrc_;
162     }
163 
SetFormSrc(std::string formSrc)164     void SetFormSrc(std::string formSrc)
165     {
166         formSrc_ = formSrc;
167     }
168 
GetCardWindowConfig()169     WindowConfig& GetCardWindowConfig()
170     {
171         return cardWindowConfig_;
172     }
173 
SetCardWindowConfig(WindowConfig cardWindowConfig)174     void SetCardWindowConfig(WindowConfig cardWindowConfig)
175     {
176         cardWindowConfig_ = cardWindowConfig;
177     }
178 
SetRunningCardId(int64_t cardId)179     void SetRunningCardId(int64_t cardId)
180     {
181         cardId_ = cardId;
182     }
183 
AddFormVisiableCallback(const OnFormVisibleCallback& callback)184     void AddFormVisiableCallback(const OnFormVisibleCallback& callback)
185     {
186         if (callback) {
187             onFormVisibleCallback_ = callback;
188         }
189     }
190 
FireFormVisiableCallback() const191     void FireFormVisiableCallback() const
192     {
193         if (onFormVisibleCallback_) {
194             onFormVisibleCallback_();
195         }
196     }
197 
198 protected:
199     void ParseManifest() const;
200 
201     ColorMode colorMode_ = ColorMode::LIGHT;
202     bool foregroundFrontend_ = false;
203     bool pageLoaded_ = false;
204     double density_ = 1.0;
205     std::string cardHapPath_;
206 
207     Framework::PipelineContextHolder holder_;
208     RefPtr<AssetManager> assetManager_;
209     RefPtr<Framework::ManifestParser> manifestParser_;
210     OnFormVisibleCallback onFormVisibleCallback_;
211 
212     mutable std::once_flag onceFlag_;
213     RefPtr<AceEventHandler> eventHandler_;
214     Framework::PageIdPool pageIdPool_;
215     std::string formSrc_;
216     WindowConfig cardWindowConfig_;
217     uint64_t cardId_ = 0; // cardId != formId, cardId is the nodeId of component.
218 
219 private:
220     RefPtr<Framework::CardFrontendDelegate> delegate_;
221     void LoadPage(const std::string& urlPath, const std::string& params);
222     void ParsePage(const RefPtr<PipelineBase>& context, const std::string& pageContent, const std::string& params,
223         const RefPtr<Framework::JsAcePage>& page);
224 
225     RefPtr<Framework::JsCardParser> parseJsCard_;
226 };
227 
228 class CardEventHandler : public AceEventHandler {
229 public:
CardEventHandler(const RefPtr<Framework::CardFrontendDelegate>& delegate)230     explicit CardEventHandler(const RefPtr<Framework::CardFrontendDelegate>& delegate) : delegate_(delegate)
231     {
232         ACE_DCHECK(delegate_);
233     }
234 
235     ~CardEventHandler() override = default;
236 
237     void HandleAsyncEvent(const EventMarker& eventMarker) override
238     {
239         delegate_->FireCardEvent(eventMarker);
240     }
241 
242     void HandleAsyncEvent(const EventMarker& eventMarker, int32_t param) override {}
243 
244     void HandleAsyncEvent(const EventMarker& eventMarker, const BaseEventInfo& info) override
245     {
246         delegate_->FireCardEvent(eventMarker);
247     }
248 
249     void HandleAsyncEvent(const EventMarker& eventMarker, const KeyEvent& info) override {}
250 
251     void HandleAsyncEvent(const EventMarker& eventMarker, const std::string& param) override
252     {
253         delegate_->FireCardEvent(eventMarker, param);
254     }
255 
256     void HandleSyncEvent(const EventMarker& eventMarker, bool& result) override {}
257 
258     void HandleSyncEvent(const EventMarker& eventMarker, const BaseEventInfo& info, bool& result) override {}
259 
260     void HandleSyncEvent(const EventMarker& eventMarker, const KeyEvent& info, bool& result) override {}
261 
262     void HandleSyncEvent(const EventMarker& eventMarker, const std::string& param, std::string& result) override {}
263 
264     void HandleSyncEvent(const EventMarker& eventMarker, const std::string& componentId, const int32_t nodeId,
265         const bool isDestroy) override
266     {}
267 
268 private:
269     RefPtr<Framework::CardFrontendDelegate> delegate_;
270 };
271 } // namespace OHOS::Ace
272 #endif // FOUNDATION_ACE_FRAMEWORKS_BRIDGE_CARD_FRONTEND_CARD_FRONTEND_H
273