1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef RENDER_SERVICE_BASE_DRAWABLE_RS_RENDER_NODE_DRAWABLE_ADAPTER_H 17 #define RENDER_SERVICE_BASE_DRAWABLE_RS_RENDER_NODE_DRAWABLE_ADAPTER_H 18 19 #include <memory> 20 #include <map> 21 #include <mutex> 22 #include <unordered_map> 23 #include <unordered_set> 24 #include <vector> 25 26 #include "common/rs_common_def.h" 27 #include "common/rs_macros.h" 28 #include "common/rs_rect.h" 29 #include "drawable/rs_property_drawable.h" 30 #include "recording/recording_canvas.h" 31 #include "pipeline/rs_render_content.h" 32 #include "utils/rect.h" 33 34 #ifndef ROSEN_CROSS_PLATFORM 35 #include <iconsumer_surface.h> 36 #endif 37 38 namespace OHOS::Rosen { 39 class RSRenderNode; 40 class RSRenderParams; 41 class RSDisplayRenderNode; 42 class RSSurfaceRenderNode; 43 class RSSurfaceHandler; 44 class RSContext; 45 class RSDirtyRegionManager; 46 class RSDrawWindowCache; 47 namespace Drawing { 48 class Canvas; 49 } 50 51 struct DrawCmdIndex { 52 int8_t envForeGroundColorIndex_ = -1; 53 int8_t shadowIndex_ = -1; 54 int8_t renderGroupBeginIndex_ = -1; 55 int8_t foregroundFilterBeginIndex_ = -1; 56 int8_t backgroundColorIndex_ = -1; 57 int8_t backgroundImageIndex_ = -1; 58 int8_t backgroundFilterIndex_ = -1; 59 int8_t useEffectIndex_ = -1; 60 int8_t backgroundEndIndex_ = -1; 61 int8_t childrenIndex_ = -1; 62 int8_t contentIndex_ = -1; 63 int8_t foregroundBeginIndex_ = -1; 64 int8_t renderGroupEndIndex_ = -1; 65 int8_t foregroundFilterEndIndex_ = -1; 66 int8_t endIndex_ = -1; 67 }; 68 namespace DrawableV2 { 69 enum class SkipType : uint8_t { 70 NONE = 0, 71 SKIP_SHADOW = 1, 72 SKIP_BACKGROUND_COLOR = 2 73 }; 74 75 enum class DrawSkipType : uint8_t { 76 NONE = 0, 77 SHOULD_NOT_PAINT = 1, 78 CANVAS_NULL = 2, 79 RENDER_THREAD_PARAMS_NULL = 3, 80 RENDER_PARAMS_NULL = 4, 81 SURFACE_PARAMS_SKIP_DRAW = 5, 82 RENDER_ENGINE_NULL = 6, 83 FILTERCACHE_OCCLUSION_SKIP = 7, 84 OCCLUSION_SKIP = 8, 85 UI_FIRST_CACHE_SKIP = 9, 86 PARALLEL_CANVAS_SKIP = 10, 87 INIT_SURFACE_FAIL = 11, 88 RENDER_PARAMS_OR_UNI_PARAMS_NULL = 12, 89 SCREEN_OFF = 13, 90 SCREEN_MANAGER_NULL = 14, 91 SKIP_FRAME = 15, 92 CREATE_PROCESSOR_FAIL = 16, 93 INIT_FOR_RENDER_THREAD_FAIL = 17, 94 WIRED_SCREEN_PROJECTION = 18, 95 EXPAND_PROCESSOR_NULL = 19, 96 MIRROR_DRAWABLE_SKIP = 20, 97 DISPLAY_NODE_SKIP = 21, 98 REQUEST_FRAME_FAIL = 22, 99 SURFACE_NULL = 23, 100 GENERATE_EFFECT_DATA_ON_DEMAND_FAIL = 24, 101 RENDER_SKIP_IF_SCREEN_OFF = 25, 102 HARD_CURSOR_ENAbLED = 26, 103 CHECK_MATCH_AND_WAIT_NOTIFY_FAIL = 27, 104 DEAL_WITH_CACHED_WINDOW = 28, 105 MULTI_ACCESS = 29, 106 RENDER_SKIP_IF_SCREEN_SWITCHING = 30, 107 UI_FIRST_CACHE_FAIL = 31, 108 SURFACE_SKIP_IN_MIRROR = 32, 109 }; 110 111 class RSB_EXPORT RSRenderNodeDrawableAdapter : public std::enable_shared_from_this<RSRenderNodeDrawableAdapter> { 112 public: 113 explicit RSRenderNodeDrawableAdapter(std::shared_ptr<const RSRenderNode>&& node); 114 virtual ~RSRenderNodeDrawableAdapter(); 115 116 // delete 117 RSRenderNodeDrawableAdapter(const RSRenderNodeDrawableAdapter&) = delete; 118 RSRenderNodeDrawableAdapter(const RSRenderNodeDrawableAdapter&&) = delete; 119 RSRenderNodeDrawableAdapter& operator=(const RSRenderNodeDrawableAdapter&) = delete; 120 RSRenderNodeDrawableAdapter& operator=(const RSRenderNodeDrawableAdapter&&) = delete; 121 122 using Ptr = RSRenderNodeDrawableAdapter*; 123 using SharedPtr = std::shared_ptr<RSRenderNodeDrawableAdapter>; 124 using WeakPtr = std::weak_ptr<RSRenderNodeDrawableAdapter>; 125 126 virtual void Draw(Drawing::Canvas& canvas) = 0; 127 virtual void DumpDrawableTree(int32_t depth, std::string& out, const RSContext& context) const; 128 129 static SharedPtr OnGenerate(const std::shared_ptr<const RSRenderNode>& node); 130 static SharedPtr GetDrawableById(NodeId id); 131 static std::vector<RSRenderNodeDrawableAdapter::SharedPtr> GetDrawableVectorById( 132 const std::unordered_set<NodeId>& ids); 133 static SharedPtr OnGenerateShadowDrawable( 134 const std::shared_ptr<const RSRenderNode>& node, const std::shared_ptr<RSRenderNodeDrawableAdapter>& drawable); 135 GetRenderParams()136 inline const std::unique_ptr<RSRenderParams>& GetRenderParams() const 137 { 138 return renderParams_; 139 } 140 GetUifirstRenderParams()141 inline const std::unique_ptr<RSRenderParams>& GetUifirstRenderParams() const 142 { 143 return uifirstRenderParams_; 144 } 145 GetId()146 inline NodeId GetId() const 147 { 148 return nodeId_; 149 } GetNodeType()150 inline RSRenderNodeType GetNodeType() const 151 { 152 return nodeType_; 153 } GetSyncDirtyManager()154 virtual std::shared_ptr<RSDirtyRegionManager> GetSyncDirtyManager() const 155 { 156 return nullptr; 157 } 158 159 using ClearSurfaceTask = std::function<void()>; 160 void RegisterClearSurfaceFunc(ClearSurfaceTask task); 161 void ResetClearSurfaceFunc(); 162 void TryClearSurfaceOnSync(); 163 164 #ifndef ROSEN_CROSS_PLATFORM RegisterDeleteBufferListenerOnSync(sptr<IConsumerSurface> consumer)165 virtual void RegisterDeleteBufferListenerOnSync(sptr<IConsumerSurface> consumer) {} 166 #endif 167 IsNeedDraw()168 virtual bool IsNeedDraw() const 169 { 170 return false; 171 } SetNeedDraw(bool flag)172 virtual void SetNeedDraw(bool flag) {} SetSkip(SkipType type)173 void SetSkip(SkipType type) { skipType_ = type; } GetSkipType()174 SkipType GetSkipType() { return skipType_; } 175 176 bool IsFilterCacheValidForOcclusion() const; 177 const RectI GetFilterCachedRegion() const; 178 179 void SetSkipCacheLayer(bool hasSkipCacheLayer); GetFilterNodeSize()180 size_t GetFilterNodeSize() const 181 { 182 return filterNodeSize_; 183 } ReduceFilterNodeSize()184 void ReduceFilterNodeSize() 185 { 186 if (filterNodeSize_ > 0) { 187 --filterNodeSize_; 188 } 189 } 190 struct FilterNodeInfo { FilterNodeInfoFilterNodeInfo191 FilterNodeInfo(NodeId nodeId, Drawing::Matrix matrix, std::vector<Drawing::RectI> rectVec) 192 : nodeId_(nodeId), matrix_(matrix), rectVec_(rectVec) {}; 193 NodeId nodeId_ = 0; 194 // Here, matrix_ and rectVec_ represent the transformation and FilterRect of the node relative to the off-screen 195 Drawing::Matrix matrix_; 196 std::vector<Drawing::RectI> rectVec_; 197 }; 198 GetfilterInfoVec()199 const std::vector<FilterNodeInfo>& GetfilterInfoVec() const 200 { 201 return filterInfoVec_; 202 } GetWithoutFilterMatrixMap()203 const std::unordered_map<NodeId, Drawing::Matrix>& GetWithoutFilterMatrixMap() const 204 { 205 return withoutFilterMatrixMap_; 206 } 207 GetUnobscuredUECMatrixMap()208 const std::unordered_map<NodeId, Drawing::Matrix>& GetUnobscuredUECMatrixMap() const 209 { 210 return unobscuredUECMatrixMap_; 211 } 212 SetLastDrawnFilterNodeId(NodeId nodeId)213 void SetLastDrawnFilterNodeId(NodeId nodeId) 214 { 215 lastDrawnFilterNodeId_ = nodeId; 216 } 217 GetLastDrawnFilterNodeId()218 NodeId GetLastDrawnFilterNodeId() const 219 { 220 return lastDrawnFilterNodeId_; 221 } 222 Purge()223 virtual void Purge() 224 { 225 if (purgeFunc_) { 226 purgeFunc_(); 227 } 228 } 229 SetUIExtensionNeedToDraw(bool needToDraw)230 virtual void SetUIExtensionNeedToDraw(bool needToDraw) {} 231 UIExtensionNeedToDraw()232 virtual bool UIExtensionNeedToDraw() const 233 { 234 return false; 235 } 236 SetDrawSkipType(DrawSkipType type)237 void SetDrawSkipType(DrawSkipType type) { 238 drawSkipType_ = type; 239 } 240 GetDrawSkipType()241 DrawSkipType GetDrawSkipType() { 242 return drawSkipType_; 243 } 244 DrawableTryLockForDraw()245 inline bool DrawableTryLockForDraw() 246 { 247 bool expected = false; 248 return isOnDraw_.compare_exchange_strong(expected, true); 249 } 250 DrawableResetLock()251 inline void DrawableResetLock() 252 { 253 isOnDraw_.store(false); 254 } 255 Snapshot()256 virtual std::shared_ptr<Drawing::Image> Snapshot() const 257 { 258 return nullptr; 259 } 260 261 protected: 262 // Util functions 263 std::string DumpDrawableVec(const std::shared_ptr<RSRenderNode>& renderNode) const; 264 bool QuickReject(Drawing::Canvas& canvas, const RectF& localDrawRect); 265 bool HasFilterOrEffect() const; 266 int ClipHoleForCacheSize(const RSRenderParams& params) const; 267 268 // Draw functions 269 void DrawAll(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 270 void DrawUifirstContentChildren(Drawing::Canvas& canvas, const Drawing::Rect& rect); 271 void DrawBackground(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 272 void DrawLeashWindowBackground(Drawing::Canvas& canvas, const Drawing::Rect& rect, 273 bool isStencilPixelOcclusionCullingEnabled = false, int64_t stencilVal = -1) const; 274 void DrawContent(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 275 void DrawChildren(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 276 void DrawForeground(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 277 void ApplyForegroundColorIfNeed(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 278 279 // used for foreground filter 280 void DrawBeforeCacheWithForegroundFilter(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 281 void DrawCacheWithForegroundFilter(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 282 void DrawAfterCacheWithForegroundFilter(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 283 284 // used for render group 285 void DrawBackgroundWithoutFilterAndEffect(Drawing::Canvas& canvas, const RSRenderParams& params); 286 void CheckShadowRectAndDrawBackground(Drawing::Canvas& canvas, const RSRenderParams& params); 287 void DrawCacheWithProperty(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 288 void DrawBeforeCacheWithProperty(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 289 void DrawAfterCacheWithProperty(Drawing::Canvas& canvas, const Drawing::Rect& rect) const; 290 void CollectInfoForNodeWithoutFilter(Drawing::Canvas& canvas); 291 void CollectInfoForUnobscuredUEC(Drawing::Canvas& canvas); 292 293 // Note, the start is included, the end is excluded, so the range is [start, end) 294 void DrawRangeImpl(Drawing::Canvas& canvas, const Drawing::Rect& rect, int8_t start, int8_t end) const; 295 void DrawImpl(Drawing::Canvas& canvas, const Drawing::Rect& rect, int8_t index) const; 296 297 // Register utils 298 using Generator = Ptr (*)(std::shared_ptr<const RSRenderNode>); 299 template<RSRenderNodeType type, Generator generator> 300 class RenderNodeDrawableRegistrar { 301 public: RenderNodeDrawableRegistrar()302 RenderNodeDrawableRegistrar() 303 { 304 RSRenderNodeDrawableAdapter::GeneratorMap.emplace(type, generator); 305 } 306 }; 307 308 const RSRenderNodeType nodeType_; 309 // deprecated 310 std::weak_ptr<const RSRenderNode> renderNode_; 311 NodeId nodeId_; 312 313 DrawCmdIndex uifirstDrawCmdIndex_; 314 DrawCmdIndex drawCmdIndex_; 315 std::unique_ptr<RSRenderParams> renderParams_; 316 static std::unordered_map<NodeId, Drawing::Matrix> unobscuredUECMatrixMap_; 317 std::shared_ptr<std::unordered_set<NodeId>> UECChildrenIds_ = std::make_shared<std::unordered_set<NodeId>>(); 318 std::unique_ptr<RSRenderParams> uifirstRenderParams_; 319 std::vector<Drawing::RecordingCanvas::DrawFunc> uifirstDrawCmdList_; 320 std::vector<Drawing::RecordingCanvas::DrawFunc> drawCmdList_; 321 std::vector<FilterNodeInfo> filterInfoVec_; 322 std::unordered_map<NodeId, Drawing::Matrix> withoutFilterMatrixMap_; 323 size_t filterNodeSize_ = 0; 324 std::shared_ptr<DrawableV2::RSFilterDrawable> backgroundFilterDrawable_ = nullptr; 325 std::shared_ptr<DrawableV2::RSFilterDrawable> compositingFilterDrawable_ = nullptr; 326 std::function<void()> purgeFunc_; 327 #ifdef ROSEN_OHOS 328 static thread_local RSRenderNodeDrawableAdapter* curDrawingCacheRoot_; 329 #else 330 static RSRenderNodeDrawableAdapter* curDrawingCacheRoot_; 331 #endif 332 // if the node needs to avoid drawing cache because of some layers, such as the security layer... 333 bool hasSkipCacheLayer_ = false; 334 ClearSurfaceTask clearSurfaceTask_ = nullptr; 335 private: 336 static void InitRenderParams(const std::shared_ptr<const RSRenderNode>& node, 337 std::shared_ptr<RSRenderNodeDrawableAdapter>& sharedPtr); 338 static std::map<RSRenderNodeType, Generator> GeneratorMap; 339 static std::map<NodeId, WeakPtr> RenderNodeDrawableCache_; 340 static inline std::mutex cacheMapMutex_; 341 SkipType skipType_ = SkipType::NONE; 342 int8_t GetSkipIndex() const; 343 DrawSkipType drawSkipType_ = DrawSkipType::NONE; 344 static void RemoveDrawableFromCache(const NodeId nodeId); 345 void UpdateFilterInfoForNodeGroup(RSPaintFilterCanvas* curCanvas); 346 NodeId lastDrawnFilterNodeId_ = 0; 347 std::atomic<bool> isOnDraw_ = false; 348 349 friend class OHOS::Rosen::RSRenderNode; 350 friend class OHOS::Rosen::RSDisplayRenderNode; 351 friend class OHOS::Rosen::RSSurfaceRenderNode; 352 friend class RSRenderNodeShadowDrawable; 353 friend class RSUseEffectDrawable; 354 friend class RSRenderNodeDrawable; 355 friend class OHOS::Rosen::RSDrawWindowCache; 356 }; 357 358 // RSRenderNodeSingleDrawableLocker: tool class that ensures drawable is exclusively used at the same time. 359 class RSB_EXPORT RSRenderNodeSingleDrawableLocker { 360 public: 361 RSRenderNodeSingleDrawableLocker() = delete; RSRenderNodeSingleDrawableLocker(RSRenderNodeDrawableAdapter * drawable)362 inline RSRenderNodeSingleDrawableLocker(RSRenderNodeDrawableAdapter* drawable) 363 : drawable_(drawable), locked_(LIKELY(drawable != nullptr) && drawable->DrawableTryLockForDraw()) 364 {} ~RSRenderNodeSingleDrawableLocker()365 inline ~RSRenderNodeSingleDrawableLocker() 366 { 367 if (LIKELY(locked_)) { 368 drawable_->DrawableResetLock(); 369 } 370 } IsLocked()371 inline bool IsLocked() const 372 { 373 return LIKELY(locked_); 374 } 375 struct MultiAccessReportInfo { 376 bool drawableNotNull = false; 377 bool paramNotNull = false; 378 RSRenderNodeType nodeType = RSRenderNodeType::UNKNOW; 379 NodeId nodeId = INVALID_NODEID; 380 NodeId uifirstRootNodeId = INVALID_NODEID; 381 NodeId firstLevelNodeId = INVALID_NODEID; 382 }; 383 void DrawableOnDrawMultiAccessEventReport(const std::string& func) const; 384 private: 385 RSRenderNodeDrawableAdapter* drawable_; 386 const bool locked_; 387 }; 388 } // namespace DrawableV2 389 } // namespace OHOS::Rosen 390 #endif // RENDER_SERVICE_BASE_DRAWABLE_RS_RENDER_NODE_DRAWABLE_ADAPTER_H 391