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 #include "core/interfaces/native/node/node_refresh_modifier.h"
16
17 #include "base/geometry/dimension.h"
18 #include "base/utils/utils.h"
19 #include "bridge/common/utils/utils.h"
20 #include "core/components/common/layout/constants.h"
21 #include "core/components/common/properties/alignment.h"
22 #include "core/components_ng/base/frame_node.h"
23 #include "core/components_ng/base/view_abstract.h"
24 #include "core/components_ng/pattern/refresh/refresh_model_ng.h"
25 #include "core/interfaces/native/node/node_api.h"
26 #include "core/interfaces/native/node/node_refresh_modifier.h"
27 #include "core/pipeline/base/element_register.h"
28
29 namespace OHOS::Ace::NG {
30 namespace {
31 const float ERROR_FLOAT_CODE = -1.0f;
32
SetRefreshing(ArkUINodeHandle node,ArkUI_Bool value)33 void SetRefreshing(ArkUINodeHandle node, ArkUI_Bool value)
34 {
35 auto* frameNode = reinterpret_cast<FrameNode*>(node);
36 CHECK_NULL_VOID(frameNode);
37 RefreshModelNG::SetRefreshing(frameNode, static_cast<bool>(value));
38 }
39
GetRefreshing(ArkUINodeHandle node)40 ArkUI_Bool GetRefreshing(ArkUINodeHandle node)
41 {
42 auto* frameNode = reinterpret_cast<FrameNode*>(node);
43 CHECK_NULL_RETURN(frameNode, false);
44 return static_cast<ArkUI_Bool>(RefreshModelNG::GetRefreshing(frameNode));
45 }
46
SetRefreshOffset(ArkUINodeHandle node,ArkUI_Float32 value,ArkUI_Int32 unit)47 void SetRefreshOffset(ArkUINodeHandle node, ArkUI_Float32 value, ArkUI_Int32 unit)
48 {
49 auto* frameNode = reinterpret_cast<FrameNode*>(node);
50 CHECK_NULL_VOID(frameNode);
51 RefreshModelNG::SetRefreshOffset(frameNode, Dimension(value, static_cast<OHOS::Ace::DimensionUnit>(unit)));
52 }
53
ResetRefreshOffset(ArkUINodeHandle node)54 void ResetRefreshOffset(ArkUINodeHandle node)
55 {
56 auto* frameNode = reinterpret_cast<FrameNode*>(node);
57 CHECK_NULL_VOID(frameNode);
58 RefreshModelNG::SetRefreshOffset(frameNode, Dimension(0.0f, DimensionUnit::VP));
59 }
60
SetPullToRefresh(ArkUINodeHandle node,ArkUI_Bool value)61 void SetPullToRefresh(ArkUINodeHandle node, ArkUI_Bool value)
62 {
63 auto* frameNode = reinterpret_cast<FrameNode*>(node);
64 CHECK_NULL_VOID(frameNode);
65 RefreshModelNG::SetPullToRefresh(frameNode, value);
66 }
67
ResetPullToRefresh(ArkUINodeHandle node)68 void ResetPullToRefresh(ArkUINodeHandle node)
69 {
70 auto* frameNode = reinterpret_cast<FrameNode*>(node);
71 CHECK_NULL_VOID(frameNode);
72 RefreshModelNG::SetPullToRefresh(frameNode, true);
73 }
74
SetRefreshContent(ArkUINodeHandle node,ArkUINodeHandle content)75 void SetRefreshContent(ArkUINodeHandle node, ArkUINodeHandle content)
76 {
77 auto* frameNode = reinterpret_cast<FrameNode*>(node);
78 CHECK_NULL_VOID(frameNode);
79 auto contentNode = reinterpret_cast<FrameNode*>(content);
80 CHECK_NULL_VOID(contentNode);
81 RefreshModelNG::SetCustomBuilder(frameNode, contentNode);
82 }
83
SetPullDownRatio(ArkUINodeHandle node,ArkUI_Float32 ratio)84 void SetPullDownRatio(ArkUINodeHandle node, ArkUI_Float32 ratio)
85 {
86 auto* frameNode = reinterpret_cast<FrameNode*>(node);
87 CHECK_NULL_VOID(frameNode);
88 float value = 0.0;
89 if (LessNotEqual(ratio, 0.0)) {
90 value = 0.0;
91 } else if (GreatNotEqual(ratio, 1.0)) {
92 value = 1.0;
93 }
94 value = ratio ;
95 std::optional<float> ratioValue = value;
96 RefreshModelNG::SetPullDownRatio(frameNode, ratioValue);
97 }
98
ResetPullDownRatio(ArkUINodeHandle node)99 void ResetPullDownRatio(ArkUINodeHandle node)
100 {
101 auto* frameNode = reinterpret_cast<FrameNode*>(node);
102 CHECK_NULL_VOID(frameNode);
103 std::optional<float> ratioValue = std::nullopt;
104 RefreshModelNG::SetPullDownRatio(frameNode, ratioValue);
105 }
106
GetPullDownRatio(ArkUINodeHandle node)107 ArkUI_Float32 GetPullDownRatio(ArkUINodeHandle node)
108 {
109 auto* frameNode = reinterpret_cast<FrameNode*>(node);
110 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
111 return RefreshModelNG::GetPullDownRatio(frameNode);
112 }
113
GetRefreshOffset(ArkUINodeHandle node,ArkUI_Int32 unit)114 ArkUI_Float32 GetRefreshOffset(ArkUINodeHandle node, ArkUI_Int32 unit)
115 {
116 auto* frameNode = reinterpret_cast<FrameNode*>(node);
117 CHECK_NULL_RETURN(frameNode, ERROR_FLOAT_CODE);
118 return RefreshModelNG::GetRefreshOffset(frameNode).GetNativeValue(static_cast<DimensionUnit>(unit));
119 }
120
GetPullToRefresh(ArkUINodeHandle node)121 ArkUI_Bool GetPullToRefresh(ArkUINodeHandle node)
122 {
123 auto* frameNode = reinterpret_cast<FrameNode*>(node);
124 CHECK_NULL_RETURN(frameNode, false);
125 return static_cast<ArkUI_Bool>(RefreshModelNG::GetPullToRefresh(frameNode));
126 }
127 } // namespace
128 namespace NodeModifier {
129
GetRefreshModifier()130 const ArkUIRefreshModifier* GetRefreshModifier()
131 {
132 static const ArkUIRefreshModifier modifier = { SetRefreshing, GetRefreshing, SetRefreshOffset, ResetRefreshOffset,
133 SetPullToRefresh, ResetPullToRefresh, SetRefreshContent, SetPullDownRatio, ResetPullDownRatio,
134 GetPullDownRatio, GetRefreshOffset, GetPullToRefresh };
135 return &modifier;
136 }
137
GetCJUIRefreshModifier()138 const CJUIRefreshModifier* GetCJUIRefreshModifier()
139 {
140 static const CJUIRefreshModifier modifier = { SetRefreshing, GetRefreshing, SetRefreshContent, SetRefreshOffset,
141 ResetRefreshOffset, SetPullToRefresh, ResetPullToRefresh, SetPullDownRatio, ResetPullDownRatio,
142 GetPullDownRatio, GetRefreshOffset, GetPullToRefresh };
143 return &modifier;
144 }
145
SetRefreshOnStateChange(ArkUINodeHandle node,void * extraParam)146 void SetRefreshOnStateChange(ArkUINodeHandle node, void* extraParam)
147 {
148 auto* frameNode = reinterpret_cast<FrameNode*>(node);
149 CHECK_NULL_VOID(frameNode);
150 auto onEvent = [node, extraParam](const int32_t value) {
151 ArkUINodeEvent event;
152 event.kind = COMPONENT_ASYNC_EVENT;
153 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
154 event.componentAsyncEvent.subKind = ON_REFRESH_STATE_CHANGE;
155 event.componentAsyncEvent.data[0].i32 = value;
156 SendArkUIAsyncEvent(&event);
157 };
158 RefreshModelNG::SetOnStateChange(frameNode, std::move(onEvent));
159 }
160
SetOnRefreshing(ArkUINodeHandle node,void * extraParam)161 void SetOnRefreshing(ArkUINodeHandle node, void* extraParam)
162 {
163 auto* frameNode = reinterpret_cast<FrameNode*>(node);
164 CHECK_NULL_VOID(frameNode);
165 auto onEvent = [node, extraParam]() {
166 ArkUINodeEvent event;
167 event.kind = COMPONENT_ASYNC_EVENT;
168 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
169 event.componentAsyncEvent.subKind = ON_REFRESH_REFRESHING;
170 SendArkUIAsyncEvent(&event);
171 };
172 RefreshModelNG::SetOnRefreshing(frameNode, std::move(onEvent));
173 }
174
SetRefreshOnOffsetChange(ArkUINodeHandle node,void * extraParam)175 void SetRefreshOnOffsetChange(ArkUINodeHandle node, void* extraParam)
176 {
177 auto* frameNode = reinterpret_cast<FrameNode*>(node);
178 CHECK_NULL_VOID(frameNode);
179 auto onEvent = [node, extraParam](const float value) {
180 ArkUINodeEvent event;
181 event.kind = COMPONENT_ASYNC_EVENT;
182 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
183 event.componentAsyncEvent.subKind = ON_REFRESH_ON_OFFSET_CHANGE;
184 event.componentAsyncEvent.data[0].f32 = value;
185 SendArkUIAsyncEvent(&event);
186 };
187 RefreshModelNG::SetOnOffsetChange(frameNode, std::move(onEvent));
188 }
189
SetRefreshChangeEvent(ArkUINodeHandle node,void * extraParam)190 void SetRefreshChangeEvent(ArkUINodeHandle node, void* extraParam)
191 {
192 auto* frameNode = reinterpret_cast<FrameNode*>(node);
193 CHECK_NULL_VOID(frameNode);
194 auto onEvent = [node, extraParam](const std::string& value) {
195 ArkUINodeEvent event;
196 event.kind = COMPONENT_ASYNC_EVENT;
197 event.extraParam = reinterpret_cast<intptr_t>(extraParam);
198 event.componentAsyncEvent.subKind = ON_REFRESH_CHANGE_EVENT;
199 bool newValue = value == "true";
200 event.componentAsyncEvent.data[0].u32 = newValue;
201 SendArkUIAsyncEvent(&event);
202 };
203 RefreshModelNG::SetChangeEvent(frameNode, std::move(onEvent));
204 }
205
ResetRefreshOnStateChange(ArkUINodeHandle node)206 void ResetRefreshOnStateChange(ArkUINodeHandle node)
207 {
208 auto* frameNode = reinterpret_cast<FrameNode*>(node);
209 CHECK_NULL_VOID(frameNode);
210 RefreshModelNG::SetOnStateChange(frameNode, nullptr);
211 }
ResetOnRefreshing(ArkUINodeHandle node)212 void ResetOnRefreshing(ArkUINodeHandle node)
213 {
214 auto* frameNode = reinterpret_cast<FrameNode*>(node);
215 CHECK_NULL_VOID(frameNode);
216 RefreshModelNG::SetOnRefreshing(frameNode, nullptr);
217 }
ResetRefreshOnOffsetChange(ArkUINodeHandle node)218 void ResetRefreshOnOffsetChange(ArkUINodeHandle node)
219 {
220 auto* frameNode = reinterpret_cast<FrameNode*>(node);
221 CHECK_NULL_VOID(frameNode);
222 RefreshModelNG::SetOnOffsetChange(frameNode, nullptr);
223 }
ResetRefreshChangeEvent(ArkUINodeHandle node)224 void ResetRefreshChangeEvent(ArkUINodeHandle node)
225 {
226 auto* frameNode = reinterpret_cast<FrameNode*>(node);
227 CHECK_NULL_VOID(frameNode);
228 RefreshModelNG::SetChangeEvent(frameNode, nullptr);
229 }
230 } // namespace NodeModifier
231 } // namespace OHOS::Ace::NG
232