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 #ifndef FOUNDATION_ACE_FRAMEWORKS_BRIDGE_JS_FRONTEND_JS_FRONTEND_H
17 #define FOUNDATION_ACE_FRAMEWORKS_BRIDGE_JS_FRONTEND_JS_FRONTEND_H
18 
19 #include <string>
20 #include <unordered_map>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/utils/string_utils.h"
24 #include "core/common/ace_page.h"
25 #include "core/common/container.h"
26 #include "core/common/frontend.h"
27 #include "core/common/js_message_dispatcher.h"
28 #include "frameworks/bridge/js_frontend/engine/common/js_engine.h"
29 #include "frameworks/bridge/js_frontend/frontend_delegate_impl.h"
30 #include "frameworks/bridge/js_frontend/js_ace_page.h"
31 
32 namespace OHOS::Ace {
33 
34 // JsFrontend is the unique entrance from ACE backend to frontend.
35 // The relationship between AceActivity, AceContainer and JsFrontend is 1:1:1.
36 // So JsFrontend would be responsible for below things:
37 // - Create and initialize QuickJS engine.
38 // - Load pages of a JS app, and parse the manifest.json before loading main page.
39 // - Maintain the page stack of JS app by FrontendDelegateImpl.
40 // - Lifecycle of JS app (also AceActivity).
41 class JsFrontend : public Frontend {
42     DECLARE_ACE_TYPE(JsFrontend, Frontend);
43 
44 public:
45     JsFrontend() = default;
46     ~JsFrontend() override;
47 
48     bool Initialize(FrontendType type, const RefPtr<TaskExecutor>& taskExecutor) override;
49 
50     void Destroy() override;
51 
52     void AttachPipelineContext(const RefPtr<PipelineBase>& context) override;
53 
54     void SetAssetManager(const RefPtr<AssetManager>& assetManager) override;
55 
56     UIContentErrorCode RunPage(const std::string& url, const std::string& params) override;
57 
58     void ReplacePage(const std::string& url, const std::string& params) override;
59 
60     void PushPage(const std::string& url, const std::string& params) override;
61 
62     // Js frontend manages all pages self.
AddPage(const RefPtr<AcePage> & page)63     void AddPage(const RefPtr<AcePage>& page) override {}
64 
GetPage(int32_t pageId)65     RefPtr<AcePage> GetPage(int32_t pageId) const override
66     {
67         return delegate_->GetPage(pageId);
68     }
69 
GetCurrentReadyPage()70     WeakPtr<AcePage> GetCurrentReadyPage() const
71     {
72         return delegate_->GetCurrentReadyPage();
73     }
74 
75     void TriggerGarbageCollection() override;
76     void DumpHeapSnapshot(bool isPrivate) override;
77     void DestroyHeapProfiler() override;
78     void ForceFullGC() override;
79     void NotifyUIIdle() override;
80 
81     void SendCallbackMessage(const std::string& callbackId, const std::string& data) const override;
82     // platform channel.
83     void SetJsMessageDispatcher(const RefPtr<JsMessageDispatcher>& dispatcher) const override;
84     void TransferComponentResponseData(int32_t callbackId, int32_t code,
85         std::vector<uint8_t>&& data) const override;
86     void TransferJsResponseData(int32_t callbackId, int32_t code, std::vector<uint8_t>&& data) const override;
87 #if defined(PREVIEW)
RunNativeEngineLoop()88     void RunNativeEngineLoop() override
89     {
90         if (jsEngine_) {
91             jsEngine_->RunNativeEngineLoop();
92         }
93     }
94     void TransferJsResponseDataPreview(int32_t callbackId, int32_t code, ResponseData responseData) const;
95 #endif
96     void TransferJsPluginGetError(int32_t callbackId, int32_t errorCode, std::string&& errorMessage) const override;
97     void TransferJsEventData(int32_t callbackId, int32_t code, std::vector<uint8_t>&& data) const override;
98     void LoadPluginJsCode(std::string&& jsCode) const override;
99     void LoadPluginJsByteCode(std::vector<uint8_t>&& jsCode, std::vector<int32_t>&& jsCodeLen) const override;
100 
101     // application lifecycle.
102     void UpdateState(Frontend::State state) override;
103 
104     // page lifecycle.
105     bool OnBackPressed() override;
OnSaveAbilityState(std::string & data)106     void OnSaveAbilityState(std::string& data) override {}
OnRestoreAbilityState(const std::string & data)107     void OnRestoreAbilityState(const std::string& data) override {}
108     void OnShow() override;
109     void OnHide() override;
110     void OnConfigurationUpdated(const std::string& data) override;
111     void OnActive() override;
112     void OnInactive() override;
113     bool OnStartContinuation() override;
114     void OnCompleteContinuation(int32_t code) override;
115     void OnRemoteTerminated() override;
116     void OnSaveData(std::string& data) override;
117     bool OnRestoreData(const std::string& data) override;
118 
OnMemoryLevel(const int32_t level)119     void OnMemoryLevel(const int32_t level) override {}
120     void OnNewRequest(const std::string& data) override;
OnNewWant(const std::string & data)121     void OnNewWant(const std::string& data) override {}
122     void CallRouterBack() override;
123     void SetColorMode(ColorMode colorMode) override;
124 
125     void OnSurfaceChanged(int32_t width, int32_t height) override;
126 
127     void OnLayoutCompleted(const std::string& componentId) override;
128     void OnDrawCompleted(const std::string& componentId) override;
129 
130     void DumpFrontend() const override;
131     std::string GetPagePath() const override;
132 
GetEventHandler()133     RefPtr<AceEventHandler> GetEventHandler() override
134     {
135         return handler_;
136     }
137 
138     // judge frontend is foreground frontend.
IsForeground()139     bool IsForeground() override
140     {
141         return foregroundFrontend_;
142     }
143 
144     RefPtr<AccessibilityManager> GetAccessibilityManager() const override;
145     WindowConfig& GetWindowConfig() override;
146 
SetJsEngine(const RefPtr<Framework::JsEngine> & jsEngine)147     void SetJsEngine(const RefPtr<Framework::JsEngine>& jsEngine)
148     {
149         jsEngine_ = jsEngine;
150     }
151 
SetNeedDebugBreakPoint(bool value)152     void SetNeedDebugBreakPoint(bool value)
153     {
154         if (jsEngine_) {
155             jsEngine_->SetNeedDebugBreakPoint(value);
156         }
157     }
158 
SetDebugVersion(bool value)159     void SetDebugVersion(bool value)
160     {
161         if (jsEngine_) {
162             jsEngine_->SetDebugVersion(value);
163         }
164     }
165 
SetInstanceName(const std::string & name)166     void SetInstanceName(const std::string& name)
167     {
168         if (jsEngine_) {
169             jsEngine_->SetInstanceName(name);
170         }
171     }
172 
173     void RebuildAllPages() override;
174 
175     void GetPluginsUsed(std::string& data) override;
176 
177 private:
178     void InitializeFrontendDelegate(const RefPtr<TaskExecutor>& taskExecutor);
179 
180     RefPtr<Framework::FrontendDelegateImpl> delegate_;
181     RefPtr<AceEventHandler> handler_;
182     RefPtr<Framework::JsEngine> jsEngine_;
183     bool foregroundFrontend_ = false;
184 };
185 
186 class JsEventHandler : public AceEventHandler {
187 public:
JsEventHandler(const RefPtr<Framework::FrontendDelegateImpl> & delegate)188     explicit JsEventHandler(const RefPtr<Framework::FrontendDelegateImpl>& delegate) : delegate_(delegate)
189     {
190         ACE_DCHECK(delegate_);
191     }
192 
193     ~JsEventHandler() override = default;
194 
195     void HandleAsyncEvent(const EventMarker& eventMarker) override;
196 
197     void HandleAsyncEvent(const EventMarker& eventMarker, int32_t param) override;
198 
199     void HandleAsyncEvent(const EventMarker& eventMarker, const BaseEventInfo& info) override;
200 
201     void HandleAsyncEvent(const EventMarker& eventMarker, const KeyEvent& info) override;
202 
203     void HandleAsyncEvent(const EventMarker& eventMarker, const GestureEvent& info) override;
204 
205     void HandleAsyncEvent(const EventMarker& eventMarker, const RotationEvent& info) override;
206 
207     void HandleAsyncEvent(const EventMarker& eventMarker, const std::string& param) override;
208 
209     void HandleSyncEvent(const EventMarker& eventMarker, bool& result) override;
210 
211     void HandleSyncEvent(const EventMarker& eventMarker, const BaseEventInfo& info, bool& result) override;
212 
213     void HandleSyncEvent(const EventMarker& eventMarker, const KeyEvent& info, bool& result) override;
214 
215     void HandleSyncEvent(const EventMarker& eventMarker, const std::string& param, std::string& result) override;
216 
217     void HandleSyncEvent(const EventMarker& eventMarker, const std::string& componentId, const int32_t nodeId,
218         const bool isDestroy) override;
219 
220 private:
221     RefPtr<Framework::FrontendDelegateImpl> delegate_;
222 };
223 
224 } // namespace OHOS::Ace
225 
226 #endif // FOUNDATION_ACE_FRAMEWORKS_BRIDGE_JS_FRONTEND_JS_FRONTEND_H
227