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 #ifndef DRAG_DRAWING_H
17 #define DRAG_DRAWING_H
18 
19 #include <vector>
20 
21 #include "display_manager.h"
22 #include "event_handler.h"
23 #include "event_runner.h"
24 #include "i_context.h"
25 #include "json_parser.h"
26 #include "libxml/tree.h"
27 #include "libxml/parser.h"
28 #include "modifier/rs_extended_modifier.h"
29 #include "modifier/rs_modifier.h"
30 #include "vsync_receiver.h"
31 
32 #include "drag_data.h"
33 #include "drag_smooth_processor.h"
34 #include "drag_vsync_station.h"
35 #include "i_context.h"
36 #include "i_drag_animation.h"
37 
38 namespace OHOS {
39 namespace Msdp {
40 namespace DeviceStatus {
41 struct DrawingInfo;
42 class DragDrawing;
43 using DragStartExtFunc = void (*)(DragData &dragData);
44 using DragNotifyExtFunc = void (*)(DragEventInfo &dragEventInfo);
45 class DrawSVGModifier : public Rosen::RSContentStyleModifier {
46 public:
DrawSVGModifier(std::shared_ptr<Media::PixelMap> stylePixelMap)47     explicit DrawSVGModifier(std::shared_ptr<Media::PixelMap> stylePixelMap) : stylePixelMap_(stylePixelMap) {}
48     ~DrawSVGModifier() = default;
49     void Draw(Rosen::RSDrawingContext& context) const override;
50 
51 private:
52     std::shared_ptr<Media::PixelMap> stylePixelMap_ { nullptr };
53 };
54 
55 class DrawPixelMapModifier : public Rosen::RSContentStyleModifier {
56 public:
57     DrawPixelMapModifier() = default;
58     ~DrawPixelMapModifier() = default;
59     void SetDragShadow(std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode) const;
60     void SetTextDragShadow(std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode) const;
61     Rosen::SHADOW_COLOR_STRATEGY ConvertShadowColorStrategy(int32_t shadowColorStrategy) const;
62     void Draw(Rosen::RSDrawingContext &context) const override;
63 };
64 
65 class DrawMouseIconModifier : public Rosen::RSContentStyleModifier {
66 public:
DrawMouseIconModifier(MMI::PointerStyle pointerStyle)67     explicit DrawMouseIconModifier(MMI::PointerStyle pointerStyle) : pointerStyle_(pointerStyle) {}
68     ~DrawMouseIconModifier() = default;
69     void Draw(Rosen::RSDrawingContext &context) const override;
70 
71 private:
72     void OnDraw(std::shared_ptr<Media::PixelMap> pixelMap) const;
73     std::shared_ptr<Media::PixelMap> DrawFromSVG() const;
74 
75 private:
76     MMI::PointerStyle pointerStyle_;
77 };
78 
79 class DrawDynamicEffectModifier : public Rosen::RSContentStyleModifier {
80 public:
81     DrawDynamicEffectModifier() = default;
82     ~DrawDynamicEffectModifier() = default;
83     void Draw(Rosen::RSDrawingContext &context) const override;
84     void SetAlpha(float alpha);
85     void SetScale(float scale);
86 
87 private:
88     std::shared_ptr<Rosen::RSAnimatableProperty<float>> alpha_ { nullptr };
89     std::shared_ptr<Rosen::RSAnimatableProperty<float>> scale_ { nullptr };
90 };
91 
92 class DrawDragStopModifier : public Rosen::RSContentStyleModifier {
93 public:
94     DrawDragStopModifier() = default;
95     ~DrawDragStopModifier() = default;
96     void Draw(Rosen::RSDrawingContext &context) const override;
97     void SetAlpha(float alpha);
98     void SetScale(float scale);
99     void SetStyleScale(float scale);
100     void SetStyleAlpha(float alpha);
101 
102 private:
103     std::shared_ptr<Rosen::RSAnimatableProperty<float>> alpha_ { nullptr };
104     std::shared_ptr<Rosen::RSAnimatableProperty<float>> scale_ { nullptr };
105     std::shared_ptr<Rosen::RSAnimatableProperty<float>> styleScale_ { nullptr };
106     std::shared_ptr<Rosen::RSAnimatableProperty<float>> styleAlpha_ { nullptr };
107 };
108 
109 class DrawStyleChangeModifier : public Rosen::RSContentStyleModifier {
110 public:
111     DrawStyleChangeModifier() = default;
DrawStyleChangeModifier(std::shared_ptr<Media::PixelMap> stylePixelMap)112     explicit DrawStyleChangeModifier(std::shared_ptr<Media::PixelMap> stylePixelMap) : stylePixelMap_(stylePixelMap) {}
113     ~DrawStyleChangeModifier() = default;
114     void Draw(Rosen::RSDrawingContext &context) const override;
115     void SetScale(float scale);
116 
117 private:
118     std::shared_ptr<Media::PixelMap> stylePixelMap_ { nullptr };
119     std::shared_ptr<Rosen::RSAnimatableProperty<float>> scale_ { nullptr };
120 };
121 
122 class DrawStyleScaleModifier : public Rosen::RSContentStyleModifier {
123 public:
124     DrawStyleScaleModifier() = default;
125     ~DrawStyleScaleModifier() = default;
126     void Draw(Rosen::RSDrawingContext &context) const override;
127     void SetScale(float scale);
128 
129 private:
130     std::shared_ptr<Rosen::RSAnimatableProperty<float>> scale_ { nullptr };
131 };
132 
133 struct FilterInfo {
134     std::string dragType;
135     bool shadowEnable { false };
136     bool shadowIsFilled { false };
137     bool shadowMask { false };
138     int32_t shadowColorStrategy { 0 };
139     float shadowCorner { 0.0F };
140     float dipScale { 0.0f };
141     float scale { 1.0f };
142     float cornerRadius1 { 0.0f };
143     float cornerRadius2 { 0.0f };
144     float cornerRadius3 { 0.0f };
145     float cornerRadius4 { 0.0f };
146     float opacity { 0.95f };
147     float offsetX { 0.0f };
148     float offsetY { 0.0f };
149     uint32_t argb { 0 };
150     std::string path;
151     float elevation { 0.0f };
152     bool isHardwareAcceleration { false };
153     Rosen::Vector2f coef;
154     float blurRadius { -1.0f };
155     float blurStaturation { -1.0f };
156     float blurBrightness { -1.0f };
157     uint32_t blurColor { 0 };
158     int32_t blurStyle { -1 };
159     float dragNodeGrayscale { 0.0f };
160 };
161 
162 struct ExtraInfo {
163     std::string componentType;
164     int32_t blurStyle { -1 };
165     float cornerRadius { 0.0f };
166     bool allowDistributed { true };
167     Rosen::Vector2f coef;
168 };
169 
170 enum class ScreenSizeType {
171     // Undefined screen width
172     UNDEFINED = 0,
173     // Screen width size is XS, grids is 2
174     XS,
175     // Screen width size is SM, grids is 4
176     SM,
177     // Screen width size is MD, grids is 8
178     MD,
179     // Screen width size is LG, grids is 12
180     LG,
181     // Screen width size is XL, maxi number of grids
182     XL,
183 };
184 
185 struct DrawingInfo {
186     std::atomic_bool isRunning { false };
187     std::atomic_bool isPreviousDefaultStyle { false };
188     std::atomic_bool isCurrentDefaultStyle { false };
189     bool isInitUiDirector { true };
190     bool isExistScalingValue { false };
191     std::atomic_bool needDestroyDragWindow { false };
192     int32_t sourceType { -1 };
193     int32_t currentDragNum { -1 };
194     DragCursorStyle currentStyle { DragCursorStyle::DEFAULT };
195     int32_t displayId { -1 };
196     int32_t pixelMapX { -1 };
197     int32_t pixelMapY { -1 };
198     int32_t displayX { -1 };
199     int32_t displayY { -1 };
200     float x { -1.0f };
201     float y { -1.0f };
202     float currentPositionX { -1.0f };
203     float currentPositionY { -1.0f };
204     int32_t mouseWidth { 0 };
205     int32_t mouseHeight { 0 };
206     int32_t rootNodeWidth { -1 };
207     int32_t rootNodeHeight { -1 };
208     std::atomic<int64_t> startNum { -1 };
209     int32_t timerId { -1 };
210     float scalingValue { 0.0 };
211     std::vector<std::shared_ptr<Rosen::RSCanvasNode>> nodes;
212     std::vector<std::shared_ptr<Rosen::RSCanvasNode>> multiSelectedNodes;
213     std::vector<std::shared_ptr<Media::PixelMap>> multiSelectedPixelMaps;
214     std::shared_ptr<Rosen::RSNode> rootNode { nullptr };
215     std::shared_ptr<Rosen::RSNode> parentNode { nullptr };
216     std::shared_ptr<Rosen::RSSurfaceNode> surfaceNode { nullptr };
217     std::shared_ptr<Media::PixelMap> pixelMap { nullptr };
218     std::shared_ptr<Media::PixelMap> stylePixelMap { nullptr };
219     IContext* context { nullptr };
220     ExtraInfo extraInfo;
221     FilterInfo filterInfo;
222 };
223 
224 struct DragWindowRotationInfo {
225     float rotation { 0.0f };
226     float pivotX { 0.0f };
227     float pivotY { 0.0f };
228 };
229 
230 class DragDrawing : public IDragAnimation {
231 public:
232     DragDrawing() = default;
233     DISALLOW_COPY_AND_MOVE(DragDrawing);
234     ~DragDrawing();
235 
236     int32_t Init(const DragData &dragData, IContext* context);
237     void NotifyDragInfo(const std::string &sourceName, const std::string &targetName);
238     void Draw(int32_t displayId, int32_t displayX, int32_t displayY, bool isNeedAdjustDisplayXY = true,
239         bool isMultiSelectedAnimation = true);
240     int32_t UpdateDragStyle(DragCursorStyle style);
241     int32_t UpdateShadowPic(const ShadowInfo &shadowInfo);
242     int32_t UpdatePreviewStyle(const PreviewStyle &previewStyle);
243     int32_t UpdatePreviewStyleWithAnimation(const PreviewStyle &previewStyle, const PreviewAnimation &animation);
244     int32_t StartVsync();
245     void OnDragSuccess(IContext* context);
246     void OnDragFail(IContext* context);
247     void OnDragMove(int32_t displayId, int32_t displayX, int32_t displayY, int64_t actionTime);
248     void EraseMouseIcon();
249     void DestroyDragWindow();
250     void UpdateDrawingState();
251     void UpdateDragWindowState(bool visible);
252     void OnStartDrag(const DragAnimationData &dragAnimationData, std::shared_ptr<Rosen::RSCanvasNode> shadowNode,
253         std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode) override;
254     void OnDragStyle(std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode,
255         std::shared_ptr<Media::PixelMap> stylePixelMap) override;
256     void OnStopDragSuccess(std::shared_ptr<Rosen::RSCanvasNode> shadowNode,
257         std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode) override;
258     void OnStopDragFail(std::shared_ptr<Rosen::RSSurfaceNode> surfaceNode,
259         std::shared_ptr<Rosen::RSNode> rootNode) override;
260     void OnStopAnimation() override;
261     int32_t EnterTextEditorArea(bool enable);
262     bool GetAllowDragState();
263     void SetScreenId(uint64_t screenId);
264     int32_t RotateDragWindowAsync(Rosen::Rotation rotation);
265     int32_t RotateDragWindowSync(const std::shared_ptr<Rosen::RSTransaction>& rsTransaction = nullptr);
266     void SetRotation(Rosen::Rotation rotation);
267     float CalculateWidthScale();
268     float GetMaxWidthScale(int32_t width);
269     void ScreenRotate(Rosen::Rotation rotation, Rosen::Rotation lastRotation);
270 
271 private:
272     int32_t CheckDragData(const DragData &dragData);
273     int32_t InitLayer();
274     void InitCanvas(int32_t width, int32_t height);
275     void CreateWindow();
276     int32_t DrawShadow(std::shared_ptr<Rosen::RSCanvasNode> shadowNode);
277     int32_t DrawMouseIcon();
278     int32_t DrawStyle(std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode,
279         std::shared_ptr<Media::PixelMap> stylePixelMap);
280     int32_t RunAnimation(std::function<int32_t()> cb);
281     int32_t InitVSync(float endAlpha, float endScale);
282     void OnVsync();
283     void InitDrawingInfo(const DragData &dragData);
284     int32_t InitDragAnimationData(DragAnimationData &dragAnimationData);
285     void RemoveModifier();
286     int32_t UpdateSvgNodeInfo(xmlNodePtr curNode, int32_t extendSvgWidth);
287     xmlNodePtr GetRectNode(xmlNodePtr curNode);
288     xmlNodePtr UpdateRectNode(int32_t extendSvgWidth, xmlNodePtr curNode);
289     void UpdateTspanNode(xmlNodePtr curNode);
290     int32_t ParseAndAdjustSvgInfo(xmlNodePtr curNode);
291     std::shared_ptr<Media::PixelMap> DecodeSvgToPixelMap(const std::string &filePath);
292     int32_t GetFilePath(std::string &filePath);
293     bool NeedAdjustSvgInfo();
294     void SetDecodeOptions(Media::DecodeOptions &decodeOpts);
295     bool ParserFilterInfo(const std::string &filterInfoStr, FilterInfo &filterInfo);
296     void ParserCornerRadiusInfo(const cJSON *cornerRadiusInfoStr, FilterInfo &filterInfo);
297     void ParserBlurInfo(const cJSON *BlurInfoInfoStr, FilterInfo &filterInfo);
298     void SetCustomDragBlur(const FilterInfo &filterInfo, std::shared_ptr<Rosen::RSCanvasNode> filterNode);
299     void SetComponentDragBlur(const FilterInfo &filterInfo, const ExtraInfo &extraInfo,
300         std::shared_ptr<Rosen::RSCanvasNode> filterNode);
301     void ParserDragShadowInfo(cJSON* filterInfoParser, FilterInfo &filterInfo);
302     void ParserTextDragShadowInfo(cJSON* filterInfoParser, FilterInfo &filterInfo);
303     void PrintDragShadowInfo();
304     void ProcessFilter();
305     bool ParserExtraInfo(const std::string &extraInfoStr, ExtraInfo &extraInfo);
306     static float RadiusVp2Sigma(float radiusVp, float dipScale);
307     void DoDrawMouse(int32_t mousePositionX, int32_t mousePositionY);
308     void UpdateMousePosition(float mousePositionX, float mousePositionY);
309     int32_t UpdateDefaultDragStyle(DragCursorStyle style);
310     int32_t UpdateValidDragStyle(DragCursorStyle style);
311     int32_t ModifyPreviewStyle(std::shared_ptr<Rosen::RSCanvasNode> node, const PreviewStyle &previewStyle);
312     int32_t ModifyMultiPreviewStyle(const std::vector<PreviewStyle> &previewStyles);
313     void MultiSelectedAnimation(int32_t positionX, int32_t positionY, int32_t adjustSize,
314         bool isMultiSelectedAnimation);
315     void DoMultiSelectedAnimation(float positionX, float positionY, float adjustSize,
316         bool isMultiSelectedAnimation = true);
317     void InitMultiSelectedNodes();
318     void ClearMultiSelectedData();
319     int32_t SetNodesLocation(int32_t positionX, int32_t positionY);
320     int32_t CreateEventRunner(int32_t positionX, int32_t positionY);
321     bool ParserRadius(float &radius);
322     void OnStopAnimationSuccess();
323     void OnStopAnimationFail();
324     void OnDragStyleAnimation();
325     void ChangeStyleAnimation();
326     void CheckStyleNodeModifier(std::shared_ptr<Rosen::RSCanvasNode> styleNode);
327     void RemoveStyleNodeModifier(std::shared_ptr<Rosen::RSCanvasNode> styleNode);
328     void StartStyleAnimation(float startScale, float endScale, int32_t duration);
329     void UpdateAnimationProtocol(Rosen::RSAnimationTimingProtocol protocol);
330     void RotateDisplayXY(int32_t &displayX, int32_t &displayY);
331     void RotatePixelMapXY();
332     void ResetAnimationParameter();
333     void ResetAnimationFlag(bool isForce = false);
334     void DoEndAnimation();
335     void ResetParameter();
336     int32_t DoRotateDragWindow(float rotation,
337         const std::shared_ptr<Rosen::RSTransaction>& rsTransaction, bool isAnimated);
338     int32_t DoRotateDragWindowAnimation(float rotation, float pivotX, float pivotY,
339         const std::shared_ptr<Rosen::RSTransaction>& rsTransaction);
340     int32_t RotateDragWindow(Rosen::Rotation rotation,
341         const std::shared_ptr<Rosen::RSTransaction>& rsTransaction = nullptr, bool isAnimated = false);
342     std::shared_ptr<AppExecFwk::EventHandler> GetSuperHubHandler();
343     void RotateCanvasNode(float pivotX, float pivotY, float rotation);
344     void ResetSuperHubHandler();
345     void FlushDragPosition(uint64_t nanoTimestamp);
346     void RotatePosition(float &displayX, float &displayY);
347     void UpdateDragPosition(int32_t displayId, float displayX, float displayY);
348     float AdjustDoubleValue(double doubleValue);
349     template <typename T>
350     void AdjustRotateDisplayXY(T &displayX, T &displayY);
351     void DrawRotateDisplayXY(float positionX, float positionY);
352     void ScreenRotateAdjustDisplayXY(
353         Rosen::Rotation rotation, Rosen::Rotation lastRotation, float &displayX, float &displayY);
354 
355 private:
356     int64_t interruptNum_ { -1 };
357     std::shared_ptr<Rosen::RSCanvasNode> canvasNode_ { nullptr };
358     std::shared_ptr<DrawSVGModifier> drawSVGModifier_ { nullptr };
359     std::shared_ptr<DrawPixelMapModifier> drawPixelMapModifier_ { nullptr };
360     std::shared_ptr<DrawMouseIconModifier> drawMouseIconModifier_ { nullptr };
361     std::shared_ptr<DrawDynamicEffectModifier> drawDynamicEffectModifier_ { nullptr };
362     std::shared_ptr<DrawDragStopModifier> drawDragStopModifier_ { nullptr };
363     std::shared_ptr<DrawStyleChangeModifier> drawStyleChangeModifier_ { nullptr };
364     std::shared_ptr<DrawStyleScaleModifier> drawStyleScaleModifier_ { nullptr };
365     std::shared_ptr<Rosen::RSUIDirector> rsUiDirector_ { nullptr };
366     std::shared_ptr<Rosen::VSyncReceiver> receiver_ { nullptr };
367     std::shared_ptr<AppExecFwk::EventHandler> handler_ { nullptr };
368     std::shared_ptr<AppExecFwk::EventHandler> superHubHandler_ { nullptr };
369     std::atomic_bool hasRunningStopAnimation_ { false };
370     std::atomic_bool hasRunningScaleAnimation_ { false };
371     std::atomic_bool needBreakStyleScaleAnimation_ { false };
372     std::atomic_bool hasRunningAnimation_ { false };
373     void* dragExtHandler_ { nullptr };
374     bool needRotatePixelMapXY_ { false };
375     uint64_t screenId_ { 0 };
376     Rosen::Rotation rotation_ { Rosen::Rotation::ROTATION_0 };
377     ScreenSizeType currentScreenSize_ = ScreenSizeType::UNDEFINED;
378     MMI::PointerStyle pointerStyle_;
379     DragVSyncStation vSyncStation_;
380     DragSmoothProcessor dragSmoothProcessor_;
381     std::shared_ptr<DragFrameCallback> frameCallback_ { nullptr };
382     std::atomic_bool isRunningRotateAnimation_ { false };
383     DragWindowRotationInfo DragWindowRotateInfo_;
384     int32_t timerId_ { -1 };
385     IContext* context_ { nullptr} ;
386 };
387 } // namespace DeviceStatus
388 } // namespace Msdp
389 } // namespace OHOS
390 #endif // DRAG_DRAWING_H