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 "core/components_ng/pattern/ui_extension/ui_extension_model_ng.h"
17 
18 #include "interfaces/inner_api/ace/modal_ui_extension_config.h"
19 #include "want.h"
20 
21 #include "core/components/common/layout/constants.h"
22 #include "core/components_ng/base/view_stack_processor.h"
23 #include "core/components_ng/pattern/ui_extension/isolated_pattern.h"
24 #include "core/components_ng/pattern/ui_extension/session_wrapper.h"
25 #include "core/components_ng/pattern/ui_extension/security_ui_extension_pattern.h"
26 #include "core/components_ng/pattern/ui_extension/ui_extension_hub.h"
27 #include "core/components_ng/pattern/ui_extension/ui_extension_pattern.h"
28 #include "core/components_v2/inspector/inspector_constants.h"
29 #include "core/pipeline_ng/pipeline_context.h"
30 
31 namespace OHOS::Ace::NG {
Create(const std::string & bundleName,const std::string & abilityName,const std::map<std::string,std::string> & params,std::function<void (int32_t)> && onRelease,std::function<void (int32_t,const std::string &,const std::string &)> && onError)32 RefPtr<FrameNode> UIExtensionModelNG::Create(const std::string& bundleName, const std::string& abilityName,
33     const std::map<std::string, std::string>& params, std::function<void(int32_t)>&& onRelease,
34     std::function<void(int32_t, const std::string&, const std::string&)>&& onError)
35 {
36     auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
37     ACE_LAYOUT_SCOPED_TRACE("Create[%s][self:%d]", V2::UI_EXTENSION_COMPONENT_ETS_TAG, nodeId);
38     auto wantWrap = WantWrap::CreateWantWrap(bundleName, abilityName);
39     wantWrap->SetWantParam(params);
40     auto frameNode = FrameNode::GetOrCreateFrameNode(
41         V2::UI_EXTENSION_COMPONENT_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<UIExtensionPattern>(); });
42     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
43     CHECK_NULL_RETURN(pattern, frameNode);
44     pattern->UpdateWant(wantWrap);
45     pattern->SetOnReleaseCallback(std::move(onRelease));
46     pattern->SetOnErrorCallback(std::move(onError));
47     return frameNode;
48 }
49 
Create(const AAFwk::Want & want,const ModalUIExtensionCallbacks & callbacks,const InnerModalUIExtensionConfig & config)50 RefPtr<FrameNode> UIExtensionModelNG::Create(
51     const AAFwk::Want& want, const ModalUIExtensionCallbacks& callbacks, const InnerModalUIExtensionConfig& config)
52 {
53     bool isAsyncModalBinding = config.isAsyncModalBinding;
54     bool isModal = config.isModal;
55     auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
56     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::UI_EXTENSION_COMPONENT_ETS_TAG, nodeId,
57         [isAsyncModalBinding, isModal]() {
58             return AceType::MakeRefPtr<UIExtensionPattern>(false, isModal, isAsyncModalBinding);
59         });
60     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
61     CHECK_NULL_RETURN(pattern, frameNode);
62     pattern->SetDensityDpi(config.isDensityFollowHost);
63     pattern->UpdateWant(want);
64     auto pipeline = PipelineContext::GetCurrentContext();
65     CHECK_NULL_RETURN(pipeline, frameNode);
66     pipeline->AddWindowStateChangedCallback(nodeId);
67     pattern->SetOnReleaseCallback(std::move(callbacks.onRelease));
68     pattern->SetOnErrorCallback(std::move(callbacks.onError));
69     pattern->SetOnResultCallback(std::move(callbacks.onResult));
70     pattern->SetOnReceiveCallback(std::move(callbacks.onReceive));
71     pattern->SetModalOnRemoteReadyCallback(std::move(callbacks.onRemoteReady));
72     pattern->SetModalOnDestroy(std::move(callbacks.onDestroy));
73     auto dragDropManager = pipeline->GetDragDropManager();
74     CHECK_NULL_RETURN(dragDropManager, frameNode);
75     dragDropManager->AddDragFrameNode(nodeId, AceType::WeakClaim(AceType::RawPtr(frameNode)));
76     return frameNode;
77 }
78 
Create(const RefPtr<OHOS::Ace::WantWrap> & wantWrap,const std::map<PlaceholderType,RefPtr<NG::FrameNode>> & placeholderMap,bool transferringCaller,bool densityDpi)79 void UIExtensionModelNG::Create(const RefPtr<OHOS::Ace::WantWrap>& wantWrap,
80     const std::map<PlaceholderType, RefPtr<NG::FrameNode>>& placeholderMap,
81     bool transferringCaller, bool densityDpi)
82 {
83     auto* stack = ViewStackProcessor::GetInstance();
84     auto nodeId = stack->ClaimNodeId();
85     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::UI_EXTENSION_COMPONENT_ETS_TAG, nodeId,
86         [transferringCaller]() { return AceType::MakeRefPtr<UIExtensionPattern>(transferringCaller); });
87     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
88     CHECK_NULL_VOID(pattern);
89     pattern->SetNeedCheckWindowSceneId(true);
90     pattern->SetPlaceholderMap(placeholderMap);
91     pattern->UpdateWant(wantWrap);
92     pattern->SetDensityDpi(densityDpi);
93     stack->Push(frameNode);
94     auto pipeline = PipelineContext::GetCurrentContext();
95     CHECK_NULL_VOID(pipeline);
96     pipeline->AddWindowStateChangedCallback(nodeId);
97     auto dragDropManager = pipeline->GetDragDropManager();
98     CHECK_NULL_VOID(dragDropManager);
99     dragDropManager->AddDragFrameNode(nodeId, AceType::WeakClaim(AceType::RawPtr(frameNode)));
100 }
101 
102 // for EmbeddedComponent
Create(const RefPtr<OHOS::Ace::WantWrap> & wantWrap,SessionType sessionType)103 void UIExtensionModelNG::Create(const RefPtr<OHOS::Ace::WantWrap>& wantWrap, SessionType sessionType)
104 {
105     auto* stack = ViewStackProcessor::GetInstance();
106     auto nodeId = stack->ClaimNodeId();
107     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::EMBEDDED_COMPONENT_ETS_TAG, nodeId,
108         [sessionType]() { return AceType::MakeRefPtr<UIExtensionPattern>(false, false, false, sessionType); });
109     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
110     CHECK_NULL_VOID(pattern);
111     pattern->SetNeedCheckWindowSceneId(true);
112     pattern->SetWantWrap(wantWrap);
113     if (frameNode->GetNodeStatus() == NodeStatus::NORMAL_NODE) {
114         pattern->UpdateWant(wantWrap);
115     }
116     stack->Push(frameNode);
117     auto pipeline = PipelineContext::GetCurrentContext();
118     CHECK_NULL_VOID(pipeline);
119     pipeline->AddWindowStateChangedCallback(nodeId);
120     auto dragDropManager = pipeline->GetDragDropManager();
121     CHECK_NULL_VOID(dragDropManager);
122     dragDropManager->AddDragFrameNode(nodeId, AceType::WeakClaim(AceType::RawPtr(frameNode)));
123 }
124 
125 // for DynamicComponent
Create()126 void UIExtensionModelNG::Create()
127 {
128     auto* stack = ViewStackProcessor::GetInstance();
129     auto nodeId = stack->ClaimNodeId();
130     auto frameNode = FrameNode::GetOrCreateFrameNode(
131         V2::ISOLATED_COMPONENT_ETS_TAG, nodeId, []() { return AceType::MakeRefPtr<IsolatedPattern>(); });
132     auto pattern = frameNode->GetPattern<IsolatedPattern>();
133     CHECK_NULL_VOID(pattern);
134     stack->Push(frameNode);
135     auto pipeline = PipelineContext::GetCurrentContext();
136     CHECK_NULL_VOID(pipeline);
137     pipeline->AddWindowStateChangedCallback(nodeId);
138 }
139 
Create(const UIExtensionConfig & config)140 void UIExtensionModelNG::Create(const UIExtensionConfig& config)
141 {
142     switch (config.sessionType) {
143         case SessionType::SECURITY_UI_EXTENSION_ABILITY:
144             CreateSecurityUIExtension(config);
145             break;
146         default:
147             LOGW("The type uiextension is not supported");
148     }
149 }
150 
CreateSecurityUIExtension(const UIExtensionConfig & config)151 void UIExtensionModelNG::CreateSecurityUIExtension(const UIExtensionConfig& config)
152 {
153     TAG_LOGI(AceLogTag::ACE_SECURITYUIEXTENSION, "CreateSecurityUIExtension");
154     auto* stack = ViewStackProcessor::GetInstance();
155     auto nodeId = stack->ClaimNodeId();
156     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::UI_EXTENSION_COMPONENT_ETS_TAG, nodeId,
157         []() { return AceType::MakeRefPtr<SecurityUIExtensionPattern>(); });
158     auto pattern = frameNode->GetPattern<SecurityUIExtensionPattern>();
159     CHECK_NULL_VOID(pattern);
160     pattern->Initialize(config);
161     pattern->SetPlaceholderNode(config.placeholderNode);
162     pattern->UpdateWant(config.wantWrap);
163     pattern->SetDensityDpi(config.densityDpi);
164     stack->Push(frameNode);
165     auto pipeline = PipelineContext::GetCurrentContext();
166     CHECK_NULL_VOID(pipeline);
167     pipeline->AddWindowStateChangedCallback(nodeId);
168     auto dragDropManager = pipeline->GetDragDropManager();
169     CHECK_NULL_VOID(dragDropManager);
170     dragDropManager->AddDragFrameNode(nodeId, AceType::WeakClaim(AceType::RawPtr(frameNode)));
171 }
172 
InitializeDynamicComponent(const RefPtr<FrameNode> & frameNode,const std::string & hapPath,const std::string & abcPath,const std::string & entryPoint,void * runtime)173 void UIExtensionModelNG::InitializeDynamicComponent(const RefPtr<FrameNode>& frameNode, const std::string& hapPath,
174     const std::string& abcPath, const std::string& entryPoint, void* runtime)
175 {
176     auto pattern = frameNode->GetPattern<IsolatedPattern>();
177     CHECK_NULL_VOID(pattern);
178     pattern->InitializeDynamicComponent(hapPath, abcPath, entryPoint, runtime);
179 }
180 
InitializeIsolatedComponent(const RefPtr<NG::FrameNode> & frameNode,const RefPtr<OHOS::Ace::WantWrap> & wantWrap,void * runtime)181 void UIExtensionModelNG::InitializeIsolatedComponent(
182     const RefPtr<NG::FrameNode>& frameNode, const RefPtr<OHOS::Ace::WantWrap>& wantWrap, void* runtime)
183 {
184     auto pattern = frameNode->GetPattern<IsolatedPattern>();
185     CHECK_NULL_VOID(pattern);
186     pattern->InitializeIsolatedComponent(wantWrap, runtime);
187 }
188 
SetAdaptiveWidth(bool state)189 void UIExtensionModelNG::SetAdaptiveWidth(bool state)
190 {
191     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
192     CHECK_NULL_VOID(frameNode);
193     auto pattern = frameNode->GetPattern<IsolatedPattern>();
194     CHECK_NULL_VOID(pattern);
195     pattern->SetAdaptiveWidth(state);
196 }
197 
SetAdaptiveHeight(bool state)198 void UIExtensionModelNG::SetAdaptiveHeight(bool state)
199 {
200     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
201     CHECK_NULL_VOID(frameNode);
202     auto pattern = frameNode->GetPattern<IsolatedPattern>();
203     CHECK_NULL_VOID(pattern);
204     pattern->SetAdaptiveHeight(state);
205 }
206 
SetOnRemoteReady(std::function<void (const RefPtr<UIExtensionProxy> &)> && onRemoteReady)207 void UIExtensionModelNG::SetOnRemoteReady(std::function<void(const RefPtr<UIExtensionProxy>&)>&& onRemoteReady)
208 {
209     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
210     CHECK_NULL_VOID(frameNode);
211     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
212     CHECK_NULL_VOID(pattern);
213     pattern->SetOnRemoteReadyCallback(std::move(onRemoteReady));
214 }
215 
SetSecurityOnRemoteReady(std::function<void (const RefPtr<NG::SecurityUIExtensionProxy> &)> && onRemoteReady)216 void UIExtensionModelNG::SetSecurityOnRemoteReady(
217     std::function<void(const RefPtr<NG::SecurityUIExtensionProxy>&)>&& onRemoteReady)
218 {
219     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
220     CHECK_NULL_VOID(frameNode);
221     auto eventHub = frameNode->GetEventHub<UIExtensionHub>();
222     CHECK_NULL_VOID(eventHub);
223     eventHub->SetOnRemoteReadyCallback(std::move(onRemoteReady));
224     return;
225 }
226 
SetOnRelease(std::function<void (int32_t)> && onRelease)227 void UIExtensionModelNG::SetOnRelease(std::function<void(int32_t)>&& onRelease)
228 {
229     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
230     CHECK_NULL_VOID(frameNode);
231     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
232     CHECK_NULL_VOID(pattern);
233     pattern->SetOnReleaseCallback(std::move(onRelease));
234 }
235 
SetOnResult(std::function<void (int32_t,const AAFwk::Want &)> && onResult)236 void UIExtensionModelNG::SetOnResult(std::function<void(int32_t, const AAFwk::Want&)>&& onResult)
237 {
238     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
239     CHECK_NULL_VOID(frameNode);
240     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
241     pattern->SetOnResultCallback(std::move(onResult));
242 }
243 
SetOnTerminated(std::function<void (int32_t,const RefPtr<WantWrap> &)> && onTerminated,NG::SessionType sessionType)244 void UIExtensionModelNG::SetOnTerminated(
245     std::function<void(int32_t, const RefPtr<WantWrap>&)>&& onTerminated, NG::SessionType sessionType)
246 {
247     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
248     CHECK_NULL_VOID(frameNode);
249     if (sessionType == SessionType::SECURITY_UI_EXTENSION_ABILITY) {
250         auto eventHub = frameNode->GetEventHub<UIExtensionHub>();
251         CHECK_NULL_VOID(eventHub);
252         eventHub->SetOnTerminatedCallback(std::move(onTerminated));
253         return;
254     }
255 
256     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
257     pattern->SetOnTerminatedCallback(std::move(onTerminated));
258 }
259 
SetOnReceive(std::function<void (const AAFwk::WantParams &)> && onReceive,NG::SessionType sessionType)260 void UIExtensionModelNG::SetOnReceive(
261     std::function<void(const AAFwk::WantParams&)>&& onReceive, NG::SessionType sessionType)
262 {
263     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
264     CHECK_NULL_VOID(frameNode);
265     if (sessionType == SessionType::SECURITY_UI_EXTENSION_ABILITY) {
266         auto eventHub = frameNode->GetEventHub<UIExtensionHub>();
267         CHECK_NULL_VOID(eventHub);
268         eventHub->SetOnReceiveCallback(std::move(onReceive));
269         return;
270     }
271 
272     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
273     pattern->SetOnReceiveCallback(std::move(onReceive));
274 }
275 
SetOnError(std::function<void (int32_t code,const std::string & name,const std::string & message)> && onError,NG::SessionType sessionType)276 void UIExtensionModelNG::SetOnError(
277     std::function<void(int32_t code, const std::string& name, const std::string& message)>&& onError,
278     NG::SessionType sessionType)
279 {
280     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
281     CHECK_NULL_VOID(frameNode);
282     if (sessionType == SessionType::SECURITY_UI_EXTENSION_ABILITY) {
283         auto pattern = frameNode->GetPattern<SecurityUIExtensionPattern>();
284         CHECK_NULL_VOID(pattern);
285         pattern->SetOnErrorCallback(std::move(onError));
286         return;
287     }
288 
289     auto pattern = frameNode->GetPattern<UIExtensionPattern>();
290     CHECK_NULL_VOID(pattern);
291     pattern->SetOnErrorCallback(std::move(onError));
292 }
293 
SetPlatformOnError(std::function<void (int32_t code,const std::string & name,const std::string & message)> && onError)294 void UIExtensionModelNG::SetPlatformOnError(
295     std::function<void(int32_t code, const std::string& name, const std::string& message)>&& onError)
296 {
297     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
298     CHECK_NULL_VOID(frameNode);
299     auto pattern = frameNode->GetPattern<IsolatedPattern>();
300     CHECK_NULL_VOID(pattern);
301     pattern->SetOnErrorCallback(std::move(onError));
302 }
303 } // namespace OHOS::Ace::NG
304