1  /*
2   * Copyright (c) 2022-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  #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_XCOMPONENT_XCOMPONENT_PATTERN_H
17  #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_XCOMPONENT_XCOMPONENT_PATTERN_H
18  
19  #include <optional>
20  #include <string>
21  #include <utility>
22  
23  #include "base/geometry/dimension.h"
24  #include "base/geometry/ng/offset_t.h"
25  #include "base/geometry/ng/rect_t.h"
26  #include "base/geometry/ng/size_t.h"
27  #include "base/geometry/size.h"
28  #include "base/memory/referenced.h"
29  #include "base/utils/utils.h"
30  #include "core/common/thread_checker.h"
31  #include "core/components/common/layout/constants.h"
32  #include "core/components/xcomponent/native_interface_xcomponent_impl.h"
33  #include "core/components_ng/event/focus_hub.h"
34  #include "core/components_ng/event/input_event.h"
35  #include "core/components_ng/pattern/pattern.h"
36  #include "core/components_ng/pattern/xcomponent/inner_xcomponent_controller.h"
37  #include "core/components_ng/pattern/xcomponent/xcomponent_accessibility_provider.h"
38  #include "core/components_ng/pattern/xcomponent/xcomponent_event_hub.h"
39  #include "core/components_ng/pattern/xcomponent/xcomponent_layout_algorithm.h"
40  #include "core/components_ng/pattern/xcomponent/xcomponent_layout_property.h"
41  #include "core/components_ng/pattern/xcomponent/xcomponent_paint_method.h"
42  #include "core/components_ng/property/property.h"
43  #include "core/components_ng/render/render_surface.h"
44  #include "core/pipeline_ng/pipeline_context.h"
45  #include "core/components_ng/manager/display_sync/ui_display_sync.h"
46  #include "core/gestures/velocity.h"
47  
48  namespace OHOS::Ace {
49  class ImageAnalyzerManager;
50  }
51  namespace OHOS::Ace::NG {
52  class XComponentExtSurfaceCallbackClient;
53  class XComponentPattern : public Pattern {
54      DECLARE_ACE_TYPE(XComponentPattern, Pattern);
55  
56  public:
57      XComponentPattern() = default;
58      XComponentPattern(const std::optional<std::string>& id, XComponentType type,
59          const std::optional<std::string>& libraryname,
60          const std::shared_ptr<InnerXComponentController>& xcomponentController, float initWidth = 0.0f,
61          float initHeight = 0.0f, bool isTypedNode = false);
62      ~XComponentPattern() override = default;
63  
64      void OnAttachToMainTree() override;
65      void OnDetachFromMainTree() override;
66  
IsAtomicNode()67      bool IsAtomicNode() const override
68      {
69          return type_ == XComponentType::SURFACE || type_ == XComponentType::TEXTURE || type_ == XComponentType::NODE;
70      }
71  
CreateLayoutProperty()72      RefPtr<LayoutProperty> CreateLayoutProperty() override
73      {
74          return MakeRefPtr<XComponentLayoutProperty>();
75      }
76  
CreateEventHub()77      RefPtr<EventHub> CreateEventHub() override
78      {
79          return MakeRefPtr<XComponentEventHub>();
80      }
81  
CreateLayoutAlgorithm()82      RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
83      {
84          return MakeRefPtr<XComponentLayoutAlgorithm>();
85      }
86  
CreateNodePaintMethod()87      RefPtr<NodePaintMethod> CreateNodePaintMethod() override
88      {
89          if (type_ == XComponentType::TEXTURE) {
90              auto paint = MakeRefPtr<XComponentPaintMethod>(renderSurface_, AceType::Claim(this));
91              return paint;
92          }
93          return nullptr;
94      }
95  
GetFocusPattern()96      FocusPattern GetFocusPattern() const override
97      {
98          if (type_ == XComponentType::NODE) {
99              return { FocusType::SCOPE, true };
100          }
101          FocusPattern focusPattern = { FocusType::NODE, false };
102          focusPattern.SetIsFocusActiveWhenFocused(true);
103          return focusPattern;
104      }
105  
NeedSoftKeyboard()106      bool NeedSoftKeyboard() const override
107      {
108          return nativeXComponentImpl_ ? nativeXComponentImpl_->IsNeedSoftKeyboard() : false;
109      }
110  
GetNativeXComponent()111      std::pair<RefPtr<OHOS::Ace::NativeXComponentImpl>, std::weak_ptr<OH_NativeXComponent>> GetNativeXComponent()
112      {
113          if (!nativeXComponent_ || !nativeXComponentImpl_) {
114              // for XComponentType::NODE
115              nativeXComponentImpl_ = AceType::MakeRefPtr<NativeXComponentImpl>();
116              nativeXComponent_ = std::make_shared<OH_NativeXComponent>(AceType::RawPtr(nativeXComponentImpl_));
117          }
118          return std::make_pair(nativeXComponentImpl_, nativeXComponent_);
119      }
120  
121      void NativeXComponentDispatchTouchEvent(const OH_NativeXComponent_TouchEvent& touchEvent,
122          const std::vector<XComponentTouchPoint>& xComponentTouchPoints);
123      void NativeXComponentDispatchMouseEvent(const OH_NativeXComponent_MouseEvent& mouseEvent);
124      void NativeXComponentDispatchAxisEvent(AxisEvent* axisEvent);
125  
126      void InitXComponent();
127      void InitNativeXComponent();
128      void InitNativeWindow(float textureWidth, float textureHeight);
129      void XComponentSizeInit();
130      void XComponentSizeChange(const RectF& surfaceRect, bool needFireNativeEvent);
NativeXComponentInit()131      void NativeXComponentInit()
132      {
133          if (!isTypedNode_) {
134              OnSurfaceCreated();
135          }
136      }
137  
GetId()138      std::string GetId() const
139      {
140          if (id_.has_value()) {
141              return id_.value();
142          }
143          auto host = GetHost();
144          return "nodeId:" + (host ? std::to_string(host->GetId()) : "-1");
145      }
146  
SetId(const std::string & id)147      void SetId(const std::string& id)
148      {
149          id_ = id;
150      }
151  
GetLibraryName()152      const std::optional<std::string>& GetLibraryName() const
153      {
154          return libraryname_;
155      }
156  
SetLibraryName(const std::optional<std::string> & libraryname)157      void SetLibraryName(const std::optional<std::string>& libraryname)
158      {
159          libraryname_ = libraryname;
160      }
161  
GetSoPath()162      const std::optional<std::string>& GetSoPath() const
163      {
164          return soPath_;
165      }
166  
SetSoPath(const std::string & soPath)167      void SetSoPath(const std::string& soPath)
168      {
169          soPath_ = soPath;
170      }
171  
GetType()172      XComponentType GetType()
173      {
174          return type_;
175      }
176  
SetType(XComponentType type)177      void SetType(XComponentType type)
178      {
179          type_ = type;
180      }
181  
GetDrawSize()182      const SizeF& GetDrawSize() const
183      {
184          return drawSize_;
185      }
186  
GetSurfaceSize()187      const SizeF& GetSurfaceSize() const
188      {
189          return surfaceSize_;
190      }
191  
GetSurfaceOffset()192      const OffsetF& GetSurfaceOffset() const
193      {
194          return surfaceOffset_;
195      }
196  
197      OffsetF GetOffsetRelativeToWindow();
198  
GetRenderContextForSurface()199      const RefPtr<RenderContext>& GetRenderContextForSurface()
200      {
201          return renderContextForSurface_;
202      }
203  
204      void SetSurfaceRotation(bool isLock);
205  
GetSurfaceRotation()206      bool GetSurfaceRotation()
207      {
208          return isSurfaceLock_;
209      }
210  
SetIsTypeNode(bool isTypeNode)211      void SetIsTypeNode(bool isTypeNode)
212      {
213          isTypedNode_ = isTypeNode;
214      }
215  
GetXComponentController()216      std::shared_ptr<InnerXComponentController> GetXComponentController()
217      {
218          return xcomponentController_;
219      }
220  
221      void SetHandlingRenderContextForSurface(const RefPtr<RenderContext>& otherRenderContext);
222  
223      void RestoreHandlingRenderContextForSurface();
224  
225      XComponentControllerErrorCode SetExtController(const RefPtr<XComponentPattern>& extPattern);
226      XComponentControllerErrorCode ResetExtController(const RefPtr<XComponentPattern>& extPattern);
227  
SetExpectedRateRangeInit()228      void SetExpectedRateRangeInit()
229      {
230          CHECK_NULL_VOID(nativeXComponentImpl_);
231          nativeXComponentImpl_->SetExpectedRateRangeEventCallback([weak = AceType::WeakClaim(this)]() {
232              auto xComponentPattern = weak.Upgrade();
233              CHECK_NULL_VOID(xComponentPattern);
234              xComponentPattern->HandleSetExpectedRateRangeEvent();
235          });
236      }
237  
OnFrameEventInit()238      void OnFrameEventInit()
239      {
240          CHECK_NULL_VOID(nativeXComponentImpl_);
241          nativeXComponentImpl_->SetOnFrameEventCallback([weak = AceType::WeakClaim(this)]() {
242              auto xComponentPattern = weak.Upgrade();
243              CHECK_NULL_VOID(xComponentPattern);
244              xComponentPattern->HandleOnFrameEvent();
245          });
246      }
247  
UnregisterOnFrameEventInit()248      void UnregisterOnFrameEventInit()
249      {
250          CHECK_NULL_VOID(nativeXComponentImpl_);
251          nativeXComponentImpl_->SetUnregisterOnFrameEventCallback([weak = AceType::WeakClaim(this)]() {
252              auto xComponentPattern = weak.Upgrade();
253              CHECK_NULL_VOID(xComponentPattern);
254              xComponentPattern->HandleUnregisterOnFrameEvent();
255          });
256      }
257  
SetXcomponentInit(bool isInit)258      void SetXcomponentInit(bool isInit)
259      {
260          hasXComponentInit_ = isInit;
261      }
262  
263      bool ChangeRenderType(NodeRenderType renderType);
264  
SetRenderType(NodeRenderType renderType)265      void SetRenderType(NodeRenderType renderType)
266      {
267          renderType_ = renderType;
268      }
269  
UpdateTransformHintChangedCallbackId(std::optional<int32_t> id)270      void UpdateTransformHintChangedCallbackId(std::optional<int32_t> id)
271      {
272          transformHintChangedCallbackId_ = id;
273      }
274  
HasTransformHintChangedCallbackId()275      bool HasTransformHintChangedCallbackId()
276      {
277          return transformHintChangedCallbackId_.has_value();
278      }
279  
NeedTriggerLoadEventImmediately()280      bool NeedTriggerLoadEventImmediately() const
281      {
282          return isTypedNode_ && isNativeXComponent_ && hasLoadNativeDone_;
283      }
284  
285      void SetExportTextureSurfaceId(const std::string& surfaceId);
286      void FireExternalEvent(RefPtr<NG::PipelineContext> context,
287          const std::string& componentId, const uint32_t nodeId, const bool isDestroy);
288      void ConfigSurface(uint32_t surfaceWidth, uint32_t surfaceHeight);
289  
290      // accessibility
291      void InitializeAccessibility();
292      void UninitializeAccessibility();
293      bool OnAccessibilityChildTreeRegister(uint32_t windowId, int32_t treeId);
294      bool OnAccessibilityChildTreeDeregister();
295      void OnSetAccessibilityChildTree(int32_t childWindowId, int32_t childTreeId);
SetAccessibilityState(bool state)296      void SetAccessibilityState(bool state) {}
297      RefPtr<AccessibilitySessionAdapter> GetAccessibilitySessionAdapter() override;
298      void InitializeAccessibilityCallback();
299      void HandleRegisterAccessibilityEvent(bool isRegister);
300  
301      void SetIdealSurfaceWidth(float surfaceWidth);
302      void SetIdealSurfaceHeight(float surfaceHeight);
303      void SetIdealSurfaceOffsetX(float offsetX);
304      void SetIdealSurfaceOffsetY(float offsetY);
305      void ClearIdealSurfaceOffset(bool isXAxis);
306      std::tuple<bool, bool, bool> UpdateSurfaceRect();
307      void HandleSurfaceChangeEvent(bool needForceRender, bool offsetChanged, bool sizeChanged, bool needFireNativeEvent,
308          bool frameOffsetChange = false);
309      void EnableAnalyzer(bool enable);
310      void SetImageAIOptions(void* options);
311      void StartImageAnalyzer(void* config, OnAnalyzedCallback& onAnalyzed);
312      void StopImageAnalyzer();
313      RectF AdjustPaintRect(float positionX, float positionY, float width, float height, bool isRound);
314      float RoundValueToPixelGrid(float value, bool isRound, bool forceCeil, bool forceFloor);
315      void OnSurfaceDestroyed();
316      void SetRenderFit(RenderFit renderFit);
317      void HandleSurfaceCreated();
318      void HandleSurfaceDestroyed();
ChangeSurfaceCallbackMode(SurfaceCallbackMode mode)319      void ChangeSurfaceCallbackMode(SurfaceCallbackMode mode)
320      {
321          if (surfaceCallbackModeChangeEvent_) {
322              surfaceCallbackModeChangeEvent_(mode);
323          }
324      }
325      void OnSurfaceCallbackModeChange(SurfaceCallbackMode mode);
326      void EnableSecure(bool isSecure);
327  
328  private:
329      void OnAttachToFrameNode() override;
330      void OnDetachFromFrameNode(FrameNode* frameNode) override;
331      void BeforeSyncGeometryProperties(const DirtySwapConfig& config) override;
332      void OnRebuildFrame() override;
333      void OnAreaChangedInner() override;
334      void OnWindowHide() override;
335      void OnWindowShow() override;
336      void OnModifyDone() override;
337      void DumpInfo() override;
338      void DumpAdvanceInfo() override;
339      void OnAttachContext(PipelineContext *context) override;
340      void OnDetachContext(PipelineContext *context) override;
341      void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const override;
342  
343      void NativeXComponentOffset(double x, double y);
344  
345      void LoadNative();
346      void OnNativeLoad(FrameNode* frameNode);
347      void OnNativeUnload(FrameNode* frameNode);
348  
349      void OnSurfaceCreated();
350      void OnSurfaceChanged(const RectF& surfaceRect, bool needResizeNativeWindow);
351  
352      void NativeSurfaceShow();
353      void NativeSurfaceHide();
354  
355      void Initialize();
356      void InitController();
357      void InitSurface();
358      void InitNativeNodeCallbacks();
359      void InitEvent();
360      void InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub);
361      void InitOnTouchIntercept(const RefPtr<GestureEventHub>& gestureHub);
362      void InitAxisEvent(const RefPtr<InputEventHub>& inputHub);
363      void HandleTouchEvent(const TouchEventInfo& info);
364      void InitMouseEvent(const RefPtr<InputEventHub>& inputHub);
365      void HandleMouseEvent(const MouseInfo& info);
366      void HandleAxisEvent(const AxisInfo& info);
367      void InitMouseHoverEvent(const RefPtr<InputEventHub>& inputHub);
368      void HandleMouseHoverEvent(bool isHover);
369      void InitFocusEvent(const RefPtr<FocusHub>& focusHub);
370      void HandleFocusEvent();
371      bool HandleKeyEvent(const KeyEvent& event);
372      void HandleBlurEvent();
373      ExternalEvent CreateExternalEvent();
374  
375      void SetTouchPoint(
376          const std::list<TouchLocationInfo>& touchInfoList, int64_t timeStamp, const TouchType& touchType);
377      void HandleSetExpectedRateRangeEvent();
378      void HandleOnFrameEvent();
379      void HandleUnregisterOnFrameEvent();
380      bool ExportTextureAvailable();
381      void AddAfterLayoutTaskForExportTexture();
382      bool DoTextureExport();
383      bool StopTextureExport();
384      void InitializeRenderContext();
385      void SetSurfaceNodeToGraphic();
386      bool IsSupportImageAnalyzerFeature();
387      void CreateAnalyzerOverlay();
388      void DestroyAnalyzerOverlay();
389      void UpdateAnalyzerOverlay();
390      void UpdateAnalyzerUIConfig(const RefPtr<NG::GeometryNode>& geometryNode);
391      void ReleaseImageAnalyzer();
392      void UpdateTransformHint();
393      void SetRotation(uint32_t rotation);
394      void RegisterSurfaceCallbackModeEvent();
395  
396  #ifdef RENDER_EXTRACT_SUPPORTED
397      RenderSurface::RenderSurfaceType CovertToRenderSurfaceType(const XComponentType& hostType);
398      void RegisterRenderContextCallBack();
399      void RequestFocus();
400  #endif
401  
402      std::vector<OH_NativeXComponent_HistoricalPoint> SetHistoryPoint(const std::list<TouchLocationInfo>& touchInfoList);
403      std::optional<std::string> id_;
404      XComponentType type_;
405      std::optional<std::string> libraryname_;
406      std::shared_ptr<InnerXComponentController> xcomponentController_;
407      std::optional<std::string> soPath_;
408  
409      RefPtr<RenderSurface> renderSurface_;
410      RefPtr<RenderContext> renderContextForSurface_;
411      RefPtr<RenderContext> handlingSurfaceRenderContext_;
412      WeakPtr<XComponentPattern> extPattern_;
413  
414      std::shared_ptr<OH_NativeXComponent> nativeXComponent_;
415      RefPtr<NativeXComponentImpl> nativeXComponentImpl_;
416  
417      bool hasXComponentInit_ = false;
418  
419      RefPtr<TouchEventImpl> touchEvent_;
420      OH_NativeXComponent_TouchEvent touchEventPoint_ = {};
421      RefPtr<InputEvent> mouseEvent_;
422      RefPtr<InputEvent> axisEvent_;
423      RefPtr<InputEvent> mouseHoverEvent_;
424      std::vector<XComponentTouchPoint> nativeXComponentTouchPoints_;
425      RefPtr<XComponentExtSurfaceCallbackClient> extSurfaceClient_;
426      SizeF initSize_;
427      OffsetF localPosition_;
428      OffsetF globalPosition_;
429      OffsetF surfaceOffset_;
430      SizeF drawSize_;
431      SizeF surfaceSize_;
432      RectF paintRect_;
433      RefPtr<UIDisplaySync> displaySync_ = AceType::MakeRefPtr<UIDisplaySync>(UIObjectType::DISPLAYSYNC_XCOMPONENT);
434  
435      std::optional<float> selfIdealSurfaceWidth_;
436      std::optional<float> selfIdealSurfaceHeight_;
437      std::optional<float> selfIdealSurfaceOffsetX_;
438      std::optional<float> selfIdealSurfaceOffsetY_;
439      std::string surfaceId_;
440      void* nativeWindow_ = nullptr;
441  
442      bool isSurfaceLock_ = false;
443      uint32_t windowId_ = 0;
444      int32_t treeId_ = 0;
445      std::shared_ptr<AccessibilityChildTreeCallback> accessibilityChildTreeCallback_;
446      RefPtr<XComponentAccessibilityProvider> accessibilityProvider_;
447      RefPtr<AccessibilitySessionAdapter> accessibilitySessionAdapter_;
448  
449      // for export texture
450      NodeRenderType renderType_ = NodeRenderType::RENDER_TYPE_DISPLAY;
451      uint64_t exportTextureSurfaceId_ = 0U;
452      bool hasReleasedSurface_ = false;
453      std::shared_ptr<ImageAnalyzerManager> imageAnalyzerManager_;
454      bool isEnableAnalyzer_ = false;
455      std::optional<int32_t> transformHintChangedCallbackId_;
456      uint32_t rotation_ = 0;
457      bool isTypedNode_ = false;
458      bool isNativeXComponent_ = false;
459      bool hasLoadNativeDone_ = false;
460      bool isEnableSecure_ = false;
461      SurfaceCallbackMode surfaceCallbackMode_ = SurfaceCallbackMode::DEFAULT;
462      std::function<void(SurfaceCallbackMode)> surfaceCallbackModeChangeEvent_;
463  };
464  } // namespace OHOS::Ace::NG
465  
466  #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_XCOMPONENT_XCOMPONENT_PATTERN_H
467