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 "drag_drawing.h" 17 18 #include <atomic> 19 #include <cstdint> 20 #include <fstream> 21 #include <limits> 22 #include <string> 23 #include <unistd.h> 24 25 #include <dlfcn.h> 26 27 #include "include/core/SkTextBlob.h" 28 #include "image_source.h" 29 #include "image_type.h" 30 #include "image_utils.h" 31 #include "input_manager.h" 32 #include "parameters.h" 33 #include "pointer_event.h" 34 #include "pointer_style.h" 35 #include "render/rs_filter.h" 36 #include "screen_manager.h" 37 #include "string_ex.h" 38 #include "transaction/rs_interfaces.h" 39 #include "ui/rs_surface_extractor.h" 40 #include "ui/rs_surface_node.h" 41 #include "ui/rs_ui_director.h" 42 43 #include "animation_curve.h" 44 #include "devicestatus_define.h" 45 #include "drag_data_manager.h" 46 #include "drag_hisysevent.h" 47 #include "include/util.h" 48 49 #undef LOG_TAG 50 #define LOG_TAG "DragDrawing" 51 52 namespace OHOS { 53 namespace Msdp { 54 namespace DeviceStatus { 55 namespace { 56 constexpr int32_t BASELINE_DENSITY { 160 }; 57 constexpr int32_t DEVICE_INDEPENDENT_PIXEL { 40 }; 58 constexpr int32_t MAGIC_INDEPENDENT_PIXEL { 25 }; 59 constexpr int32_t MAGIC_STYLE_OPT { 1 }; 60 constexpr int32_t DRAG_NUM_ONE { 1 }; 61 constexpr int32_t STRING_PX_LENGTH { 2 }; 62 constexpr int32_t EIGHT_SIZE { 8 }; 63 constexpr int32_t TWELVE_SIZE { 12 }; 64 constexpr int64_t START_TIME { 181154000809 }; 65 constexpr int64_t INTERVAL_TIME { 16666667 }; 66 constexpr int32_t SVG_WIDTH { 40 }; 67 constexpr float SCALE_THRESHOLD_EIGHT { 1.0F * INT32_MAX / (SVG_WIDTH + EIGHT_SIZE) }; 68 constexpr float SCALE_THRESHOLD_TWELVE { 1.0F * INT32_MAX / (SVG_WIDTH + TWELVE_SIZE) }; 69 constexpr int32_t SUCCESS_ANIMATION_DURATION { 300 }; 70 constexpr int32_t ANIMATION_DURATION { 400 }; 71 constexpr int32_t VIEW_BOX_POS { 2 }; 72 constexpr int32_t BACKGROUND_FILTER_INDEX { 0 }; 73 constexpr int32_t ASYNC_ROTATE_TIME { 150 }; 74 constexpr int32_t PIXEL_MAP_INDEX { 1 }; 75 constexpr int32_t DRAG_STYLE_INDEX { 2 }; 76 constexpr int32_t MOUSE_ICON_INDEX { 3 }; 77 constexpr int32_t SHORT_DURATION { 55 }; 78 constexpr int32_t LONG_DURATION { 90 }; 79 constexpr int32_t FIRST_PIXELMAP_INDEX { 0 }; 80 constexpr int32_t SECOND_PIXELMAP_INDEX { 1 }; 81 constexpr size_t TOUCH_NODE_MIN_COUNT { 3 }; 82 constexpr size_t MOUSE_NODE_MIN_COUNT { 4 }; 83 constexpr float DEFAULT_SCALING { 1.0f }; 84 constexpr float BEGIN_ALPHA { 1.0f }; 85 constexpr float END_ALPHA { 0.0f }; 86 constexpr float START_STYLE_ALPHA { 1.0f }; 87 constexpr float END_STYLE_ALPHA { 0.0f }; 88 constexpr float BEGIN_SCALE { 1.0f }; 89 constexpr float END_SCALE_FAIL { 1.2f }; 90 constexpr float END_SCALE_SUCCESS { 0.0f }; 91 constexpr float DEFAULT_PIVOT { 0.0f }; 92 constexpr float HALF_PIVOT { 0.5f }; 93 constexpr float START_STYLE_SCALE { 1.0f }; 94 constexpr float STYLE_CHANGE_SCALE { 1.1f }; 95 constexpr float STYLE_MAX_SCALE { 1.2f }; 96 constexpr float STYLE_END_SCALE { 1.0f }; 97 constexpr float SVG_ORIGINAL_SIZE { 40.0f }; 98 constexpr float DEFAULT_POSITION_X { 0.0f }; 99 constexpr float BLUR_SIGMA_SCALE { 0.57735f }; 100 constexpr float RADIUS_VP { 23.0f }; 101 constexpr float DEFAULT_SATURATION { 1.05f }; 102 constexpr float DEFAULT_BRIGHTNESS { 1.05f }; 103 constexpr float INCREASE_RATIO { 1.22f }; 104 constexpr float DRAG_WINDOW_POSITION_Z { 6999.0f }; 105 constexpr float DEFAULT_ANGLE { 0.0f }; 106 constexpr float POSITIVE_ANGLE { 8.0f }; 107 constexpr float NEGATIVE_ANGLE { -8.0f }; 108 constexpr float DEFAULT_ALPHA { 1.0f }; 109 constexpr float FIRST_PIXELMAP_ALPHA { 0.6f }; 110 constexpr float SECOND_PIXELMAP_ALPHA { 0.3f }; 111 constexpr float HALF_RATIO { 0.5f }; 112 constexpr float ROTATION_0 { 0.0f }; 113 constexpr float ROTATION_90 { 90.0f }; 114 constexpr float ROTATION_360 { 360.0f }; 115 constexpr float ROTATION_270 { 270.0f }; 116 constexpr uint32_t TRANSPARENT_COLOR_ARGB { 0x00000000 }; 117 constexpr int32_t DEFAULT_MOUSE_SIZE { 1 }; 118 constexpr int32_t DEFAULT_COLOR_VALUE { 0 }; 119 constexpr int32_t INVALID_COLOR_VALUE { -1 }; 120 constexpr int32_t GLOBAL_WINDOW_ID { -1 }; 121 constexpr int32_t MOUSE_DRAG_CURSOR_CIRCLE_STYLE { 41 }; 122 constexpr int32_t CURSOR_CIRCLE_MIDDLE { 2 }; 123 constexpr int32_t TWICE_SIZE { 2 }; 124 constexpr int32_t NUM_ONE { 1 }; 125 constexpr int32_t NUM_TWO { 2 }; 126 constexpr int32_t NUM_FOUR { 4 }; 127 const Rosen::RSAnimationTimingCurve SPRING = Rosen::RSAnimationTimingCurve::CreateSpring(0.347f, 0.99f, 0.0f); 128 constexpr int32_t HEX_FF { 0xFF }; 129 const std::string RENDER_THREAD_NAME { "os_dargRenderRunner" }; 130 constexpr float BEZIER_000 { 0.00f }; 131 constexpr float BEZIER_020 { 0.20f }; 132 constexpr float BEZIER_030 { 0.30f }; 133 constexpr float BEZIER_033 { 0.33f }; 134 constexpr float BEZIER_040 { 0.40f }; 135 constexpr float BEZIER_060 { 0.60f }; 136 constexpr float BEZIER_067 { 0.67f }; 137 constexpr float BEZIER_100 { 1.00f }; 138 constexpr float MIN_OPACITY { 0.0f }; 139 constexpr float MAX_OPACITY { 1.0f }; 140 constexpr int32_t TIME_DRAG_CHANGE_STYLE { 50 }; 141 constexpr int32_t TIME_DRAG_STYLE { 100 }; 142 constexpr int32_t TIME_STOP_FAIL_WINDOW { 125 }; 143 constexpr int32_t TIME_STOP_SUCCESS_WINDOW { 250 }; 144 constexpr int32_t TIME_STOP_SUCCESS_STYLE { 150 }; 145 constexpr int32_t TIME_STOP { 0 }; 146 constexpr int64_t TIME_SLEEP { 30000 }; 147 constexpr int32_t INTERRUPT_SCALE { 15 }; 148 constexpr int32_t TIMEOUT_MS { 500 }; 149 constexpr float MAX_SCREEN_WIDTH_SM { 320.0f }; 150 constexpr float MAX_SCREEN_WIDTH_MD { 600.0f }; 151 constexpr float MAX_SCREEN_WIDTH_LG { 840.0f }; 152 constexpr float MAX_SCREEN_WIDTH_XL { 1024.0f }; 153 constexpr float SCALE_SM { 3.0f / 4 }; 154 constexpr float SCALE_MD { 4.0f / 8 }; 155 constexpr float SCALE_LG { 5.0f / 12 }; 156 const std::string THREAD_NAME { "os_AnimationEventRunner" }; 157 const std::string SUPER_HUB_THREAD_NAME { "os_SuperHubEventRunner" }; 158 const std::string COPY_DRAG_PATH { "/system/etc/device_status/drag_icon/Copy_Drag.svg" }; 159 const std::string COPY_ONE_DRAG_PATH { "/system/etc/device_status/drag_icon/Copy_One_Drag.svg" }; 160 const std::string FORBID_DRAG_PATH { "/system/etc/device_status/drag_icon/Forbid_Drag.svg" }; 161 const std::string FORBID_ONE_DRAG_PATH { "/system/etc/device_status/drag_icon/Forbid_One_Drag.svg" }; 162 const std::string MOUSE_DRAG_DEFAULT_PATH { "/system/etc/device_status/drag_icon/Mouse_Drag_Default.svg" }; 163 const std::string MOUSE_DRAG_MAGIC_DEFAULT_PATH { "/system/etc/device_status/drag_icon/Mouse_Drag_Magic_Default.svg" }; 164 const std::string MOUSE_DRAG_CURSOR_CIRCLE_PATH { "/system/etc/device_status/drag_icon/Mouse_Drag_Cursor_Circle.png" }; 165 const std::string MOVE_DRAG_PATH { "/system/etc/device_status/drag_icon/Move_Drag.svg" }; 166 const std::string DRAG_DROP_EXTENSION_SO_PATH { "/system/lib64/drag_drop_ext/libdrag_drop_ext.z.so" }; 167 const std::string BIG_FOLDER_LABEL { "scb_folder" }; 168 struct DrawingInfo g_drawingInfo; 169 struct DragData g_dragData; 170 CheckNodesValid()171 bool CheckNodesValid() 172 { 173 FI_HILOGD("enter"); 174 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 175 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 176 return false; 177 } else if (g_drawingInfo.nodes.empty() || g_drawingInfo.nodes[DRAG_STYLE_INDEX] == nullptr) { 178 FI_HILOGE("Nodes invalid"); 179 return false; 180 } 181 if ((g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) && 182 (g_drawingInfo.nodes.size() < MOUSE_NODE_MIN_COUNT)) { 183 FI_HILOGE("Nodes size invalid when mouse type, node size:%{public}zu", g_drawingInfo.nodes.size()); 184 return false; 185 } 186 if ((g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN) && 187 (g_drawingInfo.nodes.size() < TOUCH_NODE_MIN_COUNT)) { 188 FI_HILOGE("Nodes size invalid when touchscreen type, node size:%{public}zu", g_drawingInfo.nodes.size()); 189 return false; 190 } 191 return true; 192 } 193 GetScaling()194 float GetScaling() 195 { 196 if (g_drawingInfo.isExistScalingValue) { 197 return g_drawingInfo.scalingValue; 198 } 199 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 200 if (display == nullptr) { 201 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 202 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 203 if (display == nullptr) { 204 FI_HILOGE("Get display info failed, display is nullptr"); 205 return DEFAULT_SCALING; 206 } 207 } 208 209 int32_t deviceDpi = display->GetDpi(); 210 FI_HILOGD("displayId:%{public}d, deviceDpi:%{public}d", g_drawingInfo.displayId, deviceDpi); 211 if (deviceDpi < -std::numeric_limits<float>::epsilon()) { 212 FI_HILOGE("Invalid deviceDpi:%{public}d", deviceDpi); 213 return DEFAULT_SCALING; 214 } 215 g_drawingInfo.scalingValue = (1.0 * deviceDpi * DEVICE_INDEPENDENT_PIXEL / BASELINE_DENSITY) / SVG_ORIGINAL_SIZE; 216 g_drawingInfo.isExistScalingValue = true; 217 return g_drawingInfo.scalingValue; 218 } 219 } // namespace 220 Init(const DragData & dragData,IContext * context)221 int32_t DragDrawing::Init(const DragData &dragData, IContext* context) 222 { 223 FI_HILOGI("enter"); 224 int32_t checkDragDataResult = CheckDragData(dragData); 225 if (INIT_SUCCESS != checkDragDataResult) { 226 return checkDragDataResult; 227 } 228 InitDrawingInfo(dragData); 229 g_dragData = dragData; 230 CreateWindow(); 231 CHKPR(g_drawingInfo.surfaceNode, INIT_FAIL); 232 if (InitLayer() != RET_OK) { 233 FI_HILOGE("Init layer failed"); 234 return INIT_FAIL; 235 } 236 DragAnimationData dragAnimationData; 237 if (!CheckNodesValid() || InitDragAnimationData(dragAnimationData) != RET_OK) { 238 FI_HILOGE("Init drag animation data or check nodes valid failed"); 239 return INIT_FAIL; 240 } 241 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX || g_drawingInfo.nodes.size() <= PIXEL_MAP_INDEX) { 242 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 243 return INIT_FAIL; 244 } 245 std::shared_ptr<Rosen::RSCanvasNode> shadowNode = g_drawingInfo.nodes[PIXEL_MAP_INDEX]; 246 CHKPR(shadowNode, INIT_FAIL); 247 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 248 CHKPR(dragStyleNode, INIT_FAIL); 249 FI_HILOGI("Begin to open drag drop extension library"); 250 if (dragExtHandler_ == nullptr) { 251 dragExtHandler_ = dlopen(DRAG_DROP_EXTENSION_SO_PATH.c_str(), RTLD_LAZY); 252 } 253 CHKPL(dragExtHandler_); 254 FI_HILOGI("End to open drag drop extension library"); 255 OnStartDrag(dragAnimationData, shadowNode, dragStyleNode); 256 if (!g_drawingInfo.multiSelectedNodes.empty()) { 257 g_drawingInfo.isCurrentDefaultStyle = true; 258 UpdateDragStyle(DragCursorStyle::MOVE); 259 } 260 context_ = context; 261 CHKPR(rsUiDirector_, INIT_FAIL); 262 if (g_drawingInfo.sourceType != MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 263 rsUiDirector_->SendMessages(); 264 return INIT_SUCCESS; 265 } 266 if (DrawMouseIcon() != RET_OK) { 267 FI_HILOGE("Draw mouse icon failed"); 268 return INIT_FAIL; 269 } 270 rsUiDirector_->SendMessages(); 271 FI_HILOGI("leave"); 272 return INIT_SUCCESS; 273 } 274 CheckDragData(const DragData & dragData)275 int32_t DragDrawing::CheckDragData(const DragData &dragData) 276 { 277 if (g_drawingInfo.isRunning) { 278 FI_HILOGE("Drag drawing is running, can not init again"); 279 return INIT_CANCEL; 280 } 281 if (dragData.shadowInfos.empty()) { 282 FI_HILOGE("ShadowInfos is empty"); 283 return INIT_FAIL; 284 } 285 for (const auto &shadowInfo : dragData.shadowInfos) { 286 CHKPR(shadowInfo.pixelMap, INIT_FAIL); 287 } 288 if ((dragData.sourceType != MMI::PointerEvent::SOURCE_TYPE_MOUSE) && 289 (dragData.sourceType != MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN)) { 290 FI_HILOGE("Invalid sourceType:%{public}d", dragData.sourceType); 291 return INIT_FAIL; 292 } 293 if (dragData.dragNum < 0) { 294 FI_HILOGE("Invalid dragNum:%{public}d", dragData.dragNum); 295 return INIT_FAIL; 296 } 297 return INIT_SUCCESS; 298 } 299 Draw(int32_t displayId,int32_t displayX,int32_t displayY,bool isNeedAdjustDisplayXY,bool isMultiSelectedAnimation)300 void DragDrawing::Draw(int32_t displayId, int32_t displayX, int32_t displayY, bool isNeedAdjustDisplayXY, 301 bool isMultiSelectedAnimation) 302 { 303 if (isRunningRotateAnimation_) { 304 FI_HILOGD("Doing rotate drag window animate, ignore draw drag window"); 305 return; 306 } 307 if (displayId < 0) { 308 FI_HILOGE("Invalid displayId:%{public}d", displayId); 309 return; 310 } 311 int32_t mousePositionX = displayX; 312 int32_t mousePositionY = displayY; 313 if (isNeedAdjustDisplayXY) { 314 RotateDisplayXY(displayX, displayY); 315 mousePositionX = displayX; 316 mousePositionY = displayY; 317 g_drawingInfo.currentPositionX = static_cast<float>(displayX); 318 g_drawingInfo.currentPositionY = static_cast<float>(displayY); 319 AdjustRotateDisplayXY(displayX, displayY); 320 } 321 g_drawingInfo.displayId = displayId; 322 g_drawingInfo.displayX = displayX; 323 g_drawingInfo.displayY = displayY; 324 if (displayX < 0) { 325 g_drawingInfo.displayX = 0; 326 } 327 if (displayY < 0) { 328 g_drawingInfo.displayY = 0; 329 } 330 int32_t adjustSize = TWELVE_SIZE * GetScaling(); 331 int32_t positionX = g_drawingInfo.displayX + g_drawingInfo.pixelMapX; 332 int32_t positionY = g_drawingInfo.displayY + g_drawingInfo.pixelMapY - adjustSize; 333 CHKPV(g_drawingInfo.parentNode); 334 CHKPV(g_drawingInfo.pixelMap); 335 g_drawingInfo.parentNode->SetBounds(positionX, positionY, g_drawingInfo.pixelMap->GetWidth(), 336 g_drawingInfo.pixelMap->GetHeight() + adjustSize); 337 g_drawingInfo.parentNode->SetFrame(positionX, positionY, g_drawingInfo.pixelMap->GetWidth(), 338 g_drawingInfo.pixelMap->GetHeight() + adjustSize); 339 if (g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 340 DoDrawMouse(mousePositionX, mousePositionY); 341 } 342 if (!g_drawingInfo.multiSelectedNodes.empty() && !g_drawingInfo.multiSelectedPixelMaps.empty()) { 343 MultiSelectedAnimation(positionX, positionY, adjustSize, isMultiSelectedAnimation); 344 } 345 Rosen::RSTransaction::FlushImplicitTransaction(); 346 } 347 UpdateDragPosition(int32_t displayId,float displayX,float displayY)348 void DragDrawing::UpdateDragPosition(int32_t displayId, float displayX, float displayY) 349 { 350 if (displayId < 0) { 351 FI_HILOGE("Invalid displayId:%{public}d", displayId); 352 return; 353 } 354 RotatePosition(displayX, displayY); 355 g_drawingInfo.currentPositionX = displayX; 356 g_drawingInfo.currentPositionY = displayY; 357 g_drawingInfo.displayId = displayId; 358 g_drawingInfo.displayX = static_cast<int32_t>(displayX); 359 g_drawingInfo.displayY = static_cast<int32_t>(displayY); 360 float mousePositionX = displayX; 361 float mousePositionY = displayY; 362 AdjustRotateDisplayXY(displayX, displayY); 363 g_drawingInfo.x = displayX; 364 g_drawingInfo.y = displayY; 365 if (displayX < 0) { 366 g_drawingInfo.displayX = 0; 367 } 368 if (displayY < 0) { 369 g_drawingInfo.displayY = 0; 370 } 371 float adjustSize = TWELVE_SIZE * GetScaling(); 372 float positionX = g_drawingInfo.x + g_drawingInfo.pixelMapX; 373 float positionY = g_drawingInfo.y + g_drawingInfo.pixelMapY - adjustSize; 374 auto parentNode = g_drawingInfo.parentNode; 375 auto pixelMap = g_drawingInfo.pixelMap; 376 CHKPV(parentNode); 377 CHKPV(pixelMap); 378 parentNode->SetBounds(positionX, positionY, pixelMap->GetWidth(), 379 pixelMap->GetHeight() + adjustSize); 380 parentNode->SetFrame(positionX, positionY, pixelMap->GetWidth(), 381 pixelMap->GetHeight() + adjustSize); 382 if (g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 383 UpdateMousePosition(mousePositionX, mousePositionY); 384 } 385 if (!g_drawingInfo.multiSelectedNodes.empty() && !g_drawingInfo.multiSelectedPixelMaps.empty()) { 386 DoMultiSelectedAnimation(positionX, positionY, adjustSize); 387 } 388 if (rsUiDirector_ != nullptr) { 389 rsUiDirector_->SendMessages(); 390 } else { 391 FI_HILOGE("rsUiDirector_ is nullptr"); 392 } 393 } 394 DoMultiSelectedAnimation(float positionX,float positionY,float adjustSize,bool isMultiSelectedAnimation)395 void DragDrawing::DoMultiSelectedAnimation(float positionX, float positionY, float adjustSize, 396 bool isMultiSelectedAnimation) 397 { 398 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 399 size_t multiSelectedPixelMapsSize = g_drawingInfo.multiSelectedPixelMaps.size(); 400 for (size_t i = 0; (i < multiSelectedNodesSize) && (i < multiSelectedPixelMapsSize); ++i) { 401 std::shared_ptr<Rosen::RSCanvasNode> multiSelectedNode = g_drawingInfo.multiSelectedNodes[i]; 402 std::shared_ptr<Media::PixelMap> multiSelectedPixelMap = g_drawingInfo.multiSelectedPixelMaps[i]; 403 auto pixelMap = g_drawingInfo.pixelMap; 404 CHKPV(pixelMap); 405 CHKPV(multiSelectedNode); 406 CHKPV(multiSelectedPixelMap); 407 float multiSelectedPositionX = positionX + (static_cast<float>(pixelMap->GetWidth()) / TWICE_SIZE) - 408 (static_cast<float>(multiSelectedPixelMap->GetWidth()) / TWICE_SIZE); 409 float multiSelectedPositionY = positionY + (static_cast<float>(pixelMap->GetHeight()) / TWICE_SIZE) - 410 (static_cast<float>(multiSelectedPixelMap->GetHeight()) / TWICE_SIZE - adjustSize); 411 if (isMultiSelectedAnimation) { 412 Rosen::RSAnimationTimingProtocol protocol; 413 if (i == FIRST_PIXELMAP_INDEX) { 414 protocol.SetDuration(SHORT_DURATION); 415 } else { 416 protocol.SetDuration(LONG_DURATION); 417 } 418 Rosen::RSNode::Animate(protocol, Rosen::RSAnimationTimingCurve::EASE_IN_OUT, [&]() { 419 multiSelectedNode->SetBounds(multiSelectedPositionX, multiSelectedPositionY, 420 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 421 multiSelectedNode->SetFrame(multiSelectedPositionX, multiSelectedPositionY, 422 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 423 }, []() { FI_HILOGD("DoMultiSelectedAnimation end"); }); 424 } else { 425 multiSelectedNode->SetBounds(multiSelectedPositionX, multiSelectedPositionY, 426 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 427 multiSelectedNode->SetFrame(multiSelectedPositionX, multiSelectedPositionY, 428 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 429 } 430 } 431 } 432 UpdateDragStyle(DragCursorStyle style)433 int32_t DragDrawing::UpdateDragStyle(DragCursorStyle style) 434 { 435 FI_HILOGD("style:%{public}d", style); 436 if ((style < DragCursorStyle::DEFAULT) || (style > DragCursorStyle::MOVE)) { 437 DragDFX::WriteUpdateDragStyle(style, OHOS::HiviewDFX::HiSysEvent::EventType::FAULT); 438 FI_HILOGE("Invalid style:%{public}d", style); 439 return RET_ERR; 440 } 441 if ((style == DragCursorStyle::DEFAULT) || 442 ((style == DragCursorStyle::MOVE) && (g_drawingInfo.currentDragNum == DRAG_NUM_ONE))) { 443 return UpdateDefaultDragStyle(style); 444 } 445 return UpdateValidDragStyle(style); 446 } 447 UpdateShadowPic(const ShadowInfo & shadowInfo)448 int32_t DragDrawing::UpdateShadowPic(const ShadowInfo &shadowInfo) 449 { 450 FI_HILOGD("enter"); 451 CHKPR(shadowInfo.pixelMap, RET_ERR); 452 g_drawingInfo.pixelMap = shadowInfo.pixelMap; 453 g_drawingInfo.pixelMapX = shadowInfo.x; 454 g_drawingInfo.pixelMapY = shadowInfo.y; 455 if (!CheckNodesValid()) { 456 FI_HILOGE("Check nodes valid failed"); 457 return RET_ERR; 458 } 459 if (g_drawingInfo.nodes.size() <= PIXEL_MAP_INDEX) { 460 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 461 return RET_ERR; 462 } 463 std::shared_ptr<Rosen::RSCanvasNode> shadowNode = g_drawingInfo.nodes[PIXEL_MAP_INDEX]; 464 CHKPR(shadowNode, RET_ERR); 465 DrawShadow(shadowNode); 466 float scalingValue = GetScaling(); 467 if (SCALE_THRESHOLD_TWELVE < scalingValue || fabsf(SCALE_THRESHOLD_TWELVE - scalingValue) < EPSILON) { 468 FI_HILOGE("Invalid scalingValue:%{public}f", scalingValue); 469 return RET_ERR; 470 } 471 if (g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 472 DrawMouseIcon(); 473 } 474 ProcessFilter(); 475 Draw(g_drawingInfo.displayId, g_drawingInfo.displayX, g_drawingInfo.displayY, false); 476 RotateDragWindow(rotation_); 477 Rosen::RSTransaction::FlushImplicitTransaction(); 478 CHKPR(rsUiDirector_, RET_ERR); 479 rsUiDirector_->SendMessages(); 480 FI_HILOGD("leave"); 481 return RET_OK; 482 } 483 OnDragSuccess(IContext * context)484 void DragDrawing::OnDragSuccess(IContext* context) 485 { 486 FI_HILOGI("enter"); 487 if (!CheckNodesValid()) { 488 FI_HILOGE("Check nodes valid failed"); 489 return; 490 } 491 if (g_drawingInfo.nodes.size() <= PIXEL_MAP_INDEX || g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 492 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 493 return; 494 } 495 std::shared_ptr<Rosen::RSCanvasNode> shadowNode = g_drawingInfo.nodes[PIXEL_MAP_INDEX]; 496 CHKPV(shadowNode); 497 std::shared_ptr<Rosen::RSCanvasNode> styleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 498 CHKPV(styleNode); 499 g_drawingInfo.context = context; 500 OnStopDragSuccess(shadowNode, styleNode); 501 FI_HILOGI("leave"); 502 } 503 OnDragFail(IContext * context)504 void DragDrawing::OnDragFail(IContext* context) 505 { 506 FI_HILOGI("enter"); 507 std::shared_ptr<Rosen::RSSurfaceNode> surfaceNode = g_drawingInfo.surfaceNode; 508 CHKPV(surfaceNode); 509 std::shared_ptr<Rosen::RSNode> rootNode = g_drawingInfo.rootNode; 510 CHKPV(rootNode); 511 g_drawingInfo.context = context; 512 OnStopDragFail(surfaceNode, rootNode); 513 FI_HILOGI("leave"); 514 } 515 EraseMouseIcon()516 void DragDrawing::EraseMouseIcon() 517 { 518 FI_HILOGI("enter"); 519 if (g_drawingInfo.nodes.size() < MOUSE_NODE_MIN_COUNT) { 520 FI_HILOGE("Nodes size invalid, node size:%{public}zu", g_drawingInfo.nodes.size()); 521 return; 522 } 523 if (g_drawingInfo.nodes.size() <= MOUSE_ICON_INDEX) { 524 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 525 return; 526 } 527 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = g_drawingInfo.nodes[MOUSE_ICON_INDEX]; 528 CHKPV(mouseIconNode); 529 if (drawMouseIconModifier_ != nullptr) { 530 mouseIconNode->RemoveModifier(drawMouseIconModifier_); 531 drawMouseIconModifier_ = nullptr; 532 } 533 CHKPV(g_drawingInfo.rootNode); 534 g_drawingInfo.rootNode->RemoveChild(mouseIconNode); 535 CHKPV(rsUiDirector_); 536 rsUiDirector_->SendMessages(); 537 FI_HILOGI("leave"); 538 } 539 DestroyDragWindow()540 void DragDrawing::DestroyDragWindow() 541 { 542 FI_HILOGI("enter"); 543 ResetParameter(); 544 RemoveModifier(); 545 ClearMultiSelectedData(); 546 if (!g_drawingInfo.nodes.empty()) { 547 g_drawingInfo.nodes.clear(); 548 g_drawingInfo.nodes.shrink_to_fit(); 549 } 550 if (g_drawingInfo.parentNode != nullptr) { 551 g_drawingInfo.parentNode->ClearChildren(); 552 g_drawingInfo.parentNode.reset(); 553 g_drawingInfo.parentNode = nullptr; 554 } 555 if (g_drawingInfo.rootNode != nullptr) { 556 g_drawingInfo.rootNode->ClearChildren(); 557 g_drawingInfo.rootNode.reset(); 558 g_drawingInfo.rootNode = nullptr; 559 } 560 if (g_drawingInfo.surfaceNode != nullptr) { 561 g_drawingInfo.surfaceNode->DetachToDisplay(screenId_); 562 screenId_ = 0; 563 g_drawingInfo.displayId = -1; 564 g_drawingInfo.surfaceNode = nullptr; 565 Rosen::RSTransaction::FlushImplicitTransaction(); 566 } 567 CHKPV(rsUiDirector_); 568 rsUiDirector_->SetRoot(-1); 569 rsUiDirector_->SendMessages(); 570 FI_HILOGI("leave"); 571 } 572 UpdateDrawingState()573 void DragDrawing::UpdateDrawingState() 574 { 575 FI_HILOGD("enter"); 576 g_drawingInfo.isRunning = false; 577 FI_HILOGD("leave"); 578 } 579 UpdateDragWindowState(bool visible)580 void DragDrawing::UpdateDragWindowState(bool visible) 581 { 582 CHKPV(g_drawingInfo.surfaceNode); 583 if (visible) { 584 g_drawingInfo.surfaceNode->SetVisible(true); 585 FI_HILOGI("Drag surfaceNode show success"); 586 } else { 587 g_drawingInfo.surfaceNode->SetVisible(false); 588 FI_HILOGI("Drag surfaceNode hide success"); 589 } 590 Rosen::RSTransaction::FlushImplicitTransaction(); 591 } 592 OnStartDrag(const DragAnimationData & dragAnimationData,std::shared_ptr<Rosen::RSCanvasNode> shadowNode,std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode)593 void DragDrawing::OnStartDrag(const DragAnimationData &dragAnimationData, 594 std::shared_ptr<Rosen::RSCanvasNode> shadowNode, std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode) 595 { 596 FI_HILOGI("enter"); 597 CHKPV(shadowNode); 598 if (DrawShadow(shadowNode) != RET_OK) { 599 FI_HILOGE("Draw shadow failed"); 600 return; 601 } 602 g_drawingInfo.isCurrentDefaultStyle = true; 603 if (dragExtHandler_ == nullptr) { 604 FI_HILOGE("Fail to open drag drop extension library"); 605 return; 606 } 607 auto dragDropStartExtFunc = reinterpret_cast<DragStartExtFunc>(dlsym(dragExtHandler_, "OnStartDragExt")); 608 if (dragDropStartExtFunc == nullptr) { 609 FI_HILOGE("Fail to get drag drop extension function"); 610 dlclose(dragExtHandler_); 611 dragExtHandler_ = nullptr; 612 return; 613 } 614 #ifdef OHOS_DRAG_ENABLE_ANIMATION 615 if (!GetSuperHubHandler()->PostTask([dragDropStartExtFunc] { return dragDropStartExtFunc(g_dragData); })) { 616 FI_HILOGE("Start style animation failed"); 617 } 618 #endif // OHOS_DRAG_ENABLE_ANIMATION 619 FI_HILOGI("leave"); 620 } 621 NotifyDragInfo(const std::string & sourceName,const std::string & targetName)622 void DragDrawing::NotifyDragInfo(const std::string &sourceName, const std::string &targetName) 623 { 624 FI_HILOGI("NotifyDragInfo"); 625 if (dragExtHandler_ == nullptr) { 626 FI_HILOGE("Fail to open drag drop extension library"); 627 return; 628 } 629 auto dragDropExtFunc = reinterpret_cast<DragNotifyExtFunc>(dlsym(dragExtHandler_, "OnNotifyDragInfo")); 630 if (dragDropExtFunc == nullptr) { 631 FI_HILOGE("Fail to get drag drop extension function"); 632 dlclose(dragExtHandler_); 633 dragExtHandler_ = nullptr; 634 return; 635 } 636 struct DragEventInfo dragEventInfo; 637 dragEventInfo.sourcePkgName = sourceName; 638 dragEventInfo.targetPkgName = targetName; 639 if (!GetSuperHubHandler()->PostTask([dragDropExtFunc, dragEventInfo] () 640 mutable { return dragDropExtFunc(dragEventInfo); })) { 641 FI_HILOGE("notify drag info failed"); 642 } 643 } 644 GetSuperHubHandler()645 std::shared_ptr<AppExecFwk::EventHandler> DragDrawing::GetSuperHubHandler() 646 { 647 if (superHubHandler_ == nullptr) { 648 auto runner = AppExecFwk::EventRunner::Create(SUPER_HUB_THREAD_NAME); 649 superHubHandler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner)); 650 } 651 return superHubHandler_; 652 } 653 ResetSuperHubHandler()654 void DragDrawing::ResetSuperHubHandler() 655 { 656 if (superHubHandler_ != nullptr) { 657 superHubHandler_->RemoveAllEvents(); 658 superHubHandler_ = nullptr; 659 } 660 } 661 AdjustDoubleValue(double doubleValue)662 float DragDrawing::AdjustDoubleValue(double doubleValue) 663 { 664 FI_HILOGI("doubleValue is %{public}f", doubleValue); 665 float dragOriginDpi = DRAG_DATA_MGR.GetDragOriginDpi(); 666 if (dragOriginDpi > EPSILON) { 667 float scalingValue = GetScaling() / dragOriginDpi; 668 doubleValue = doubleValue * scalingValue; 669 if (fabs(scalingValue - 1.0f) > EPSILON) { 670 float widthScale = CalculateWidthScale(); 671 doubleValue = doubleValue * widthScale; 672 } 673 } 674 float floatValue = static_cast<float>(doubleValue); 675 FI_HILOGI("floatValue is %{public}f", floatValue); 676 return floatValue; 677 } 678 CheckStyleNodeModifier(std::shared_ptr<Rosen::RSCanvasNode> styleNode)679 void DragDrawing::CheckStyleNodeModifier(std::shared_ptr<Rosen::RSCanvasNode> styleNode) 680 { 681 FI_HILOGD("enter"); 682 CHKPV(styleNode); 683 if (drawStyleChangeModifier_ != nullptr) { 684 styleNode->RemoveModifier(drawStyleChangeModifier_); 685 drawStyleChangeModifier_ = nullptr; 686 } 687 if (drawStyleScaleModifier_ != nullptr && hasRunningScaleAnimation_) { 688 needBreakStyleScaleAnimation_ = true; 689 } 690 styleNode->RemoveAllAnimations(); 691 FI_HILOGD("leave"); 692 } 693 RemoveStyleNodeModifier(std::shared_ptr<Rosen::RSCanvasNode> styleNode)694 void DragDrawing::RemoveStyleNodeModifier(std::shared_ptr<Rosen::RSCanvasNode> styleNode) 695 { 696 FI_HILOGD("enter"); 697 CHKPV(styleNode); 698 if (drawStyleChangeModifier_ != nullptr) { 699 styleNode->RemoveModifier(drawStyleChangeModifier_); 700 drawStyleChangeModifier_ = nullptr; 701 } 702 if (drawStyleScaleModifier_ != nullptr) { 703 styleNode->RemoveModifier(drawStyleScaleModifier_); 704 drawStyleScaleModifier_ = nullptr; 705 } 706 FI_HILOGD("leave"); 707 } 708 UpdateAnimationProtocol(Rosen::RSAnimationTimingProtocol protocol)709 void DragDrawing::UpdateAnimationProtocol(Rosen::RSAnimationTimingProtocol protocol) 710 { 711 FI_HILOGD("enter"); 712 g_drawingInfo.startNum = START_TIME; 713 interruptNum_ = START_TIME * INTERRUPT_SCALE; 714 hasRunningAnimation_ = true; 715 bool stopSignal = true; 716 CHKPV(rsUiDirector_); 717 while (hasRunningAnimation_) { 718 hasRunningAnimation_ = rsUiDirector_->FlushAnimation(g_drawingInfo.startNum); 719 rsUiDirector_->FlushModifier(); 720 rsUiDirector_->SendMessages(); 721 if ((g_drawingInfo.startNum >= interruptNum_) && stopSignal) { 722 protocol.SetDuration(TIME_STOP); 723 stopSignal = false; 724 } 725 g_drawingInfo.startNum += INTERVAL_TIME; 726 usleep(TIME_SLEEP); 727 } 728 FI_HILOGD("leave"); 729 } 730 StartStyleAnimation(float startScale,float endScale,int32_t duration)731 void DragDrawing::StartStyleAnimation(float startScale, float endScale, int32_t duration) 732 { 733 FI_HILOGI("StartStyleAnimation, startScale is %{public}lf", startScale); 734 if (!CheckNodesValid() || needBreakStyleScaleAnimation_ || hasRunningStopAnimation_) { 735 FI_HILOGE("needBreakStyleScaleAnimation_ or hasRunningStopAnimation_, return"); 736 return; 737 } 738 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 739 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 740 return; 741 } 742 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 743 CHKPV(dragStyleNode); 744 RemoveStyleNodeModifier(dragStyleNode); 745 drawStyleScaleModifier_ = std::make_shared<DrawStyleScaleModifier>(); 746 dragStyleNode->AddModifier(drawStyleScaleModifier_); 747 CHKPV(drawStyleScaleModifier_); 748 drawStyleScaleModifier_->SetScale(startScale); 749 Rosen::RSAnimationTimingProtocol protocol; 750 protocol.SetDuration(duration); 751 auto springCurveStyle = endScale == STYLE_END_SCALE 752 ? Rosen::RSAnimationTimingCurve::CreateCubicCurve(BEZIER_030, BEZIER_000, BEZIER_040, BEZIER_100) 753 : Rosen::RSAnimationTimingCurve::CreateCubicCurve(BEZIER_020, BEZIER_000, BEZIER_060, BEZIER_100); 754 Rosen::RSNode::Animate(protocol, springCurveStyle, [&]() { 755 if (drawStyleScaleModifier_ != nullptr) { 756 drawStyleScaleModifier_->SetScale(endScale); 757 } 758 }); 759 UpdateAnimationProtocol(protocol); 760 if (endScale == STYLE_CHANGE_SCALE) { 761 if (drawStyleChangeModifier_ != nullptr) { 762 dragStyleNode->RemoveModifier(drawStyleChangeModifier_); 763 drawStyleChangeModifier_ = nullptr; 764 } 765 if (drawStyleScaleModifier_ != nullptr) { 766 dragStyleNode->RemoveModifier(drawStyleScaleModifier_); 767 drawStyleScaleModifier_ = nullptr; 768 } 769 drawStyleChangeModifier_ = std::make_shared<DrawStyleChangeModifier>(g_drawingInfo.stylePixelMap); 770 dragStyleNode->AddModifier(drawStyleChangeModifier_); 771 } 772 if (endScale == STYLE_END_SCALE && drawStyleScaleModifier_ != nullptr) { 773 dragStyleNode->RemoveModifier(drawStyleScaleModifier_); 774 drawStyleScaleModifier_ = nullptr; 775 } 776 } 777 ChangeStyleAnimation()778 void DragDrawing::ChangeStyleAnimation() 779 { 780 FI_HILOGD("enter"); 781 hasRunningScaleAnimation_ = true; 782 StartStyleAnimation(START_STYLE_SCALE, STYLE_CHANGE_SCALE, TIME_DRAG_CHANGE_STYLE); 783 StartStyleAnimation(STYLE_CHANGE_SCALE, STYLE_MAX_SCALE, TIME_DRAG_CHANGE_STYLE); 784 StartStyleAnimation(STYLE_MAX_SCALE, STYLE_END_SCALE, TIME_DRAG_STYLE); 785 needBreakStyleScaleAnimation_ = false; 786 hasRunningScaleAnimation_ = false; 787 FI_HILOGD("leave"); 788 } 789 OnDragStyleAnimation()790 void DragDrawing::OnDragStyleAnimation() 791 { 792 FI_HILOGD("enter"); 793 if (!CheckNodesValid()) { 794 FI_HILOGE("Check nodes valid failed"); 795 return; 796 } 797 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 798 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 799 return; 800 } 801 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 802 CHKPV(dragStyleNode); 803 needBreakStyleScaleAnimation_ = false; 804 if (g_drawingInfo.isPreviousDefaultStyle == true || g_drawingInfo.isCurrentDefaultStyle == true) { 805 FI_HILOGE("Has DefaultStyle, change style and return"); 806 CheckStyleNodeModifier(dragStyleNode); 807 drawStyleChangeModifier_ = std::make_shared<DrawStyleChangeModifier>(g_drawingInfo.stylePixelMap); 808 dragStyleNode->AddModifier(drawStyleChangeModifier_); 809 return; 810 } 811 if (handler_ == nullptr) { 812 auto runner = AppExecFwk::EventRunner::Create(THREAD_NAME); 813 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner)); 814 } 815 CheckStyleNodeModifier(dragStyleNode); 816 handler_->PostTask([this] { this->ChangeStyleAnimation(); }); 817 FI_HILOGD("leave"); 818 } 819 OnDragStyle(std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode,std::shared_ptr<Media::PixelMap> stylePixelMap)820 void DragDrawing::OnDragStyle(std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode, 821 std::shared_ptr<Media::PixelMap> stylePixelMap) 822 { 823 FI_HILOGD("enter"); 824 CHKPV(dragStyleNode); 825 CHKPV(stylePixelMap); 826 #ifdef OHOS_DRAG_ENABLE_ANIMATION 827 if (handler_ == nullptr) { 828 auto runner = AppExecFwk::EventRunner::Create(THREAD_NAME); 829 CHKPV(runner); 830 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner)); 831 } 832 if (drawSVGModifier_ != nullptr) { 833 dragStyleNode->RemoveModifier(drawSVGModifier_); 834 drawSVGModifier_ = nullptr; 835 } 836 if (!handler_->PostTask([this] { this->OnDragStyleAnimation(); })) { 837 FI_HILOGE("Drag style animation failed"); 838 DrawStyle(dragStyleNode, stylePixelMap); 839 } 840 #else // OHOS_DRAG_ENABLE_ANIMATION 841 DrawStyle(dragStyleNode, stylePixelMap); 842 #endif // OHOS_DRAG_ENABLE_ANIMATION 843 FI_HILOGD("leave"); 844 } 845 OnStopAnimationSuccess()846 void DragDrawing::OnStopAnimationSuccess() 847 { 848 FI_HILOGI("enter"); 849 if (!CheckNodesValid()) { 850 FI_HILOGE("Check nodes valid failed"); 851 return; 852 } 853 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 854 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 855 return; 856 } 857 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 858 if (dragStyleNode != nullptr && drawStyleScaleModifier_ != nullptr) { 859 dragStyleNode->RemoveModifier(drawStyleScaleModifier_); 860 dragStyleNode->RemoveAllAnimations(); 861 drawStyleScaleModifier_ = nullptr; 862 needBreakStyleScaleAnimation_ = true; 863 } 864 CHKPV(g_drawingInfo.rootNode); 865 hasRunningStopAnimation_ = true; 866 if (drawDragStopModifier_ != nullptr) { 867 g_drawingInfo.rootNode->RemoveModifier(drawDragStopModifier_); 868 drawDragStopModifier_ = nullptr; 869 } 870 drawDragStopModifier_ = std::make_shared<DrawDragStopModifier>(); 871 g_drawingInfo.rootNode->AddModifier(drawDragStopModifier_); 872 drawDragStopModifier_->SetAlpha(BEGIN_ALPHA); 873 drawDragStopModifier_->SetScale(BEGIN_SCALE); 874 drawDragStopModifier_->SetStyleScale(START_STYLE_SCALE); 875 drawDragStopModifier_->SetStyleAlpha(START_STYLE_ALPHA); 876 Rosen::RSAnimationTimingProtocol windowProtocol; 877 Rosen::RSAnimationTimingProtocol styleProtocol; 878 windowProtocol.SetDuration(TIME_STOP_SUCCESS_WINDOW); 879 styleProtocol.SetDuration(TIME_STOP_SUCCESS_STYLE); 880 auto springCurveSuccessWindow = Rosen::RSAnimationTimingCurve::CreateCubicCurve(BEZIER_040, BEZIER_000, 881 BEZIER_100, BEZIER_100); 882 auto springCurveSuccessStyle = Rosen::RSAnimationTimingCurve::CreateCubicCurve(BEZIER_000, BEZIER_000, 883 BEZIER_100, BEZIER_100); 884 Rosen::RSNode::Animate(windowProtocol, springCurveSuccessWindow, [&]() { 885 drawDragStopModifier_->SetAlpha(BEGIN_ALPHA); 886 drawDragStopModifier_->SetScale(END_SCALE_SUCCESS); 887 Rosen::RSNode::Animate(styleProtocol, springCurveSuccessStyle, [&]() { 888 drawDragStopModifier_->SetStyleAlpha(END_STYLE_ALPHA); 889 drawDragStopModifier_->SetStyleScale(START_STYLE_SCALE); 890 }); 891 }); 892 DoEndAnimation(); 893 FI_HILOGI("leave"); 894 } 895 OnStopDragSuccess(std::shared_ptr<Rosen::RSCanvasNode> shadowNode,std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode)896 void DragDrawing::OnStopDragSuccess(std::shared_ptr<Rosen::RSCanvasNode> shadowNode, 897 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode) 898 { 899 FI_HILOGD("enter"); 900 auto animateCb = [this] { return this->InitVSync(END_ALPHA, END_SCALE_SUCCESS); }; 901 #ifdef OHOS_DRAG_ENABLE_ANIMATION 902 ResetAnimationParameter(); 903 auto runner = AppExecFwk::EventRunner::Create(THREAD_NAME); 904 CHKPV(runner); 905 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner)); 906 if (!handler_->PostTask([this] { return this->OnStopAnimationSuccess(); })) { 907 FI_HILOGE("Failed to stop style animation"); 908 RunAnimation(animateCb); 909 } 910 #else // OHOS_DRAG_ENABLE_ANIMATION 911 RunAnimation(animateCb); 912 #endif // OHOS_DRAG_ENABLE_ANIMATION 913 FI_HILOGD("leave"); 914 } 915 OnStopAnimationFail()916 void DragDrawing::OnStopAnimationFail() 917 { 918 FI_HILOGI("enter"); 919 if (!CheckNodesValid()) { 920 FI_HILOGE("Check nodes valid failed"); 921 return; 922 } 923 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 924 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 925 return; 926 } 927 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 928 if (dragStyleNode != nullptr && drawStyleScaleModifier_ != nullptr) { 929 dragStyleNode->RemoveModifier(drawStyleScaleModifier_); 930 dragStyleNode->RemoveAllAnimations(); 931 drawStyleScaleModifier_ = nullptr; 932 needBreakStyleScaleAnimation_ = true; 933 } 934 CHKPV(g_drawingInfo.rootNode); 935 if (drawDragStopModifier_ != nullptr) { 936 g_drawingInfo.rootNode->RemoveModifier(drawDragStopModifier_); 937 drawDragStopModifier_ = nullptr; 938 } 939 drawDragStopModifier_ = std::make_shared<DrawDragStopModifier>(); 940 hasRunningStopAnimation_ = true; 941 g_drawingInfo.rootNode->AddModifier(drawDragStopModifier_); 942 drawDragStopModifier_->SetAlpha(BEGIN_ALPHA); 943 drawDragStopModifier_->SetScale(BEGIN_SCALE); 944 drawDragStopModifier_->SetStyleScale(START_STYLE_SCALE); 945 drawDragStopModifier_->SetStyleAlpha(START_STYLE_ALPHA); 946 Rosen::RSAnimationTimingProtocol protocol; 947 protocol.SetDuration(TIME_STOP_FAIL_WINDOW); 948 auto springCurveFail = Rosen::RSAnimationTimingCurve::CreateCubicCurve(BEZIER_033, BEZIER_000, 949 BEZIER_067, BEZIER_100); 950 Rosen::RSNode::Animate(protocol, springCurveFail, [&]() { 951 drawDragStopModifier_->SetAlpha(END_ALPHA); 952 drawDragStopModifier_->SetScale(END_SCALE_FAIL); 953 drawDragStopModifier_->SetStyleScale(START_STYLE_SCALE); 954 drawDragStopModifier_->SetStyleAlpha(END_STYLE_ALPHA); 955 }); 956 DoEndAnimation(); 957 FI_HILOGI("leave"); 958 } 959 OnStopDragFail(std::shared_ptr<Rosen::RSSurfaceNode> surfaceNode,std::shared_ptr<Rosen::RSNode> rootNode)960 void DragDrawing::OnStopDragFail(std::shared_ptr<Rosen::RSSurfaceNode> surfaceNode, 961 std::shared_ptr<Rosen::RSNode> rootNode) 962 { 963 FI_HILOGD("enter"); 964 auto animateCb = [this] { return this->InitVSync(END_ALPHA, END_SCALE_FAIL); }; 965 #ifdef OHOS_DRAG_ENABLE_ANIMATION 966 ResetAnimationParameter(); 967 auto runner = AppExecFwk::EventRunner::Create(THREAD_NAME); 968 CHKPV(runner); 969 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner)); 970 if (!handler_->PostTask([this] { this->OnStopAnimationFail(); })) { 971 FI_HILOGE("Failed to stop style animation"); 972 RunAnimation(animateCb); 973 } 974 #else // OHOS_DRAG_ENABLE_ANIMATION 975 RunAnimation(animateCb); 976 #endif // OHOS_DRAG_ENABLE_ANIMATION 977 FI_HILOGD("leave"); 978 } 979 OnStopAnimation()980 void DragDrawing::OnStopAnimation() 981 { 982 FI_HILOGD("enter"); 983 } 984 RunAnimation(std::function<int32_t ()> cb)985 int32_t DragDrawing::RunAnimation(std::function<int32_t()> cb) 986 { 987 FI_HILOGD("enter"); 988 ResetAnimationParameter(); 989 auto runner = AppExecFwk::EventRunner::Create(THREAD_NAME); 990 CHKPR(runner, RET_ERR); 991 handler_ = std::make_shared<AppExecFwk::EventHandler>(std::move(runner)); 992 if (!handler_->PostTask(cb)) { 993 FI_HILOGE("Send vsync event failed"); 994 return RET_ERR; 995 } 996 FI_HILOGD("leave"); 997 return RET_OK; 998 } 999 DrawShadow(std::shared_ptr<Rosen::RSCanvasNode> shadowNode)1000 int32_t DragDrawing::DrawShadow(std::shared_ptr<Rosen::RSCanvasNode> shadowNode) 1001 { 1002 FI_HILOGD("enter"); 1003 CHKPR(shadowNode, RET_ERR); 1004 if (drawPixelMapModifier_ != nullptr) { 1005 shadowNode->RemoveModifier(drawPixelMapModifier_); 1006 drawPixelMapModifier_ = nullptr; 1007 } 1008 drawPixelMapModifier_ = std::make_shared<DrawPixelMapModifier>(); 1009 shadowNode->AddModifier(drawPixelMapModifier_); 1010 FilterInfo filterInfo = g_drawingInfo.filterInfo; 1011 Rosen::Vector4f cornerRadiusVector = { filterInfo.cornerRadius1, filterInfo.cornerRadius2, 1012 filterInfo.cornerRadius3, filterInfo.cornerRadius4 }; 1013 shadowNode->SetCornerRadius(cornerRadiusVector * filterInfo.dipScale * filterInfo.scale); 1014 shadowNode->SetAlpha(filterInfo.opacity); 1015 FI_HILOGD("leave"); 1016 return RET_OK; 1017 } 1018 DrawMouseIcon()1019 int32_t DragDrawing::DrawMouseIcon() 1020 { 1021 FI_HILOGD("enter"); 1022 if (g_drawingInfo.nodes.size() < MOUSE_NODE_MIN_COUNT) { 1023 FI_HILOGE("Nodes size invalid, node size:%{public}zu", g_drawingInfo.nodes.size()); 1024 return RET_ERR; 1025 } 1026 if (g_drawingInfo.nodes.size() <= MOUSE_ICON_INDEX) { 1027 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 1028 return RET_ERR; 1029 } 1030 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = g_drawingInfo.nodes[MOUSE_ICON_INDEX]; 1031 CHKPR(mouseIconNode, RET_ERR); 1032 if (drawMouseIconModifier_ != nullptr) { 1033 mouseIconNode->RemoveModifier(drawMouseIconModifier_); 1034 drawMouseIconModifier_ = nullptr; 1035 } 1036 int32_t ret = MMI::InputManager::GetInstance()->GetPointerStyle(GLOBAL_WINDOW_ID, pointerStyle_); 1037 if (ret != RET_OK) { 1038 FI_HILOGE("Get pointer style failed, ret:%{public}d", ret); 1039 return RET_ERR; 1040 } 1041 drawMouseIconModifier_ = std::make_shared<DrawMouseIconModifier>(pointerStyle_); 1042 mouseIconNode->AddModifier(drawMouseIconModifier_); 1043 FI_HILOGD("leave"); 1044 return RET_OK; 1045 } 1046 FlushDragPosition(uint64_t nanoTimestamp)1047 void DragDrawing::FlushDragPosition(uint64_t nanoTimestamp) 1048 { 1049 if (rsUiDirector_ != nullptr) { 1050 rsUiDirector_->SetTimeStamp(nanoTimestamp, RENDER_THREAD_NAME); 1051 } else { 1052 FI_HILOGE("rsUiDirector_ is nullptr"); 1053 } 1054 DragMoveEvent event = dragSmoothProcessor_.SmoothMoveEvent(nanoTimestamp, 1055 vSyncStation_.GetVSyncPeriod()); 1056 FI_HILOGD("Move position x:%{private}f, y:%{private}f, timestamp:%{public}" PRId64 1057 "displayId:%{public}d", event.displayX, event.displayY, event.timestamp, event.displayId); 1058 UpdateDragPosition(event.displayId, event.displayX, event.displayY); 1059 } 1060 OnDragMove(int32_t displayId,int32_t displayX,int32_t displayY,int64_t actionTime)1061 void DragDrawing::OnDragMove(int32_t displayId, int32_t displayX, int32_t displayY, int64_t actionTime) 1062 { 1063 if (isRunningRotateAnimation_) { 1064 FI_HILOGD("Doing rotate drag window animate, ignore draw drag window"); 1065 return; 1066 } 1067 std::chrono::microseconds microseconds(actionTime); 1068 TimeStamp time(microseconds); 1069 uint64_t actionTimeCount = static_cast<uint64_t>(time.time_since_epoch().count()); 1070 DragMoveEvent event = { 1071 .displayX = displayX, 1072 .displayY = displayY, 1073 .displayId = displayId, 1074 .timestamp = actionTimeCount, 1075 }; 1076 dragSmoothProcessor_.InsertEvent(event); 1077 if (frameCallback_ == nullptr) { 1078 frameCallback_ = std::make_shared<DragFrameCallback>([this](uint64_t nanoTimestamp) { 1079 this->FlushDragPosition(nanoTimestamp); 1080 }); 1081 } 1082 vSyncStation_.RequestFrame(TYPE_FLUSH_DRAG_POSITION, frameCallback_); 1083 } 1084 DrawStyle(std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode,std::shared_ptr<Media::PixelMap> stylePixelMap)1085 int32_t DragDrawing::DrawStyle(std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode, 1086 std::shared_ptr<Media::PixelMap> stylePixelMap) 1087 { 1088 FI_HILOGD("enter"); 1089 CHKPR(dragStyleNode, RET_ERR); 1090 CHKPR(stylePixelMap, RET_ERR); 1091 if (drawSVGModifier_ != nullptr) { 1092 dragStyleNode->RemoveModifier(drawSVGModifier_); 1093 drawSVGModifier_ = nullptr; 1094 } 1095 drawSVGModifier_ = std::make_shared<DrawSVGModifier>(stylePixelMap); 1096 dragStyleNode->AddModifier(drawSVGModifier_); 1097 FI_HILOGD("leave"); 1098 return RET_OK; 1099 } 1100 InitVSync(float endAlpha,float endScale)1101 int32_t DragDrawing::InitVSync(float endAlpha, float endScale) 1102 { 1103 FI_HILOGD("enter"); 1104 CHKPR(g_drawingInfo.rootNode, RET_ERR); 1105 if (drawDynamicEffectModifier_ != nullptr) { 1106 g_drawingInfo.rootNode->RemoveModifier(drawDynamicEffectModifier_); 1107 drawDynamicEffectModifier_ = nullptr; 1108 } 1109 drawDynamicEffectModifier_ = std::make_shared<DrawDynamicEffectModifier>(); 1110 g_drawingInfo.rootNode->AddModifier(drawDynamicEffectModifier_); 1111 drawDynamicEffectModifier_->SetAlpha(BEGIN_ALPHA); 1112 drawDynamicEffectModifier_->SetScale(BEGIN_SCALE); 1113 1114 Rosen::RSAnimationTimingProtocol protocol; 1115 protocol.SetDuration(SUCCESS_ANIMATION_DURATION); 1116 Rosen::RSNode::Animate(protocol, Rosen::RSAnimationTimingCurve::EASE_IN_OUT, [&]() { 1117 drawDynamicEffectModifier_->SetAlpha(endAlpha); 1118 drawDynamicEffectModifier_->SetScale(endScale); 1119 }); 1120 Rosen::RSTransaction::FlushImplicitTransaction(); 1121 DoEndAnimation(); 1122 FI_HILOGD("leave"); 1123 return RET_OK; 1124 } 1125 StartVsync()1126 int32_t DragDrawing::StartVsync() 1127 { 1128 FI_HILOGI("enter"); 1129 if (receiver_ == nullptr) { 1130 CHKPR(handler_, RET_ERR); 1131 receiver_ = Rosen::RSInterfaces::GetInstance().CreateVSyncReceiver("DragDrawing", handler_); 1132 CHKPR(receiver_, RET_ERR); 1133 } 1134 int32_t ret = receiver_->Init(); 1135 if (ret != RET_OK) { 1136 FI_HILOGE("Receiver init failed"); 1137 return RET_ERR; 1138 } 1139 Rosen::VSyncReceiver::FrameCallback fcb = { 1140 .userData_ = this, 1141 .callback_ = [this](int64_t parm1, void *parm2) { this->OnVsync(); } 1142 }; 1143 ret = receiver_->RequestNextVSync(fcb); 1144 if (ret != RET_OK) { 1145 FI_HILOGE("Request next vsync failed"); 1146 } 1147 FI_HILOGI("leave"); 1148 return ret; 1149 } 1150 OnVsync()1151 void DragDrawing::OnVsync() 1152 { 1153 FI_HILOGD("enter"); 1154 CHKPV(rsUiDirector_); 1155 bool hasRunningAnimation = rsUiDirector_->FlushAnimation(g_drawingInfo.startNum); 1156 rsUiDirector_->FlushModifier(); 1157 rsUiDirector_->SendMessages(); 1158 if (!hasRunningAnimation) { 1159 FI_HILOGI("Stop runner, hasRunningAnimation:%{public}d, needDestroyDragWindow:%{public}d", 1160 hasRunningAnimation, g_drawingInfo.needDestroyDragWindow.load()); 1161 if (g_drawingInfo.needDestroyDragWindow) { 1162 ResetAnimationFlag(); 1163 } 1164 return; 1165 } 1166 Rosen::VSyncReceiver::FrameCallback fcb = { 1167 .userData_ = this, 1168 .callback_ = [this](int64_t parm1, void *parm2) { this->OnVsync(); } 1169 }; 1170 CHKPV(receiver_); 1171 int32_t ret = receiver_->RequestNextVSync(fcb); 1172 if (ret != RET_OK) { 1173 FI_HILOGE("Request next vsync failed"); 1174 } 1175 rsUiDirector_->SendMessages(); 1176 g_drawingInfo.startNum += INTERVAL_TIME; 1177 FI_HILOGD("leave"); 1178 } 1179 InitDrawingInfo(const DragData & dragData)1180 void DragDrawing::InitDrawingInfo(const DragData &dragData) 1181 { 1182 g_drawingInfo.isRunning = true; 1183 if (dragData.shadowInfos.empty()) { 1184 FI_HILOGE("ShadowInfos is empty"); 1185 return; 1186 } 1187 g_drawingInfo.pixelMap = dragData.shadowInfos.front().pixelMap; 1188 g_drawingInfo.pixelMapX = dragData.shadowInfos.front().x; 1189 g_drawingInfo.pixelMapY = dragData.shadowInfos.front().y; 1190 float dragOriginDpi = DRAG_DATA_MGR.GetDragOriginDpi(); 1191 if (dragOriginDpi > EPSILON) { 1192 float scalingValue = GetScaling() / dragOriginDpi; 1193 CHKPV(g_drawingInfo.pixelMap); 1194 g_drawingInfo.pixelMap->scale(scalingValue, scalingValue, Media::AntiAliasingOption::HIGH); 1195 g_drawingInfo.pixelMapX = g_drawingInfo.pixelMapX * scalingValue; 1196 g_drawingInfo.pixelMapY = g_drawingInfo.pixelMapY * scalingValue; 1197 if (fabs(scalingValue - 1.0f) > EPSILON) { 1198 float widthScale = CalculateWidthScale(); 1199 CHKPV(g_drawingInfo.pixelMap); 1200 g_drawingInfo.pixelMap->scale(widthScale, widthScale, Media::AntiAliasingOption::HIGH); 1201 g_drawingInfo.pixelMapX = g_drawingInfo.pixelMapX * widthScale; 1202 g_drawingInfo.pixelMapY = g_drawingInfo.pixelMapY * widthScale; 1203 } 1204 } 1205 g_drawingInfo.currentDragNum = dragData.dragNum; 1206 g_drawingInfo.sourceType = dragData.sourceType; 1207 g_drawingInfo.displayId = dragData.displayId; 1208 g_drawingInfo.displayX = dragData.displayX; 1209 g_drawingInfo.displayY = dragData.displayY; 1210 RotateDisplayXY(g_drawingInfo.displayX, g_drawingInfo.displayY); 1211 if (!ParserExtraInfo(dragData.extraInfo, g_drawingInfo.extraInfo)) { 1212 FI_HILOGI("No parser valid extraInfo data"); 1213 } 1214 if (!ParserFilterInfo(dragData.filterInfo, g_drawingInfo.filterInfo)) { 1215 FI_HILOGI("No parser valid filterInfo data"); 1216 } 1217 size_t shadowInfosSize = dragData.shadowInfos.size(); 1218 for (size_t i = 1; i < shadowInfosSize; ++i) { 1219 std::shared_ptr<Media::PixelMap> pixelMap = dragData.shadowInfos[i].pixelMap; 1220 if (dragOriginDpi > EPSILON) { 1221 float scalingValue = GetScaling() / dragOriginDpi; 1222 CHKPV(pixelMap); 1223 pixelMap->scale(scalingValue, scalingValue, Media::AntiAliasingOption::HIGH); 1224 } 1225 g_drawingInfo.multiSelectedPixelMaps.emplace_back(pixelMap); 1226 } 1227 } 1228 InitDragAnimationData(DragAnimationData & dragAnimationData)1229 int32_t DragDrawing::InitDragAnimationData(DragAnimationData &dragAnimationData) 1230 { 1231 CHKPR(g_drawingInfo.pixelMap, RET_ERR); 1232 dragAnimationData.pixelMap = g_drawingInfo.pixelMap; 1233 dragAnimationData.displayX = g_drawingInfo.displayX; 1234 dragAnimationData.displayY = g_drawingInfo.displayY; 1235 dragAnimationData.offsetX = g_drawingInfo.pixelMapX; 1236 dragAnimationData.offsetY = g_drawingInfo.pixelMapY; 1237 return RET_OK; 1238 } 1239 InitLayer()1240 int32_t DragDrawing::InitLayer() 1241 { 1242 FI_HILOGI("enter"); 1243 if (g_drawingInfo.surfaceNode == nullptr) { 1244 FI_HILOGE("Init layer failed, surfaceNode is nullptr"); 1245 return RET_ERR; 1246 } 1247 auto surface = g_drawingInfo.surfaceNode->GetSurface(); 1248 if (surface == nullptr) { 1249 g_drawingInfo.surfaceNode->DetachToDisplay(g_drawingInfo.displayId); 1250 g_drawingInfo.surfaceNode = nullptr; 1251 FI_HILOGE("Init layer failed, surface is nullptr"); 1252 Rosen::RSTransaction::FlushImplicitTransaction(); 1253 return RET_ERR; 1254 } 1255 if (g_drawingInfo.isInitUiDirector) { 1256 g_drawingInfo.isInitUiDirector = false; 1257 rsUiDirector_ = Rosen::RSUIDirector::Create(); 1258 CHKPR(rsUiDirector_, RET_ERR); 1259 rsUiDirector_->Init(); 1260 } 1261 rsUiDirector_->SetRSSurfaceNode(g_drawingInfo.surfaceNode); 1262 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 1263 if (display == nullptr) { 1264 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 1265 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 1266 if (display == nullptr) { 1267 FI_HILOGE("Get display info failed, display is nullptr"); 1268 return RET_ERR; 1269 } 1270 } 1271 int32_t rootNodeSize = std::max(display->GetWidth(), display->GetHeight()); 1272 InitCanvas(rootNodeSize, rootNodeSize); 1273 if (rotation_ != Rosen::Rotation::ROTATION_0) { 1274 RotateDragWindow(rotation_); 1275 } else { 1276 DragWindowRotateInfo_.rotation = ROTATION_0; 1277 } 1278 Rosen::RSTransaction::FlushImplicitTransaction(); 1279 FI_HILOGI("leave"); 1280 return RET_OK; 1281 } 1282 InitCanvas(int32_t width,int32_t height)1283 void DragDrawing::InitCanvas(int32_t width, int32_t height) 1284 { 1285 FI_HILOGI("enter"); 1286 if (g_drawingInfo.rootNode == nullptr) { 1287 g_drawingInfo.rootNode = Rosen::RSRootNode::Create(); 1288 CHKPV(g_drawingInfo.rootNode); 1289 } 1290 g_drawingInfo.rootNode->SetBounds(0, 0, width, height); 1291 g_drawingInfo.rootNode->SetFrame(0, 0, width, height); 1292 g_drawingInfo.rootNode->SetBackgroundColor(SK_ColorTRANSPARENT); 1293 std::shared_ptr<Rosen::RSCanvasNode> filterNode = Rosen::RSCanvasNode::Create(); 1294 CHKPV(filterNode); 1295 g_drawingInfo.nodes.emplace_back(filterNode); 1296 ProcessFilter(); 1297 std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode = Rosen::RSCanvasNode::Create(); 1298 CHKPV(pixelMapNode); 1299 pixelMapNode->SetForegroundColor(TRANSPARENT_COLOR_ARGB); 1300 pixelMapNode->SetGrayScale(g_drawingInfo.filterInfo.dragNodeGrayscale); 1301 g_drawingInfo.nodes.emplace_back(pixelMapNode); 1302 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = Rosen::RSCanvasNode::Create(); 1303 CHKPV(dragStyleNode); 1304 g_drawingInfo.nodes.emplace_back(dragStyleNode); 1305 if (g_drawingInfo.parentNode == nullptr) { 1306 g_drawingInfo.parentNode = Rosen::RSCanvasNode::Create(); 1307 CHKPV(g_drawingInfo.parentNode); 1308 } 1309 g_drawingInfo.parentNode->AddChild(filterNode); 1310 g_drawingInfo.parentNode->AddChild(pixelMapNode); 1311 if (!g_drawingInfo.multiSelectedPixelMaps.empty()) { 1312 InitMultiSelectedNodes(); 1313 if (!g_drawingInfo.multiSelectedNodes.empty()) { 1314 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 1315 for (size_t i = 0; i < multiSelectedNodesSize; ++i) { 1316 g_drawingInfo.rootNode->AddChild(g_drawingInfo.multiSelectedNodes[i]); 1317 } 1318 } 1319 } 1320 g_drawingInfo.rootNode->AddChild(g_drawingInfo.parentNode); 1321 CHKPV(rsUiDirector_); 1322 if (g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 1323 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = Rosen::RSCanvasNode::Create(); 1324 CHKPV(mouseIconNode); 1325 g_drawingInfo.nodes.emplace_back(mouseIconNode); 1326 g_drawingInfo.rootNode->AddChild(mouseIconNode); 1327 rsUiDirector_->SetRoot(g_drawingInfo.rootNode->GetId()); 1328 return; 1329 } 1330 rsUiDirector_->SetRoot(g_drawingInfo.rootNode->GetId()); 1331 FI_HILOGI("leave"); 1332 } 1333 CreateWindow()1334 void DragDrawing::CreateWindow() 1335 { 1336 FI_HILOGD("Parameter screen number:%{public}llu", static_cast<unsigned long long>(screenId_)); 1337 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1338 surfaceNodeConfig.SurfaceNodeName = "drag window"; 1339 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1340 g_drawingInfo.surfaceNode = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1341 CHKPV(g_drawingInfo.surfaceNode); 1342 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 1343 if (display == nullptr) { 1344 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 1345 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 1346 if (display == nullptr) { 1347 FI_HILOGE("Get display info failed, display is nullptr"); 1348 return; 1349 } 1350 } 1351 uint64_t rsScreenId = screenId_; 1352 sptr<Rosen::Screen> screen = Rosen::ScreenManager::GetInstance().GetScreenById(screenId_); 1353 if ((screen != nullptr) && (!screen->IsReal())) { 1354 if (!Rosen::DisplayManager::GetInstance().ConvertScreenIdToRsScreenId(screenId_, rsScreenId)) { 1355 FI_HILOGE("ConvertScreenIdToRsScreenId failed"); 1356 return; 1357 } 1358 } 1359 int32_t surfaceNodeSize = std::max(display->GetWidth(), display->GetHeight()); 1360 g_drawingInfo.surfaceNode->SetBounds(0, 0, surfaceNodeSize, surfaceNodeSize); 1361 g_drawingInfo.surfaceNode->SetFrameGravity(Rosen::Gravity::RESIZE_ASPECT_FILL); 1362 g_drawingInfo.surfaceNode->SetPositionZ(DRAG_WINDOW_POSITION_Z); 1363 g_drawingInfo.surfaceNode->SetBackgroundColor(SK_ColorTRANSPARENT); 1364 g_drawingInfo.surfaceNode->AttachToDisplay(rsScreenId); 1365 g_drawingInfo.surfaceNode->SetVisible(false); 1366 Rosen::RSTransaction::FlushImplicitTransaction(); 1367 } 1368 RemoveModifier()1369 void DragDrawing::RemoveModifier() 1370 { 1371 FI_HILOGD("enter"); 1372 if ((g_drawingInfo.nodes.size() < TOUCH_NODE_MIN_COUNT)) { 1373 FI_HILOGE("Nodes size invalid, node size:%{public}zu", g_drawingInfo.nodes.size()); 1374 return; 1375 } 1376 1377 if (g_drawingInfo.nodes.size() <= PIXEL_MAP_INDEX || g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 1378 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 1379 return; 1380 } 1381 std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode = g_drawingInfo.nodes[PIXEL_MAP_INDEX]; 1382 CHKPV(pixelMapNode); 1383 if (drawPixelMapModifier_ != nullptr) { 1384 pixelMapNode->RemoveModifier(drawPixelMapModifier_); 1385 drawPixelMapModifier_ = nullptr; 1386 } 1387 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 1388 CHKPV(dragStyleNode); 1389 if (drawSVGModifier_ != nullptr) { 1390 dragStyleNode->RemoveModifier(drawSVGModifier_); 1391 drawSVGModifier_ = nullptr; 1392 } 1393 FI_HILOGD("leave"); 1394 } 1395 UpdateSvgNodeInfo(xmlNodePtr curNode,int32_t extendSvgWidth)1396 int32_t DragDrawing::UpdateSvgNodeInfo(xmlNodePtr curNode, int32_t extendSvgWidth) 1397 { 1398 FI_HILOGD("enter"); 1399 if (xmlStrcmp(curNode->name, BAD_CAST "svg")) { 1400 FI_HILOGE("Svg format invalid"); 1401 return RET_ERR; 1402 } 1403 std::ostringstream oStrStream; 1404 oStrStream << xmlGetProp(curNode, BAD_CAST "width"); 1405 std::string srcSvgWidth = oStrStream.str(); 1406 if (srcSvgWidth.length() < STRING_PX_LENGTH) { 1407 FI_HILOGE("Svg width invalid, srcSvgWidth:%{public}s", srcSvgWidth.c_str()); 1408 return RET_ERR; 1409 } 1410 srcSvgWidth = srcSvgWidth.substr(0, srcSvgWidth.length() - STRING_PX_LENGTH); 1411 if (!IsNum(srcSvgWidth)) { 1412 FI_HILOGE("srcSvgWidth is not digital, srcSvgWidth:%{public}s", srcSvgWidth.c_str()); 1413 return RET_ERR; 1414 } 1415 int32_t number = std::stoi(srcSvgWidth) + extendSvgWidth; 1416 std::string tgtSvgWidth = std::to_string(number); 1417 tgtSvgWidth.append("px"); 1418 xmlSetProp(curNode, BAD_CAST "width", BAD_CAST tgtSvgWidth.c_str()); 1419 oStrStream.str(""); 1420 oStrStream << xmlGetProp(curNode, BAD_CAST "viewBox"); 1421 std::string srcViewBox = oStrStream.str(); 1422 std::istringstream iStrStream(srcViewBox); 1423 std::string tmpString; 1424 std::string tgtViewBox; 1425 int32_t i = 0; 1426 while (iStrStream >> tmpString) { 1427 if (i == VIEW_BOX_POS) { 1428 if (!IsNum(tmpString)) { 1429 FI_HILOGE("tmpString is not digital, tmpString:%{public}s", tmpString.c_str()); 1430 return RET_ERR; 1431 } 1432 number = std::stoi(tmpString) + extendSvgWidth; 1433 tmpString = std::to_string(number); 1434 } 1435 tgtViewBox.append(tmpString); 1436 tgtViewBox += " "; 1437 ++i; 1438 } 1439 1440 xmlSetProp(curNode, BAD_CAST "viewBox", BAD_CAST tgtViewBox.c_str()); 1441 FI_HILOGD("leave"); 1442 return RET_OK; 1443 } 1444 GetRectNode(xmlNodePtr curNode)1445 xmlNodePtr DragDrawing::GetRectNode(xmlNodePtr curNode) 1446 { 1447 FI_HILOGD("enter"); 1448 curNode = curNode->xmlChildrenNode; 1449 while (curNode != nullptr) { 1450 if (!xmlStrcmp(curNode->name, BAD_CAST "g")) { 1451 while (!xmlStrcmp(curNode->name, BAD_CAST "g")) { 1452 curNode = curNode->xmlChildrenNode; 1453 } 1454 break; 1455 } 1456 curNode = curNode->next; 1457 } 1458 FI_HILOGD("leave"); 1459 return curNode; 1460 } 1461 UpdateRectNode(int32_t extendSvgWidth,xmlNodePtr curNode)1462 xmlNodePtr DragDrawing::UpdateRectNode(int32_t extendSvgWidth, xmlNodePtr curNode) 1463 { 1464 FI_HILOGD("enter"); 1465 while (curNode != nullptr) { 1466 if (!xmlStrcmp(curNode->name, BAD_CAST "rect")) { 1467 std::ostringstream oStrStream; 1468 oStrStream << xmlGetProp(curNode, BAD_CAST "width"); 1469 std::string srcRectWidth = oStrStream.str(); 1470 if (!IsNum(srcRectWidth)) { 1471 FI_HILOGE("srcRectWidth is not digital, srcRectWidth:%{public}s", srcRectWidth.c_str()); 1472 return nullptr; 1473 } 1474 int32_t number = std::stoi(srcRectWidth) + extendSvgWidth; 1475 xmlSetProp(curNode, BAD_CAST "width", BAD_CAST std::to_string(number).c_str()); 1476 } 1477 if (!xmlStrcmp(curNode->name, BAD_CAST "text")) { 1478 return curNode->xmlChildrenNode; 1479 } 1480 curNode = curNode->next; 1481 } 1482 FI_HILOGE("Empty node of XML"); 1483 return nullptr; 1484 } 1485 UpdateTspanNode(xmlNodePtr curNode)1486 void DragDrawing::UpdateTspanNode(xmlNodePtr curNode) 1487 { 1488 FI_HILOGD("enter"); 1489 while (curNode != nullptr) { 1490 if (!xmlStrcmp(curNode->name, BAD_CAST "tspan")) { 1491 xmlNodeSetContent(curNode, BAD_CAST std::to_string(g_drawingInfo.currentDragNum).c_str()); 1492 } 1493 curNode = curNode->next; 1494 } 1495 FI_HILOGD("leave"); 1496 } 1497 ParseAndAdjustSvgInfo(xmlNodePtr curNode)1498 int32_t DragDrawing::ParseAndAdjustSvgInfo(xmlNodePtr curNode) 1499 { 1500 FI_HILOGD("enter"); 1501 CHKPR(curNode, RET_ERR); 1502 std::string strStyle = std::to_string(g_drawingInfo.currentDragNum); 1503 if (strStyle.empty()) { 1504 FI_HILOGE("strStyle size:%{public}zu invalid", strStyle.size()); 1505 return RET_ERR; 1506 } 1507 int32_t extendSvgWidth = (static_cast<int32_t>(strStyle.size()) - 1) * EIGHT_SIZE; 1508 xmlKeepBlanksDefault(0); 1509 int32_t ret = UpdateSvgNodeInfo(curNode, extendSvgWidth); 1510 if (ret != RET_OK) { 1511 FI_HILOGE("Update svg node info failed, ret:%{public}d", ret); 1512 return RET_ERR; 1513 } 1514 curNode = GetRectNode(curNode); 1515 CHKPR(curNode, RET_ERR); 1516 curNode = UpdateRectNode(extendSvgWidth, curNode); 1517 CHKPR(curNode, RET_ERR); 1518 UpdateTspanNode(curNode); 1519 FI_HILOGD("leave"); 1520 return RET_OK; 1521 } 1522 DecodeSvgToPixelMap(const std::string & filePath)1523 std::shared_ptr<Media::PixelMap> DragDrawing::DecodeSvgToPixelMap( 1524 const std::string &filePath) 1525 { 1526 FI_HILOGD("enter"); 1527 xmlDocPtr xmlDoc = xmlReadFile(filePath.c_str(), 0, XML_PARSE_NOBLANKS); 1528 if (NeedAdjustSvgInfo()) { 1529 xmlNodePtr node = xmlDocGetRootElement(xmlDoc); 1530 CHKPP(node); 1531 int32_t ret = ParseAndAdjustSvgInfo(node); 1532 if (ret != RET_OK) { 1533 FI_HILOGE("Parse and adjust svg info failed, ret:%{public}d", ret); 1534 return nullptr; 1535 } 1536 } 1537 xmlChar *xmlbuff = nullptr; 1538 int32_t buffersize = 0; 1539 xmlDocDumpFormatMemory(xmlDoc, &xmlbuff, &buffersize, 1); 1540 std::ostringstream oStrStream; 1541 oStrStream << xmlbuff; 1542 std::string content = oStrStream.str(); 1543 xmlFree(xmlbuff); 1544 xmlFreeDoc(xmlDoc); 1545 Media::SourceOptions opts; 1546 opts.formatHint = "image/svg+xml"; 1547 uint32_t errCode = 0; 1548 auto imageSource = Media::ImageSource::CreateImageSource(reinterpret_cast<const uint8_t*>(content.c_str()), 1549 content.size(), opts, errCode); 1550 CHKPP(imageSource); 1551 Media::DecodeOptions decodeOpts; 1552 SetDecodeOptions(decodeOpts); 1553 std::shared_ptr<Media::PixelMap> pixelMap = imageSource->CreatePixelMap(decodeOpts, errCode); 1554 FI_HILOGD("leave"); 1555 return pixelMap; 1556 } 1557 NeedAdjustSvgInfo()1558 bool DragDrawing::NeedAdjustSvgInfo() 1559 { 1560 FI_HILOGD("enter"); 1561 if (g_drawingInfo.currentStyle == DragCursorStyle::DEFAULT) { 1562 return false; 1563 } 1564 if ((g_drawingInfo.currentStyle == DragCursorStyle::COPY) && 1565 (g_drawingInfo.currentDragNum == DRAG_NUM_ONE)) { 1566 return false; 1567 } 1568 if ((g_drawingInfo.currentStyle == DragCursorStyle::MOVE) && 1569 (g_drawingInfo.currentDragNum == DRAG_NUM_ONE)) { 1570 return false; 1571 } 1572 if ((g_drawingInfo.currentStyle == DragCursorStyle::FORBIDDEN) && 1573 (g_drawingInfo.currentDragNum == DRAG_NUM_ONE)) { 1574 return false; 1575 } 1576 FI_HILOGD("leave"); 1577 return true; 1578 } 1579 GetFilePath(std::string & filePath)1580 int32_t DragDrawing::GetFilePath(std::string &filePath) 1581 { 1582 FI_HILOGD("enter"); 1583 switch (g_drawingInfo.currentStyle) { 1584 case DragCursorStyle::COPY: { 1585 if (g_drawingInfo.currentDragNum == DRAG_NUM_ONE) { 1586 filePath = COPY_ONE_DRAG_PATH; 1587 } else { 1588 filePath = COPY_DRAG_PATH; 1589 } 1590 break; 1591 } 1592 case DragCursorStyle::MOVE: { 1593 filePath = MOVE_DRAG_PATH; 1594 break; 1595 } 1596 case DragCursorStyle::FORBIDDEN: { 1597 if (g_drawingInfo.currentDragNum == DRAG_NUM_ONE) { 1598 filePath = FORBID_ONE_DRAG_PATH; 1599 } else { 1600 filePath = FORBID_DRAG_PATH; 1601 } 1602 break; 1603 } 1604 case DragCursorStyle::DEFAULT: 1605 default: { 1606 FI_HILOGW("Not need draw svg style, DragCursorStyle:%{public}d", g_drawingInfo.currentStyle); 1607 break; 1608 } 1609 } 1610 FI_HILOGD("leave"); 1611 return RET_OK; 1612 } 1613 SetDecodeOptions(Media::DecodeOptions & decodeOpts)1614 void DragDrawing::SetDecodeOptions(Media::DecodeOptions &decodeOpts) 1615 { 1616 FI_HILOGD("enter"); 1617 std::string strStyle = std::to_string(g_drawingInfo.currentDragNum); 1618 if (strStyle.empty()) { 1619 FI_HILOGE("strStyle size:%{public}zu invalid", strStyle.size()); 1620 return; 1621 } 1622 int32_t extendSvgWidth = (static_cast<int32_t>(strStyle.size()) - 1) * EIGHT_SIZE; 1623 if ((g_drawingInfo.currentStyle == DragCursorStyle::COPY) && (g_drawingInfo.currentDragNum == DRAG_NUM_ONE)) { 1624 decodeOpts.desiredSize = { 1625 .width = DEVICE_INDEPENDENT_PIXEL * GetScaling(), 1626 .height = DEVICE_INDEPENDENT_PIXEL * GetScaling() 1627 }; 1628 } else { 1629 decodeOpts.desiredSize = { 1630 .width = (DEVICE_INDEPENDENT_PIXEL + extendSvgWidth) * GetScaling(), 1631 .height = DEVICE_INDEPENDENT_PIXEL * GetScaling() 1632 }; 1633 } 1634 FI_HILOGD("leave"); 1635 } 1636 ParserDragShadowInfo(cJSON * filterInfoParser,FilterInfo & filterInfo)1637 void DragDrawing::ParserDragShadowInfo(cJSON* filterInfoParser, FilterInfo &filterInfo) 1638 { 1639 CHKPV(filterInfoParser); 1640 cJSON *offsetX = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "drag_shadow_offsetX"); 1641 if (cJSON_IsNumber(offsetX)) { 1642 filterInfo.offsetX = static_cast<float>(offsetX->valuedouble); 1643 } 1644 cJSON *offsetY = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "drag_shadow_offsetY"); 1645 if (cJSON_IsNumber(offsetY)) { 1646 filterInfo.offsetY = static_cast<float>(offsetY->valuedouble); 1647 } 1648 cJSON *argb = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "drag_shadow_argb"); 1649 if (cJSON_IsNumber(argb)) { 1650 filterInfo.argb = static_cast<uint32_t>(argb->valueint); 1651 } 1652 cJSON *shadowIsFilled = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "shadow_is_filled"); 1653 if (cJSON_IsBool(shadowIsFilled)) { 1654 filterInfo.shadowIsFilled = cJSON_IsTrue(shadowIsFilled); 1655 } 1656 cJSON *shadowMask = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "shadow_mask"); 1657 if (cJSON_IsBool(shadowMask)) { 1658 filterInfo.shadowMask = cJSON_IsTrue(shadowMask); 1659 } 1660 cJSON *shadowColorStrategy = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "shadow_color_strategy"); 1661 if (cJSON_IsNumber(shadowColorStrategy)) { 1662 filterInfo.shadowColorStrategy = shadowColorStrategy->valueint; 1663 } 1664 cJSON *isHardwareAcceleration = cJSON_GetObjectItemCaseSensitive( 1665 filterInfoParser, "shadow_is_hardwareacceleration"); 1666 if (cJSON_IsBool(isHardwareAcceleration)) { 1667 filterInfo.isHardwareAcceleration = cJSON_IsTrue(isHardwareAcceleration); 1668 } 1669 if (filterInfo.isHardwareAcceleration) { 1670 cJSON *elevation = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "shadow_elevation"); 1671 if (cJSON_IsNumber(elevation)) { 1672 filterInfo.elevation = static_cast<float>(elevation->valuedouble); 1673 } 1674 } else { 1675 cJSON *shadowCorner = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "shadow_corner"); 1676 if (cJSON_IsNumber(shadowCorner)) { 1677 filterInfo.shadowCorner = static_cast<float>(shadowCorner->valuedouble); 1678 } 1679 } 1680 } 1681 ParserTextDragShadowInfo(cJSON * filterInfoParser,FilterInfo & filterInfo)1682 void DragDrawing::ParserTextDragShadowInfo(cJSON* filterInfoParser, FilterInfo &filterInfo) 1683 { 1684 CHKPV(filterInfoParser); 1685 cJSON *path = cJSON_GetObjectItemCaseSensitive(filterInfoParser, "drag_shadow_path"); 1686 if (cJSON_IsString(path)) { 1687 float dragOriginDpi = DRAG_DATA_MGR.GetDragOriginDpi(); 1688 if (dragOriginDpi > EPSILON) { 1689 filterInfo.path = ""; 1690 } else { 1691 filterInfo.path = path->valuestring; 1692 } 1693 } 1694 } 1695 PrintDragShadowInfo()1696 void DragDrawing::PrintDragShadowInfo() 1697 { 1698 FilterInfo filterInfo = g_drawingInfo.filterInfo; 1699 if (!filterInfo.shadowEnable) { 1700 FI_HILOGI("Not supported shadow"); 1701 return; 1702 } 1703 FI_HILOGI("dragType:%{public}s, shadowIsFilled:%{public}s, shadowMask:%{public}s, shadowColorStrategy :%{public}d, " 1704 "shadowCorner:%{public}f, offsetX:%{private}f, offsetY:%{private}f, argb:%{public}u, elevation:%{public}f, " 1705 "isHardwareAcceleration:%{public}s", filterInfo.dragType.c_str(), 1706 filterInfo.shadowIsFilled ? "true" : "false", filterInfo.shadowMask ? "true" : "false", 1707 filterInfo.shadowColorStrategy, filterInfo.shadowCorner, filterInfo.offsetX, filterInfo.offsetY, 1708 filterInfo.argb, filterInfo.elevation, filterInfo.isHardwareAcceleration ? "true" : "false"); 1709 if (!filterInfo.path.empty()) { 1710 FI_HILOGI("path:%{private}s", filterInfo.path.c_str()); 1711 } 1712 } 1713 ParserFilterInfo(const std::string & filterInfoStr,FilterInfo & filterInfo)1714 bool DragDrawing::ParserFilterInfo(const std::string &filterInfoStr, FilterInfo &filterInfo) 1715 { 1716 FI_HILOGD("FilterInfo size:%{public}zu, filterInfo:%{public}s", filterInfoStr.size(), filterInfoStr.c_str()); 1717 if (filterInfoStr.empty()) { 1718 FI_HILOGD("FilterInfo is empty"); 1719 return false; 1720 } 1721 JsonParser filterInfoParser; 1722 filterInfoParser.json = cJSON_Parse(filterInfoStr.c_str()); 1723 if (!cJSON_IsObject(filterInfoParser.json)) { 1724 FI_HILOGE("FilterInfo is not json object"); 1725 return false; 1726 } 1727 cJSON *dipScale = cJSON_GetObjectItemCaseSensitive(filterInfoParser.json, "dip_scale"); 1728 if (cJSON_IsNumber(dipScale)) { 1729 filterInfo.dipScale = AdjustDoubleValue(dipScale->valuedouble); 1730 } 1731 cJSON *scale = cJSON_GetObjectItemCaseSensitive(filterInfoParser.json, "scale"); 1732 if (cJSON_IsNumber(scale)) { 1733 filterInfo.scale = AdjustDoubleValue(scale->valuedouble); 1734 } 1735 ParserCornerRadiusInfo(filterInfoParser.json, g_drawingInfo.filterInfo); 1736 cJSON *dragType = cJSON_GetObjectItemCaseSensitive(filterInfoParser.json, "drag_type"); 1737 if (cJSON_IsString(dragType)) { 1738 filterInfo.dragType = dragType->valuestring; 1739 } 1740 cJSON *shadowEnable = cJSON_GetObjectItemCaseSensitive(filterInfoParser.json, "shadow_enable"); 1741 if (cJSON_IsBool(shadowEnable)) { 1742 filterInfo.shadowEnable = cJSON_IsTrue(shadowEnable); 1743 } 1744 if (filterInfo.shadowEnable) { 1745 ParserDragShadowInfo(filterInfoParser.json, filterInfo); 1746 if (filterInfo.dragType == "text") { 1747 ParserTextDragShadowInfo(filterInfoParser.json, filterInfo); 1748 } 1749 PrintDragShadowInfo(); 1750 } 1751 ParserBlurInfo(filterInfoParser.json, g_drawingInfo.filterInfo); 1752 cJSON *dragNodeGrayscale = cJSON_GetObjectItemCaseSensitive(filterInfoParser.json, "drag_node_gray_scale"); 1753 if (cJSON_IsNumber(dragNodeGrayscale)) { 1754 filterInfo.dragNodeGrayscale = static_cast<float>(dragNodeGrayscale->valuedouble); 1755 } 1756 return true; 1757 } 1758 ParserCornerRadiusInfo(const cJSON * cornerRadiusInfoStr,FilterInfo & filterInfo)1759 void DragDrawing::ParserCornerRadiusInfo(const cJSON *cornerRadiusInfoStr, FilterInfo &filterInfo) 1760 { 1761 CHKPV(cornerRadiusInfoStr); 1762 cJSON *cornerRadius1 = cJSON_GetObjectItemCaseSensitive(cornerRadiusInfoStr, "drag_corner_radius1"); 1763 if (cJSON_IsNumber(cornerRadius1)) { 1764 filterInfo.cornerRadius1 = static_cast<float>(cornerRadius1->valuedouble); 1765 } 1766 cJSON *cornerRadius2 = cJSON_GetObjectItemCaseSensitive(cornerRadiusInfoStr, "drag_corner_radius2"); 1767 if (cJSON_IsNumber(cornerRadius2)) { 1768 filterInfo.cornerRadius2 = static_cast<float>(cornerRadius2->valuedouble); 1769 } 1770 cJSON *cornerRadius3 = cJSON_GetObjectItemCaseSensitive(cornerRadiusInfoStr, "drag_corner_radius3"); 1771 if (cJSON_IsNumber(cornerRadius3)) { 1772 filterInfo.cornerRadius3 = static_cast<float>(cornerRadius3->valuedouble); 1773 } 1774 cJSON *cornerRadius4 = cJSON_GetObjectItemCaseSensitive(cornerRadiusInfoStr, "drag_corner_radius4"); 1775 if (cJSON_IsNumber(cornerRadius4)) { 1776 filterInfo.cornerRadius4 = static_cast<float>(cornerRadius4->valuedouble); 1777 } 1778 } 1779 ParserBlurInfo(const cJSON * BlurInfoInfoStr,FilterInfo & filterInfo)1780 void DragDrawing::ParserBlurInfo(const cJSON *BlurInfoInfoStr, FilterInfo &filterInfo) 1781 { 1782 CHKPV(BlurInfoInfoStr); 1783 cJSON *opacity = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "dip_opacity"); 1784 if (cJSON_IsNumber(opacity)) { 1785 if ((opacity->valuedouble) > MAX_OPACITY || (opacity->valuedouble) <= MIN_OPACITY) { 1786 FI_HILOGE("Parser opacity limits abnormal, opacity:%{public}f", opacity->valuedouble); 1787 } else { 1788 filterInfo.opacity = static_cast<float>(opacity->valuedouble); 1789 } 1790 } 1791 float tempCoef1 = 0.0f; 1792 cJSON *coef1 = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_coef1"); 1793 if (cJSON_IsNumber(coef1)) { 1794 tempCoef1 = static_cast<float>(coef1->valuedouble); 1795 } 1796 float tempCoef2 = 0.0f; 1797 cJSON *coef2 = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_coef2"); 1798 if (cJSON_IsNumber(coef2)) { 1799 tempCoef2 = static_cast<float>(coef2->valuedouble); 1800 } 1801 filterInfo.coef = { tempCoef1, tempCoef2 }; 1802 cJSON *blurRadius = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_radius"); 1803 if (cJSON_IsNumber(blurRadius)) { 1804 filterInfo.blurRadius = AdjustDoubleValue(blurRadius->valuedouble); 1805 } 1806 cJSON *blurStaturation = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_staturation"); 1807 if (cJSON_IsNumber(blurStaturation)) { 1808 filterInfo.blurStaturation = static_cast<float>(blurStaturation->valuedouble); 1809 } 1810 cJSON *blurBrightness = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_brightness"); 1811 if (cJSON_IsNumber(blurBrightness)) { 1812 filterInfo.blurBrightness = static_cast<float>(blurBrightness->valuedouble); 1813 } 1814 cJSON *blurColor = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_color"); 1815 if (cJSON_IsNumber(blurColor)) { 1816 filterInfo.blurColor = static_cast<uint32_t>(blurColor->valueint); 1817 } 1818 cJSON *blurStyle = cJSON_GetObjectItemCaseSensitive(BlurInfoInfoStr, "blur_style"); 1819 if (cJSON_IsNumber(blurStyle)) { 1820 filterInfo.blurStyle = blurStyle->valueint; 1821 } 1822 return; 1823 } 1824 ParserExtraInfo(const std::string & extraInfoStr,ExtraInfo & extraInfo)1825 bool DragDrawing::ParserExtraInfo(const std::string &extraInfoStr, ExtraInfo &extraInfo) 1826 { 1827 FI_HILOGD("ExtraInfo size:%{public}zu, extraInfo:%{public}s", 1828 extraInfoStr.size(), extraInfoStr.c_str()); 1829 if (extraInfoStr.empty()) { 1830 FI_HILOGD("ExtraInfo is empty"); 1831 return false; 1832 } 1833 JsonParser extraInfoParser; 1834 extraInfoParser.json = cJSON_Parse(extraInfoStr.c_str()); 1835 if (!cJSON_IsObject(extraInfoParser.json)) { 1836 FI_HILOGE("ExtraInfo is not json object"); 1837 return false; 1838 } 1839 cJSON *componentType = cJSON_GetObjectItemCaseSensitive(extraInfoParser.json, "drag_data_type"); 1840 if (cJSON_IsString(componentType)) { 1841 extraInfo.componentType = componentType->valuestring; 1842 } 1843 cJSON *blurStyle = cJSON_GetObjectItemCaseSensitive(extraInfoParser.json, "drag_blur_style"); 1844 if (cJSON_IsNumber(blurStyle)) { 1845 extraInfo.blurStyle = blurStyle->valueint; 1846 } 1847 cJSON *cornerRadius = cJSON_GetObjectItemCaseSensitive(extraInfoParser.json, "drag_corner_radius"); 1848 if (cJSON_IsNumber(cornerRadius)) { 1849 extraInfo.cornerRadius = static_cast<float>(cornerRadius->valuedouble); 1850 } 1851 cJSON *allowDistributed = cJSON_GetObjectItemCaseSensitive(extraInfoParser.json, "drag_allow_distributed"); 1852 if (cJSON_IsBool(allowDistributed)) { 1853 extraInfo.allowDistributed = cJSON_IsTrue(allowDistributed) ? true : false; 1854 } 1855 float tempCoef1 = 0.0f; 1856 cJSON *coef1 = cJSON_GetObjectItemCaseSensitive(extraInfoParser.json, "blur_coef1"); 1857 if (cJSON_IsNumber(coef1)) { 1858 tempCoef1 = static_cast<float>(coef1->valuedouble); 1859 } 1860 float tempCoef2 = 0.0f; 1861 cJSON *coef2 = cJSON_GetObjectItemCaseSensitive(extraInfoParser.json, "blur_coef2"); 1862 if (cJSON_IsNumber(coef2)) { 1863 tempCoef2 = static_cast<float>(coef2->valuedouble); 1864 } 1865 extraInfo.coef = { tempCoef1, tempCoef2 }; 1866 return true; 1867 } 1868 GetAllowDragState()1869 bool DragDrawing::GetAllowDragState() 1870 { 1871 return g_drawingInfo.extraInfo.allowDistributed; 1872 } 1873 SetScreenId(uint64_t screenId)1874 void DragDrawing::SetScreenId(uint64_t screenId) 1875 { 1876 FI_HILOGD("enter"); 1877 screenId_ = screenId; 1878 } 1879 RotateDragWindow(Rosen::Rotation rotation,const std::shared_ptr<Rosen::RSTransaction> & rsTransaction,bool isAnimated)1880 int32_t DragDrawing::RotateDragWindow(Rosen::Rotation rotation, 1881 const std::shared_ptr<Rosen::RSTransaction>& rsTransaction, bool isAnimated) 1882 { 1883 if (needRotatePixelMapXY_) { 1884 CHKPR(g_drawingInfo.pixelMap, RET_ERR); 1885 g_drawingInfo.pixelMapX = -(HALF_RATIO * g_drawingInfo.pixelMap->GetWidth()); 1886 g_drawingInfo.pixelMapY = -(EIGHT_SIZE * GetScaling()); 1887 } 1888 float rotateAngle = (rotation == Rosen::Rotation::ROTATION_0) ? ROTATION_0 : 1889 ROTATION_360 - (ROTATION_90 * static_cast<int32_t>(rotation)); 1890 FI_HILOGI("rotateAngle:%{public}f, isAnimated:%{public}d", rotateAngle, isAnimated); 1891 return DoRotateDragWindow(rotateAngle, rsTransaction, isAnimated); 1892 } 1893 RotateCanvasNode(float pivotX,float pivotY,float rotation)1894 void DragDrawing::RotateCanvasNode(float pivotX, float pivotY, float rotation) 1895 { 1896 FI_HILOGD("enter"); 1897 CHKPV(g_drawingInfo.parentNode); 1898 g_drawingInfo.parentNode->SetPivot(pivotX, pivotY); 1899 g_drawingInfo.parentNode->SetRotation(rotation); 1900 if (!g_drawingInfo.multiSelectedNodes.empty()) { 1901 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 1902 for (size_t i = 0; i < multiSelectedNodesSize; ++i) { 1903 std::shared_ptr<Rosen::RSCanvasNode> multiSelectedNode = g_drawingInfo.multiSelectedNodes[i]; 1904 CHKPV(multiSelectedNode); 1905 float degrees = DEFAULT_ANGLE; 1906 if (i == FIRST_PIXELMAP_INDEX) { 1907 degrees = rotation + POSITIVE_ANGLE; 1908 } else if (i == SECOND_PIXELMAP_INDEX) { 1909 degrees = rotation + NEGATIVE_ANGLE; 1910 } 1911 multiSelectedNode->SetPivot(HALF_PIVOT, HALF_PIVOT); 1912 multiSelectedNode->SetRotation(degrees); 1913 } 1914 } 1915 if (g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 1916 if (!CheckNodesValid()) { 1917 FI_HILOGE("Check nodes valid failed"); 1918 return; 1919 } 1920 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = g_drawingInfo.nodes[MOUSE_ICON_INDEX]; 1921 CHKPV(mouseIconNode); 1922 mouseIconNode->SetPivot(DEFAULT_PIVOT, DEFAULT_PIVOT); 1923 mouseIconNode->SetRotation(rotation); 1924 } 1925 float positionX = g_drawingInfo.currentPositionX; 1926 float positionY = g_drawingInfo.currentPositionY; 1927 AdjustRotateDisplayXY(positionX, positionY); 1928 DrawRotateDisplayXY(positionX, positionY); 1929 FI_HILOGD("leave"); 1930 } 1931 SetRotation(Rosen::Rotation rotation)1932 void DragDrawing::SetRotation(Rosen::Rotation rotation) 1933 { 1934 rotation_ = rotation; 1935 } 1936 ProcessFilter()1937 void DragDrawing::ProcessFilter() 1938 { 1939 FI_HILOGD("enter"); 1940 if (g_drawingInfo.nodes.size() <= BACKGROUND_FILTER_INDEX) { 1941 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 1942 return; 1943 } 1944 std::shared_ptr<Rosen::RSCanvasNode> filterNode = g_drawingInfo.nodes[BACKGROUND_FILTER_INDEX]; 1945 CHKPV(filterNode); 1946 CHKPV(g_drawingInfo.pixelMap); 1947 FilterInfo filterInfo = g_drawingInfo.filterInfo; 1948 ExtraInfo extraInfo = g_drawingInfo.extraInfo; 1949 if (filterInfo.blurStyle != -1) { 1950 SetCustomDragBlur(filterInfo, filterNode); 1951 } else if (extraInfo.componentType == BIG_FOLDER_LABEL) { 1952 SetComponentDragBlur(filterInfo, extraInfo, filterNode); 1953 } 1954 FI_HILOGD("Add filter successfully"); 1955 FI_HILOGD("leave"); 1956 } 1957 SetCustomDragBlur(const FilterInfo & filterInfo,std::shared_ptr<Rosen::RSCanvasNode> filterNode)1958 void DragDrawing::SetCustomDragBlur(const FilterInfo &filterInfo, std::shared_ptr<Rosen::RSCanvasNode> filterNode) 1959 { 1960 CHKPV(filterNode); 1961 CHKPV(g_drawingInfo.pixelMap); 1962 Rosen::BLUR_COLOR_MODE mode = (Rosen::BLUR_COLOR_MODE)filterInfo.blurStyle; 1963 std::shared_ptr<Rosen::RSFilter> backFilter = Rosen::RSFilter::CreateMaterialFilter( 1964 RadiusVp2Sigma(filterInfo.blurRadius, filterInfo.dipScale), 1965 filterInfo.blurStaturation, filterInfo.blurBrightness, filterInfo.blurColor, mode); 1966 if (backFilter == nullptr) { 1967 FI_HILOGE("Create backgroundFilter failed"); 1968 return; 1969 } 1970 filterNode->SetBackgroundFilter(backFilter); 1971 filterNode->SetGreyCoef(filterInfo.coef); 1972 filterNode->SetAlpha(filterInfo.opacity); 1973 int32_t adjustSize = TWELVE_SIZE * GetScaling(); 1974 filterNode->SetBounds(DEFAULT_POSITION_X, adjustSize, g_drawingInfo.pixelMap->GetWidth(), 1975 g_drawingInfo.pixelMap->GetHeight()); 1976 filterNode->SetFrame(DEFAULT_POSITION_X, adjustSize, g_drawingInfo.pixelMap->GetWidth(), 1977 g_drawingInfo.pixelMap->GetHeight()); 1978 if ((filterInfo.blurRadius < 0) || (filterInfo.dipScale < 0) || 1979 (fabs(filterInfo.dipScale) < EPSILON) || ((std::numeric_limits<float>::max() 1980 / filterInfo.dipScale) < filterInfo.blurRadius)) { 1981 FI_HILOGE("Invalid parameters, cornerRadius:%{public}f, dipScale:%{public}f", 1982 filterInfo.blurRadius, filterInfo.dipScale); 1983 return; 1984 } 1985 Rosen::Vector4f cornerRadiusVector = { filterInfo.cornerRadius1, filterInfo.cornerRadius2, 1986 filterInfo.cornerRadius3, filterInfo.cornerRadius4 }; 1987 filterNode->SetCornerRadius(cornerRadiusVector * filterInfo.dipScale); 1988 FI_HILOGD("Set custom drag blur successfully"); 1989 } 1990 SetComponentDragBlur(const FilterInfo & filterInfo,const ExtraInfo & extraInfo,std::shared_ptr<Rosen::RSCanvasNode> filterNode)1991 void DragDrawing::SetComponentDragBlur(const FilterInfo &filterInfo, const ExtraInfo &extraInfo, 1992 std::shared_ptr<Rosen::RSCanvasNode> filterNode) 1993 { 1994 CHKPV(filterNode); 1995 CHKPV(g_drawingInfo.pixelMap); 1996 std::shared_ptr<Rosen::RSFilter> backFilter = Rosen::RSFilter::CreateMaterialFilter( 1997 RadiusVp2Sigma(RADIUS_VP, filterInfo.dipScale), 1998 DEFAULT_SATURATION, DEFAULT_BRIGHTNESS, DEFAULT_COLOR_VALUE); 1999 if (backFilter == nullptr) { 2000 FI_HILOGE("Create backgroundFilter failed"); 2001 return; 2002 } 2003 filterNode->SetBackgroundFilter(backFilter); 2004 filterNode->SetGreyCoef(extraInfo.coef); 2005 filterNode->SetAlpha(filterInfo.opacity); 2006 int32_t adjustSize = TWELVE_SIZE * GetScaling(); 2007 filterNode->SetBounds(DEFAULT_POSITION_X, adjustSize, g_drawingInfo.pixelMap->GetWidth(), 2008 g_drawingInfo.pixelMap->GetHeight()); 2009 filterNode->SetFrame(DEFAULT_POSITION_X, adjustSize, g_drawingInfo.pixelMap->GetWidth(), 2010 g_drawingInfo.pixelMap->GetHeight()); 2011 if ((extraInfo.cornerRadius < 0) || (filterInfo.dipScale < 0) || 2012 (fabs(filterInfo.dipScale) < EPSILON) || ((std::numeric_limits<float>::max() 2013 / filterInfo.dipScale) < extraInfo.cornerRadius)) { 2014 FI_HILOGE("Invalid parameters, cornerRadius:%{public}f, dipScale:%{public}f", 2015 extraInfo.cornerRadius, filterInfo.dipScale); 2016 return; 2017 } 2018 filterNode->SetCornerRadius(extraInfo.cornerRadius * filterInfo.dipScale); 2019 FI_HILOGD("Set component drag blur successfully"); 2020 return; 2021 } 2022 SetNodesLocation(int32_t positionX,int32_t positionY)2023 int32_t DragDrawing::SetNodesLocation(int32_t positionX, int32_t positionY) 2024 { 2025 FI_HILOGD("enter"); 2026 Rosen::RSAnimationTimingProtocol protocol; 2027 int32_t adjustSize = TWELVE_SIZE * GetScaling(); 2028 CHKPR(g_drawingInfo.parentNode, RET_ERR); 2029 CHKPR(g_drawingInfo.pixelMap, RET_ERR); 2030 Rosen::RSNode::Animate(protocol, SPRING, [&]() { 2031 g_drawingInfo.parentNode->SetBounds(positionX, positionY, g_drawingInfo.pixelMap->GetWidth(), 2032 g_drawingInfo.pixelMap->GetHeight() + adjustSize); 2033 g_drawingInfo.parentNode->SetFrame(positionX, positionY, g_drawingInfo.pixelMap->GetWidth(), 2034 g_drawingInfo.pixelMap->GetHeight() + adjustSize); 2035 }); 2036 g_drawingInfo.startNum = START_TIME; 2037 g_drawingInfo.needDestroyDragWindow = false; 2038 StartVsync(); 2039 FI_HILOGD("leave"); 2040 return RET_OK; 2041 } 2042 2043 EnterTextEditorArea(bool enable)2044 int32_t DragDrawing::EnterTextEditorArea(bool enable) 2045 { 2046 FI_HILOGD("enter"); 2047 if (enable) { 2048 DRAG_DATA_MGR.SetInitialPixelMapLocation({ g_drawingInfo.pixelMapX, g_drawingInfo.pixelMapY }); 2049 needRotatePixelMapXY_ = true; 2050 RotatePixelMapXY(); 2051 } else { 2052 needRotatePixelMapXY_ = false; 2053 auto initialPixelMapLocation = DRAG_DATA_MGR.GetInitialPixelMapLocation(); 2054 g_drawingInfo.pixelMapX = initialPixelMapLocation.first; 2055 g_drawingInfo.pixelMapY = initialPixelMapLocation.second; 2056 } 2057 DRAG_DATA_MGR.SetPixelMapLocation({ g_drawingInfo.pixelMapX, g_drawingInfo.pixelMapY }); 2058 float displayX = g_drawingInfo.currentPositionX; 2059 float displayY = g_drawingInfo.currentPositionY; 2060 AdjustRotateDisplayXY(displayX, displayY); 2061 int32_t positionX = displayX + g_drawingInfo.pixelMapX; 2062 int32_t positionY = displayY + g_drawingInfo.pixelMapY - TWELVE_SIZE * GetScaling(); 2063 if (RunAnimation([this, positionX, positionY] { 2064 return this->SetNodesLocation(positionX, positionY); 2065 }) != RET_OK) { 2066 FI_HILOGE("RunAnimation to SetNodesLocation failed"); 2067 return RET_ERR; 2068 } 2069 DRAG_DATA_MGR.SetTextEditorAreaFlag(enable); 2070 FI_HILOGI("EnterTextEditorArea %{public}s successfully", (enable ? "true" : "false")); 2071 return RET_OK; 2072 } 2073 RadiusVp2Sigma(float radiusVp,float dipScale)2074 float DragDrawing::RadiusVp2Sigma(float radiusVp, float dipScale) 2075 { 2076 float radiusPx = radiusVp * dipScale; 2077 return radiusPx > 0.0f ? BLUR_SIGMA_SCALE * radiusPx + 0.5f : 0.0f; 2078 } 2079 UpdatePreviewStyle(const PreviewStyle & previewStyle)2080 int32_t DragDrawing::UpdatePreviewStyle(const PreviewStyle &previewStyle) 2081 { 2082 FI_HILOGD("enter"); 2083 if (g_drawingInfo.nodes.size() <= PIXEL_MAP_INDEX) { 2084 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 2085 return RET_ERR; 2086 } else if (ModifyPreviewStyle(g_drawingInfo.nodes[PIXEL_MAP_INDEX], previewStyle) != RET_OK) { 2087 FI_HILOGE("ModifyPreviewStyle failed"); 2088 return RET_ERR; 2089 } 2090 if (ModifyMultiPreviewStyle(std::vector<PreviewStyle>(g_drawingInfo.multiSelectedNodes.size(), previewStyle)) != 2091 RET_OK) { 2092 FI_HILOGE("ModifyPreviewStyle failed"); 2093 return RET_ERR; 2094 } 2095 Rosen::RSTransaction::FlushImplicitTransaction(); 2096 FI_HILOGD("leave"); 2097 return RET_OK; 2098 } 2099 UpdatePreviewStyleWithAnimation(const PreviewStyle & previewStyle,const PreviewAnimation & animation)2100 int32_t DragDrawing::UpdatePreviewStyleWithAnimation(const PreviewStyle &previewStyle, 2101 const PreviewAnimation &animation) 2102 { 2103 FI_HILOGD("enter"); 2104 std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode = g_drawingInfo.nodes[PIXEL_MAP_INDEX]; 2105 CHKPR(pixelMapNode, RET_ERR); 2106 PreviewStyle originStyle; 2107 originStyle.types = previewStyle.types; 2108 if (auto color = pixelMapNode->GetShowingProperties().GetForegroundColor(); color.has_value()) { 2109 originStyle.foregroundColor = color->AsArgbInt(); 2110 originStyle.radius = previewStyle.radius; 2111 } 2112 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 2113 std::vector<PreviewStyle> multiOriginStyles; 2114 for (size_t i = 0; i < multiSelectedNodesSize; ++i) { 2115 if (auto color = g_drawingInfo.multiSelectedNodes[i]->GetShowingProperties().GetForegroundColor(); 2116 color.has_value()) { 2117 PreviewStyle currentStyle; 2118 currentStyle.types = { PreviewType::FOREGROUND_COLOR, PreviewType::RADIUS }; 2119 currentStyle.foregroundColor = color->AsArgbInt(); 2120 currentStyle.radius = previewStyle.radius; 2121 multiOriginStyles.push_back(currentStyle); 2122 } 2123 } 2124 if (ModifyPreviewStyle(pixelMapNode, originStyle) != RET_OK) { 2125 FI_HILOGE("ModifyPreviewStyle failed"); 2126 return RET_ERR; 2127 } 2128 if (ModifyMultiPreviewStyle(multiOriginStyles) != RET_OK) { 2129 FI_HILOGE("ModifyMultiPreviewStyle failed"); 2130 return RET_ERR; 2131 } 2132 Rosen::RSAnimationTimingProtocol protocol; 2133 protocol.SetDuration(animation.duration); 2134 auto curve = AnimationCurve::CreateCurve(animation.curveName, animation.curve); 2135 Rosen::RSNode::Animate(protocol, curve, [&]() { 2136 if (ModifyPreviewStyle(pixelMapNode, previewStyle) != RET_OK) { 2137 FI_HILOGE("ModifyPreviewStyle failed"); 2138 } 2139 if (ModifyMultiPreviewStyle(std::vector<PreviewStyle>(multiSelectedNodesSize, previewStyle)) != RET_OK) { 2140 FI_HILOGE("ModifyMultiPreviewStyle failed"); 2141 } 2142 }); 2143 FI_HILOGD("leave"); 2144 return RET_OK; 2145 } 2146 UpdateMousePosition(float mousePositionX,float mousePositionY)2147 void DragDrawing::UpdateMousePosition(float mousePositionX, float mousePositionY) 2148 { 2149 if (!CheckNodesValid()) { 2150 FI_HILOGE("Check nodes valid failed"); 2151 return; 2152 } 2153 if (g_drawingInfo.nodes.size() <= MOUSE_ICON_INDEX) { 2154 FI_HILOGE("The index out of bounds, node size:%{public}zu", g_drawingInfo.nodes.size()); 2155 return; 2156 } 2157 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = g_drawingInfo.nodes[MOUSE_ICON_INDEX]; 2158 CHKPV(mouseIconNode); 2159 if (pointerStyle_.id == MOUSE_DRAG_CURSOR_CIRCLE_STYLE || pointerStyle_.options == MAGIC_STYLE_OPT) { 2160 float positionX = mousePositionX - (static_cast<float>(g_drawingInfo.mouseWidth) / CURSOR_CIRCLE_MIDDLE); 2161 float positionY = mousePositionY - (static_cast<float>(g_drawingInfo.mouseHeight) / CURSOR_CIRCLE_MIDDLE); 2162 mouseIconNode->SetBounds(positionX, positionY, g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2163 mouseIconNode->SetFrame(positionX, positionY, g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2164 } else { 2165 mouseIconNode->SetBounds(mousePositionX, mousePositionY, 2166 g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2167 mouseIconNode->SetFrame(mousePositionX, mousePositionY, 2168 g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2169 } 2170 } 2171 RotateDragWindowAsync(Rosen::Rotation rotation)2172 int32_t DragDrawing::RotateDragWindowAsync(Rosen::Rotation rotation) 2173 { 2174 CHKPR(context_, RET_ERR); 2175 isRunningRotateAnimation_ = true; 2176 int32_t repeatTime = 1; 2177 timerId_ = context_->GetTimerManager().AddTimer(ASYNC_ROTATE_TIME, repeatTime, [this]() { 2178 RotateDragWindow(rotation_, nullptr, true); 2179 isRunningRotateAnimation_ = false; 2180 }); 2181 if (timerId_ < 0) { 2182 FI_HILOGE("Add timer failed, timerId_:%{public}d", timerId_); 2183 isRunningRotateAnimation_ = false; 2184 return RET_ERR; 2185 } 2186 return RET_OK; 2187 } 2188 RotateDragWindowSync(const std::shared_ptr<Rosen::RSTransaction> & rsTransaction)2189 int32_t DragDrawing::RotateDragWindowSync(const std::shared_ptr<Rosen::RSTransaction>& rsTransaction) 2190 { 2191 FI_HILOGD("enter"); 2192 isRunningRotateAnimation_ = true; 2193 RotateDragWindow(rotation_, rsTransaction, true); 2194 isRunningRotateAnimation_ = false; 2195 if ((context_ != nullptr) && (timerId_ >= 0)) { 2196 context_->GetTimerManager().RemoveTimer(timerId_); 2197 timerId_ = -1; 2198 } 2199 return RET_OK; 2200 } 2201 DoDrawMouse(int32_t mousePositionX,int32_t mousePositionY)2202 void DragDrawing::DoDrawMouse(int32_t mousePositionX, int32_t mousePositionY) 2203 { 2204 if (!CheckNodesValid()) { 2205 FI_HILOGE("Check nodes valid failed"); 2206 return; 2207 } 2208 if (g_drawingInfo.nodes.size() <= MOUSE_ICON_INDEX) { 2209 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 2210 return; 2211 } 2212 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = g_drawingInfo.nodes[MOUSE_ICON_INDEX]; 2213 CHKPV(mouseIconNode); 2214 if (pointerStyle_.id == MOUSE_DRAG_CURSOR_CIRCLE_STYLE || pointerStyle_.options == MAGIC_STYLE_OPT) { 2215 int32_t positionX = mousePositionX - (g_drawingInfo.mouseWidth / CURSOR_CIRCLE_MIDDLE); 2216 int32_t positionY = mousePositionY - (g_drawingInfo.mouseHeight / CURSOR_CIRCLE_MIDDLE); 2217 mouseIconNode->SetBounds(positionX, positionY, g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2218 mouseIconNode->SetFrame(positionX, positionY, g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2219 } else { 2220 mouseIconNode->SetBounds(mousePositionX, mousePositionY, 2221 g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2222 mouseIconNode->SetFrame(mousePositionX, mousePositionY, 2223 g_drawingInfo.mouseWidth, g_drawingInfo.mouseHeight); 2224 } 2225 } 2226 UpdateDefaultDragStyle(DragCursorStyle style)2227 int32_t DragDrawing::UpdateDefaultDragStyle(DragCursorStyle style) 2228 { 2229 if (!CheckNodesValid()) { 2230 FI_HILOGE("Check nodes valid failed"); 2231 return RET_ERR; 2232 } 2233 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 2234 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 2235 return RET_ERR; 2236 } 2237 if (!g_drawingInfo.isCurrentDefaultStyle) { 2238 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 2239 CHKPR(dragStyleNode, RET_ERR); 2240 CHKPR(g_drawingInfo.parentNode, RET_ERR); 2241 g_drawingInfo.parentNode->RemoveChild(dragStyleNode); 2242 CHKPR(rsUiDirector_, RET_ERR); 2243 rsUiDirector_->SendMessages(); 2244 } 2245 g_drawingInfo.currentStyle = style; 2246 bool isPreviousDefaultStyle = g_drawingInfo.isCurrentDefaultStyle; 2247 g_drawingInfo.isPreviousDefaultStyle = isPreviousDefaultStyle; 2248 g_drawingInfo.isCurrentDefaultStyle = true; 2249 return RET_OK; 2250 } 2251 UpdateValidDragStyle(DragCursorStyle style)2252 int32_t DragDrawing::UpdateValidDragStyle(DragCursorStyle style) 2253 { 2254 g_drawingInfo.currentStyle = style; 2255 if (g_drawingInfo.isCurrentDefaultStyle) { 2256 if (!CheckNodesValid()) { 2257 FI_HILOGE("Check nodes valid failed"); 2258 return RET_ERR; 2259 } 2260 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 2261 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 2262 return RET_ERR; 2263 } 2264 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 2265 CHKPR(dragStyleNode, RET_ERR); 2266 CHKPR(g_drawingInfo.parentNode, RET_ERR); 2267 g_drawingInfo.parentNode->AddChild(dragStyleNode); 2268 } 2269 std::string filePath; 2270 if (GetFilePath(filePath) != RET_OK) { 2271 FI_HILOGD("Get file path failed"); 2272 return RET_ERR; 2273 } 2274 if (!IsValidSvgFile(filePath)) { 2275 FI_HILOGE("Svg file is invalid"); 2276 return RET_ERR; 2277 } 2278 std::shared_ptr<Media::PixelMap> pixelMap = DecodeSvgToPixelMap(filePath); 2279 CHKPR(pixelMap, RET_ERR); 2280 bool isPreviousDefaultStyle = g_drawingInfo.isCurrentDefaultStyle; 2281 g_drawingInfo.isPreviousDefaultStyle = isPreviousDefaultStyle; 2282 g_drawingInfo.isCurrentDefaultStyle = false; 2283 g_drawingInfo.stylePixelMap = pixelMap; 2284 if (!CheckNodesValid()) { 2285 FI_HILOGE("Check nodes valid failed"); 2286 return RET_ERR; 2287 } 2288 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 2289 CHKPR(dragStyleNode, RET_ERR); 2290 OnDragStyle(dragStyleNode, pixelMap); 2291 CHKPR(rsUiDirector_, RET_ERR); 2292 rsUiDirector_->SendMessages(); 2293 DragDFX::WriteUpdateDragStyle(style, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR); 2294 return RET_OK; 2295 } 2296 ModifyPreviewStyle(std::shared_ptr<Rosen::RSCanvasNode> node,const PreviewStyle & previewStyle)2297 int32_t DragDrawing::ModifyPreviewStyle(std::shared_ptr<Rosen::RSCanvasNode> node, const PreviewStyle &previewStyle) 2298 { 2299 FI_HILOGD("enter"); 2300 CHKPR(node, RET_ERR); 2301 if (float radius = 0.0F; ParserRadius(radius)) { 2302 node->SetCornerRadius(radius); 2303 FI_HILOGD("SetCornerRadius by radius:%{public}f", radius); 2304 } 2305 for (const auto &type : previewStyle.types) { 2306 switch (type) { 2307 case PreviewType::FOREGROUND_COLOR: { 2308 node->SetForegroundColor(previewStyle.foregroundColor); 2309 break; 2310 } 2311 case PreviewType::OPACITY: { 2312 node->SetAlpha(previewStyle.opacity / static_cast<float>(HEX_FF)); 2313 break; 2314 } 2315 case PreviewType::RADIUS: { 2316 node->SetCornerRadius(previewStyle.radius); 2317 break; 2318 } 2319 case PreviewType::SCALE: { 2320 node->SetScale(previewStyle.scale); 2321 break; 2322 } 2323 default: { 2324 FI_HILOGE("Unsupported type"); 2325 break; 2326 } 2327 } 2328 } 2329 FI_HILOGD("leave"); 2330 return RET_OK; 2331 } 2332 ModifyMultiPreviewStyle(const std::vector<PreviewStyle> & previewStyles)2333 int32_t DragDrawing::ModifyMultiPreviewStyle(const std::vector<PreviewStyle> &previewStyles) 2334 { 2335 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 2336 if (previewStyles.size() != multiSelectedNodesSize) { 2337 FI_HILOGE("Size of previewStyles:%{public}zu does not match multiSelectedNodesSize:%{public}zu", 2338 previewStyles.size(), multiSelectedNodesSize); 2339 return RET_ERR; 2340 } 2341 for (size_t i = 0; i < multiSelectedNodesSize; ++i) { 2342 if (ModifyPreviewStyle(g_drawingInfo.multiSelectedNodes[i], previewStyles[i]) != RET_OK) { 2343 FI_HILOGW("ModifyPreviewStyle No.%{public}zu failed", i); 2344 } 2345 } 2346 return RET_OK; 2347 } 2348 MultiSelectedAnimation(int32_t positionX,int32_t positionY,int32_t adjustSize,bool isMultiSelectedAnimation)2349 void DragDrawing::MultiSelectedAnimation(int32_t positionX, int32_t positionY, int32_t adjustSize, 2350 bool isMultiSelectedAnimation) 2351 { 2352 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 2353 size_t multiSelectedPixelMapsSize = g_drawingInfo.multiSelectedPixelMaps.size(); 2354 for (size_t i = 0; (i < multiSelectedNodesSize) && (i < multiSelectedPixelMapsSize); ++i) { 2355 std::shared_ptr<Rosen::RSCanvasNode> multiSelectedNode = g_drawingInfo.multiSelectedNodes[i]; 2356 std::shared_ptr<Media::PixelMap> multiSelectedPixelMap = g_drawingInfo.multiSelectedPixelMaps[i]; 2357 CHKPV(g_drawingInfo.pixelMap); 2358 CHKPV(multiSelectedNode); 2359 CHKPV(multiSelectedPixelMap); 2360 int32_t multiSelectedPositionX = positionX + (g_drawingInfo.pixelMap->GetWidth() / TWICE_SIZE) - 2361 (multiSelectedPixelMap->GetWidth() / TWICE_SIZE); 2362 int32_t multiSelectedPositionY = positionY + (g_drawingInfo.pixelMap->GetHeight() / TWICE_SIZE) - 2363 ((multiSelectedPixelMap->GetHeight() / TWICE_SIZE) - adjustSize); 2364 if (isMultiSelectedAnimation) { 2365 Rosen::RSAnimationTimingProtocol protocol; 2366 if (i == FIRST_PIXELMAP_INDEX) { 2367 protocol.SetDuration(SHORT_DURATION); 2368 } else { 2369 protocol.SetDuration(LONG_DURATION); 2370 } 2371 Rosen::RSNode::Animate(protocol, Rosen::RSAnimationTimingCurve::EASE_IN_OUT, [&]() { 2372 multiSelectedNode->SetBounds(multiSelectedPositionX, multiSelectedPositionY, 2373 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 2374 multiSelectedNode->SetFrame(multiSelectedPositionX, multiSelectedPositionY, 2375 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 2376 }); 2377 } else { 2378 multiSelectedNode->SetBounds(multiSelectedPositionX, multiSelectedPositionY, 2379 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 2380 multiSelectedNode->SetFrame(multiSelectedPositionX, multiSelectedPositionY, 2381 multiSelectedPixelMap->GetWidth(), multiSelectedPixelMap->GetHeight()); 2382 } 2383 } 2384 } 2385 InitMultiSelectedNodes()2386 void DragDrawing::InitMultiSelectedNodes() 2387 { 2388 FI_HILOGD("enter"); 2389 size_t multiSelectedPixelMapsSize = g_drawingInfo.multiSelectedPixelMaps.size(); 2390 for (size_t i = 0; i < multiSelectedPixelMapsSize; ++i) { 2391 std::shared_ptr<Media::PixelMap> multiSelectedPixelMap = g_drawingInfo.multiSelectedPixelMaps[i]; 2392 std::shared_ptr<Rosen::RSCanvasNode> multiSelectedNode = Rosen::RSCanvasNode::Create(); 2393 multiSelectedNode->SetBgImageWidth(multiSelectedPixelMap->GetWidth()); 2394 multiSelectedNode->SetBgImageHeight(multiSelectedPixelMap->GetHeight()); 2395 multiSelectedNode->SetBgImagePositionX(0); 2396 multiSelectedNode->SetBgImagePositionY(0); 2397 multiSelectedNode->SetForegroundColor(TRANSPARENT_COLOR_ARGB); 2398 auto rosenImage = std::make_shared<Rosen::RSImage>(); 2399 rosenImage->SetPixelMap(multiSelectedPixelMap); 2400 rosenImage->SetImageRepeat(0); 2401 multiSelectedNode->SetBgImage(rosenImage); 2402 float alpha = DEFAULT_ALPHA; 2403 float degrees = DEFAULT_ANGLE; 2404 if (i == FIRST_PIXELMAP_INDEX) { 2405 alpha = FIRST_PIXELMAP_ALPHA; 2406 degrees = POSITIVE_ANGLE; 2407 } else if (i == SECOND_PIXELMAP_INDEX) { 2408 alpha = SECOND_PIXELMAP_ALPHA; 2409 degrees = NEGATIVE_ANGLE; 2410 } 2411 multiSelectedNode->SetRotation(degrees); 2412 multiSelectedNode->SetCornerRadius(g_drawingInfo.filterInfo.cornerRadius1 * g_drawingInfo.filterInfo.dipScale * 2413 g_drawingInfo.filterInfo.scale); 2414 multiSelectedNode->SetAlpha(alpha); 2415 g_drawingInfo.multiSelectedNodes.emplace_back(multiSelectedNode); 2416 } 2417 FI_HILOGD("leave"); 2418 } 2419 ClearMultiSelectedData()2420 void DragDrawing::ClearMultiSelectedData() 2421 { 2422 FI_HILOGD("enter"); 2423 if (!g_drawingInfo.multiSelectedNodes.empty()) { 2424 g_drawingInfo.multiSelectedNodes.clear(); 2425 g_drawingInfo.multiSelectedNodes.shrink_to_fit(); 2426 } 2427 if (!g_drawingInfo.multiSelectedPixelMaps.empty()) { 2428 g_drawingInfo.multiSelectedPixelMaps.clear(); 2429 g_drawingInfo.multiSelectedPixelMaps.shrink_to_fit(); 2430 } 2431 FI_HILOGD("leave"); 2432 } 2433 RotateDisplayXY(int32_t & displayX,int32_t & displayY)2434 void DragDrawing::RotateDisplayXY(int32_t &displayX, int32_t &displayY) 2435 { 2436 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 2437 if (display == nullptr) { 2438 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 2439 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 2440 CHKPV(display); 2441 } 2442 switch (rotation_) { 2443 case Rosen::Rotation::ROTATION_0: { 2444 break; 2445 } 2446 case Rosen::Rotation::ROTATION_90: { 2447 int32_t temp = displayY; 2448 displayY = display->GetWidth() - displayX; 2449 displayX = temp; 2450 break; 2451 } 2452 case Rosen::Rotation::ROTATION_180: { 2453 displayX = display->GetWidth() - displayX; 2454 displayY = display->GetHeight() - displayY; 2455 break; 2456 } 2457 case Rosen::Rotation::ROTATION_270: { 2458 int32_t temp = displayX; 2459 displayX = display->GetHeight() - displayY; 2460 displayY = temp; 2461 break; 2462 } 2463 default: { 2464 FI_HILOGW("Unknown parameter, rotation:%{public}d", static_cast<int32_t>(rotation_)); 2465 break; 2466 } 2467 } 2468 } 2469 RotatePosition(float & displayX,float & displayY)2470 void DragDrawing::RotatePosition(float &displayX, float &displayY) 2471 { 2472 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 2473 if (display == nullptr) { 2474 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 2475 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 2476 CHKPV(display); 2477 } 2478 switch (rotation_) { 2479 case Rosen::Rotation::ROTATION_0: { 2480 break; 2481 } 2482 case Rosen::Rotation::ROTATION_90: { 2483 int32_t temp = displayY; 2484 displayY = display->GetWidth() - displayX; 2485 displayX = temp; 2486 break; 2487 } 2488 case Rosen::Rotation::ROTATION_180: { 2489 displayX = display->GetWidth() - displayX; 2490 displayY = display->GetHeight() - displayY; 2491 break; 2492 } 2493 case Rosen::Rotation::ROTATION_270: { 2494 int32_t temp = displayX; 2495 displayX = display->GetHeight() - displayY; 2496 displayY = temp; 2497 break; 2498 } 2499 default: { 2500 FI_HILOGE("Invalid parameter, rotation:%{public}d", static_cast<int32_t>(rotation_)); 2501 break; 2502 } 2503 } 2504 } 2505 RotatePixelMapXY()2506 void DragDrawing::RotatePixelMapXY() 2507 { 2508 FI_HILOGI("rotation:%{public}d", static_cast<int32_t>(rotation_)); 2509 CHKPV(g_drawingInfo.pixelMap); 2510 switch (rotation_) { 2511 case Rosen::Rotation::ROTATION_0: 2512 case Rosen::Rotation::ROTATION_180: { 2513 g_drawingInfo.pixelMapX = -(HALF_RATIO * g_drawingInfo.pixelMap->GetWidth()); 2514 g_drawingInfo.pixelMapY = -(EIGHT_SIZE * GetScaling()); 2515 break; 2516 } 2517 case Rosen::Rotation::ROTATION_90: 2518 case Rosen::Rotation::ROTATION_270: { 2519 g_drawingInfo.pixelMapX = -(HALF_RATIO * g_drawingInfo.pixelMap->GetWidth()); 2520 g_drawingInfo.pixelMapY = -(EIGHT_SIZE * GetScaling()); 2521 break; 2522 } 2523 default: { 2524 FI_HILOGE("Invalid parameter, rotation:%{public}d", static_cast<int32_t>(rotation_)); 2525 break; 2526 } 2527 } 2528 } 2529 ResetAnimationParameter()2530 void DragDrawing::ResetAnimationParameter() 2531 { 2532 FI_HILOGI("enter"); 2533 hasRunningScaleAnimation_ = false; 2534 CHKPV(handler_); 2535 handler_->RemoveAllEvents(); 2536 handler_->RemoveAllFileDescriptorListeners(); 2537 handler_ = nullptr; 2538 receiver_ = nullptr; 2539 ResetSuperHubHandler(); 2540 FI_HILOGI("leave"); 2541 } 2542 ResetAnimationFlag(bool isForce)2543 void DragDrawing::ResetAnimationFlag(bool isForce) 2544 { 2545 FI_HILOGI("enter"); 2546 if (!isForce && (g_drawingInfo.context != nullptr) && (g_drawingInfo.timerId >= 0)) { 2547 g_drawingInfo.context->GetTimerManager().RemoveTimer(g_drawingInfo.timerId); 2548 g_drawingInfo.timerId = -1; 2549 } 2550 if (drawDynamicEffectModifier_ != nullptr) { 2551 CHKPV(g_drawingInfo.rootNode); 2552 g_drawingInfo.rootNode->RemoveModifier(drawDynamicEffectModifier_); 2553 drawDynamicEffectModifier_ = nullptr; 2554 } 2555 DestroyDragWindow(); 2556 g_drawingInfo.isRunning = false; 2557 g_drawingInfo.timerId = -1; 2558 ResetAnimationParameter(); 2559 FI_HILOGI("leave"); 2560 } 2561 DoEndAnimation()2562 void DragDrawing::DoEndAnimation() 2563 { 2564 FI_HILOGI("enter"); 2565 g_drawingInfo.startNum = START_TIME; 2566 g_drawingInfo.needDestroyDragWindow = true; 2567 if (g_drawingInfo.context != nullptr) { 2568 int32_t repeatCount = 1; 2569 g_drawingInfo.timerId = g_drawingInfo.context->GetTimerManager().AddTimer(TIMEOUT_MS, repeatCount, [this]() { 2570 FI_HILOGW("Timeout, automatically reset animation flag"); 2571 ResetAnimationFlag(true); 2572 }); 2573 } 2574 StartVsync(); 2575 FI_HILOGI("leave"); 2576 } 2577 ResetParameter()2578 void DragDrawing::ResetParameter() 2579 { 2580 FI_HILOGI("enter"); 2581 g_drawingInfo.startNum = START_TIME; 2582 g_drawingInfo.needDestroyDragWindow = false; 2583 needRotatePixelMapXY_ = false; 2584 hasRunningStopAnimation_ = false; 2585 pointerStyle_ = {}; 2586 g_drawingInfo.currentPositionX = -1.0f; 2587 g_drawingInfo.currentPositionY = -1.0f; 2588 g_drawingInfo.sourceType = -1; 2589 g_drawingInfo.currentDragNum = -1; 2590 g_drawingInfo.pixelMapX = -1; 2591 g_drawingInfo.pixelMapY = -1; 2592 g_drawingInfo.displayX = -1; 2593 g_drawingInfo.displayY = -1; 2594 g_drawingInfo.mouseWidth = 0; 2595 g_drawingInfo.mouseHeight = 0; 2596 g_drawingInfo.rootNodeWidth = -1; 2597 g_drawingInfo.rootNodeHeight = -1; 2598 g_drawingInfo.pixelMap = nullptr; 2599 g_drawingInfo.stylePixelMap = nullptr; 2600 g_drawingInfo.isPreviousDefaultStyle = false; 2601 g_drawingInfo.isCurrentDefaultStyle = false; 2602 g_drawingInfo.currentStyle = DragCursorStyle::DEFAULT; 2603 g_drawingInfo.filterInfo = {}; 2604 g_drawingInfo.extraInfo = {}; 2605 dragSmoothProcessor_.ResetParameters(); 2606 vSyncStation_.StopVSyncRequest(); 2607 frameCallback_ = nullptr; 2608 FI_HILOGI("leave"); 2609 } 2610 DoRotateDragWindow(float rotation,const std::shared_ptr<Rosen::RSTransaction> & rsTransaction,bool isAnimated)2611 int32_t DragDrawing::DoRotateDragWindow(float rotation, 2612 const std::shared_ptr<Rosen::RSTransaction>& rsTransaction, bool isAnimated) 2613 { 2614 FI_HILOGD("rotation:%{public}f, isAnimated:%{public}d", rotation, isAnimated); 2615 CHKPR(g_drawingInfo.pixelMap, RET_ERR); 2616 if ((g_drawingInfo.pixelMap->GetWidth() <= 0) || (g_drawingInfo.pixelMap->GetHeight() <= 0)) { 2617 FI_HILOGE("Invalid parameter pixelmap"); 2618 return RET_ERR; 2619 } 2620 float adjustSize = TWELVE_SIZE * GetScaling(); 2621 float pivotX = HALF_PIVOT; 2622 float pivotY = 0.0f; 2623 if (fabsf(adjustSize + g_drawingInfo.pixelMap->GetHeight()) < EPSILON) { 2624 pivotY = HALF_PIVOT; 2625 } else { 2626 pivotY = ((g_drawingInfo.pixelMap->GetHeight() * 1.0 / TWICE_SIZE) + adjustSize) / 2627 (adjustSize + g_drawingInfo.pixelMap->GetHeight()); 2628 } 2629 if (!isAnimated) { 2630 DragWindowRotateInfo_.rotation = rotation; 2631 DragWindowRotateInfo_.pivotX = pivotX; 2632 DragWindowRotateInfo_.pivotY = pivotY; 2633 RotateCanvasNode(pivotX, pivotY, rotation); 2634 Rosen::RSTransaction::FlushImplicitTransaction(); 2635 return RET_OK; 2636 } 2637 return DoRotateDragWindowAnimation(rotation, pivotX, pivotY, rsTransaction); 2638 } 2639 2640 template <typename T> AdjustRotateDisplayXY(T & displayX,T & displayY)2641 void DragDrawing::AdjustRotateDisplayXY(T &displayX, T &displayY) 2642 { 2643 FI_HILOGD("rotation:%{public}d", static_cast<int32_t>(rotation_)); 2644 CHKPV(g_drawingInfo.pixelMap); 2645 switch (rotation_) { 2646 case Rosen::Rotation::ROTATION_0: { 2647 break; 2648 } 2649 case Rosen::Rotation::ROTATION_90: { 2650 displayX -= (g_drawingInfo.pixelMap->GetWidth() - g_drawingInfo.pixelMap->GetHeight()) / TWICE_SIZE + 2651 g_drawingInfo.pixelMapX - g_drawingInfo.pixelMapY; 2652 displayY -= (g_drawingInfo.pixelMap->GetWidth() - g_drawingInfo.pixelMap->GetHeight()) / TWICE_SIZE + 2653 g_drawingInfo.pixelMapX + g_drawingInfo.pixelMap->GetHeight() + g_drawingInfo.pixelMapY; 2654 break; 2655 } 2656 case Rosen::Rotation::ROTATION_180: { 2657 displayX -= g_drawingInfo.pixelMap->GetWidth() + (g_drawingInfo.pixelMapX * TWICE_SIZE); 2658 displayY -= g_drawingInfo.pixelMap->GetHeight() + (g_drawingInfo.pixelMapY * TWICE_SIZE); 2659 break; 2660 } 2661 case Rosen::Rotation::ROTATION_270: { 2662 displayX -= (g_drawingInfo.pixelMap->GetWidth() - g_drawingInfo.pixelMap->GetHeight()) / TWICE_SIZE + 2663 g_drawingInfo.pixelMapX + g_drawingInfo.pixelMap->GetHeight() + g_drawingInfo.pixelMapY; 2664 displayY += (g_drawingInfo.pixelMap->GetWidth() - g_drawingInfo.pixelMap->GetHeight()) / TWICE_SIZE + 2665 g_drawingInfo.pixelMapX - g_drawingInfo.pixelMapY; 2666 break; 2667 } 2668 default: { 2669 FI_HILOGE("Invalid parameter, rotation:%{public}d", static_cast<int32_t>(rotation_)); 2670 break; 2671 } 2672 } 2673 } 2674 DrawRotateDisplayXY(float positionX,float positionY)2675 void DragDrawing::DrawRotateDisplayXY(float positionX, float positionY) 2676 { 2677 FI_HILOGD("enter"); 2678 float adjustSize = TWELVE_SIZE * GetScaling(); 2679 float parentPositionX = positionX + g_drawingInfo.pixelMapX; 2680 float parentPositionY = positionY + g_drawingInfo.pixelMapY - adjustSize; 2681 auto parentNode = g_drawingInfo.parentNode; 2682 auto pixelMap = g_drawingInfo.pixelMap; 2683 CHKPV(parentNode); 2684 CHKPV(pixelMap); 2685 parentNode->SetBounds(parentPositionX, parentPositionY, pixelMap->GetWidth(), 2686 pixelMap->GetHeight() + adjustSize); 2687 parentNode->SetFrame(parentPositionX, parentPositionY, pixelMap->GetWidth(), 2688 pixelMap->GetHeight() + adjustSize); 2689 if (!g_drawingInfo.multiSelectedNodes.empty() && !g_drawingInfo.multiSelectedPixelMaps.empty()) { 2690 DoMultiSelectedAnimation(parentPositionX, parentPositionY, adjustSize, false); 2691 } 2692 FI_HILOGD("leave"); 2693 } 2694 ScreenRotateAdjustDisplayXY(Rosen::Rotation rotation,Rosen::Rotation lastRotation,float & displayX,float & displayY)2695 void DragDrawing::ScreenRotateAdjustDisplayXY( 2696 Rosen::Rotation rotation, Rosen::Rotation lastRotation, float &displayX, float &displayY) 2697 { 2698 FI_HILOGI("enter"); 2699 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 2700 if (display == nullptr) { 2701 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 2702 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 2703 CHKPV(display); 2704 } 2705 int32_t width = display->GetWidth(); 2706 int32_t height = display->GetHeight(); 2707 if ((static_cast<int32_t>(lastRotation) + NUM_ONE) % NUM_FOUR == static_cast<int32_t>(rotation)) { 2708 int32_t temp = displayX; 2709 displayX = width - displayY; 2710 displayY = temp; 2711 } else if ((static_cast<int32_t>(lastRotation) + NUM_TWO) % NUM_FOUR == static_cast<int32_t>(rotation)) { 2712 displayX = width - displayX; 2713 displayY = height - displayY; 2714 } else { 2715 int32_t temp = displayY; 2716 displayY = height - displayX; 2717 displayX = temp; 2718 } 2719 FI_HILOGI("leave"); 2720 } 2721 ScreenRotate(Rosen::Rotation rotation,Rosen::Rotation lastRotation)2722 void DragDrawing::ScreenRotate(Rosen::Rotation rotation, Rosen::Rotation lastRotation) 2723 { 2724 FI_HILOGI("enter, rotation:%{public}d, lastRotation:%{public}d", static_cast<int32_t>(rotation), 2725 static_cast<int32_t>(lastRotation)); 2726 ScreenRotateAdjustDisplayXY(rotation, lastRotation, g_drawingInfo.x, g_drawingInfo.y); 2727 DrawRotateDisplayXY(g_drawingInfo.x, g_drawingInfo.y); 2728 2729 if (g_drawingInfo.sourceType == MMI::PointerEvent::SOURCE_TYPE_MOUSE) { 2730 ScreenRotateAdjustDisplayXY( 2731 rotation, lastRotation, g_drawingInfo.currentPositionX, g_drawingInfo.currentPositionY); 2732 UpdateMousePosition(g_drawingInfo.currentPositionX, g_drawingInfo.currentPositionY); 2733 } 2734 Rosen::RSTransaction::FlushImplicitTransaction(); 2735 FI_HILOGI("leave"); 2736 } 2737 DoRotateDragWindowAnimation(float rotation,float pivotX,float pivotY,const std::shared_ptr<Rosen::RSTransaction> & rsTransaction)2738 int32_t DragDrawing::DoRotateDragWindowAnimation(float rotation, float pivotX, float pivotY, 2739 const std::shared_ptr<Rosen::RSTransaction>& rsTransaction) 2740 { 2741 FI_HILOGD("enter"); 2742 if (rsTransaction != nullptr) { 2743 Rosen::RSTransaction::FlushImplicitTransaction(); 2744 rsTransaction->Begin(); 2745 } 2746 if ((rotation == ROTATION_0) && (DragWindowRotateInfo_.rotation == ROTATION_270)) { 2747 RotateCanvasNode(DragWindowRotateInfo_.pivotX, DragWindowRotateInfo_.pivotY, -ROTATION_90); 2748 } else if ((rotation == ROTATION_270) && (DragWindowRotateInfo_.rotation == ROTATION_0)) { 2749 RotateCanvasNode(DragWindowRotateInfo_.pivotX, DragWindowRotateInfo_.pivotY, ROTATION_360); 2750 } 2751 2752 Rosen::RSAnimationTimingProtocol protocol; 2753 protocol.SetDuration(ANIMATION_DURATION); 2754 Rosen::RSNode::Animate(protocol, SPRING, [&]() { 2755 RotateCanvasNode(pivotX, pivotY, rotation); 2756 DragWindowRotateInfo_.rotation = rotation; 2757 DragWindowRotateInfo_.pivotX = pivotX; 2758 DragWindowRotateInfo_.pivotY = pivotY; 2759 return RET_OK; 2760 }); 2761 if (rsTransaction != nullptr) { 2762 rsTransaction->Commit(); 2763 } else { 2764 Rosen::RSTransaction::FlushImplicitTransaction(); 2765 } 2766 FI_HILOGD("leave"); 2767 return RET_OK; 2768 } 2769 ParserRadius(float & radius)2770 bool DragDrawing::ParserRadius(float &radius) 2771 { 2772 FilterInfo filterInfo = g_drawingInfo.filterInfo; 2773 ExtraInfo extraInfo = g_drawingInfo.extraInfo; 2774 if ((extraInfo.cornerRadius < 0) || (filterInfo.dipScale < 0) || 2775 (fabs(filterInfo.dipScale) < EPSILON) || ((std::numeric_limits<float>::max() 2776 / filterInfo.dipScale) < extraInfo.cornerRadius)) { 2777 FI_HILOGE("Invalid parameters, cornerRadius:%{public}f, dipScale:%{public}f", 2778 extraInfo.cornerRadius, filterInfo.dipScale); 2779 return false; 2780 } 2781 radius = extraInfo.cornerRadius * filterInfo.dipScale; 2782 return true; 2783 } 2784 ~DragDrawing()2785 DragDrawing::~DragDrawing() 2786 { 2787 if (dragExtHandler_ != nullptr) { 2788 dlclose(dragExtHandler_); 2789 dragExtHandler_ = nullptr; 2790 } 2791 } 2792 Draw(Rosen::RSDrawingContext & context) const2793 void DrawSVGModifier::Draw(Rosen::RSDrawingContext& context) const 2794 { 2795 FI_HILOGD("enter"); 2796 CHKPV(stylePixelMap_); 2797 CHKPV(g_drawingInfo.pixelMap); 2798 float scalingValue = GetScaling(); 2799 if (SCALE_THRESHOLD_EIGHT < scalingValue || fabsf(SCALE_THRESHOLD_EIGHT - scalingValue) < EPSILON) { 2800 FI_HILOGE("Invalid scalingValue:%{public}f", scalingValue); 2801 return; 2802 } 2803 int32_t adjustSize = EIGHT_SIZE * scalingValue; 2804 int32_t svgTouchPositionX = g_drawingInfo.pixelMap->GetWidth() + adjustSize - stylePixelMap_->GetWidth(); 2805 if (!CheckNodesValid()) { 2806 FI_HILOGE("Check nodes valid failed"); 2807 return; 2808 } 2809 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 2810 CHKPV(dragStyleNode); 2811 adjustSize = (TWELVE_SIZE - EIGHT_SIZE) * scalingValue; 2812 dragStyleNode->SetBounds(svgTouchPositionX, adjustSize, stylePixelMap_->GetWidth() + adjustSize, 2813 stylePixelMap_->GetHeight()); 2814 dragStyleNode->SetFrame(svgTouchPositionX, adjustSize, stylePixelMap_->GetWidth() + adjustSize, 2815 stylePixelMap_->GetHeight()); 2816 dragStyleNode->SetBgImageWidth(stylePixelMap_->GetWidth()); 2817 dragStyleNode->SetBgImageHeight(stylePixelMap_->GetHeight()); 2818 dragStyleNode->SetBgImagePositionX(0); 2819 dragStyleNode->SetBgImagePositionY(0); 2820 auto rosenImage = std::make_shared<Rosen::RSImage>(); 2821 rosenImage->SetPixelMap(stylePixelMap_); 2822 rosenImage->SetImageRepeat(0); 2823 dragStyleNode->SetBgImage(rosenImage); 2824 Rosen::RSTransaction::FlushImplicitTransaction(); 2825 FI_HILOGD("leave"); 2826 } 2827 ConvertShadowColorStrategy(int32_t shadowColorStrategy) const2828 Rosen::SHADOW_COLOR_STRATEGY DrawPixelMapModifier::ConvertShadowColorStrategy(int32_t shadowColorStrategy) const 2829 { 2830 if (shadowColorStrategy == static_cast<int32_t>(Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_NONE)) { 2831 return Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_NONE ; 2832 } else if (shadowColorStrategy == static_cast<int32_t>(Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_AVERAGE)) { 2833 return Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_AVERAGE ; 2834 } else if (shadowColorStrategy == static_cast<int32_t>(Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_MAIN)) { 2835 return Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_MAIN ; 2836 } else { 2837 return Rosen::SHADOW_COLOR_STRATEGY::COLOR_STRATEGY_NONE; 2838 } 2839 } 2840 SetTextDragShadow(std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode) const2841 void DrawPixelMapModifier::SetTextDragShadow(std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode) const 2842 { 2843 if (!g_drawingInfo.filterInfo.path.empty()) { 2844 FI_HILOGD("path:%{private}s", g_drawingInfo.filterInfo.path.c_str()); 2845 pixelMapNode->SetShadowPath(Rosen::RSPath::CreateRSPath(g_drawingInfo.filterInfo.path)); 2846 } else { 2847 FI_HILOGW("path is empty"); 2848 } 2849 } 2850 SetDragShadow(std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode) const2851 void DrawPixelMapModifier::SetDragShadow(std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode) const 2852 { 2853 if ((g_drawingInfo.filterInfo.dragType == "text") && (g_drawingInfo.filterInfo.path.empty())) { 2854 FI_HILOGI("path is empty"); 2855 return; 2856 } 2857 pixelMapNode->SetShadowOffset(g_drawingInfo.filterInfo.offsetX, g_drawingInfo.filterInfo.offsetY); 2858 pixelMapNode->SetShadowColor(g_drawingInfo.filterInfo.argb); 2859 pixelMapNode->SetShadowMask(g_drawingInfo.filterInfo.shadowMask); 2860 pixelMapNode->SetShadowIsFilled(g_drawingInfo.filterInfo.shadowIsFilled); 2861 pixelMapNode->SetShadowColorStrategy(ConvertShadowColorStrategy(g_drawingInfo.filterInfo.shadowColorStrategy)); 2862 if (g_drawingInfo.filterInfo.isHardwareAcceleration) { 2863 pixelMapNode->SetShadowElevation(g_drawingInfo.filterInfo.elevation); 2864 } else { 2865 pixelMapNode->SetShadowRadius(g_drawingInfo.filterInfo.shadowCorner); 2866 } 2867 if (g_drawingInfo.filterInfo.dragType == "text") { 2868 SetTextDragShadow(pixelMapNode); 2869 } 2870 } 2871 Draw(Rosen::RSDrawingContext & context) const2872 void DrawPixelMapModifier::Draw(Rosen::RSDrawingContext &context) const 2873 { 2874 FI_HILOGD("enter"); 2875 CHKPV(g_drawingInfo.pixelMap); 2876 int32_t pixelMapWidth = g_drawingInfo.pixelMap->GetWidth(); 2877 int32_t pixelMapHeight = g_drawingInfo.pixelMap->GetHeight(); 2878 if (!CheckNodesValid()) { 2879 FI_HILOGE("Check nodes valid failed"); 2880 return; 2881 } 2882 std::shared_ptr<Rosen::RSCanvasNode> pixelMapNode = g_drawingInfo.nodes[PIXEL_MAP_INDEX]; 2883 CHKPV(pixelMapNode); 2884 if (g_drawingInfo.filterInfo.shadowEnable) { 2885 SetDragShadow(pixelMapNode); 2886 } 2887 int32_t adjustSize = TWELVE_SIZE * GetScaling(); 2888 pixelMapNode->SetBounds(DEFAULT_POSITION_X, adjustSize, pixelMapWidth, pixelMapHeight); 2889 pixelMapNode->SetFrame(DEFAULT_POSITION_X, adjustSize, pixelMapWidth, pixelMapHeight); 2890 pixelMapNode->SetBgImageWidth(pixelMapWidth); 2891 pixelMapNode->SetBgImageHeight(pixelMapHeight); 2892 pixelMapNode->SetBgImagePositionX(0); 2893 pixelMapNode->SetBgImagePositionY(0); 2894 Rosen::Drawing::AdaptiveImageInfo rsImageInfo = { 1, 0, {}, 1, 0, pixelMapWidth, pixelMapHeight }; 2895 auto cvs = pixelMapNode->BeginRecording(pixelMapWidth, pixelMapHeight); 2896 CHKPV(cvs); 2897 Rosen::Drawing::Brush brush; 2898 cvs->AttachBrush(brush); 2899 FilterInfo filterInfo = g_drawingInfo.filterInfo; 2900 if (g_drawingInfo.filterInfo.shadowEnable && !filterInfo.path.empty() && 2901 g_drawingInfo.filterInfo.dragType == "text") { 2902 auto rsPath = Rosen::RSPath::CreateRSPath(filterInfo.path); 2903 cvs->Save(); 2904 cvs->ClipPath(rsPath->GetDrawingPath(), Rosen::Drawing::ClipOp::INTERSECT, true); 2905 cvs->DrawPixelMapWithParm(g_drawingInfo.pixelMap, rsImageInfo, Rosen::Drawing::SamplingOptions()); 2906 cvs->Restore(); 2907 } else { 2908 cvs->DrawPixelMapWithParm(g_drawingInfo.pixelMap, rsImageInfo, Rosen::Drawing::SamplingOptions()); 2909 } 2910 cvs->DetachBrush(); 2911 pixelMapNode->SetClipToBounds(true); 2912 pixelMapNode->FinishRecording(); 2913 Rosen::RSTransaction::FlushImplicitTransaction(); 2914 FI_HILOGD("leave"); 2915 } 2916 Draw(Rosen::RSDrawingContext & context) const2917 void DrawMouseIconModifier::Draw(Rosen::RSDrawingContext &context) const 2918 { 2919 FI_HILOGD("enter"); 2920 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>(); 2921 int32_t ret = RET_ERR; 2922 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR 2923 ret = MMI::InputManager::GetInstance()->GetPointerSnapshot(&pixelMap); 2924 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR 2925 if (ret != RET_OK) { 2926 FI_HILOGE("Get pointer snapshot failed, ret:%{public}d", ret); 2927 pixelMap = DrawFromSVG(); 2928 } 2929 CHKPV(pixelMap); 2930 OnDraw(pixelMap); 2931 FI_HILOGD("leave"); 2932 } 2933 DrawFromSVG() const2934 std::shared_ptr<Media::PixelMap> DrawMouseIconModifier::DrawFromSVG() const 2935 { 2936 std::string imagePath; 2937 if (pointerStyle_.id == MOUSE_DRAG_CURSOR_CIRCLE_STYLE) { 2938 imagePath = MOUSE_DRAG_CURSOR_CIRCLE_PATH; 2939 } else { 2940 imagePath = MOUSE_DRAG_DEFAULT_PATH; 2941 } 2942 int32_t pointerSize = pointerStyle_.size; 2943 int32_t pointerColor = pointerStyle_.color; 2944 int32_t cursorPixel = DEVICE_INDEPENDENT_PIXEL; 2945 if (pointerStyle_.options == MAGIC_STYLE_OPT) { 2946 imagePath = MOUSE_DRAG_MAGIC_DEFAULT_PATH; 2947 int32_t ret = MMI::InputManager::GetInstance()->GetPointerSize(pointerSize); 2948 if (ret != RET_OK) { 2949 FI_HILOGW("Get pointer size failed, ret:%{public}d", ret); 2950 } 2951 ret = MMI::InputManager::GetInstance()->GetPointerColor(pointerColor); 2952 if (ret != RET_OK) { 2953 FI_HILOGW("Get pointer color failed, ret:%{public}d", ret); 2954 } 2955 cursorPixel = MAGIC_INDEPENDENT_PIXEL; 2956 } 2957 Media::SourceOptions opts; 2958 opts.formatHint = "image/svg+xml"; 2959 uint32_t errCode = 0; 2960 auto imageSource = Media::ImageSource::CreateImageSource(imagePath, opts, errCode); 2961 if (imageSource == nullptr) { 2962 FI_HILOGW("imageSource is null"); 2963 return nullptr; 2964 } 2965 if (pointerSize < DEFAULT_MOUSE_SIZE) { 2966 FI_HILOGD("Invalid pointerSize:%{public}d", pointerSize); 2967 pointerSize = DEFAULT_MOUSE_SIZE; 2968 } 2969 Media::DecodeOptions decodeOpts; 2970 decodeOpts.desiredSize = { 2971 .width = pow(INCREASE_RATIO, pointerSize - 1) * cursorPixel * GetScaling(), 2972 .height = pow(INCREASE_RATIO, pointerSize - 1) * cursorPixel * GetScaling() 2973 }; 2974 if (pointerColor != INVALID_COLOR_VALUE) { 2975 decodeOpts.SVGOpts.fillColor = {.isValidColor = true, .color = pointerColor}; 2976 } 2977 return imageSource->CreatePixelMap(decodeOpts, errCode); 2978 } 2979 OnDraw(std::shared_ptr<Media::PixelMap> pixelMap) const2980 void DrawMouseIconModifier::OnDraw(std::shared_ptr<Media::PixelMap> pixelMap) const 2981 { 2982 FI_HILOGD("enter"); 2983 CHKPV(pixelMap); 2984 if (!CheckNodesValid()) { 2985 FI_HILOGE("Check nodes valid failed"); 2986 return; 2987 } 2988 g_drawingInfo.mouseWidth = pixelMap->GetWidth(); 2989 g_drawingInfo.mouseHeight = pixelMap->GetHeight(); 2990 if (g_drawingInfo.nodes.size() <= MOUSE_ICON_INDEX) { 2991 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 2992 return; 2993 } 2994 std::shared_ptr<Rosen::RSCanvasNode> mouseIconNode = g_drawingInfo.nodes[MOUSE_ICON_INDEX]; 2995 CHKPV(mouseIconNode); 2996 mouseIconNode->SetBgImageWidth(pixelMap->GetWidth()); 2997 mouseIconNode->SetBgImageHeight(pixelMap->GetHeight()); 2998 mouseIconNode->SetBgImagePositionX(0); 2999 mouseIconNode->SetBgImagePositionY(0); 3000 auto rosenImage = std::make_shared<Rosen::RSImage>(); 3001 rosenImage->SetPixelMap(pixelMap); 3002 rosenImage->SetImageRepeat(0); 3003 mouseIconNode->SetBgImage(rosenImage); 3004 Rosen::RSTransaction::FlushImplicitTransaction(); 3005 FI_HILOGD("leave"); 3006 } 3007 Draw(Rosen::RSDrawingContext & context) const3008 void DrawDynamicEffectModifier::Draw(Rosen::RSDrawingContext &context) const 3009 { 3010 FI_HILOGD("enter"); 3011 CHKPV(alpha_); 3012 CHKPV(g_drawingInfo.parentNode); 3013 g_drawingInfo.parentNode->SetAlpha(alpha_->Get()); 3014 CHKPV(scale_); 3015 g_drawingInfo.parentNode->SetScale(scale_->Get(), scale_->Get()); 3016 Rosen::RSTransaction::FlushImplicitTransaction(); 3017 FI_HILOGD("leave"); 3018 } 3019 SetAlpha(float alpha)3020 void DrawDynamicEffectModifier::SetAlpha(float alpha) 3021 { 3022 FI_HILOGD("enter"); 3023 if (alpha_ == nullptr) { 3024 alpha_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(alpha); 3025 Rosen::RSModifier::AttachProperty(alpha_); 3026 return; 3027 } 3028 alpha_->Set(alpha); 3029 FI_HILOGD("leave"); 3030 } 3031 SetScale(float scale)3032 void DrawDynamicEffectModifier::SetScale(float scale) 3033 { 3034 FI_HILOGD("enter"); 3035 if (scale_ == nullptr) { 3036 scale_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(scale); 3037 Rosen::RSModifier::AttachProperty(scale_); 3038 return; 3039 } 3040 scale_->Set(scale); 3041 FI_HILOGD("leave"); 3042 } 3043 Draw(Rosen::RSDrawingContext & context) const3044 void DrawStyleChangeModifier::Draw(Rosen::RSDrawingContext &context) const 3045 { 3046 FI_HILOGD("enter"); 3047 if (!CheckNodesValid()) { 3048 FI_HILOGE("Check nodes valid failed"); 3049 return; 3050 } 3051 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 3052 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 3053 return; 3054 } 3055 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 3056 CHKPV(dragStyleNode); 3057 CHKPV(g_drawingInfo.pixelMap); 3058 float pixelMapWidth = g_drawingInfo.pixelMap->GetWidth(); 3059 if (stylePixelMap_ == nullptr) { 3060 if (scale_ == nullptr) { 3061 return; 3062 } 3063 dragStyleNode->SetScale(scale_->Get()); 3064 return; 3065 } 3066 float scalingValue = GetScaling(); 3067 if ((1.0 * INT_MAX / EIGHT_SIZE) <= scalingValue) { 3068 return; 3069 } 3070 int32_t adjustSize = EIGHT_SIZE * scalingValue; 3071 int32_t svgTouchPositionX = pixelMapWidth + adjustSize - stylePixelMap_->GetWidth(); 3072 dragStyleNode->SetBounds(svgTouchPositionX, (TWELVE_SIZE-EIGHT_SIZE)*scalingValue, stylePixelMap_->GetWidth(), 3073 stylePixelMap_->GetHeight()); 3074 dragStyleNode->SetFrame(svgTouchPositionX, (TWELVE_SIZE-EIGHT_SIZE)*scalingValue, stylePixelMap_->GetWidth(), 3075 stylePixelMap_->GetHeight()); 3076 dragStyleNode->SetBgImageWidth(stylePixelMap_->GetWidth()); 3077 dragStyleNode->SetBgImageHeight(stylePixelMap_->GetHeight()); 3078 dragStyleNode->SetBgImagePositionX(0); 3079 dragStyleNode->SetBgImagePositionY(0); 3080 auto rosenImage = std::make_shared<Rosen::RSImage>(); 3081 rosenImage->SetPixelMap(stylePixelMap_); 3082 rosenImage->SetImageRepeat(0); 3083 dragStyleNode->SetBgImage(rosenImage); 3084 Rosen::RSTransaction::FlushImplicitTransaction(); 3085 FI_HILOGD("leave"); 3086 } 3087 SetScale(float scale)3088 void DrawStyleChangeModifier::SetScale(float scale) 3089 { 3090 FI_HILOGD("enter"); 3091 if (scale_ == nullptr) { 3092 scale_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(scale); 3093 Rosen::RSModifier::AttachProperty(scale_); 3094 } else { 3095 scale_->Set(scale); 3096 } 3097 FI_HILOGD("leave"); 3098 } 3099 Draw(Rosen::RSDrawingContext & context) const3100 void DrawStyleScaleModifier::Draw(Rosen::RSDrawingContext &context) const 3101 { 3102 FI_HILOGD("enter"); 3103 if (!CheckNodesValid()) { 3104 FI_HILOGE("Check nodes valid failed"); 3105 return; 3106 } 3107 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 3108 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 3109 return; 3110 } 3111 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 3112 CHKPV(dragStyleNode); 3113 CHKPV(scale_); 3114 dragStyleNode->SetScale(scale_->Get()); 3115 FI_HILOGD("leave"); 3116 } 3117 SetScale(float scale)3118 void DrawStyleScaleModifier::SetScale(float scale) 3119 { 3120 FI_HILOGD("enter"); 3121 if (scale_ == nullptr) { 3122 scale_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(scale); 3123 Rosen::RSModifier::AttachProperty(scale_); 3124 } else { 3125 scale_->Set(scale); 3126 } 3127 FI_HILOGD("leave"); 3128 } 3129 Draw(Rosen::RSDrawingContext & context) const3130 void DrawDragStopModifier::Draw(Rosen::RSDrawingContext &context) const 3131 { 3132 FI_HILOGD("enter"); 3133 CHKPV(alpha_); 3134 CHKPV(scale_); 3135 if (!CheckNodesValid()) { 3136 FI_HILOGE("Check nodes valid failed"); 3137 return; 3138 } 3139 CHKPV(g_drawingInfo.parentNode); 3140 g_drawingInfo.parentNode->SetAlpha(alpha_->Get()); 3141 g_drawingInfo.parentNode->SetScale(scale_->Get(), scale_->Get()); 3142 if (!g_drawingInfo.multiSelectedNodes.empty()) { 3143 size_t multiSelectedNodesSize = g_drawingInfo.multiSelectedNodes.size(); 3144 for (size_t i = 0; i < multiSelectedNodesSize; ++i) { 3145 std::shared_ptr<Rosen::RSCanvasNode> multiSelectedNode = g_drawingInfo.multiSelectedNodes[i]; 3146 CHKPV(multiSelectedNode); 3147 multiSelectedNode->SetAlpha(alpha_->Get()); 3148 multiSelectedNode->SetScale(scale_->Get(), scale_->Get()); 3149 } 3150 } 3151 if (g_drawingInfo.nodes.size() <= DRAG_STYLE_INDEX) { 3152 FI_HILOGE("The index is out of bounds, node size is %{public}zu", g_drawingInfo.nodes.size()); 3153 return; 3154 } 3155 std::shared_ptr<Rosen::RSCanvasNode> dragStyleNode = g_drawingInfo.nodes[DRAG_STYLE_INDEX]; 3156 CHKPV(dragStyleNode); 3157 dragStyleNode->SetScale(styleScale_->Get()); 3158 dragStyleNode->SetAlpha(styleAlpha_->Get()); 3159 FI_HILOGD("leave"); 3160 } 3161 SetAlpha(float alpha)3162 void DrawDragStopModifier::SetAlpha(float alpha) 3163 { 3164 FI_HILOGD("enter"); 3165 if (alpha_ == nullptr) { 3166 alpha_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(alpha); 3167 Rosen::RSModifier::AttachProperty(alpha_); 3168 } else { 3169 alpha_->Set(alpha); 3170 } 3171 FI_HILOGD("leave"); 3172 } 3173 SetScale(float scale)3174 void DrawDragStopModifier::SetScale(float scale) 3175 { 3176 FI_HILOGD("enter"); 3177 if (scale_ == nullptr) { 3178 scale_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(scale); 3179 Rosen::RSModifier::AttachProperty(scale_); 3180 } else { 3181 scale_->Set(scale); 3182 } 3183 FI_HILOGD("leave"); 3184 } 3185 SetStyleScale(float scale)3186 void DrawDragStopModifier::SetStyleScale(float scale) 3187 { 3188 FI_HILOGD("enter"); 3189 if (styleScale_ == nullptr) { 3190 styleScale_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(scale); 3191 Rosen::RSModifier::AttachProperty(styleScale_); 3192 } else { 3193 styleScale_->Set(scale); 3194 } 3195 FI_HILOGD("leave"); 3196 } 3197 SetStyleAlpha(float alpha)3198 void DrawDragStopModifier::SetStyleAlpha(float alpha) 3199 { 3200 FI_HILOGD("enter"); 3201 if (styleAlpha_ == nullptr) { 3202 styleAlpha_ = std::make_shared<Rosen::RSAnimatableProperty<float>>(alpha); 3203 Rosen::RSModifier::AttachProperty(styleAlpha_); 3204 } else { 3205 styleAlpha_->Set(alpha); 3206 } 3207 FI_HILOGD("leave"); 3208 } 3209 CalculateWidthScale()3210 float DragDrawing::CalculateWidthScale() 3211 { 3212 sptr<Rosen::Display> display = Rosen::DisplayManager::GetInstance().GetDisplayById(g_drawingInfo.displayId); 3213 if (display == nullptr) { 3214 FI_HILOGD("Get display info failed, display:%{public}d", g_drawingInfo.displayId); 3215 display = Rosen::DisplayManager::GetInstance().GetDisplayById(0); 3216 if (display == nullptr) { 3217 FI_HILOGE("Get display info failed, display is nullptr"); 3218 return DEFAULT_SCALING; 3219 } 3220 } 3221 auto defaultDisplay = Rosen::DisplayManager::GetInstance().GetDefaultDisplay(); 3222 if (defaultDisplay == nullptr) { 3223 FI_HILOGE("defaultDisplay is nullptr"); 3224 return DEFAULT_SCALING; 3225 } 3226 int32_t width = display->GetWidth(); 3227 float density = defaultDisplay->GetVirtualPixelRatio(); 3228 FI_HILOGD("density:%{public}f, width:%{public}d", density, width); 3229 if (width < MAX_SCREEN_WIDTH_SM * density) { 3230 currentScreenSize_ = ScreenSizeType::XS; 3231 } else if (width < MAX_SCREEN_WIDTH_MD * density) { 3232 currentScreenSize_ = ScreenSizeType::SM; 3233 } else if (width < MAX_SCREEN_WIDTH_LG * density) { 3234 currentScreenSize_ = ScreenSizeType::MD; 3235 } else if (width < MAX_SCREEN_WIDTH_XL * density) { 3236 currentScreenSize_ = ScreenSizeType::LG; 3237 } else { 3238 currentScreenSize_ = ScreenSizeType::XL; 3239 } 3240 float widthScale = GetMaxWidthScale(width); 3241 return widthScale; 3242 } 3243 GetMaxWidthScale(int32_t width)3244 float DragDrawing::GetMaxWidthScale(int32_t width) 3245 { 3246 float scale = 1.0; 3247 float widthScale = 1.0; 3248 if (g_drawingInfo.pixelMap == nullptr) { 3249 FI_HILOGE("pixelMap is nullptr"); 3250 return DEFAULT_SCALING; 3251 } 3252 int32_t pixelMapWidth = g_drawingInfo.pixelMap->GetWidth(); 3253 if (pixelMapWidth == 0) { 3254 FI_HILOGW("pixelMapWidth is 0"); 3255 return DEFAULT_SCALING; 3256 } 3257 switch (currentScreenSize_) { 3258 case ScreenSizeType::XS: { 3259 return widthScale; 3260 } 3261 case ScreenSizeType::SM: { 3262 scale = width * SCALE_SM; 3263 if (pixelMapWidth > scale) { 3264 widthScale = scale / pixelMapWidth; 3265 return widthScale; 3266 } 3267 return widthScale; 3268 } 3269 case ScreenSizeType::MD: { 3270 scale = width * SCALE_MD; 3271 if (pixelMapWidth > scale) { 3272 widthScale = scale / pixelMapWidth; 3273 return widthScale; 3274 } 3275 return widthScale; 3276 } 3277 case ScreenSizeType::LG: { 3278 scale = width * SCALE_LG; 3279 if (pixelMapWidth > scale) { 3280 widthScale = scale / pixelMapWidth; 3281 return widthScale; 3282 } 3283 return widthScale; 3284 } 3285 default: { 3286 FI_HILOGI("Screen Size Type is XL"); 3287 break; 3288 } 3289 } 3290 return widthScale; 3291 } 3292 } // namespace DeviceStatus 3293 } // namespace Msdp 3294 } // namespace OHOS 3295
