• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
18 
19 #include <cstdint>
20 #include <string>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/utils/noncopyable.h"
24 #include "core/common/clipboard/clipboard.h"
25 #include "core/common/interaction/interaction_data.h"
26 #include "core/common/udmf/udmf_client.h"
27 #include "core/components_ng/base/frame_node.h"
28 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h"
29 #include "core/components_ng/manager/drag_drop/utils/internal_drag_action.h"
30 #include "core/event/pointer_event.h"
31 #include "core/gestures/velocity_tracker.h"
32 
33 namespace OHOS::Ace {
34 class UnifiedData;
35 class GridColumnInfo;
36 }
37 namespace OHOS::Rosen {
38 class RSSyncTransactionController;
39 class RSSyncTransactionHandler;
40 } // namespace OHOS::Rosen
41 namespace OHOS::Ace::NG {
42 class DragDropSpringLoadingDetector;
43 enum class DragDropMgrState : int32_t {
44     IDLE,
45     ABOUT_TO_PREVIEW,
46     DRAGGING
47 };
48 
49 struct GatherAnimationInfo {
50     float scale = 0.0f;
51     float width = 0.0f;
52     float height = 0.0f;
53     OffsetF gatherNodeCenter;
54     std::optional<BorderRadiusProperty> borderRadius;
55 };
56 
57 struct ScaleDataInfo {
58     bool isNeedScale = false;
59     double scale = 1.0f;
60     float shortSide = 0.0f;
61 };
62 
63 class ACE_EXPORT DragDropManager : public virtual AceType {
64     DECLARE_ACE_TYPE(DragDropManager, AceType);
65 
66 public:
67     DragDropManager();
68     ~DragDropManager() override = default;
69 
70     RefPtr<DragDropProxy> CreateAndShowItemDragOverlay(
71         const RefPtr<PixelMap>& pixelMap, const GestureEvent& info, const RefPtr<EventHub>& eventHub);
72     RefPtr<DragDropProxy> CreateAndShowItemDragOverlay(
73         const RefPtr<UINode>& customNode, const GestureEvent& info, const RefPtr<EventHub>& eventHub);
74     RefPtr<DragDropProxy> CreateTextDragDropProxy();
75 
76     void RemoveDragFrameNode(int32_t id);
77 
AddGridDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)78     void AddGridDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
79     {
80         gridDragFrameNodes_.try_emplace(id, dragFrameNode);
81     }
82 
AddListDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)83     void AddListDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
84     {
85         listDragFrameNodes_.try_emplace(id, dragFrameNode);
86     }
87 
AddTextFieldDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)88     void AddTextFieldDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
89     {
90         textFieldDragFrameNodes_.try_emplace(id, dragFrameNode);
91     }
92 
SetEventStrictReportingEnabled(bool dragEventStrictReportingEnabled)93     void SetEventStrictReportingEnabled(bool dragEventStrictReportingEnabled)
94     {
95         eventStrictReportingEnabled_ = dragEventStrictReportingEnabled;
96     }
97 
IsEventStrictReportingEnabled()98     bool IsEventStrictReportingEnabled()
99     {
100         return eventStrictReportingEnabled_;
101     }
102 
GetCurrentAnimationCnt()103     int32_t GetCurrentAnimationCnt() const
104     {
105         return currentAnimationCnt_;
106     }
107 
SetCurrentAnimationCnt(int32_t value)108     void SetCurrentAnimationCnt(int32_t value)
109     {
110         currentAnimationCnt_ = value;
111     }
112 
GetAllAnimationCnt()113     int32_t GetAllAnimationCnt() const
114     {
115         return allAnimationCnt_;
116     }
117 
SetAllAnimationCnt(int32_t value)118     void SetAllAnimationCnt(int32_t value)
119     {
120         allAnimationCnt_ = value;
121     }
122 
123     void UpdateItemDragPosition(int32_t globalX, int32_t globalY);
124     void OnDragStart(const Point& point);
125     void OnDragStart(const Point& point, const RefPtr<FrameNode>& frameNode);
126     void OnDragStartForDragEvent(const DragPointerEvent& pointerEvent, const RefPtr<FrameNode>& frameNode);
127     void OnDragMove(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
128         const RefPtr<FrameNode>& node = nullptr);
129     void OnDragEnd(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
130         const RefPtr<FrameNode>& node = nullptr, const bool keyEscape = false);
131     bool HandleUIExtensionComponentDragCancel(const RefPtr<FrameNode>& preTargetFrameNode,
132         const RefPtr<FrameNode>& dragFrameNode, const bool keyEscape, const DragPointerEvent& pointerEvent,
133         const Point& point);
134     void HandleOnDragMove(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
135         const RefPtr<FrameNode>& dragFrameNode);
136     void HandleOnDragEnd(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
137         const RefPtr<FrameNode>& dragFrameNode);
138     void OnDragThrow(const DragPointerEvent& pointerEvent);
139     void OnDragPullCancel(const DragPointerEvent& pointerEvent);
140     void ResetDragEndOption(
141         const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent, int32_t currentId);
142     void DoDragReset();
143     void DoDropAction(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
144         const RefPtr<UnifiedData>& unifiedData, const std::string& udKey);
145     void RequestDragSummaryInfoAndPrivilege();
146     RefPtr<UnifiedData> RequestUDMFDataWithUDKey(const std::string& udKey);
147     void TryGetDataBackGround(
148         const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
149         const std::string& udKey, int32_t count = 0);
150     void OnDragDrop(RefPtr<OHOS::Ace::DragEvent>& event, const RefPtr<FrameNode>& dragFrameNode,
151         const OHOS::Ace::DragPointerEvent& pointerEvent);
152     std::function<void(const DragRet&)> GetStopDragCallBack(const RefPtr<FrameNode>& dragFrameNode,
153         const DragPointerEvent& pointerEvent, const RefPtr<OHOS::Ace::DragEvent>& event,
154         const std::string& extraParams);
155     bool PostStopDrag(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
156         const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
157     void HandleStopDrag(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
158         const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
159     void ExecuteStopDrag(const RefPtr<OHOS::Ace::DragEvent>& event, DragRet dragResult, bool useCustomAnimation,
160         int32_t windowId, DragBehavior dragBehavior, const OHOS::Ace::DragPointerEvent& pointerEvent);
161     void ExecuteCustomDropAnimation(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, DragDropRet dragDropRet);
162     void ResetDragDropStatus(const Point& point, const DragDropRet& dragDropRet, int32_t windowId);
163     bool CheckRemoteData(
164         const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent, const std::string& udKey);
165     void OnDragMoveOut(const DragPointerEvent& pointerEvent);
166     void HandleDragEvent(const DragPointerEvent& pointerEvent, DragEventAction action,
167         const RefPtr<FrameNode>& node = nullptr);
168     void OnTextDragEnd(float globalX, float globalY, const std::string& extraInfo);
169     void onDragCancel();
170     void OnDragAsyncEnd();
171     void SetCallAnsyncDragEnd(const std::function<void(DragStartRequestStatus)>& cb);
172     void OnItemDragStart(float globalX, float globalY, const RefPtr<FrameNode>& frameNode);
173     void OnItemDragMove(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
174     void OnItemDragEnd(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
175     void onItemDragCancel();
176     void AddDataToClipboard(const std::string& extraInfo);
177     void GetExtraInfoFromClipboard(std::string& extraInfo);
178     void RestoreClipboardData();
179     void DestroyDragWindow();
180     void CancelItemDrag();
181     std::string GetExtraInfo();
182     void SetExtraInfo(const std::string& extraInfo);
183     void ClearExtraInfo();
184     float GetWindowScale() const;
185     void UpdateDragCursorStyle(const RefPtr<FrameNode>& frameNode, const RefPtr<OHOS::Ace::DragEvent>& event,
186         const int32_t eventId = -1);
187     void UpdateDragStyle(
188         const DragCursorStyleCore& dragCursorStyleCore = DragCursorStyleCore::DEFAULT, const int32_t eventId = -1);
189     void UpdateDragAllowDrop(const RefPtr<FrameNode>& dragFrameNode, const DragBehavior dragBehavior,
190         const int32_t eventId = -1, bool isCapi = false);
191     bool CheckExtraSituation(const RefPtr<FrameNode>& dragFrameNode) const;
192     bool CheckInRichEditor(const RefPtr<FrameNode>& dragFrameNode) const;
193     void RequireSummary();
194     void ClearSummary();
SetSummaryMap(const std::map<std::string,int64_t> & summaryMap)195     void SetSummaryMap(const std::map<std::string, int64_t>& summaryMap)
196     {
197         summaryMap_ = summaryMap;
198     }
GetSummaryMap()199     const std::map<std::string, int64_t>& GetSummaryMap()
200     {
201         return summaryMap_;
202     }
203     void ResetRecordSize(uint32_t recordSize = 0);
204     uint32_t GetRecordSize() const;
205     Rect GetDragWindowRect(const Point& point);
206     RefPtr<DragDropProxy> CreateFrameworkDragDropProxy();
207     void HideDragPreviewOverlay();
208     void HideDragPreviewWindow(int32_t containerId);
209     void HideSubwindowDragNode();
210     bool IsMSDPDragging() const;
211     void UpdateDragEvent(RefPtr<OHOS::Ace::DragEvent>& event, const OHOS::Ace::DragPointerEvent& pointerEvent);
212     void UpdateNotifyDragEvent(
213         RefPtr<NotifyDragEvent>& notifyEvent, const Point& point, const DragEventType dragEventType);
214     bool CheckDragDropProxy(int64_t id) const;
215     void NotifyEnterTextEditorArea();
216     void FireOnEditableTextComponent(const RefPtr<FrameNode>& frameNode, DragEventType type);
217     void FireOnDragLeave(const RefPtr<FrameNode>& preTargetFrameNode_, const DragPointerEvent& pointerEven,
218         const std::string& extraInfo);
219 
IsWindowConsumed()220     bool IsWindowConsumed() const
221     {
222         return isWindowConsumed_;
223     }
224 
SetIsWindowConsumed(bool consumed)225     void SetIsWindowConsumed(bool consumed)
226     {
227         isWindowConsumed_ = consumed;
228     }
229 
IsDragged()230     bool IsDragged() const
231     {
232         return isDragged_;
233     }
234 
235     void SetIsDragged(bool isDragged);
236 
SetDragDampStartPoint(const Point & point)237     void SetDragDampStartPoint(const Point& point)
238     {
239         dragDampStartPoint_ = point;
240     }
241 
GetDragDampStartPoint()242     const Point& GetDragDampStartPoint() const
243     {
244         return dragDampStartPoint_;
245     }
246 
SetIsDragCancel(bool isDragCancel)247     void SetIsDragCancel(bool isDragCancel)
248     {
249         isDragCancel_ = isDragCancel;
250     }
251 
IsMouseDrag()252     bool IsMouseDrag() const
253     {
254         return isMouseDragged_;
255     }
256 
SetIsMouseDrag(bool isMouseDragged)257     void SetIsMouseDrag(bool isMouseDragged)
258     {
259         isMouseDragged_ = isMouseDragged;
260     }
261 
SetIsDragWindowShow(bool isDragWindowShow)262     void SetIsDragWindowShow(bool isDragWindowShow)
263     {
264         isDragWindowShow_ = isDragWindowShow;
265     }
266 
IsDragWindowShow()267     bool IsDragWindowShow() const
268     {
269         return isDragWindowShow_;
270     }
271 
SetPreviewRect(const Rect & rect)272     void SetPreviewRect(const Rect& rect)
273     {
274         previewRect_ = rect;
275     }
276 
GetPreviewRect()277     Rect GetPreviewRect() const
278     {
279         return previewRect_;
280     }
281 
SetDragCursorStyleCore(DragCursorStyleCore dragCursorStyleCore)282     void SetDragCursorStyleCore(DragCursorStyleCore dragCursorStyleCore)
283     {
284         dragCursorStyleCore_ = dragCursorStyleCore;
285     }
286 
GetDragAction()287     std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> GetDragAction()
288     {
289         return dragAction_;
290     }
291 
292     RefPtr<FrameNode> FindTargetInChildNodes(const RefPtr<UINode> parentNode,
293         std::vector<RefPtr<FrameNode>> hitFrameNodes, bool findDrop);
294 
295     bool CheckFrameNodeCanDrop(const RefPtr<FrameNode>& node);
296 
297     RefPtr<FrameNode> FindTargetDropNode(const RefPtr<UINode> parentNode, PointF localPoint);
298 
299     std::unordered_set<int32_t> FindHitFrameNodes(const Point& point);
300 
301     void UpdateDragListener(const Point& point);
302 
303     void NotifyDragRegisterFrameNode(std::unordered_map<int32_t, WeakPtr<FrameNode>> nodes, DragEventType dragEventType,
304         RefPtr<NotifyDragEvent>& notifyEvent);
305 
306     void RegisterDragStatusListener(int32_t nodeId, const WeakPtr<FrameNode>& node);
307 
UnRegisterDragStatusListener(int32_t nodeId)308     void UnRegisterDragStatusListener(int32_t nodeId)
309     {
310         nodesForDragNotify_.erase(nodeId);
311     }
312 
313     void RegisterPullEventListener(int32_t uniqueIdentify, std::function<void(const DragPointerEvent&)> callback);
314 
315     void UnRegisterPullEventListener(int32_t uniqueIdentify);
316 
317     void NotifyPullEventListener(const DragPointerEvent& dragPointerEvent);
318 
SetNotifyInDraggedCallback(const std::function<void (void)> & callback)319     void SetNotifyInDraggedCallback(const std::function<void(void)>& callback)
320     {
321         notifyInDraggedCallback_ = callback;
322     }
323 
IsDragging()324     bool IsDragging() const
325     {
326         return dragDropState_ == DragDropMgrState::DRAGGING;
327     }
328 
IsItemDragging()329     bool IsItemDragging() const
330     {
331         return dragDropState_ == DragDropMgrState::DRAGGING && draggedGridFrameNode_ != nullptr;
332     }
333 
IsAboutToPreview()334     bool IsAboutToPreview() const
335     {
336         return dragDropState_ == DragDropMgrState::ABOUT_TO_PREVIEW;
337     }
338 
339     void ResetDragging(DragDropMgrState dragDropMgrState = DragDropMgrState::IDLE)
340     {
341         dragDropState_ = dragDropMgrState;
342     }
343 
344     void ResetPreTargetFrameNode(int32_t instanceId);
345 
SetDraggingPressedState(bool pointerPressed)346     void SetDraggingPressedState(bool pointerPressed)
347     {
348         draggingPressedState_ = pointerPressed;
349     }
350 
351     bool IsDraggingPressed(int32_t currentPointerId) const;
352 
IsSameDraggingPointer(int32_t currentPointerId)353     bool IsSameDraggingPointer(int32_t currentPointerId) const
354     {
355         return currentPointerId_ == currentPointerId;
356     }
357 
SetDraggingPointer(int32_t currentPointerId)358     void SetDraggingPointer(int32_t currentPointerId)
359     {
360         currentPointerId_ = currentPointerId;
361     }
362 
IsEditableTextComponent(const std::string & frameTag)363     static inline bool IsEditableTextComponent(const std::string& frameTag)
364     {
365         if (frameTag != V2::TEXTINPUT_ETS_TAG && frameTag != V2::TEXTAREA_ETS_TAG &&
366             frameTag != V2::RICH_EDITOR_ETS_TAG && frameTag != V2::SEARCH_Field_ETS_TAG) {
367             return false;
368         }
369         return true;
370     }
371 
372     typedef struct DragPreviewInfo {
373         double width { 0.0 };
374         double height { 0.0 };
375         double maxWidth { 0.0 };
376         double scale { -1.0 };
377         VectorF originScale { 1.0f, 1.0f };
378         OffsetF originOffset;
379         RefPtr<FrameNode> imageNode { nullptr };
380         RefPtr<FrameNode> textNode { nullptr };
381         RefPtr<FrameNode> menuPreviewNode { nullptr };
382         RefPtr<FrameNode> menuPreviewImageNode { nullptr };
383         RefPtr<FrameNode> relativeContainerNode { nullptr };
384         RefPtr<FrameNode> stackNode { nullptr };
385         RefPtr<FrameNode> menuNode { nullptr };
386         RectF originPreviewRect;
387         RectF dragPreviewRect;
388         bool isMenuShow = false;
389         NG::DraggingSizeChangeEffect sizeChangeEffect = DraggingSizeChangeEffect::DEFAULT;
390         bool isDragController = false;
391     } DragPreviewInfo;
392     bool IsNeedScaleDragPreview();
393     void DoDragMoveAnimate(const DragPointerEvent& pointerEvent);
394     void DragMoveAnimation(const Offset& newOffset, const RefPtr<OverlayManager>& overlayManager, Point point);
395     void DragMoveDefaultAnimation(const RefPtr<OverlayManager>& overlayManager, const DragPreviewInfo& info,
396         AnimationOption option, const Offset& newOffset, Point point);
397     void DragMoveTransitionAnimation(const RefPtr<OverlayManager>& overlayManager, const DragPreviewInfo& info,
398         AnimationOption option, const Offset& newOffset, Point point);
399     void DoDragStartAnimation(const RefPtr<OverlayManager>& overlayManager,
400         const GestureEvent& event, const RefPtr<GestureEventHub>& gestureHub, PreparedInfoForDrag& data);
401     void DragStartAnimation(const Offset& newOffset, const RefPtr<OverlayManager>& overlayManager,
402         PreparedInfoForDrag& data, Point point = { 1, 1 });
403     void SetDragStartAnimationOption(AnimationOption& option, int32_t containerId);
404     void HandleStartDragAnimationFinish(int32_t containerId);
405     void SetDragResult(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
406     void SetDragBehavior(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
ResetDragPreviewInfo()407     void ResetDragPreviewInfo()
408     {
409         info_ = DragPreviewInfo();
410     }
411 
SetDragPreviewInfo(const DragPreviewInfo & newInfo)412     void SetDragPreviewInfo(const DragPreviewInfo& newInfo)
413     {
414         info_ = newInfo;
415     }
416 
GetDragPreviewInfo()417     DragPreviewInfo GetDragPreviewInfo() const
418     {
419         return info_;
420     }
421 
422     void ResetPullMoveReceivedForCurrentDrag(bool isPullMoveReceivedForCurrentDrag = false)
423     {
424         isPullMoveReceivedForCurrentDrag_ = isPullMoveReceivedForCurrentDrag;
425     }
426 
IsPullMoveReceivedForCurrentDrag()427     bool IsPullMoveReceivedForCurrentDrag() const
428     {
429         return isPullMoveReceivedForCurrentDrag_;
430     }
431 
432     void RemoveDeadlineTimer();
433 
434     void ExecuteDeadlineTimer();
435 
436     void HandleSyncOnDragStart(DragStartRequestStatus dragStartRequestStatus);
437 
438     const Point GetDragMoveLastPointByCurrentPointer(int32_t pointerId);
439 
440     void SetDelayDragCallBack(const std::function<void()>& cb) noexcept;
441 
IsStartAnimationFInished()442     bool IsStartAnimationFInished() const
443     {
444         return isStartAnimationFinished_;
445     }
446 
SetStartAnimation(bool flag)447     void SetStartAnimation(bool flag)
448     {
449         isStartAnimationFinished_ = flag;
450     }
451 
452     static OffsetF GetTouchOffsetRelativeToSubwindow(int32_t containerId, int32_t x = 0, int32_t y = 0);
453     static RectF GetMenuPreviewRect();
454     static void UpdateGatherNodeAttr(const RefPtr<OverlayManager>& overlayManager, const GatherAnimationInfo& info);
455     static void UpdateGatherNodePosition(const RefPtr<OverlayManager>& overlayManager,
456         const RefPtr<FrameNode>& imageNode);
457     static void UpdateTextNodePosition(const RefPtr<FrameNode>& textNode, const Offset& localPoint);
458     double CalcGatherNodeMaxDistanceWithPoint(const RefPtr<OverlayManager>& overlayManager, int32_t x, int32_t y);
459 
SetPixelMapOffset(OffsetF pixelMapOffset)460     void SetPixelMapOffset(OffsetF pixelMapOffset)
461     {
462         pixelMapOffset_ = pixelMapOffset;
463     }
464 
GetPixelMapOffset()465     OffsetF GetPixelMapOffset()
466     {
467         return pixelMapOffset_;
468     }
469 
SetCurPointerOffset(OffsetF curPointerOffset)470     void SetCurPointerOffset(OffsetF curPointerOffset)
471     {
472         curPointerOffset_ = curPointerOffset;
473     }
474 
475     bool IsNeedDisplayInSubwindow();
ClearGatherPixelMap()476     void ClearGatherPixelMap()
477     {
478         gatherPixelMaps_.clear();
479     }
480 
481     void PushGatherPixelMap(const RefPtr<PixelMap>& pixelMap);
482     void GetGatherPixelMap(DragDataCore& dragData, float scale, float previewWidth = 0.0f,
483         float previewHeight = 0.0f);
484 
GetDragDropPointerEvent()485     const DragPointerEvent& GetDragDropPointerEvent() const
486     {
487         return dragDropPointerEvent_;
488     }
489 
SetDragDropPointerEvent(const DragPointerEvent & dragDropPointerEvent)490     void SetDragDropPointerEvent(const DragPointerEvent& dragDropPointerEvent)
491     {
492         dragDropPointerEvent_ = dragDropPointerEvent;
493     }
494 
GetDragAnimationPointerEvent()495     const DragPointerEvent& GetDragAnimationPointerEvent() const
496     {
497         return dragAnimationPointerEvent_;
498     }
499 
500     void SetDragAnimationPointerEvent(
501         const DragPointerEvent& pointerEvent, const RefPtr<NG::FrameNode>& node = nullptr);
502 
IsDragFwkShow()503     bool IsDragFwkShow() const
504     {
505         return isDragFwkShow_;
506     }
507 
SetDragFwkShow(bool value)508     void SetDragFwkShow(bool value)
509     {
510         isDragFwkShow_ = value;
511     }
512 
SetIsShowBadgeAnimation(bool isShowBadgeAnimation)513     void SetIsShowBadgeAnimation(bool isShowBadgeAnimation)
514     {
515         isShowBadgeAnimation_ = isShowBadgeAnimation;
516     }
517 
IsShowBadgeAnimation()518     bool IsShowBadgeAnimation()
519     {
520         return isShowBadgeAnimation_;
521     }
522 
IsDragWithContextMenu()523     bool IsDragWithContextMenu() const
524     {
525         return isDragWithContextMenu_;
526     }
527 
SetIsDragWithContextMenu(bool isDragWithContextMenu)528     void SetIsDragWithContextMenu(bool isDragWithContextMenu)
529     {
530         isDragWithContextMenu_ = isDragWithContextMenu;
531     }
532 
533     void SetIsDragNodeNeedClean(bool isDragNodeNeedClean = false)
534     {
535         isDragNodeNeedClean_ = isDragNodeNeedClean;
536     }
537 
IsDragNodeNeedClean()538     bool IsDragNodeNeedClean() const
539     {
540         return isDragNodeNeedClean_;
541     }
542 
543     void UpdateDragMovePosition(const NG::OffsetF& offset, bool isRedragStart = false);
544 
545     void ResetContextMenuDragPosition();
546 
547     void ResetContextMenuRedragPosition();
548 
GetUpdateDragMovePosition()549     OffsetF GetUpdateDragMovePosition() const
550     {
551         return dragTotalMovePosition_;
552     }
553 
554     bool IsDropAllowed(const RefPtr<FrameNode>& dragFrameNode);
555 
SetDragAction(const std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> & dragAction)556     void SetDragAction(const std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction>& dragAction)
557     {
558         dragAction_ = dragAction;
559     }
560 
561     void AddNewDragAnimation();
562 
563     void AddNewDragStartAnimation();
564 
565     bool IsAllAnimationFinished();
566 
567     bool IsAllStartAnimationFinished();
568 
569     float GetCurrentDistance(float x, float y);
570 
GetDampingOverflowCount()571     uint32_t GetDampingOverflowCount() const
572     {
573         return dampingOverflowCount_;
574     }
575 
SetDampingOverflowCount(uint32_t count)576     void SetDampingOverflowCount(uint32_t count)
577     {
578         dampingOverflowCount_ = count;
579     }
580 
SetDampingOverflowCount()581     void SetDampingOverflowCount()
582     {
583         dampingOverflowCount_++;
584     }
585     static double GetMaxWidthBaseOnGridSystem(const RefPtr<PipelineBase>& pipeline);
586 
587     static std::shared_ptr<ScaleDataInfo> GetScaleInfo(float width, float height, bool textDraggable);
588 
589     static std::shared_ptr<ScaleDataInfo> CalculateScale(
590         float width, float height, float widthLimit, float heightLimit);
591 
GetMenuWrapperNode()592     RefPtr<FrameNode> GetMenuWrapperNode()
593     {
594         return menuWrapperNode_.Upgrade();
595     }
596 
SetMenuWrapperNode(const RefPtr<FrameNode> & frameNode)597     void SetMenuWrapperNode(const RefPtr<FrameNode>& frameNode)
598     {
599         menuWrapperNode_ = frameNode;
600     }
601 
602     bool CheckIsNewDrag(const DragPointerEvent& pointerEvent) const;
603 
604     void RequireSummaryAndDragBundleInfoIfNecessary(const DragPointerEvent& pointerEvent);
605 
ResetPullId()606     inline void ResetPullId()
607     {
608         summaryMap_.clear();
609         parentHitNodes_.clear();
610         currentPullId_ = -1;
611     }
612 
613     void SetIsDisableDefaultDropAnimation(bool disableDefaultDropAnimation = false)
614     {
615         disableDefaultDropAnimation_ = disableDefaultDropAnimation;
616     }
617 
IsDisableDefaultDropAnimation()618     bool IsDisableDefaultDropAnimation() const
619     {
620         return disableDefaultDropAnimation_;
621     }
622 
623     void ResetDraggingStatus(const TouchEvent& touchPoint);
624 
SetGrayedState(bool state)625     void SetGrayedState(bool state)
626     {
627         grayedState_ = state;
628     }
629 
GetGrayedState()630     bool GetGrayedState() const
631     {
632         return grayedState_;
633     }
634 
635     void SetIsAnyDraggableHit(bool isAnyDraggableHit = false)
636     {
637         isAnyDraggableHit_ = isAnyDraggableHit;
638     }
639 
640     bool IsAnyDraggableHit(const RefPtr<PipelineBase>& pipeline, int32_t pointId);
641 
642     RefPtr<FrameNode> GetRootNode();
643 
644     int32_t CancelUDMFDataLoading(const std::string& key);
645 
GetPreDragPointerEvent()646     const DragPointerEvent& GetPreDragPointerEvent() const
647     {
648         return preDragPointerEvent_;
649     }
650 
SetIsReDragStart(bool isReDragStart)651     void SetIsReDragStart(bool isReDragStart)
652     {
653         isReDragStart_ = isReDragStart;
654     }
655 
SetDragStartAnimationRate(float rate)656     void SetDragStartAnimationRate(float rate)
657     {
658         dragStartAnimationRate_ = rate;
659     }
660 
SetDragStartPoint(double globalX,double globalY)661     void SetDragStartPoint(double globalX, double globalY)
662     {
663         dragStartPoint_ = { globalX, globalY };
664     }
665 
666     bool CheckIsFolderSubwindowBoundary(float x, float y, int32_t instanceId);
667 
668     bool CheckIsUIExtensionBoundary(float x, float y, int32_t instanceId);
669 
670     void UpdatePointInfoForFinger(int32_t pointerId, Point point);
671 
672     void HandleTouchEvent(const TouchEvent& event, const RefPtr<NG::FrameNode>& node = nullptr);
673     void HandleMouseEvent(const MouseEvent& event);
674     void HandlePipelineOnHide();
675 
676     void ResetBundleInfo();
677 
678     void RequireBundleInfo();
679 
SetRootNode(RefPtr<FrameNode> & rootNode)680     void SetRootNode(RefPtr<FrameNode>& rootNode)
681     {
682         rootNode_ = rootNode;
683     }
684 
685 private:
686     double CalcDragPreviewDistanceWithPoint(
687         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
688     Offset CalcDragMoveOffset(
689         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
690     Offset CalcContentTrationOffset(
691         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
692     Offset CalculateNewOffset(
693         const RefPtr<FrameNode>& frameNode, const GestureEvent& event, bool isDragStartPending);
694     bool UpdateDragMovePositionFinished(
695         bool needDoDragMoveAnimate, bool isMenuShow, const Offset& newOffset, int32_t containerId);
696     void InitDragAnimationPointerEvent(const GestureEvent& event, bool isDragStartPending);
697     void UpdateDragPreviewScale();
698     bool GetDragPreviewInfo(const OHOS::Ace::RefPtr<OHOS::Ace::NG::OverlayManager>& overlayManager,
699         DragPreviewInfo& dragPreviewInfo, const RefPtr<GestureEventHub>& gestureHub, PreparedInfoForDrag& data);
700     void CopyPreparedInfoForDrag(DragPreviewInfo& dragPreviewInfo, PreparedInfoForDrag& data);
701     bool IsNeedDoDragMoveAnimate(const DragPointerEvent& pointerEvent);
702     const RefPtr<NG::OverlayManager> GetDragAnimationOverlayManager(int32_t containerId);
703     RefPtr<FrameNode> FindDragFrameNodeByPosition(float globalX, float globalY,
704         const RefPtr<FrameNode>& node = nullptr);
705     RefPtr<FrameNode> FilterSubwindowDragRootNode(const RefPtr<FrameNode>& node);
706     void FireOnDragEvent(
707         const RefPtr<FrameNode>& frameNode, const DragPointerEvent& pointerEvent,
708         DragEventType type, const std::string& extraInfo);
709     void FireOnItemDragEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
710         const ItemDragInfo& itemDragInfo, DragEventType type, int32_t draggedIndex, int32_t insertIndex = 0);
711     bool FireOnItemDropEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
712         const ItemDragInfo& itemDragInfo, int32_t draggedIndex, int32_t insertIndex, bool isSuccess);
713     int32_t GetItemIndex(const RefPtr<FrameNode>& frameNode, DragType dragType, float globalX, float globalY);
714     void CreateDragWindow(const GestureEvent& info, uint32_t width, uint32_t height);
715     RefPtr<FrameNode> CreateDragRootNode(const RefPtr<UINode>& customNode);
716     void ClearVelocityInfo();
717     void UpdateVelocityTrackerPoint(const Point& point, bool isEnd = false);
718     void PrintDragFrameNode(const OHOS::Ace::DragPointerEvent& pointerEvent, const RefPtr<FrameNode>& dragFrameNode);
719     void PrintGridDragFrameNode(const float globalX, const float globalY, const RefPtr<FrameNode>& dragFrameNode);
720     void FireOnDragEventWithDragType(const RefPtr<EventHub>& eventHub, DragEventType type,
721         RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
722     void FireOnDragSpringLoadingEventWithDragType(const RefPtr<FrameNode>& frameNode, const RefPtr<EventHub>& eventHub,
723         DragEventType type, const std::string& extraParams);
724     void NotifyDragFrameNode(
725         const Point& point, const DragEventType& dragEventType, const DragRet& dragRet = DragRet::DRAG_DEFAULT);
726     void TransDragWindowToDragFwk(int32_t windowContainerId);
727     void ResetDragDrop(int32_t windowId, const Point& point);
728     bool isDistanceLimited(const Point& point);
729     bool isTimeLimited(const DragPointerEvent& pointerEvent, const Point& point);
730     bool ReachMoveLimit(const DragPointerEvent& pointerEvent, const Point& point);
731     bool IsUIExtensionShowPlaceholder(const RefPtr<NG::UINode>& node);
732     bool IsUIExtensionOrDynamicComponent(const RefPtr<NG::UINode>& node);
733     void HandleUIExtensionDragEvent(
734         const RefPtr<FrameNode>& frameNode, const DragPointerEvent& pointerEvent, DragEventType type);
735     int32_t GetWindowId();
736     void AddItemDrag(const RefPtr<FrameNode>& frameNode, const RefPtr<EventHub>& eventHub);
737     void RemoveItemDrag();
738     void StartDragDefaultAnimation(AnimationOption option, const Offset& newOffset,
739         const RefPtr<OverlayManager>& overlayManager, const RefPtr<NodeAnimatablePropertyFloat>& property, Point point);
740     void StartDragTransitionAnimation(const Offset& newOffset, AnimationOption option,
741         const RefPtr<OverlayManager>& overlayManager, const RefPtr<NodeAnimatablePropertyFloat>& property, Point point);
742     void ReportOnItemDropEvent(
743         DragType dragType, const RefPtr<FrameNode>& dragFrameNode, double dropPositionX, double dropPositionY);
744     void NotifyDragSpringLoadingMove(const RefPtr<FrameNode>& dragFrameNode, const std::string& extraInfo);
745     void NotifyDragSpringLoadingIntercept(std::string_view extraParams);
746     void SetRSSyncTransaction(OHOS::Rosen::RSSyncTransactionController** transactionController,
747         std::shared_ptr<Rosen::RSSyncTransactionHandler>& transactionHandler,
748         const RefPtr<NG::PipelineContext>& pipeline);
749 
750     std::map<int32_t, WeakPtr<FrameNode>> gridDragFrameNodes_;
751     std::map<int32_t, WeakPtr<FrameNode>> listDragFrameNodes_;
752     std::map<int32_t, WeakPtr<FrameNode>> textFieldDragFrameNodes_;
753     RefPtr<FrameNode> draggedFrameNode_;
754     RefPtr<FrameNode> preTargetFrameNode_;
755     RefPtr<FrameNode> draggedGridFrameNode_;
756     RefPtr<FrameNode> preGridTargetFrameNode_;
757     RefPtr<FrameNode> itemDragOverlayNode_;
758     RefPtr<FrameNode> rootNode_ = nullptr;
759     RefPtr<Clipboard> clipboard_;
760     Point preMovePoint_ = Point(0, 0);
761     DragPointerEvent preDragPointerEvent_;
762     uint64_t preTimeStamp_ = 0L;
763     std::function<void(const std::string&)> addDataCallback_ = nullptr;
764     std::function<void(const std::string&)> getDataCallback_ = nullptr;
765     std::function<void(const std::string&)> deleteDataCallback_ = nullptr;
766     std::string extraInfo_;
767     std::unique_ptr<JsonValue> newData_ = nullptr;
768     bool isDragCancel_ = false;
769     std::unordered_map<int32_t, WeakPtr<FrameNode>> nodesForDragNotify_;
770     std::unordered_set<int32_t> parentHitNodes_;
771     std::unordered_map<int32_t, std::function<void(const DragPointerEvent&)>> pullEventListener_;
772     DragCursorStyleCore dragCursorStyleCore_ = DragCursorStyleCore::DEFAULT;
773     std::map<std::string, int64_t> summaryMap_;
774     DragSummaryInfo dragSummaryInfo_;
775     uint32_t recordSize_ = 0;
776     int64_t currentId_ = -1;
777     int32_t currentPointerId_ = -1;
778     int32_t currentPullId_ = -1;
779     bool draggingPressedState_ = false;
780 
781     std::function<void(void)> notifyInDraggedCallback_ = nullptr;
782     bool isDragged_ = false;
783     bool isMouseDragged_ = false;
784     bool isWindowConsumed_ = false;
785     bool isDragWindowShow_ = false;
786     bool hasNotifiedTransformation_ = false;
787     bool isPullMoveReceivedForCurrentDrag_ = false;
788     bool isDragWindowSubWindow_ = false;
789     bool isDragNodeNeedClean_ = false;
790     bool isAnyDraggableHit_ = false;
791     bool isReDragStart_ = false;
792     VelocityTracker velocityTracker_;
793     DragDropMgrState dragDropState_ = DragDropMgrState::IDLE;
794     Rect previewRect_ { -1, -1, -1, -1 };
795     DragPreviewInfo info_;
796     DragPointerEvent dragDropPointerEvent_;
797     DragPointerEvent dragAnimationPointerEvent_;
798     bool isDragFwkShow_ = true;
799     OffsetF pixelMapOffset_;
800     OffsetF curPointerOffset_;
801     std::vector<RefPtr<PixelMap>> gatherPixelMaps_;
802     bool isShowBadgeAnimation_ = true;
803     bool eventStrictReportingEnabled_ = false;
804     float dragStartAnimationRate_ = 0.0f;
805     int32_t badgeNumber_ = -1;
806     int32_t currentAnimationCnt_ = 0;
807     int32_t allAnimationCnt_ = 0;
808     int32_t currentStartAnimationCnt_ = 0;
809     int32_t allStartAnimationCnt_ = 0;
810     bool isDragWithContextMenu_ = false;
811     bool disableDefaultDropAnimation_ = false;
812     Point dragDampStartPoint_ { 1, 1 };
813     OffsetF dragMovePosition_ = OffsetF(0.0f, 0.0f);
814     OffsetF lastDragMovePosition_ = OffsetF(0.0f, 0.0f);
815     OffsetF dragTotalMovePosition_ = OffsetF(0.0f, 0.0f);
816     uint32_t dampingOverflowCount_ = 0;
817     std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> dragAction_;
818     RefPtr<GridColumnInfo> columnInfo_;
819     WeakPtr<FrameNode> menuWrapperNode_;
820     WeakPtr<OverlayManager> subwindowOverlayManager_;
821     ACE_DISALLOW_COPY_AND_MOVE(DragDropManager);
822     bool grayedState_ = false;
823     Point dragStartPoint_ { 0, 0 };
824     RefPtr<DragDropSpringLoadingDetector> dragDropSpringLoadingDetector_;
825 
826     std::map<int32_t, Point> fingerPointInfo_;
827     bool isStartAnimationFinished_{};
828     bool isPullThrow_ = false;
829     int32_t BundlecurrentPullId_ = -1;
830     DragBundleInfo dragBundleInfo_;
831 };
832 } // namespace OHOS::Ace::NG
833 
834 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
835