1 /*
2 * Copyright (c) 2021-2023 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 "pipeline/rs_render_node_map.h"
17 #include "pipeline/rs_base_render_node.h"
18 #include "pipeline/rs_canvas_render_node.h"
19 #include "pipeline/rs_surface_render_node.h"
20 #include "platform/common/rs_log.h"
21
22 namespace OHOS {
23 namespace Rosen {
24
RSRenderNodeMap()25 RSRenderNodeMap::RSRenderNodeMap()
26 {
27 // add animation fallback node
28 renderNodeMap_.emplace(0, new RSCanvasRenderNode(0));
29 }
30
RegisterRenderNode(const std::shared_ptr<RSBaseRenderNode> & nodePtr)31 bool RSRenderNodeMap::RegisterRenderNode(const std::shared_ptr<RSBaseRenderNode>& nodePtr)
32 {
33 NodeId id = nodePtr->GetId();
34 if (renderNodeMap_.find(id) != renderNodeMap_.end()) {
35 return false;
36 }
37 renderNodeMap_.emplace(id, nodePtr);
38 if (nodePtr->GetType() == RSRenderNodeType::SURFACE_NODE) {
39 surfaceNodeMap_.emplace(id, nodePtr->ReinterpretCastTo<RSSurfaceRenderNode>());
40 }
41 return true;
42 }
43
UnregisterRenderNode(NodeId id)44 void RSRenderNodeMap::UnregisterRenderNode(NodeId id)
45 {
46 renderNodeMap_.erase(id);
47 surfaceNodeMap_.erase(id);
48 }
49
FilterNodeByPid(pid_t pid)50 void RSRenderNodeMap::FilterNodeByPid(pid_t pid)
51 {
52 ROSEN_LOGI("RSRenderNodeMap::FilterNodeByPid removing all nodes belong to pid %d", pid);
53 // remove all nodes belong to given pid (by matching higher 32 bits of node id)
54 EraseIf(renderNodeMap_, [pid](const auto& pair) -> bool {
55 if (static_cast<pid_t>(pair.first >> 32) != pid) {
56 return false;
57 }
58 if (auto renderNode = RSBaseRenderNode::ReinterpretCast<RSRenderNode>(pair.second)) {
59 // update node flag to avoid animation fallback
60 renderNode->fallbackAnimationOnDestroy_ = false;
61 }
62 // remove node from tree
63 pair.second->RemoveFromTree(false);
64 return true;
65 });
66
67 EraseIf(surfaceNodeMap_, [pid](const auto& pair) -> bool {
68 return static_cast<pid_t>(pair.first >> 32) == pid;
69 });
70
71 auto fallbackNode = RSBaseRenderNode::ReinterpretCast<RSRenderNode>(renderNodeMap_.at(0));
72 if (fallbackNode) {
73 // remove all fallback animations belong to given pid
74 fallbackNode->GetAnimationManager().FilterAnimationByPid(pid);
75 }
76 }
77
TraversalNodes(std::function<void (const std::shared_ptr<RSBaseRenderNode> &)> func) const78 void RSRenderNodeMap::TraversalNodes(std::function<void (const std::shared_ptr<RSBaseRenderNode>&)> func) const
79 {
80 for (const auto& [_, node] : renderNodeMap_) {
81 func(node);
82 }
83 }
84
TraverseSurfaceNodes(std::function<void (const std::shared_ptr<RSSurfaceRenderNode> &)> func) const85 void RSRenderNodeMap::TraverseSurfaceNodes(std::function<void (const std::shared_ptr<RSSurfaceRenderNode>&)> func) const
86 {
87 for (const auto& [_, node] : surfaceNodeMap_) {
88 func(node);
89 }
90 }
91
92 template<>
GetRenderNode(NodeId id) const93 const std::shared_ptr<RSBaseRenderNode> RSRenderNodeMap::GetRenderNode(NodeId id) const
94 {
95 auto itr = renderNodeMap_.find(id);
96 if (itr == renderNodeMap_.end()) {
97 return nullptr;
98 }
99 return itr->second;
100 }
101
GetAnimationFallbackNode() const102 const std::shared_ptr<RSRenderNode> RSRenderNodeMap::GetAnimationFallbackNode() const
103 {
104 auto itr = renderNodeMap_.find(0);
105 if (itr == renderNodeMap_.end()) {
106 return nullptr;
107 }
108 return std::static_pointer_cast<RSRenderNode>(renderNodeMap_.at(0));
109 }
110
111 } // namespace Rosen
112 } // namespace OHOS
113