1 /*
2 * Copyright (c) 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 "js_ui_observer.h"
17 #include "ui_observer.h"
18
19 #include "core/common/ace_engine.h"
20 #include "core/components_ng/base/inspector.h"
21 #include "core/components_ng/base/node_render_status_monitor.h"
22 #include "interfaces/napi/kits/observer/gesture/gesture_observer.h"
23 #include "interfaces/napi/kits/utils/napi_utils.h"
24
25
26 namespace OHOS::Ace::Napi {
27 namespace {
28 #define GET_PARAMS(env, info, max) \
29 size_t argc = max; \
30 napi_value argv[max] = { 0 }; \
31 napi_value thisVar = nullptr; \
32 void* data; \
33 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data)
34
35 static constexpr uint32_t PARAM_SIZE_ONE = 1;
36 static constexpr uint32_t PARAM_SIZE_TWO = 2;
37 static constexpr uint32_t PARAM_SIZE_THREE = 3;
38 static constexpr uint32_t PARAM_SIZE_FOUR = 4;
39
40 static constexpr size_t PARAM_INDEX_ZERO = 0;
41 static constexpr size_t PARAM_INDEX_ONE = 1;
42 static constexpr size_t PARAM_INDEX_TWO = 2;
43 static constexpr size_t PARAM_INDEX_THREE = 3;
44
45 static constexpr uint32_t ON_SHOWN = 0;
46 static constexpr uint32_t ON_HIDDEN = 1;
47 static constexpr uint32_t ON_APPEAR = 2;
48 static constexpr uint32_t ON_DISAPPEAR = 3;
49 static constexpr uint32_t ON_WILL_SHOW = 4;
50 static constexpr uint32_t ON_WILL_HIDE = 5;
51 static constexpr uint32_t ON_WILL_APPEAR = 6;
52 static constexpr uint32_t ON_WILL_DISAPPEAR = 7;
53 static constexpr uint32_t ON_ACTIVE = 8;
54 static constexpr uint32_t ON_INACTIVE = 9;
55 static constexpr uint32_t ON_BACKPRESS = 100;
56
57 static constexpr uint32_t SCROLL_START = 0;
58 static constexpr uint32_t SCROLL_STOP = 1;
59
60 static constexpr uint32_t ABOUT_TO_APPEAR = 0;
61 static constexpr uint32_t ABOUT_TO_DISAPPEAR = 1;
62 static constexpr uint32_t ON_PAGE_SHOW = 2;
63 static constexpr uint32_t ON_PAGE_HIDE = 3;
64 static constexpr uint32_t ON_BACK_PRESS = 4;
65
66 static constexpr uint32_t ON_SHOW = 0;
67 static constexpr uint32_t ON_HIDE = 1;
68
69 static constexpr uint32_t TAP_GESTURE = 0;
70 static constexpr uint32_t LONG_PRESS_GESTURE = 1;
71 static constexpr uint32_t PAN_GESTURE = 2;
72 static constexpr uint32_t PINCH_GESTURE = 3;
73 static constexpr uint32_t SWIPE_GESTURE = 4;
74 static constexpr uint32_t ROTATION_GESTURE = 5;
75 static constexpr uint32_t DRAG = 6;
76 static constexpr uint32_t CLICK = 7;
77
78 static constexpr uint32_t ABOUT_TO_RENDER_IN = 0;
79 static constexpr uint32_t ABOUT_TO_RENDER_OUT = 1;
80
81 static constexpr uint32_t READY = 0;
82 static constexpr uint32_t DETECTING = 1;
83 static constexpr uint32_t PENDING = 2;
84 static constexpr uint32_t BLOCKED = 3;
85 static constexpr uint32_t SUCCESSFUL = 4;
86 static constexpr uint32_t FAILED = 5;
87
88 constexpr char NAVDESTINATION_UPDATE[] = "navDestinationUpdate";
89 constexpr char NAVDESTINATION_UPDATE_BY_UNIQUEID[] = "navDestinationUpdateByUniqueId";
90 constexpr char ROUTERPAGE_UPDATE[] = "routerPageUpdate";
91 constexpr char SCROLL_EVENT[] = "scrollEvent";
92 constexpr char DENSITY_UPDATE[] = "densityUpdate";
93 constexpr char LAYOUT_DONE[] = "didLayout";
94 constexpr char DRAW_COMMAND_SEND[] = "willDraw";
95 constexpr char NAVDESTINATION_SWITCH[] = "navDestinationSwitch";
96 constexpr char WILLCLICK_UPDATE[] = "willClick";
97 constexpr char DIDCLICK_UPDATE[] = "didClick";
98 constexpr char TAB_CONTENT_STATE[] = "tabContentUpdate";
99 constexpr char BEFORE_PAN_START[] = "beforePanStart";
100 constexpr char BEFORE_PAN_END[] = "beforePanEnd";
101 constexpr char AFTER_PAN_START[] = "afterPanStart";
102 constexpr char AFTER_PAN_END[] = "afterPanEnd";
103 constexpr char NODE_RENDER_STATE[] = "nodeRenderState";
104 constexpr char NODE_RENDER_STATE_REGISTER_ERR_MSG[] =
105 "The count of nodes monitoring render state is over the limitation";
106
IsUIAbilityContext(napi_env env,napi_value context)107 bool IsUIAbilityContext(napi_env env, napi_value context)
108 {
109 napi_value abilityInfo = nullptr;
110 napi_get_named_property(env, context, "abilityInfo", &abilityInfo);
111 if (!abilityInfo) {
112 return false;
113 }
114 napi_value abilityInfoName = nullptr;
115 napi_get_named_property(env, abilityInfo, "name", &abilityInfoName);
116 if (abilityInfoName) {
117 return true;
118 }
119 return false;
120 }
121
GetUIContextInstanceId(napi_env env,napi_value uiContext)122 int32_t GetUIContextInstanceId(napi_env env, napi_value uiContext)
123 {
124 int32_t result = 0;
125 if (IsUIAbilityContext(env, uiContext)) {
126 return result;
127 }
128 napi_value instanceId = nullptr;
129 napi_get_named_property(env, uiContext, "instanceId_", &instanceId);
130 napi_get_value_int32(env, instanceId, &result);
131 return result;
132 }
133
MatchValueType(napi_env env,napi_value value,napi_valuetype targetType)134 bool MatchValueType(napi_env env, napi_value value, napi_valuetype targetType)
135 {
136 napi_valuetype valueType = napi_undefined;
137 napi_typeof(env, value, &valueType);
138 return valueType == targetType;
139 }
140
ParseStringFromNapi(napi_env env,napi_value val,std::string & str)141 bool ParseStringFromNapi(napi_env env, napi_value val, std::string& str)
142 {
143 napi_valuetype type;
144 return GetNapiString(env, val, str, type);
145 }
146
ParseNavigationId(napi_env env,napi_value obj,std::string & navigationStr)147 bool ParseNavigationId(napi_env env, napi_value obj, std::string& navigationStr)
148 {
149 napi_value navigationId = nullptr;
150 napi_get_named_property(env, obj, "navigationId", &navigationId);
151 return ParseStringFromNapi(env, navigationId, navigationStr);
152 }
153
ParseScrollId(napi_env env,napi_value obj,std::string & result)154 bool ParseScrollId(napi_env env, napi_value obj, std::string& result)
155 {
156 napi_value resultId = nullptr;
157 napi_get_named_property(env, obj, "id", &resultId);
158 if (!MatchValueType(env, resultId, napi_string)) {
159 return false;
160 }
161 return ParseStringFromNapi(env, resultId, result);
162 }
163
IsNavDestSwitchOptions(napi_env env,napi_value obj,std::string & navigationId)164 bool IsNavDestSwitchOptions(napi_env env, napi_value obj, std::string& navigationId)
165 {
166 if (!MatchValueType(env, obj, napi_object)) {
167 return false;
168 }
169 napi_value navId = nullptr;
170 napi_get_named_property(env, obj, "navigationId", &navId);
171 return ParseStringFromNapi(env, navId, navigationId);
172 }
173
ParseNodeRenderStateFrameNode(napi_env env,napi_value value)174 RefPtr<NG::FrameNode> ParseNodeRenderStateFrameNode(napi_env env, napi_value value)
175 {
176 if (MatchValueType(env, value, napi_number)) {
177 int32_t uniqueId = 0;
178 napi_get_value_int32(env, value, &uniqueId);
179 auto node = OHOS::Ace::ElementRegister::GetInstance()->GetUINodeById(uniqueId);
180 CHECK_NULL_RETURN(node, nullptr);
181 auto frameNode = AceType::DynamicCast<NG::FrameNode>(node);
182 if (!frameNode) {
183 TAG_LOGW(AceLogTag::ACE_OBSERVER, "node with id: %{public}d not exist.", uniqueId);
184 return nullptr;
185 }
186 if (node->GetTag() == V2::ROOT_ETS_TAG || node->GetTag() == V2::STAGE_ETS_TAG ||
187 node->GetTag() == V2::PAGE_ETS_TAG) {
188 return nullptr;
189 }
190 return frameNode;
191 }
192 if (MatchValueType(env, value, napi_string)) {
193 std::string inspectorId;
194 if (!ParseStringFromNapi(env, value, inspectorId)) {
195 return nullptr;
196 }
197 auto frameNode = NG::Inspector::GetFrameNodeByKey(inspectorId);
198 if (!frameNode) {
199 TAG_LOGW(AceLogTag::ACE_OBSERVER, "node with id: %{public}s not exist.", inspectorId.c_str());
200 }
201 return frameNode;
202 }
203 return nullptr;
204 }
205
206 struct NavDestinationSwitchParams {
207 bool isUIContext = true;
208 std::optional<std::string> navigationId;
209 napi_value callback = nullptr;
210 napi_value abilityUIContext = nullptr;
211 int32_t uiContextInstanceId = 0;
212 };
213
ParseNavDestSwitchRegisterParams(napi_env env,napi_callback_info info,NavDestinationSwitchParams & params)214 bool ParseNavDestSwitchRegisterParams(napi_env env, napi_callback_info info, NavDestinationSwitchParams& params)
215 {
216 GET_PARAMS(env, info, PARAM_SIZE_FOUR);
217
218 auto& secondArg = argv[PARAM_INDEX_ONE];
219 auto& thirdArg = argv[PARAM_INDEX_TWO];
220 auto& fourthArg = argv[PARAM_INDEX_THREE];
221 std::string navigationId;
222 if (argc == PARAM_SIZE_TWO && MatchValueType(env, secondArg, napi_function)) {
223 // js code: UIObserver.on('navDestinationSwitch', callback)
224 params.callback = secondArg;
225 } else if (argc == PARAM_SIZE_THREE && MatchValueType(env, secondArg, napi_object) &&
226 MatchValueType(env, thirdArg, napi_function)) {
227 if (IsNavDestSwitchOptions(env, secondArg, navigationId)) {
228 // js code: UIObserver.on('navDestinationSwitch', { navigationId: navId }, callback)
229 params.navigationId = navigationId;
230 } else if (IsUIAbilityContext(env, secondArg)) {
231 // js code: observer.on('navDestinationSwitch', AbilityUIContext, callback)
232 params.isUIContext = false;
233 params.abilityUIContext = secondArg;
234 } else {
235 // js code: observer.on('navDestinationSwitch', UIContext, callback)
236 params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
237 }
238 params.callback = thirdArg;
239 } else if (argc == PARAM_SIZE_FOUR && MatchValueType(env, secondArg, napi_object) &&
240 IsNavDestSwitchOptions(env, thirdArg, navigationId) &&
241 MatchValueType(env, fourthArg, napi_function)) {
242 if (IsUIAbilityContext(env, secondArg)) {
243 // js code: observer.on('navDestinationSwitch', AbilityUIContext, { navigationId: navId }, callback)
244 params.isUIContext = false;
245 params.abilityUIContext = secondArg;
246 } else {
247 // js code: observer.on('navDestinationSwitch', UIContext, { navigationId: navId }, callback)
248 params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
249 }
250 params.navigationId = navigationId;
251 params.callback = fourthArg;
252 } else {
253 return false;
254 }
255
256 return true;
257 }
258
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_value secondArg,NavDestinationSwitchParams & params)259 bool ParseNavDestSwitchUnRegisterParams(
260 napi_env env, napi_value secondArg, NavDestinationSwitchParams& params)
261 {
262 std::string navigationId;
263 if (MatchValueType(env, secondArg, napi_function)) {
264 // js code: UIObserver.off('navDestinationSwitch', callback)
265 params.callback = secondArg;
266 } else if (IsNavDestSwitchOptions(env, secondArg, navigationId)) {
267 // js code: UIObserver.off('navDestinationSwitch', { navigationId: navId })
268 params.navigationId = navigationId;
269 } else if (MatchValueType(env, secondArg, napi_object)) {
270 if (IsUIAbilityContext(env, secondArg)) {
271 // js code: observer.off('navDestinationSwitch', AbilityUIContext)
272 params.isUIContext = false;
273 params.abilityUIContext = secondArg;
274 } else {
275 // js code: observer.off('navDestinationSwitch', UIContext)
276 params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
277 }
278 } else {
279 return false;
280 }
281
282 return true;
283 }
284
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_value secondArg,napi_value thirdArg,NavDestinationSwitchParams & params)285 bool ParseNavDestSwitchUnRegisterParams(
286 napi_env env, napi_value secondArg, napi_value thirdArg, NavDestinationSwitchParams& params)
287 {
288 std::string navigationId;
289 if (MatchValueType(env, thirdArg, napi_function)) {
290 params.callback = thirdArg;
291 if (IsNavDestSwitchOptions(env, secondArg, navigationId)) {
292 // js code: UIObserver.off('navDestinationSwitch', { navigationId: navId }, callback)
293 params.navigationId = navigationId;
294 } else if (MatchValueType(env, secondArg, napi_object)) {
295 if (IsUIAbilityContext(env, secondArg)) {
296 // js code: observer.off('navDestinationSwitch', AbilityUIContext, callback)
297 params.isUIContext = false;
298 params.abilityUIContext = secondArg;
299 } else {
300 // js code: observer.off('navDestinationSwitch', UIContext, callback)
301 params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
302 }
303 } else {
304 return false;
305 }
306 } else if (MatchValueType(env, secondArg, napi_object) &&
307 IsNavDestSwitchOptions(env, thirdArg, navigationId)) {
308 if (IsUIAbilityContext(env, secondArg)) {
309 // js code: observer.off('navDestinationSwitch', AbilityUIContext, { navigationId: navId })
310 params.isUIContext = false;
311 params.abilityUIContext = secondArg;
312 } else {
313 // js code: observer.off('navDestinationSwitch', UIContext, { navigationId: navId })
314 params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
315 }
316 params.navigationId = navigationId;
317 } else {
318 return false;
319 }
320
321 return true;
322 }
323
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_value secondArg,napi_value thirdArg,napi_value fourthArg,NavDestinationSwitchParams & params)324 bool ParseNavDestSwitchUnRegisterParams(
325 napi_env env, napi_value secondArg, napi_value thirdArg,
326 napi_value fourthArg, NavDestinationSwitchParams& params)
327 {
328 std::string navigationId;
329 auto& context = secondArg;
330 auto& options = thirdArg;
331 auto& callback = fourthArg;
332 if (MatchValueType(env, context, napi_object) &&
333 IsNavDestSwitchOptions(env, options, navigationId) &&
334 MatchValueType(env, callback, napi_function)) {
335 if (IsUIAbilityContext(env, context)) {
336 // js code: observer.off('navDestinationSwitch', AbilityUIContext, { navigationId: navId }, callback)
337 params.isUIContext = false;
338 params.abilityUIContext = context;
339 } else {
340 // js code: observer.off('navDestinationSwitch', UIContext, { navigationId: navId }, callback)
341 params.uiContextInstanceId = GetUIContextInstanceId(env, context);
342 }
343 params.navigationId = navigationId;
344 params.callback = callback;
345 return true;
346 }
347
348 return false;
349 }
350
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_callback_info info,NavDestinationSwitchParams & params)351 bool ParseNavDestSwitchUnRegisterParams(
352 napi_env env, napi_callback_info info, NavDestinationSwitchParams& params)
353 {
354 GET_PARAMS(env, info, PARAM_SIZE_FOUR);
355
356 if (argc == PARAM_SIZE_TWO) {
357 return ParseNavDestSwitchUnRegisterParams(env, argv[PARAM_INDEX_ONE], params);
358 } else if (argc == PARAM_SIZE_THREE) {
359 return ParseNavDestSwitchUnRegisterParams(env, argv[PARAM_INDEX_ONE], argv[PARAM_INDEX_TWO], params);
360 } else if (argc == PARAM_SIZE_FOUR) {
361 return ParseNavDestSwitchUnRegisterParams(
362 env, argv[PARAM_INDEX_ONE], argv[PARAM_INDEX_TWO], argv[PARAM_INDEX_THREE], params);
363 } else if (argc != PARAM_SIZE_ONE) {
364 return false;
365 }
366
367 return true;
368 }
369 } // namespace
370
ObserverProcess()371 ObserverProcess::ObserverProcess()
372 {
373 registerProcessMap_ = {
374 { NAVDESTINATION_UPDATE, &ObserverProcess::ProcessNavigationRegister },
375 { NAVDESTINATION_UPDATE_BY_UNIQUEID, &ObserverProcess::ProcessNavigationRegisterByUniqueId },
376 { SCROLL_EVENT, &ObserverProcess::ProcessScrollEventRegister },
377 { ROUTERPAGE_UPDATE, &ObserverProcess::ProcessRouterPageRegister },
378 { DENSITY_UPDATE, &ObserverProcess::ProcessDensityRegister },
379 { LAYOUT_DONE, &ObserverProcess::ProcessLayoutDoneRegister },
380 { DRAW_COMMAND_SEND, &ObserverProcess::ProcessDrawCommandSendRegister },
381 { NAVDESTINATION_SWITCH, &ObserverProcess::ProcessNavDestinationSwitchRegister },
382 { WILLCLICK_UPDATE, &ObserverProcess::ProcessWillClickRegister },
383 { DIDCLICK_UPDATE, &ObserverProcess::ProcessDidClickRegister },
384 { TAB_CONTENT_STATE, &ObserverProcess::ProcessTabContentStateRegister },
385 { BEFORE_PAN_START, &ObserverProcess::ProcessBeforePanStartRegister },
386 { AFTER_PAN_START, &ObserverProcess::ProcessAfterPanStartRegister },
387 { BEFORE_PAN_END, &ObserverProcess::ProcessBeforePanEndRegister },
388 { AFTER_PAN_END, &ObserverProcess::ProcessAfterPanEndRegister },
389 { NODE_RENDER_STATE, &ObserverProcess::ProcessNodeRenderStateRegister },
390 };
391 unregisterProcessMap_ = {
392 { NAVDESTINATION_UPDATE, &ObserverProcess::ProcessNavigationUnRegister },
393 { NAVDESTINATION_UPDATE_BY_UNIQUEID, &ObserverProcess::ProcessNavigationUnRegisterByUniqueId },
394 { SCROLL_EVENT, &ObserverProcess::ProcessScrollEventUnRegister },
395 { ROUTERPAGE_UPDATE, &ObserverProcess::ProcessRouterPageUnRegister },
396 { DENSITY_UPDATE, &ObserverProcess::ProcessDensityUnRegister },
397 { LAYOUT_DONE, &ObserverProcess::ProcessLayoutDoneUnRegister },
398 { DRAW_COMMAND_SEND, &ObserverProcess::ProcessDrawCommandSendUnRegister},
399 { NAVDESTINATION_SWITCH, &ObserverProcess::ProcessNavDestinationSwitchUnRegister },
400 { WILLCLICK_UPDATE, &ObserverProcess::ProcessWillClickUnRegister },
401 { DIDCLICK_UPDATE, &ObserverProcess::ProcessDidClickUnRegister },
402 { TAB_CONTENT_STATE, &ObserverProcess::ProcessTabContentStateUnRegister },
403 { BEFORE_PAN_START, &ObserverProcess::ProcessBeforePanStartUnRegister },
404 { AFTER_PAN_START, &ObserverProcess::ProcessAfterPanStartUnRegister },
405 { BEFORE_PAN_END, &ObserverProcess::ProcessBeforePanEndUnRegister },
406 { AFTER_PAN_END, &ObserverProcess::ProcessAfterPanEndUnRegister },
407 { NODE_RENDER_STATE, &ObserverProcess::ProcessNodeRenderStateUnRegister },
408 };
409 }
410
GetInstance()411 ObserverProcess& ObserverProcess::GetInstance()
412 {
413 static ObserverProcess instance;
414 return instance;
415 }
416
ProcessRegister(napi_env env,napi_callback_info info)417 napi_value ObserverProcess::ProcessRegister(napi_env env, napi_callback_info info)
418 {
419 GET_PARAMS(env, info, PARAM_SIZE_THREE);
420 NAPI_ASSERT(env, (argc >= PARAM_SIZE_TWO && thisVar != nullptr), "Invalid arguments");
421 std::string type;
422 if (!ParseStringFromNapi(env, argv[PARAM_INDEX_ZERO], type)) {
423 return nullptr;
424 }
425 auto it = registerProcessMap_.find(type);
426 if (it == registerProcessMap_.end()) {
427 return nullptr;
428 }
429 return (this->*(it->second))(env, info);
430 }
431
ProcessUnRegister(napi_env env,napi_callback_info info)432 napi_value ObserverProcess::ProcessUnRegister(napi_env env, napi_callback_info info)
433 {
434 GET_PARAMS(env, info, PARAM_SIZE_THREE);
435 NAPI_ASSERT(env, (argc >= PARAM_SIZE_ONE && thisVar != nullptr), "Invalid arguments");
436 std::string type;
437 if (!ParseStringFromNapi(env, argv[PARAM_INDEX_ZERO], type)) {
438 return nullptr;
439 }
440 auto it = unregisterProcessMap_.find(type);
441 if (it == unregisterProcessMap_.end()) {
442 return nullptr;
443 }
444 return (this->*(it->second))(env, info);
445 }
446
ProcessNavigationRegister(napi_env env,napi_callback_info info)447 napi_value ObserverProcess::ProcessNavigationRegister(napi_env env, napi_callback_info info)
448 {
449 GET_PARAMS(env, info, PARAM_SIZE_THREE);
450
451 if (!isNavigationHandleFuncSetted_) {
452 NG::UIObserverHandler::GetInstance().SetHandleNavigationChangeFunc(&UIObserver::HandleNavigationStateChange);
453 isNavigationHandleFuncSetted_ = true;
454 }
455
456 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
457 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
458 UIObserver::RegisterNavigationCallback(listener);
459 }
460
461 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
462 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
463 std::string id;
464 if (ParseNavigationId(env, argv[PARAM_INDEX_ONE], id)) {
465 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
466 UIObserver::RegisterNavigationCallback(id, listener);
467 }
468 }
469
470 napi_value result = nullptr;
471 return result;
472 }
473
ProcessNavigationRegisterByUniqueId(napi_env env,napi_callback_info info)474 napi_value ObserverProcess::ProcessNavigationRegisterByUniqueId(napi_env env, napi_callback_info info)
475 {
476 GET_PARAMS(env, info, PARAM_SIZE_THREE);
477
478 if (!isNavigationHandleFuncSetted_) {
479 NG::UIObserverHandler::GetInstance().SetHandleNavigationChangeFunc(&UIObserver::HandleNavigationStateChange);
480 isNavigationHandleFuncSetted_ = true;
481 }
482
483 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_number) &&
484 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
485 int32_t navigationUniqueId;
486 if (napi_get_value_int32(env, argv[PARAM_INDEX_ONE], &navigationUniqueId) == napi_ok) {
487 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
488 UIObserver::RegisterNavigationCallback(navigationUniqueId, listener);
489 }
490 }
491
492 napi_value result = nullptr;
493 return result;
494 }
495
ProcessNavigationUnRegister(napi_env env,napi_callback_info info)496 napi_value ObserverProcess::ProcessNavigationUnRegister(napi_env env, napi_callback_info info)
497 {
498 GET_PARAMS(env, info, PARAM_SIZE_THREE);
499
500 if (argc == PARAM_SIZE_ONE) {
501 UIObserver::UnRegisterNavigationCallback(nullptr);
502 }
503
504 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
505 UIObserver::UnRegisterNavigationCallback(argv[PARAM_INDEX_ONE]);
506 }
507
508 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
509 std::string id;
510 if (ParseNavigationId(env, argv[PARAM_INDEX_ONE], id)) {
511 UIObserver::UnRegisterNavigationCallback(id, nullptr);
512 }
513 }
514
515 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
516 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
517 std::string id;
518 if (ParseNavigationId(env, argv[PARAM_INDEX_ONE], id)) {
519 UIObserver::UnRegisterNavigationCallback(id, argv[PARAM_INDEX_TWO]);
520 }
521 }
522
523 napi_value result = nullptr;
524 return result;
525 }
526
ProcessNavigationUnRegisterByUniqueId(napi_env env,napi_callback_info info)527 napi_value ObserverProcess::ProcessNavigationUnRegisterByUniqueId(napi_env env, napi_callback_info info)
528 {
529 GET_PARAMS(env, info, PARAM_SIZE_THREE);
530
531 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_number)) {
532 int32_t navigationUniqueId;
533 if (napi_get_value_int32(env, argv[PARAM_INDEX_ONE], &navigationUniqueId) == napi_ok) {
534 UIObserver::UnRegisterNavigationCallback(navigationUniqueId, nullptr);
535 }
536 }
537
538 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_number) &&
539 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
540 int32_t navigationUniqueId;
541 if (napi_get_value_int32(env, argv[PARAM_INDEX_ONE], &navigationUniqueId) == napi_ok) {
542 UIObserver::UnRegisterNavigationCallback(navigationUniqueId, argv[PARAM_INDEX_TWO]);
543 }
544 }
545
546 napi_value result = nullptr;
547 return result;
548 }
549
ProcessScrollEventRegister(napi_env env,napi_callback_info info)550 napi_value ObserverProcess::ProcessScrollEventRegister(napi_env env, napi_callback_info info)
551 {
552 GET_PARAMS(env, info, PARAM_SIZE_THREE);
553
554 if (!isScrollEventChangeFuncSetted_) {
555 NG::UIObserverHandler::GetInstance().SetHandleScrollEventChangeFunc(&UIObserver::HandleScrollEventStateChange);
556 isScrollEventChangeFuncSetted_ = true;
557 }
558 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
559 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
560 UIObserver::RegisterScrollEventCallback(listener);
561 }
562
563 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
564 && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
565 std::string id;
566 if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
567 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
568 UIObserver::RegisterScrollEventCallback(id, listener);
569 }
570 }
571
572 napi_value result = nullptr;
573 return result;
574 }
575
ProcessScrollEventUnRegister(napi_env env,napi_callback_info info)576 napi_value ObserverProcess::ProcessScrollEventUnRegister(napi_env env, napi_callback_info info)
577 {
578 GET_PARAMS(env, info, PARAM_SIZE_THREE);
579
580 if (argc == PARAM_SIZE_ONE) {
581 UIObserver::UnRegisterScrollEventCallback(nullptr);
582 }
583
584 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
585 UIObserver::UnRegisterScrollEventCallback(argv[PARAM_INDEX_ONE]);
586 }
587
588 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
589 std::string id;
590 if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
591 UIObserver::UnRegisterScrollEventCallback(id, nullptr);
592 }
593 }
594
595 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
596 && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
597 std::string id;
598 if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
599 UIObserver::UnRegisterScrollEventCallback(id, argv[PARAM_INDEX_TWO]);
600 }
601 }
602
603 napi_value result = nullptr;
604 return result;
605 }
606
ProcessRouterPageRegister(napi_env env,napi_callback_info info)607 napi_value ObserverProcess::ProcessRouterPageRegister(napi_env env, napi_callback_info info)
608 {
609 GET_PARAMS(env, info, PARAM_SIZE_THREE);
610
611 if (!isRouterPageHandleFuncSetted_) {
612 NG::UIObserverHandler::GetInstance().SetHandleRouterPageChangeFunc(&UIObserver::HandleRouterPageStateChange);
613 isRouterPageHandleFuncSetted_ = true;
614 }
615
616 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
617 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
618 UIObserver::RegisterRouterPageCallback(0, listener);
619 }
620
621 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
622 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
623 auto context = argv[PARAM_INDEX_ONE];
624 if (context) {
625 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
626 if (IsUIAbilityContext(env, context)) {
627 UIObserver::RegisterRouterPageCallback(env, context, listener);
628 } else {
629 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
630 UIObserver::RegisterRouterPageCallback(uiContextInstanceId, listener);
631 }
632 }
633 }
634
635 napi_value result = nullptr;
636 return result;
637 }
638
ProcessRouterPageUnRegister(napi_env env,napi_callback_info info)639 napi_value ObserverProcess::ProcessRouterPageUnRegister(napi_env env, napi_callback_info info)
640 {
641 GET_PARAMS(env, info, PARAM_SIZE_THREE);
642
643 if (argc == PARAM_SIZE_ONE) {
644 UIObserver::UnRegisterRouterPageCallback(0, nullptr);
645 }
646
647 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
648 UIObserver::UnRegisterRouterPageCallback(0, argv[PARAM_INDEX_ONE]);
649 }
650
651 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
652 napi_value context = argv[PARAM_INDEX_ONE];
653 if (context) {
654 if (IsUIAbilityContext(env, context)) {
655 UIObserver::UnRegisterRouterPageCallback(env, context, nullptr);
656 } else {
657 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
658 UIObserver::UnRegisterRouterPageCallback(uiContextInstanceId, nullptr);
659 }
660 }
661 }
662
663 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
664 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
665 napi_value context = argv[PARAM_INDEX_ONE];
666 if (context) {
667 if (IsUIAbilityContext(env, context)) {
668 UIObserver::UnRegisterRouterPageCallback(env, context, argv[PARAM_INDEX_TWO]);
669 } else {
670 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
671 UIObserver::UnRegisterRouterPageCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
672 }
673 }
674 }
675
676 napi_value result = nullptr;
677 return result;
678 }
679
ProcessDensityRegister(napi_env env,napi_callback_info info)680 napi_value ObserverProcess::ProcessDensityRegister(napi_env env, napi_callback_info info)
681 {
682 GET_PARAMS(env, info, PARAM_SIZE_THREE);
683
684 if (!isDensityChangeSetted_) {
685 NG::UIObserverHandler::GetInstance().SetHandleDensityChangeFunc(&UIObserver::HandleDensityChange);
686 isDensityChangeSetted_ = true;
687 }
688 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
689 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
690 int32_t instanceId = ContainerScope::CurrentId();
691 UIObserver::RegisterDensityCallback(instanceId, listener);
692 }
693
694 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
695 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
696 auto context = argv[PARAM_INDEX_ONE];
697 if (context) {
698 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
699 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
700 UIObserver::RegisterDensityCallback(uiContextInstanceId, listener);
701 }
702 }
703
704 napi_value result = nullptr;
705 return result;
706 }
707
ProcessDensityUnRegister(napi_env env,napi_callback_info info)708 napi_value ObserverProcess::ProcessDensityUnRegister(napi_env env, napi_callback_info info)
709 {
710 GET_PARAMS(env, info, PARAM_SIZE_THREE);
711
712 if (argc == PARAM_SIZE_ONE) {
713 int32_t instanceId = ContainerScope::CurrentId();
714 UIObserver::UnRegisterDensityCallback(instanceId, nullptr);
715 }
716
717 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
718 napi_value context = argv[PARAM_INDEX_ONE];
719 if (context) {
720 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
721 UIObserver::UnRegisterDensityCallback(uiContextInstanceId, nullptr);
722 }
723 }
724
725 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
726 int32_t instanceId = ContainerScope::CurrentId();
727 UIObserver::UnRegisterDensityCallback(instanceId, argv[PARAM_INDEX_ONE]);
728 }
729
730 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
731 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
732 napi_value context = argv[PARAM_INDEX_ONE];
733 if (context) {
734 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
735 UIObserver::UnRegisterDensityCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
736 }
737 }
738
739 napi_value result = nullptr;
740 return result;
741 }
742
ProcessDrawCommandSendRegister(napi_env env,napi_callback_info info)743 napi_value ObserverProcess::ProcessDrawCommandSendRegister(napi_env env, napi_callback_info info)
744 {
745 GET_PARAMS(env, info, 3); // 3: Param Size Three
746
747 if (!isDrawCommandSendChangeSetted_) {
748 NG::UIObserverHandler::GetInstance().SetDrawCommandSendHandleFunc(&UIObserver::HandDrawCommandSendChange);
749 isDrawCommandSendChangeSetted_ = true;
750 }
751
752 if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
753 auto listener = std::make_shared<UIObserverListener>(env, argv[1]);
754 int32_t instanceId = ContainerScope::CurrentId();
755 UIObserver::RegisterDrawCallback(instanceId, listener);
756 }
757 if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
758 MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
759 auto context = argv[1];
760 if (context) {
761 auto listener = std::make_shared<UIObserverListener>(env, argv[2]); // 2: Param Index Two
762 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
763 UIObserver::RegisterDrawCallback(uiContextInstanceId, listener);
764 }
765 }
766 napi_value result = nullptr;
767 return result;
768 }
769
ProcessDrawCommandSendUnRegister(napi_env env,napi_callback_info info)770 napi_value ObserverProcess::ProcessDrawCommandSendUnRegister(napi_env env, napi_callback_info info)
771 {
772 GET_PARAMS(env, info, 3); // 3: Param Size Three
773
774 if (argc == 1) {
775 int32_t instanceId = ContainerScope::CurrentId();
776 UIObserver::UnRegisterDrawCallback(instanceId, nullptr);
777 }
778
779 if (argc == 2 && MatchValueType(env, argv[1], napi_object)) { // 2: Param Size Two
780 napi_value context = argv[1];
781 if (context) {
782 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
783 UIObserver::UnRegisterDrawCallback(uiContextInstanceId, nullptr);
784 }
785 }
786
787 if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
788 int32_t instanceId = ContainerScope::CurrentId();
789 UIObserver::UnRegisterDrawCallback(instanceId, argv[1]);
790 }
791
792 if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
793 MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
794 napi_value context = argv[1];
795 if (context) {
796 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
797 UIObserver::UnRegisterDrawCallback(uiContextInstanceId, argv[2]); // 2: Param Index Two
798 }
799 }
800
801 napi_value result = nullptr;
802 return result;
803 }
804
ProcessLayoutDoneRegister(napi_env env,napi_callback_info info)805 napi_value ObserverProcess::ProcessLayoutDoneRegister(napi_env env, napi_callback_info info)
806 {
807 GET_PARAMS(env, info, 3); // 3: Param Size Three
808
809 if (!isLayoutDoneChangeSetted_) {
810 NG::UIObserverHandler::GetInstance().SetLayoutDoneHandleFunc(&UIObserver::HandLayoutDoneChange);
811 isLayoutDoneChangeSetted_ = true;
812 }
813
814 if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
815 auto listener = std::make_shared<UIObserverListener>(env, argv[1]);
816 int32_t instanceId = ContainerScope::CurrentId();
817 UIObserver::RegisterLayoutCallback(instanceId, listener);
818 }
819 if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
820 MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
821 auto context = argv[1];
822 if (context) {
823 auto listener = std::make_shared<UIObserverListener>(env, argv[2]); // 2: Param Index Two
824 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
825 UIObserver::RegisterLayoutCallback(uiContextInstanceId, listener);
826 }
827 }
828 napi_value result = nullptr;
829 return result;
830 }
831
ProcessLayoutDoneUnRegister(napi_env env,napi_callback_info info)832 napi_value ObserverProcess::ProcessLayoutDoneUnRegister(napi_env env, napi_callback_info info)
833 {
834 GET_PARAMS(env, info, 3); // 3: Param Size Three
835
836 if (argc == 1) {
837 int32_t instanceId = ContainerScope::CurrentId();
838 UIObserver::UnRegisterLayoutCallback(instanceId, nullptr);
839 }
840
841 if (argc == 2 && MatchValueType(env, argv[1], napi_object)) { // 2: Param Size Two
842 napi_value context = argv[1];
843 if (context) {
844 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
845 UIObserver::UnRegisterLayoutCallback(uiContextInstanceId, nullptr);
846 }
847 }
848
849 if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
850 int32_t instanceId = ContainerScope::CurrentId();
851 UIObserver::UnRegisterLayoutCallback(instanceId, argv[1]);
852 }
853
854 if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
855 MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
856 napi_value context = argv[1];
857 if (context) {
858 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
859 UIObserver::UnRegisterLayoutCallback(uiContextInstanceId, argv[2]); // 2: Param Index Two
860 }
861 }
862
863 napi_value result = nullptr;
864 return result;
865 }
866
ProcessNavDestinationSwitchRegister(napi_env env,napi_callback_info info)867 napi_value ObserverProcess::ProcessNavDestinationSwitchRegister(napi_env env, napi_callback_info info)
868 {
869 NavDestinationSwitchParams params;
870 if (!ParseNavDestSwitchRegisterParams(env, info, params)) {
871 return nullptr;
872 }
873
874 if (!isDestinationSwitchHandleFuncSetted_) {
875 NG::UIObserverHandler::GetInstance().SetHandleNavDestinationSwitchFunc(&UIObserver::HandleNavDestinationSwitch);
876 isDestinationSwitchHandleFuncSetted_ = true;
877 }
878
879 auto listener = std::make_shared<UIObserverListener>(env, params.callback);
880 if (params.isUIContext) {
881 UIObserver::RegisterNavDestinationSwitchCallback(params.uiContextInstanceId, params.navigationId, listener);
882 } else {
883 UIObserver::RegisterNavDestinationSwitchCallback(env, params.abilityUIContext, params.navigationId, listener);
884 }
885
886 return nullptr;
887 }
888
ProcessNavDestinationSwitchUnRegister(napi_env env,napi_callback_info info)889 napi_value ObserverProcess::ProcessNavDestinationSwitchUnRegister(napi_env env, napi_callback_info info)
890 {
891 NavDestinationSwitchParams params;
892 if (!ParseNavDestSwitchUnRegisterParams(env, info, params)) {
893 return nullptr;
894 }
895
896 if (params.isUIContext) {
897 UIObserver::UnRegisterNavDestinationSwitchCallback(
898 params.uiContextInstanceId, params.navigationId, params.callback);
899 } else {
900 UIObserver::UnRegisterNavDestinationSwitchCallback(
901 env, params.abilityUIContext, params.navigationId, params.callback);
902 }
903
904 return nullptr;
905 }
906
ProcessWillClickRegister(napi_env env,napi_callback_info info)907 napi_value ObserverProcess::ProcessWillClickRegister(napi_env env, napi_callback_info info)
908 {
909 GET_PARAMS(env, info, PARAM_SIZE_THREE);
910
911 if (!isWillClickFuncSetted_) {
912 NG::UIObserverHandler::GetInstance().SetWillClickFunc(&UIObserver::HandleWillClick);
913 isWillClickFuncSetted_ = true;
914 }
915
916 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
917 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
918 UIObserver::RegisterWillClickCallback(0, listener);
919 }
920
921 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
922 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
923 auto context = argv[PARAM_INDEX_ONE];
924 if (context) {
925 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
926 if (IsUIAbilityContext(env, context)) {
927 UIObserver::RegisterWillClickCallback(env, context, listener);
928 } else {
929 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
930 UIObserver::RegisterWillClickCallback(uiContextInstanceId, listener);
931 }
932 }
933 }
934
935 return nullptr;
936 }
937
ProcessWillClickUnRegister(napi_env env,napi_callback_info info)938 napi_value ObserverProcess::ProcessWillClickUnRegister(napi_env env, napi_callback_info info)
939 {
940 GET_PARAMS(env, info, PARAM_SIZE_THREE);
941
942 if (argc == PARAM_SIZE_ONE) {
943 UIObserver::UnRegisterWillClickCallback(0, nullptr);
944 }
945
946 if (argc == PARAM_SIZE_TWO) {
947 if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
948 UIObserver::UnRegisterWillClickCallback(0, argv[PARAM_INDEX_ONE]);
949 } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
950 napi_value context = argv[PARAM_INDEX_ONE];
951 if (!context) {
952 return nullptr;
953 }
954 if (IsUIAbilityContext(env, context)) {
955 UIObserver::UnRegisterWillClickCallback(env, context, nullptr);
956 } else {
957 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
958 UIObserver::UnRegisterWillClickCallback(uiContextInstanceId, nullptr);
959 }
960 }
961 }
962
963 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
964 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
965 napi_value context = argv[PARAM_INDEX_ONE];
966 if (context) {
967 if (IsUIAbilityContext(env, context)) {
968 UIObserver::UnRegisterWillClickCallback(env, context, argv[PARAM_INDEX_TWO]);
969 } else {
970 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
971 UIObserver::UnRegisterWillClickCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
972 }
973 }
974 }
975
976 return nullptr;
977 }
978
ProcessDidClickRegister(napi_env env,napi_callback_info info)979 napi_value ObserverProcess::ProcessDidClickRegister(napi_env env, napi_callback_info info)
980 {
981 GET_PARAMS(env, info, PARAM_SIZE_THREE);
982
983 if (!isDidClickFuncSetted_) {
984 NG::UIObserverHandler::GetInstance().SetDidClickFunc(&UIObserver::HandleDidClick);
985 isDidClickFuncSetted_ = true;
986 }
987
988 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
989 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
990 UIObserver::RegisterDidClickCallback(0, listener);
991 }
992
993 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
994 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
995 auto context = argv[PARAM_INDEX_ONE];
996 if (context) {
997 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
998 if (IsUIAbilityContext(env, context)) {
999 UIObserver::RegisterDidClickCallback(env, context, listener);
1000 } else {
1001 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1002 UIObserver::RegisterDidClickCallback(uiContextInstanceId, listener);
1003 }
1004 }
1005 }
1006
1007 return nullptr;
1008 }
1009
ProcessDidClickUnRegister(napi_env env,napi_callback_info info)1010 napi_value ObserverProcess::ProcessDidClickUnRegister(napi_env env, napi_callback_info info)
1011 {
1012 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1013
1014 if (argc == PARAM_SIZE_ONE) {
1015 UIObserver::UnRegisterDidClickCallback(0, nullptr);
1016 }
1017
1018 if (argc == PARAM_SIZE_TWO) {
1019 if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1020 UIObserver::UnRegisterDidClickCallback(0, argv[PARAM_INDEX_ONE]);
1021 } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
1022 napi_value context = argv[PARAM_INDEX_ONE];
1023 if (!context) {
1024 return nullptr;
1025 }
1026 if (IsUIAbilityContext(env, context)) {
1027 UIObserver::UnRegisterDidClickCallback(env, context, nullptr);
1028 } else {
1029 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1030 UIObserver::UnRegisterDidClickCallback(uiContextInstanceId, nullptr);
1031 }
1032 }
1033 }
1034
1035 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1036 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1037 napi_value context = argv[PARAM_INDEX_ONE];
1038 if (context) {
1039 if (IsUIAbilityContext(env, context)) {
1040 UIObserver::UnRegisterDidClickCallback(env, context, argv[PARAM_INDEX_TWO]);
1041 } else {
1042 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1043 UIObserver::UnRegisterDidClickCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
1044 }
1045 }
1046 }
1047
1048 return nullptr;
1049 }
1050
ProcessTabContentStateRegister(napi_env env,napi_callback_info info)1051 napi_value ObserverProcess::ProcessTabContentStateRegister(napi_env env, napi_callback_info info)
1052 {
1053 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1054
1055 if (!isTabContentStateUpdateFuncSetted_) {
1056 NG::UIObserverHandler::GetInstance().SetHandleTabContentStateUpdateFunc(
1057 &UIObserver::HandleTabContentStateChange);
1058 isTabContentStateUpdateFuncSetted_ = true;
1059 }
1060
1061 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1062 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
1063 UIObserver::RegisterTabContentStateCallback(listener);
1064 }
1065
1066 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
1067 && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1068 std::string id;
1069 if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
1070 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
1071 UIObserver::RegisterTabContentStateCallback(id, listener);
1072 }
1073 }
1074
1075 napi_value result = nullptr;
1076 return result;
1077 }
1078
ProcessTabContentStateUnRegister(napi_env env,napi_callback_info info)1079 napi_value ObserverProcess::ProcessTabContentStateUnRegister(napi_env env, napi_callback_info info)
1080 {
1081 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1082
1083 if (argc == PARAM_SIZE_ONE) {
1084 UIObserver::UnRegisterTabContentStateCallback(nullptr);
1085 }
1086
1087 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1088 UIObserver::UnRegisterTabContentStateCallback(argv[PARAM_INDEX_ONE]);
1089 }
1090
1091 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
1092 std::string id;
1093 if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
1094 UIObserver::UnRegisterTabContentStateCallback(id, nullptr);
1095 }
1096 }
1097
1098 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
1099 && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1100 std::string id;
1101 if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
1102 UIObserver::UnRegisterTabContentStateCallback(id, argv[PARAM_INDEX_TWO]);
1103 }
1104 }
1105
1106 napi_value result = nullptr;
1107 return result;
1108 }
1109
ProcessBeforePanStartRegister(napi_env env,napi_callback_info info)1110 napi_value ObserverProcess::ProcessBeforePanStartRegister(napi_env env, napi_callback_info info)
1111 {
1112 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1113
1114 if (!isPanGestureHandleFuncSetted_) {
1115 NG::UIObserverHandler::GetInstance().SetPanGestureHandleFunc(&UIObserver::HandlePanGestureAccept);
1116 isPanGestureHandleFuncSetted_ = true;
1117 }
1118
1119 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1120 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
1121 UIObserver::RegisterBeforePanStartCallback(0, listener);
1122 }
1123
1124 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1125 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1126 auto context = argv[PARAM_INDEX_ONE];
1127 if (context) {
1128 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
1129 if (IsUIAbilityContext(env, context)) {
1130 UIObserver::RegisterBeforePanStartCallback(env, context, listener);
1131 } else {
1132 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1133 UIObserver::RegisterBeforePanStartCallback(uiContextInstanceId, listener);
1134 }
1135 }
1136 }
1137
1138 return nullptr;
1139 }
1140
ProcessBeforePanStartUnRegister(napi_env env,napi_callback_info info)1141 napi_value ObserverProcess::ProcessBeforePanStartUnRegister(napi_env env, napi_callback_info info)
1142 {
1143 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1144
1145 if (argc == PARAM_SIZE_ONE) {
1146 UIObserver::UnRegisterBeforePanStartCallback(0, nullptr);
1147 }
1148
1149 if (argc == PARAM_SIZE_TWO) {
1150 if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1151 UIObserver::UnRegisterBeforePanStartCallback(0, argv[PARAM_INDEX_ONE]);
1152 } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
1153 napi_value context = argv[PARAM_INDEX_ONE];
1154 if (!context) {
1155 return nullptr;
1156 }
1157 if (IsUIAbilityContext(env, context)) {
1158 UIObserver::UnRegisterBeforePanStartCallback(env, context, nullptr);
1159 } else {
1160 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1161 UIObserver::UnRegisterBeforePanStartCallback(uiContextInstanceId, nullptr);
1162 }
1163 }
1164 }
1165
1166 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1167 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1168 napi_value context = argv[PARAM_INDEX_ONE];
1169 if (context) {
1170 if (IsUIAbilityContext(env, context)) {
1171 UIObserver::UnRegisterBeforePanStartCallback(env, context, argv[PARAM_INDEX_TWO]);
1172 } else {
1173 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1174 UIObserver::UnRegisterBeforePanStartCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
1175 }
1176 }
1177 }
1178
1179 return nullptr;
1180 }
1181
ProcessBeforePanEndRegister(napi_env env,napi_callback_info info)1182 napi_value ObserverProcess::ProcessBeforePanEndRegister(napi_env env, napi_callback_info info)
1183 {
1184 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1185
1186 if (!isPanGestureHandleFuncSetted_) {
1187 NG::UIObserverHandler::GetInstance().SetPanGestureHandleFunc(&UIObserver::HandlePanGestureAccept);
1188 isPanGestureHandleFuncSetted_ = true;
1189 }
1190
1191 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1192 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
1193 UIObserver::RegisterBeforePanEndCallback(0, listener);
1194 }
1195
1196 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1197 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1198 auto context = argv[PARAM_INDEX_ONE];
1199 if (context) {
1200 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
1201 if (IsUIAbilityContext(env, context)) {
1202 UIObserver::RegisterBeforePanEndCallback(env, context, listener);
1203 } else {
1204 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1205 UIObserver::RegisterBeforePanEndCallback(uiContextInstanceId, listener);
1206 }
1207 }
1208 }
1209
1210 return nullptr;
1211 }
1212
ProcessBeforePanEndUnRegister(napi_env env,napi_callback_info info)1213 napi_value ObserverProcess::ProcessBeforePanEndUnRegister(napi_env env, napi_callback_info info)
1214 {
1215 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1216
1217 if (argc == PARAM_SIZE_ONE) {
1218 UIObserver::UnRegisterBeforePanEndCallback(0, nullptr);
1219 }
1220
1221 if (argc == PARAM_SIZE_TWO) {
1222 if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1223 UIObserver::UnRegisterBeforePanEndCallback(0, argv[PARAM_INDEX_ONE]);
1224 } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
1225 napi_value context = argv[PARAM_INDEX_ONE];
1226 if (!context) {
1227 return nullptr;
1228 }
1229 if (IsUIAbilityContext(env, context)) {
1230 UIObserver::UnRegisterBeforePanEndCallback(env, context, nullptr);
1231 } else {
1232 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1233 UIObserver::UnRegisterBeforePanEndCallback(uiContextInstanceId, nullptr);
1234 }
1235 }
1236 }
1237
1238 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1239 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1240 napi_value context = argv[PARAM_INDEX_ONE];
1241 if (context) {
1242 if (IsUIAbilityContext(env, context)) {
1243 UIObserver::UnRegisterBeforePanEndCallback(env, context, argv[PARAM_INDEX_TWO]);
1244 } else {
1245 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1246 UIObserver::UnRegisterBeforePanEndCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
1247 }
1248 }
1249 }
1250
1251 return nullptr;
1252 }
1253
ProcessAfterPanStartRegister(napi_env env,napi_callback_info info)1254 napi_value ObserverProcess::ProcessAfterPanStartRegister(napi_env env, napi_callback_info info)
1255 {
1256 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1257
1258 if (!isPanGestureHandleFuncSetted_) {
1259 NG::UIObserverHandler::GetInstance().SetPanGestureHandleFunc(&UIObserver::HandlePanGestureAccept);
1260 isPanGestureHandleFuncSetted_ = true;
1261 }
1262
1263 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1264 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
1265 UIObserver::RegisterAfterPanStartCallback(0, listener);
1266 }
1267
1268 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1269 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1270 auto context = argv[PARAM_INDEX_ONE];
1271 if (context) {
1272 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
1273 if (IsUIAbilityContext(env, context)) {
1274 UIObserver::RegisterAfterPanStartCallback(env, context, listener);
1275 } else {
1276 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1277 UIObserver::RegisterAfterPanStartCallback(uiContextInstanceId, listener);
1278 }
1279 }
1280 }
1281
1282 return nullptr;
1283 }
1284
ProcessAfterPanStartUnRegister(napi_env env,napi_callback_info info)1285 napi_value ObserverProcess::ProcessAfterPanStartUnRegister(napi_env env, napi_callback_info info)
1286 {
1287 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1288
1289 if (argc == PARAM_SIZE_ONE) {
1290 UIObserver::UnRegisterAfterPanStartCallback(0, nullptr);
1291 }
1292
1293 if (argc == PARAM_SIZE_TWO) {
1294 if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1295 UIObserver::UnRegisterAfterPanStartCallback(0, argv[PARAM_INDEX_ONE]);
1296 } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
1297 napi_value context = argv[PARAM_INDEX_ONE];
1298 if (!context) {
1299 return nullptr;
1300 }
1301 if (IsUIAbilityContext(env, context)) {
1302 UIObserver::UnRegisterAfterPanStartCallback(env, context, nullptr);
1303 } else {
1304 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1305 UIObserver::UnRegisterAfterPanStartCallback(uiContextInstanceId, nullptr);
1306 }
1307 }
1308 }
1309
1310 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1311 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1312 napi_value context = argv[PARAM_INDEX_ONE];
1313 if (context) {
1314 if (IsUIAbilityContext(env, context)) {
1315 UIObserver::UnRegisterAfterPanStartCallback(env, context, argv[PARAM_INDEX_TWO]);
1316 } else {
1317 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1318 UIObserver::UnRegisterAfterPanStartCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
1319 }
1320 }
1321 }
1322
1323 return nullptr;
1324 }
1325
ProcessAfterPanEndRegister(napi_env env,napi_callback_info info)1326 napi_value ObserverProcess::ProcessAfterPanEndRegister(napi_env env, napi_callback_info info)
1327 {
1328 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1329
1330 if (!isPanGestureHandleFuncSetted_) {
1331 NG::UIObserverHandler::GetInstance().SetPanGestureHandleFunc(&UIObserver::HandlePanGestureAccept);
1332 isPanGestureHandleFuncSetted_ = true;
1333 }
1334
1335 if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1336 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
1337 UIObserver::RegisterAfterPanEndCallback(0, listener);
1338 }
1339
1340 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1341 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1342 auto context = argv[PARAM_INDEX_ONE];
1343 if (context) {
1344 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
1345 if (IsUIAbilityContext(env, context)) {
1346 UIObserver::RegisterAfterPanEndCallback(env, context, listener);
1347 } else {
1348 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1349 UIObserver::RegisterAfterPanEndCallback(uiContextInstanceId, listener);
1350 }
1351 }
1352 }
1353
1354 return nullptr;
1355 }
1356
ProcessAfterPanEndUnRegister(napi_env env,napi_callback_info info)1357 napi_value ObserverProcess::ProcessAfterPanEndUnRegister(napi_env env, napi_callback_info info)
1358 {
1359 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1360
1361 if (argc == PARAM_SIZE_ONE) {
1362 UIObserver::UnRegisterAfterPanEndCallback(0, nullptr);
1363 }
1364
1365 if (argc == PARAM_SIZE_TWO) {
1366 if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
1367 UIObserver::UnRegisterAfterPanEndCallback(0, argv[PARAM_INDEX_ONE]);
1368 } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
1369 napi_value context = argv[PARAM_INDEX_ONE];
1370 if (!context) {
1371 return nullptr;
1372 }
1373 if (IsUIAbilityContext(env, context)) {
1374 UIObserver::UnRegisterAfterPanEndCallback(env, context, nullptr);
1375 } else {
1376 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1377 UIObserver::UnRegisterAfterPanEndCallback(uiContextInstanceId, nullptr);
1378 }
1379 }
1380 }
1381
1382 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
1383 MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1384 napi_value context = argv[PARAM_INDEX_ONE];
1385 if (context) {
1386 if (IsUIAbilityContext(env, context)) {
1387 UIObserver::UnRegisterAfterPanEndCallback(env, context, argv[PARAM_INDEX_TWO]);
1388 } else {
1389 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
1390 UIObserver::UnRegisterAfterPanEndCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
1391 }
1392 }
1393 }
1394
1395 return nullptr;
1396 }
1397
ProcessNodeRenderStateRegister(napi_env env,napi_callback_info info)1398 napi_value ObserverProcess::ProcessNodeRenderStateRegister(napi_env env, napi_callback_info info)
1399 {
1400 auto container = AceEngine::Get().GetContainer(Container::CurrentIdSafely());
1401 auto pipeline = container->GetPipelineContext();
1402 CHECK_NULL_RETURN(pipeline, nullptr);
1403 auto pipelineContext = AceType::DynamicCast<NG::PipelineContext>(pipeline);
1404 CHECK_NULL_RETURN(pipelineContext, nullptr);
1405 auto monitor = pipelineContext->GetNodeRenderStatusMonitor();
1406 if (monitor->IsRegisterNodeRenderStateChangeCallbackExceedLimit()) {
1407 TAG_LOGE(AceLogTag::ACE_OBSERVER, "register node render state change callback exceed limit.");
1408 NapiThrow(env, NODE_RENDER_STATE_REGISTER_ERR_MSG, NODE_RENDER_STATE_REGISTER_ERR_CODE);
1409 return nullptr;
1410 }
1411 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1412
1413 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1414 auto frameNode = ParseNodeRenderStateFrameNode(env, argv[PARAM_INDEX_ONE]);
1415 auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
1416 UIObserver::RegisterNodeRenderStateChangeCallback(frameNode, listener, monitor);
1417 }
1418
1419 return nullptr;
1420 }
1421
ProcessNodeRenderStateUnRegister(napi_env env,napi_callback_info info)1422 napi_value ObserverProcess::ProcessNodeRenderStateUnRegister(napi_env env, napi_callback_info info)
1423 {
1424 auto container = AceEngine::Get().GetContainer(Container::CurrentIdSafely());
1425 auto pipeline = container->GetPipelineContext();
1426 CHECK_NULL_RETURN(pipeline, nullptr);
1427 auto pipelineContext = AceType::DynamicCast<NG::PipelineContext>(pipeline);
1428 CHECK_NULL_RETURN(pipelineContext, nullptr);
1429 auto monitor = pipelineContext->GetNodeRenderStatusMonitor();
1430 GET_PARAMS(env, info, PARAM_SIZE_THREE);
1431
1432 RefPtr<NG::FrameNode> frameNode = nullptr;
1433 napi_value callback = nullptr;
1434 if (argc == PARAM_SIZE_TWO) {
1435 frameNode = ParseNodeRenderStateFrameNode(env, argv[PARAM_INDEX_ONE]);
1436 }
1437
1438 if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
1439 frameNode = ParseNodeRenderStateFrameNode(env, argv[PARAM_INDEX_ONE]);
1440 callback = argv[PARAM_INDEX_TWO];
1441 }
1442 UIObserver::UnRegisterNodeRenderStateChangeCallback(frameNode, callback, monitor);
1443 return nullptr;
1444 }
1445
ObserverOn(napi_env env,napi_callback_info info)1446 napi_value ObserverOn(napi_env env, napi_callback_info info)
1447 {
1448 return ObserverProcess::GetInstance().ProcessRegister(env, info);
1449 }
1450
ObserverOff(napi_env env,napi_callback_info info)1451 napi_value ObserverOff(napi_env env, napi_callback_info info)
1452 {
1453 return ObserverProcess::GetInstance().ProcessUnRegister(env, info);
1454 }
1455
AddToScrollEventType(napi_env env)1456 napi_value AddToScrollEventType(napi_env env)
1457 {
1458 napi_value scrollEventType = nullptr;
1459 napi_value prop = nullptr;
1460 napi_create_object(env, &scrollEventType);
1461 napi_create_uint32(env, SCROLL_START, &prop);
1462 napi_set_named_property(env, scrollEventType, "SCROLL_START", prop);
1463 napi_create_uint32(env, SCROLL_STOP, &prop);
1464 napi_set_named_property(env, scrollEventType, "SCROLL_STOP", prop);
1465 return scrollEventType;
1466 }
1467
AddToRouterPageState(napi_env env)1468 napi_value AddToRouterPageState(napi_env env)
1469 {
1470 napi_value routerPageState = nullptr;
1471 napi_value prop = nullptr;
1472 napi_create_object(env, &routerPageState);
1473 napi_create_uint32(env, ABOUT_TO_APPEAR, &prop);
1474 napi_set_named_property(env, routerPageState, "ABOUT_TO_APPEAR", prop);
1475 napi_create_uint32(env, ABOUT_TO_DISAPPEAR, &prop);
1476 napi_set_named_property(env, routerPageState, "ABOUT_TO_DISAPPEAR", prop);
1477 napi_create_uint32(env, ON_PAGE_SHOW, &prop);
1478 napi_set_named_property(env, routerPageState, "ON_PAGE_SHOW", prop);
1479 napi_create_uint32(env, ON_PAGE_HIDE, &prop);
1480 napi_set_named_property(env, routerPageState, "ON_PAGE_HIDE", prop);
1481 napi_create_uint32(env, ON_BACK_PRESS, &prop);
1482 napi_set_named_property(env, routerPageState, "ON_BACK_PRESS", prop);
1483 return routerPageState;
1484 }
1485
CreateNavDestinationState(napi_env env)1486 napi_value CreateNavDestinationState(napi_env env)
1487 {
1488 napi_value navDestinationState = nullptr;
1489 napi_create_object(env, &navDestinationState);
1490 napi_value prop = nullptr;
1491 napi_create_uint32(env, ON_SHOWN, &prop);
1492 napi_set_named_property(env, navDestinationState, "ON_SHOWN", prop);
1493 napi_create_uint32(env, ON_HIDDEN, &prop);
1494 napi_set_named_property(env, navDestinationState, "ON_HIDDEN", prop);
1495 napi_create_uint32(env, ON_APPEAR, &prop);
1496 napi_set_named_property(env, navDestinationState, "ON_APPEAR", prop);
1497 napi_create_uint32(env, ON_DISAPPEAR, &prop);
1498 napi_set_named_property(env, navDestinationState, "ON_DISAPPEAR", prop);
1499 napi_create_uint32(env, ON_WILL_SHOW, &prop);
1500 napi_set_named_property(env, navDestinationState, "ON_WILL_SHOW", prop);
1501 napi_create_uint32(env, ON_WILL_HIDE, &prop);
1502 napi_set_named_property(env, navDestinationState, "ON_WILL_HIDE", prop);
1503 napi_create_uint32(env, ON_WILL_APPEAR, &prop);
1504 napi_set_named_property(env, navDestinationState, "ON_WILL_APPEAR", prop);
1505 napi_create_uint32(env, ON_WILL_DISAPPEAR, &prop);
1506 napi_set_named_property(env, navDestinationState, "ON_WILL_DISAPPEAR", prop);
1507 napi_create_uint32(env, ON_BACKPRESS, &prop);
1508 napi_set_named_property(env, navDestinationState, "ON_BACKPRESS", prop);
1509 napi_create_uint32(env, ON_ACTIVE, &prop);
1510 napi_set_named_property(env, navDestinationState, "ON_ACTIVE", prop);
1511 napi_create_uint32(env, ON_INACTIVE, &prop);
1512 napi_set_named_property(env, navDestinationState, "ON_INACTIVE", prop);
1513 return navDestinationState;
1514 }
1515
AddToNodeRenderStateType(napi_env env)1516 napi_value AddToNodeRenderStateType(napi_env env)
1517 {
1518 napi_value nodeRenderStateType = nullptr;
1519 napi_value prop = nullptr;
1520 napi_create_object(env, &nodeRenderStateType);
1521 napi_create_uint32(env, ABOUT_TO_RENDER_IN, &prop);
1522 napi_set_named_property(env, nodeRenderStateType, "ABOUT_TO_RENDER_IN", prop);
1523 napi_create_uint32(env, ABOUT_TO_RENDER_OUT, &prop);
1524 napi_set_named_property(env, nodeRenderStateType, "ABOUT_TO_RENDER_OUT", prop);
1525 return nodeRenderStateType;
1526 }
1527
AddToTabContentState(napi_env env)1528 napi_value AddToTabContentState(napi_env env)
1529 {
1530 napi_value tabContentState = nullptr;
1531 napi_value prop = nullptr;
1532 napi_create_object(env, &tabContentState);
1533 napi_create_uint32(env, ON_SHOW, &prop);
1534 napi_set_named_property(env, tabContentState, "ON_SHOW", prop);
1535 napi_create_uint32(env, ON_HIDE, &prop);
1536 napi_set_named_property(env, tabContentState, "ON_HIDE", prop);
1537 return tabContentState;
1538 }
1539
AddToGestureType(napi_env env)1540 napi_value AddToGestureType(napi_env env)
1541 {
1542 napi_value gestureType = nullptr;
1543 napi_value prop = nullptr;
1544 napi_create_object(env, &gestureType);
1545 napi_create_uint32(env, TAP_GESTURE, &prop);
1546 napi_set_named_property(env, gestureType, "TAP_GESTURE", prop);
1547 napi_create_uint32(env, LONG_PRESS_GESTURE, &prop);
1548 napi_set_named_property(env, gestureType, "LONG_PRESS_GESTURE", prop);
1549 napi_create_uint32(env, PAN_GESTURE, &prop);
1550 napi_set_named_property(env, gestureType, "PAN_GESTURE", prop);
1551 napi_create_uint32(env, PINCH_GESTURE, &prop);
1552 napi_set_named_property(env, gestureType, "PINCH_GESTURE", prop);
1553 napi_create_uint32(env, SWIPE_GESTURE, &prop);
1554 napi_set_named_property(env, gestureType, "SWIPE_GESTURE", prop);
1555 napi_create_uint32(env, ROTATION_GESTURE, &prop);
1556 napi_set_named_property(env, gestureType, "ROTATION_GESTURE", prop);
1557 napi_create_uint32(env, DRAG, &prop);
1558 napi_set_named_property(env, gestureType, "DRAG", prop);
1559 napi_create_uint32(env, CLICK, &prop);
1560 napi_set_named_property(env, gestureType, "CLICK", prop);
1561 return gestureType;
1562 }
1563
AddToGestureRecognizerState(napi_env env)1564 napi_value AddToGestureRecognizerState(napi_env env)
1565 {
1566 napi_value gestureRecognizerState = nullptr;
1567 napi_value prop = nullptr;
1568 napi_create_object(env, &gestureRecognizerState);
1569 napi_create_uint32(env, READY, &prop);
1570 napi_set_named_property(env, gestureRecognizerState, "READY", prop);
1571 napi_create_uint32(env, DETECTING, &prop);
1572 napi_set_named_property(env, gestureRecognizerState, "DETECTING", prop);
1573 napi_create_uint32(env, PENDING, &prop);
1574 napi_set_named_property(env, gestureRecognizerState, "PENDING", prop);
1575 napi_create_uint32(env, BLOCKED, &prop);
1576 napi_set_named_property(env, gestureRecognizerState, "BLOCKED", prop);
1577 napi_create_uint32(env, SUCCESSFUL, &prop);
1578 napi_set_named_property(env, gestureRecognizerState, "SUCCESSFUL", prop);
1579 napi_create_uint32(env, FAILED, &prop);
1580 napi_set_named_property(env, gestureRecognizerState, "FAILED", prop);
1581 return gestureRecognizerState;
1582 }
1583
UIObserverExport(napi_env env,napi_value exports)1584 static napi_value UIObserverExport(napi_env env, napi_value exports)
1585 {
1586 napi_value navDestinationState = CreateNavDestinationState(env);
1587
1588 napi_value scrollEventType = nullptr;
1589 scrollEventType = AddToScrollEventType(env);
1590
1591 napi_value routerPageState = nullptr;
1592 routerPageState = AddToRouterPageState(env);
1593
1594 napi_value tabContentState = nullptr;
1595 tabContentState = AddToTabContentState(env);
1596
1597 napi_value gestureType = nullptr;
1598 gestureType = AddToGestureType(env);
1599
1600 napi_value gestureRecognizerState = nullptr;
1601 gestureRecognizerState = AddToGestureRecognizerState(env);
1602
1603 napi_value nodeRenderStateType = nullptr;
1604 nodeRenderStateType = AddToNodeRenderStateType(env);
1605
1606 napi_property_descriptor uiObserverDesc[] = {
1607 DECLARE_NAPI_FUNCTION("on", ObserverOn),
1608 DECLARE_NAPI_FUNCTION("off", ObserverOff),
1609 DECLARE_NAPI_PROPERTY("NavDestinationState", navDestinationState),
1610 DECLARE_NAPI_PROPERTY("ScrollEventType", scrollEventType),
1611 DECLARE_NAPI_PROPERTY("RouterPageState", routerPageState),
1612 DECLARE_NAPI_PROPERTY("TabContentState", tabContentState),
1613 DECLARE_NAPI_PROPERTY("GestureType", gestureType),
1614 DECLARE_NAPI_PROPERTY("GestureRecognizerState", gestureRecognizerState),
1615 DECLARE_NAPI_PROPERTY("NodeRenderState", nodeRenderStateType),
1616 };
1617 NAPI_CALL(
1618 env, napi_define_properties(env, exports, sizeof(uiObserverDesc) / sizeof(uiObserverDesc[0]), uiObserverDesc));
1619 NAPI_CALL(env, GestureObserver::DefineGestureObserver(env, exports));
1620 return exports;
1621 }
1622
1623 static napi_module uiObserverModule = {
1624 .nm_version = 1,
1625 .nm_flags = 0,
1626 .nm_filename = nullptr,
1627 .nm_register_func = UIObserverExport,
1628 .nm_modname = "arkui.observer",
1629 .nm_priv = ((void*)0),
1630 .reserved = { 0 },
1631 };
1632
ObserverRegister()1633 extern "C" __attribute__((constructor)) void ObserverRegister()
1634 {
1635 napi_module_register(&uiObserverModule);
1636 }
1637 } // namespace OHOS::Ace::Napi
1638