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 #include "ui_observer_listener.h"
19 
20 #include <map>
21 #include <optional>
22 #include <string>
23 
24 #include "interfaces/napi/kits/utils/napi_utils.h"
25 #include "js_native_api.h"
26 #include "js_native_api_types.h"
27 
28 #include "core/components_ng/base/observer_handler.h"
29 #include "core/common/container_scope.h"
30 
31 namespace OHOS::Ace::Napi {
32 namespace {
33 #define GET_PARAMS(env, info, max) \
34     size_t argc = max;             \
35     napi_value argv[max] = { 0 };  \
36     napi_value thisVar = nullptr;  \
37     void* data;                    \
38     napi_get_cb_info(env, info, &argc, argv, &thisVar, &data)
39 
40 static constexpr uint32_t PARAM_SIZE_ONE = 1;
41 static constexpr uint32_t PARAM_SIZE_TWO = 2;
42 static constexpr uint32_t PARAM_SIZE_THREE = 3;
43 static constexpr uint32_t PARAM_SIZE_FOUR = 4;
44 
45 static constexpr size_t PARAM_INDEX_ZERO = 0;
46 static constexpr size_t PARAM_INDEX_ONE = 1;
47 static constexpr size_t PARAM_INDEX_TWO = 2;
48 static constexpr size_t PARAM_INDEX_THREE = 3;
49 
50 static constexpr uint32_t ON_SHOWN = 0;
51 static constexpr uint32_t ON_HIDDEN = 1;
52 static constexpr uint32_t ON_APPEAR = 2;
53 static constexpr uint32_t ON_DISAPPEAR = 3;
54 static constexpr uint32_t ON_WILL_SHOW = 4;
55 static constexpr uint32_t ON_WILL_HIDE = 5;
56 static constexpr uint32_t ON_WILL_APPEAR = 6;
57 static constexpr uint32_t ON_WILL_DISAPPEAR = 7;
58 static constexpr uint32_t ON_BACKPRESS = 100;
59 
60 static constexpr uint32_t SCROLL_START = 0;
61 static constexpr uint32_t SCROLL_STOP = 1;
62 
63 static constexpr uint32_t ABOUT_TO_APPEAR = 0;
64 static constexpr uint32_t ABOUT_TO_DISAPPEAR = 1;
65 static constexpr uint32_t ON_PAGE_SHOW = 2;
66 static constexpr uint32_t ON_PAGE_HIDE = 3;
67 static constexpr uint32_t ON_BACK_PRESS = 4;
68 
69 static constexpr uint32_t ON_SHOW = 0;
70 static constexpr uint32_t ON_HIDE = 1;
71 
72 constexpr char NAVDESTINATION_UPDATE[] = "navDestinationUpdate";
73 constexpr char ROUTERPAGE_UPDATE[] = "routerPageUpdate";
74 constexpr char SCROLL_EVENT[] = "scrollEvent";
75 constexpr char DENSITY_UPDATE[] = "densityUpdate";
76 constexpr char LAYOUT_DONE[] = "didLayout";
77 constexpr char DRAW_COMMAND_SEND[] = "willDraw";
78 constexpr char NAVDESTINATION_SWITCH[] = "navDestinationSwitch";
79 constexpr char WILLCLICK_UPDATE[] = "willClick";
80 constexpr char DIDCLICK_UPDATE[] = "didClick";
81 constexpr char TAB_CONTENT_STATE[] = "tabContentUpdate";
82 
IsUIAbilityContext(napi_env env,napi_value context)83 bool IsUIAbilityContext(napi_env env, napi_value context)
84 {
85     napi_value abilityInfo = nullptr;
86     napi_get_named_property(env, context, "abilityInfo", &abilityInfo);
87     if (!abilityInfo) {
88         return false;
89     }
90     napi_value abilityInfoName = nullptr;
91     napi_get_named_property(env, abilityInfo, "name", &abilityInfoName);
92     if (abilityInfoName) {
93         return true;
94     }
95     return false;
96 }
97 
GetUIContextInstanceId(napi_env env,napi_value uiContext)98 int32_t GetUIContextInstanceId(napi_env env, napi_value uiContext)
99 {
100     int32_t result = 0;
101     if (IsUIAbilityContext(env, uiContext)) {
102         return result;
103     }
104     napi_value instanceId = nullptr;
105     napi_get_named_property(env, uiContext, "instanceId_", &instanceId);
106     napi_get_value_int32(env, instanceId, &result);
107     return result;
108 }
109 
MatchValueType(napi_env env,napi_value value,napi_valuetype targetType)110 bool MatchValueType(napi_env env, napi_value value, napi_valuetype targetType)
111 {
112     napi_valuetype valueType = napi_undefined;
113     napi_typeof(env, value, &valueType);
114     return valueType == targetType;
115 }
116 
ParseStringFromNapi(napi_env env,napi_value val,std::string & str)117 bool ParseStringFromNapi(napi_env env, napi_value val, std::string& str)
118 {
119     napi_valuetype type;
120     return GetNapiString(env, val, str, type);
121 }
122 
ParseNavigationId(napi_env env,napi_value obj,std::string & navigationStr)123 bool ParseNavigationId(napi_env env, napi_value obj, std::string& navigationStr)
124 {
125     napi_value navigationId = nullptr;
126     napi_get_named_property(env, obj, "navigationId", &navigationId);
127     return ParseStringFromNapi(env, navigationId, navigationStr);
128 }
129 
ParseScrollId(napi_env env,napi_value obj,std::string & result)130 bool ParseScrollId(napi_env env, napi_value obj, std::string& result)
131 {
132     napi_value resultId = nullptr;
133     napi_get_named_property(env, obj, "id", &resultId);
134     if (!MatchValueType(env, resultId, napi_string)) {
135         return false;
136     }
137     return ParseStringFromNapi(env, resultId, result);
138 }
139 
IsNavDestSwitchOptions(napi_env env,napi_value obj,std::string & navigationId)140 bool IsNavDestSwitchOptions(napi_env env, napi_value obj, std::string& navigationId)
141 {
142     if (!MatchValueType(env, obj, napi_object)) {
143         return false;
144     }
145     napi_value navId = nullptr;
146     napi_get_named_property(env, obj, "navigationId", &navId);
147     return ParseStringFromNapi(env, navId, navigationId);
148 }
149 
150 struct NavDestinationSwitchParams {
151     bool isUIContext = true;
152     std::optional<std::string> navigationId;
153     napi_value callback = nullptr;
154     napi_value abilityUIContext = nullptr;
155     int32_t uiContextInstanceId = 0;
156 };
157 
ParseNavDestSwitchRegisterParams(napi_env env,napi_callback_info info,NavDestinationSwitchParams & params)158 bool ParseNavDestSwitchRegisterParams(napi_env env, napi_callback_info info, NavDestinationSwitchParams& params)
159 {
160     GET_PARAMS(env, info, PARAM_SIZE_FOUR);
161 
162     auto& secondArg = argv[PARAM_INDEX_ONE];
163     auto& thirdArg = argv[PARAM_INDEX_TWO];
164     auto& fourthArg = argv[PARAM_INDEX_THREE];
165     std::string navigationId;
166     if (argc == PARAM_SIZE_TWO && MatchValueType(env, secondArg, napi_function)) {
167         // js code: UIObserver.on('navDestinationSwitch', callback)
168         params.callback = secondArg;
169     } else if (argc == PARAM_SIZE_THREE && MatchValueType(env, secondArg, napi_object) &&
170         MatchValueType(env, thirdArg, napi_function)) {
171         if (IsNavDestSwitchOptions(env, secondArg, navigationId)) {
172             // js code: UIObserver.on('navDestinationSwitch', { navigationId: navId }, callback)
173             params.navigationId = navigationId;
174         } else if (IsUIAbilityContext(env, secondArg)) {
175             // js code: observer.on('navDestinationSwitch', AbilityUIContext, callback)
176             params.isUIContext = false;
177             params.abilityUIContext = secondArg;
178         } else {
179             // js code: observer.on('navDestinationSwitch', UIContext, callback)
180             params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
181         }
182         params.callback = thirdArg;
183     } else if (argc == PARAM_SIZE_FOUR && MatchValueType(env, secondArg, napi_object) &&
184         IsNavDestSwitchOptions(env, thirdArg, navigationId) &&
185         MatchValueType(env, fourthArg, napi_function)) {
186         if (IsUIAbilityContext(env, secondArg)) {
187             // js code: observer.on('navDestinationSwitch', AbilityUIContext, { navigationId: navId }, callback)
188             params.isUIContext = false;
189             params.abilityUIContext = secondArg;
190         } else {
191             // js code: observer.on('navDestinationSwitch', UIContext, { navigationId: navId }, callback)
192             params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
193         }
194         params.navigationId = navigationId;
195         params.callback = fourthArg;
196     } else {
197         return false;
198     }
199 
200     return true;
201 }
202 
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_value secondArg,NavDestinationSwitchParams & params)203 bool ParseNavDestSwitchUnRegisterParams(
204     napi_env env, napi_value secondArg, NavDestinationSwitchParams& params)
205 {
206     std::string navigationId;
207     if (MatchValueType(env, secondArg, napi_function)) {
208         // js code: UIObserver.off('navDestinationSwitch', callback)
209         params.callback = secondArg;
210     } else if (IsNavDestSwitchOptions(env, secondArg, navigationId)) {
211         // js code: UIObserver.off('navDestinationSwitch', { navigationId: navId })
212         params.navigationId = navigationId;
213     } else if (MatchValueType(env, secondArg, napi_object)) {
214         if (IsUIAbilityContext(env, secondArg)) {
215             // js code: observer.off('navDestinationSwitch', AbilityUIContext)
216             params.isUIContext = false;
217             params.abilityUIContext = secondArg;
218         } else {
219             // js code: observer.off('navDestinationSwitch', UIContext)
220             params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
221         }
222     } else {
223         return false;
224     }
225 
226     return true;
227 }
228 
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_value secondArg,napi_value thirdArg,NavDestinationSwitchParams & params)229 bool ParseNavDestSwitchUnRegisterParams(
230     napi_env env, napi_value secondArg, napi_value thirdArg, NavDestinationSwitchParams& params)
231 {
232     std::string navigationId;
233     if (MatchValueType(env, thirdArg, napi_function)) {
234         params.callback = thirdArg;
235         if (IsNavDestSwitchOptions(env, secondArg, navigationId)) {
236             // js code: UIObserver.off('navDestinationSwitch', { navigationId: navId }, callback)
237             params.navigationId = navigationId;
238         } else if (MatchValueType(env, secondArg, napi_object)) {
239             if (IsUIAbilityContext(env, secondArg)) {
240                 // js code: observer.off('navDestinationSwitch', AbilityUIContext, callback)
241                 params.isUIContext = false;
242                 params.abilityUIContext = secondArg;
243             } else {
244                 // js code: observer.off('navDestinationSwitch', UIContext, callback)
245                 params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
246             }
247         } else {
248             return false;
249         }
250     } else if (MatchValueType(env, secondArg, napi_object) &&
251         IsNavDestSwitchOptions(env, thirdArg, navigationId)) {
252         if (IsUIAbilityContext(env, secondArg)) {
253             // js code: observer.off('navDestinationSwitch', AbilityUIContext, { navigationId: navId })
254             params.isUIContext = false;
255             params.abilityUIContext = secondArg;
256         } else {
257             // js code: observer.off('navDestinationSwitch', UIContext, { navigationId: navId })
258             params.uiContextInstanceId = GetUIContextInstanceId(env, secondArg);
259         }
260         params.navigationId = navigationId;
261     } else {
262         return false;
263     }
264 
265     return true;
266 }
267 
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_value secondArg,napi_value thirdArg,napi_value fourthArg,NavDestinationSwitchParams & params)268 bool ParseNavDestSwitchUnRegisterParams(
269     napi_env env, napi_value secondArg, napi_value thirdArg,
270     napi_value fourthArg, NavDestinationSwitchParams& params)
271 {
272     std::string navigationId;
273     auto& context = secondArg;
274     auto& options = thirdArg;
275     auto& callback = fourthArg;
276     if (MatchValueType(env, context, napi_object) &&
277         IsNavDestSwitchOptions(env, options, navigationId) &&
278         MatchValueType(env, callback, napi_function)) {
279         if (IsUIAbilityContext(env, context)) {
280             // js code: observer.off('navDestinationSwitch', AbilityUIContext, { navigationId: navId }, callback)
281             params.isUIContext = false;
282             params.abilityUIContext = context;
283         } else {
284             // js code: observer.off('navDestinationSwitch', UIContext, { navigationId: navId }, callback)
285             params.uiContextInstanceId = GetUIContextInstanceId(env, context);
286         }
287         params.navigationId = navigationId;
288         params.callback = callback;
289         return true;
290     }
291 
292     return false;
293 }
294 
ParseNavDestSwitchUnRegisterParams(napi_env env,napi_callback_info info,NavDestinationSwitchParams & params)295 bool ParseNavDestSwitchUnRegisterParams(
296     napi_env env, napi_callback_info info, NavDestinationSwitchParams& params)
297 {
298     GET_PARAMS(env, info, PARAM_SIZE_FOUR);
299 
300     if (argc == PARAM_SIZE_TWO) {
301         return ParseNavDestSwitchUnRegisterParams(env, argv[PARAM_INDEX_ONE], params);
302     } else if (argc == PARAM_SIZE_THREE) {
303         return ParseNavDestSwitchUnRegisterParams(env, argv[PARAM_INDEX_ONE], argv[PARAM_INDEX_TWO], params);
304     } else if (argc == PARAM_SIZE_FOUR) {
305         return ParseNavDestSwitchUnRegisterParams(
306             env, argv[PARAM_INDEX_ONE], argv[PARAM_INDEX_TWO], argv[PARAM_INDEX_THREE], params);
307     } else if (argc != PARAM_SIZE_ONE) {
308         return false;
309     }
310 
311     return true;
312 }
313 } // namespace
314 
ObserverProcess()315 ObserverProcess::ObserverProcess()
316 {
317     registerProcessMap_ = {
318         { NAVDESTINATION_UPDATE, &ObserverProcess::ProcessNavigationRegister },
319         { SCROLL_EVENT, &ObserverProcess::ProcessScrollEventRegister },
320         { ROUTERPAGE_UPDATE, &ObserverProcess::ProcessRouterPageRegister },
321         { DENSITY_UPDATE, &ObserverProcess::ProcessDensityRegister },
322         { LAYOUT_DONE, &ObserverProcess::ProcessLayoutDoneRegister },
323         { DRAW_COMMAND_SEND, &ObserverProcess::ProcessDrawCommandSendRegister },
324         { NAVDESTINATION_SWITCH, &ObserverProcess::ProcessNavDestinationSwitchRegister },
325         { WILLCLICK_UPDATE, &ObserverProcess::ProcessWillClickRegister },
326         { DIDCLICK_UPDATE, &ObserverProcess::ProcessDidClickRegister },
327         { TAB_CONTENT_STATE, &ObserverProcess::ProcessTabContentStateRegister },
328     };
329     unregisterProcessMap_ = {
330         { NAVDESTINATION_UPDATE, &ObserverProcess::ProcessNavigationUnRegister },
331         { SCROLL_EVENT, &ObserverProcess::ProcessScrollEventUnRegister },
332         { ROUTERPAGE_UPDATE, &ObserverProcess::ProcessRouterPageUnRegister },
333         { DENSITY_UPDATE, &ObserverProcess::ProcessDensityUnRegister },
334         { LAYOUT_DONE, &ObserverProcess::ProcessLayoutDoneUnRegister },
335         { DRAW_COMMAND_SEND, &ObserverProcess::ProcessDrawCommandSendUnRegister},
336         { NAVDESTINATION_SWITCH, &ObserverProcess::ProcessNavDestinationSwitchUnRegister },
337         { WILLCLICK_UPDATE, &ObserverProcess::ProcessWillClickUnRegister },
338         { DIDCLICK_UPDATE, &ObserverProcess::ProcessDidClickUnRegister },
339         { TAB_CONTENT_STATE, &ObserverProcess::ProcessTabContentStateUnRegister },
340     };
341 }
342 
GetInstance()343 ObserverProcess& ObserverProcess::GetInstance()
344 {
345     static ObserverProcess instance;
346     return instance;
347 }
348 
ProcessRegister(napi_env env,napi_callback_info info)349 napi_value ObserverProcess::ProcessRegister(napi_env env, napi_callback_info info)
350 {
351     GET_PARAMS(env, info, PARAM_SIZE_THREE);
352     NAPI_ASSERT(env, (argc >= PARAM_SIZE_TWO && thisVar != nullptr), "Invalid arguments");
353     std::string type;
354     if (!ParseStringFromNapi(env, argv[PARAM_INDEX_ZERO], type)) {
355         return nullptr;
356     }
357     auto it = registerProcessMap_.find(type);
358     if (it == registerProcessMap_.end()) {
359         return nullptr;
360     }
361     return (this->*(it->second))(env, info);
362 }
363 
ProcessUnRegister(napi_env env,napi_callback_info info)364 napi_value ObserverProcess::ProcessUnRegister(napi_env env, napi_callback_info info)
365 {
366     GET_PARAMS(env, info, PARAM_SIZE_THREE);
367     NAPI_ASSERT(env, (argc >= PARAM_SIZE_ONE && thisVar != nullptr), "Invalid arguments");
368     std::string type;
369     if (!ParseStringFromNapi(env, argv[PARAM_INDEX_ZERO], type)) {
370         return nullptr;
371     }
372     auto it = unregisterProcessMap_.find(type);
373     if (it == unregisterProcessMap_.end()) {
374         return nullptr;
375     }
376     return (this->*(it->second))(env, info);
377 }
378 
ProcessNavigationRegister(napi_env env,napi_callback_info info)379 napi_value ObserverProcess::ProcessNavigationRegister(napi_env env, napi_callback_info info)
380 {
381     GET_PARAMS(env, info, PARAM_SIZE_THREE);
382 
383     if (!isNavigationHandleFuncSetted_) {
384         NG::UIObserverHandler::GetInstance().SetHandleNavigationChangeFunc(&UIObserver::HandleNavigationStateChange);
385         isNavigationHandleFuncSetted_ = true;
386     }
387 
388     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
389         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
390         UIObserver::RegisterNavigationCallback(listener);
391     }
392 
393     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
394         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
395         std::string id;
396         if (ParseNavigationId(env, argv[PARAM_INDEX_ONE], id)) {
397             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
398             UIObserver::RegisterNavigationCallback(id, listener);
399         }
400     }
401 
402     napi_value result = nullptr;
403     return result;
404 }
405 
ProcessNavigationUnRegister(napi_env env,napi_callback_info info)406 napi_value ObserverProcess::ProcessNavigationUnRegister(napi_env env, napi_callback_info info)
407 {
408     GET_PARAMS(env, info, PARAM_SIZE_THREE);
409 
410     if (argc == PARAM_SIZE_ONE) {
411         UIObserver::UnRegisterNavigationCallback(nullptr);
412     }
413 
414     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
415         UIObserver::UnRegisterNavigationCallback(argv[PARAM_INDEX_ONE]);
416     }
417 
418     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
419         std::string id;
420         if (ParseNavigationId(env, argv[PARAM_INDEX_ONE], id)) {
421             UIObserver::UnRegisterNavigationCallback(id, nullptr);
422         }
423     }
424 
425     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
426         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
427         std::string id;
428         if (ParseNavigationId(env, argv[PARAM_INDEX_ONE], id)) {
429             UIObserver::UnRegisterNavigationCallback(id, argv[PARAM_INDEX_TWO]);
430         }
431     }
432 
433     napi_value result = nullptr;
434     return result;
435 }
436 
ProcessScrollEventRegister(napi_env env,napi_callback_info info)437 napi_value ObserverProcess::ProcessScrollEventRegister(napi_env env, napi_callback_info info)
438 {
439     GET_PARAMS(env, info, PARAM_SIZE_THREE);
440 
441     if (!isScrollEventChangeFuncSetted_) {
442         NG::UIObserverHandler::GetInstance().SetHandleScrollEventChangeFunc(&UIObserver::HandleScrollEventStateChange);
443         isScrollEventChangeFuncSetted_ = true;
444     }
445     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
446         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
447         UIObserver::RegisterScrollEventCallback(listener);
448     }
449 
450     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
451         && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
452         std::string id;
453         if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
454             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
455             UIObserver::RegisterScrollEventCallback(id, listener);
456         }
457     }
458 
459     napi_value result = nullptr;
460     return result;
461 }
462 
ProcessScrollEventUnRegister(napi_env env,napi_callback_info info)463 napi_value ObserverProcess::ProcessScrollEventUnRegister(napi_env env, napi_callback_info info)
464 {
465     GET_PARAMS(env, info, PARAM_SIZE_THREE);
466 
467     if (argc == PARAM_SIZE_ONE) {
468         UIObserver::UnRegisterScrollEventCallback(nullptr);
469     }
470 
471     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
472         UIObserver::UnRegisterScrollEventCallback(argv[PARAM_INDEX_ONE]);
473     }
474 
475     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
476         std::string id;
477         if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
478             UIObserver::UnRegisterScrollEventCallback(id, nullptr);
479         }
480     }
481 
482     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
483         && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
484         std::string id;
485         if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
486             UIObserver::UnRegisterScrollEventCallback(id, argv[PARAM_INDEX_TWO]);
487         }
488     }
489 
490     napi_value result = nullptr;
491     return result;
492 }
493 
ProcessRouterPageRegister(napi_env env,napi_callback_info info)494 napi_value ObserverProcess::ProcessRouterPageRegister(napi_env env, napi_callback_info info)
495 {
496     GET_PARAMS(env, info, PARAM_SIZE_THREE);
497 
498     if (!isRouterPageHandleFuncSetted_) {
499         NG::UIObserverHandler::GetInstance().SetHandleRouterPageChangeFunc(&UIObserver::HandleRouterPageStateChange);
500         isRouterPageHandleFuncSetted_ = true;
501     }
502 
503     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
504         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
505         UIObserver::RegisterRouterPageCallback(0, listener);
506     }
507 
508     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
509         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
510         auto context = argv[PARAM_INDEX_ONE];
511         if (context) {
512             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
513             if (IsUIAbilityContext(env, context)) {
514                 UIObserver::RegisterRouterPageCallback(env, context, listener);
515             } else {
516                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
517                 UIObserver::RegisterRouterPageCallback(uiContextInstanceId, listener);
518             }
519         }
520     }
521 
522     napi_value result = nullptr;
523     return result;
524 }
525 
ProcessRouterPageUnRegister(napi_env env,napi_callback_info info)526 napi_value ObserverProcess::ProcessRouterPageUnRegister(napi_env env, napi_callback_info info)
527 {
528     GET_PARAMS(env, info, PARAM_SIZE_THREE);
529 
530     if (argc == PARAM_SIZE_ONE) {
531         UIObserver::UnRegisterRouterPageCallback(0, nullptr);
532     }
533 
534     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
535         UIObserver::UnRegisterRouterPageCallback(0, argv[PARAM_INDEX_ONE]);
536     }
537 
538     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
539         napi_value context = argv[PARAM_INDEX_ONE];
540         if (context) {
541             if (IsUIAbilityContext(env, context)) {
542                 UIObserver::UnRegisterRouterPageCallback(env, context, nullptr);
543             } else {
544                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
545                 UIObserver::UnRegisterRouterPageCallback(uiContextInstanceId, nullptr);
546             }
547         }
548     }
549 
550     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
551         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
552         napi_value context = argv[PARAM_INDEX_ONE];
553         if (context) {
554             if (IsUIAbilityContext(env, context)) {
555                 UIObserver::UnRegisterRouterPageCallback(env, context, argv[PARAM_INDEX_TWO]);
556             } else {
557                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
558                 UIObserver::UnRegisterRouterPageCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
559             }
560         }
561     }
562 
563     napi_value result = nullptr;
564     return result;
565 }
566 
ProcessDensityRegister(napi_env env,napi_callback_info info)567 napi_value ObserverProcess::ProcessDensityRegister(napi_env env, napi_callback_info info)
568 {
569     GET_PARAMS(env, info, PARAM_SIZE_THREE);
570 
571     if (!isDensityChangeSetted_) {
572         NG::UIObserverHandler::GetInstance().SetHandleDensityChangeFunc(&UIObserver::HandleDensityChange);
573         isDensityChangeSetted_ = true;
574     }
575     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
576         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
577         int32_t instanceId = ContainerScope::CurrentId();
578         UIObserver::RegisterDensityCallback(instanceId, listener);
579     }
580 
581     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
582         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
583         auto context = argv[PARAM_INDEX_ONE];
584         if (context) {
585             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
586             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
587             UIObserver::RegisterDensityCallback(uiContextInstanceId, listener);
588         }
589     }
590 
591     napi_value result = nullptr;
592     return result;
593 }
594 
ProcessDensityUnRegister(napi_env env,napi_callback_info info)595 napi_value ObserverProcess::ProcessDensityUnRegister(napi_env env, napi_callback_info info)
596 {
597     GET_PARAMS(env, info, PARAM_SIZE_THREE);
598 
599     if (argc == PARAM_SIZE_ONE) {
600         int32_t instanceId = ContainerScope::CurrentId();
601         UIObserver::UnRegisterDensityCallback(instanceId, nullptr);
602     }
603 
604     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
605         napi_value context = argv[PARAM_INDEX_ONE];
606         if (context) {
607             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
608             UIObserver::UnRegisterDensityCallback(uiContextInstanceId, nullptr);
609         }
610     }
611 
612     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
613         int32_t instanceId = ContainerScope::CurrentId();
614         UIObserver::UnRegisterDensityCallback(instanceId, argv[PARAM_INDEX_ONE]);
615     }
616 
617     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
618         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
619         napi_value context = argv[PARAM_INDEX_ONE];
620         if (context) {
621             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
622             UIObserver::UnRegisterDensityCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
623         }
624     }
625 
626     napi_value result = nullptr;
627     return result;
628 }
629 
ProcessDrawCommandSendRegister(napi_env env,napi_callback_info info)630 napi_value ObserverProcess::ProcessDrawCommandSendRegister(napi_env env, napi_callback_info info)
631 {
632     GET_PARAMS(env, info, 3); // 3: Param Size Three
633 
634     if (!isDrawCommandSendChangeSetted_) {
635         NG::UIObserverHandler::GetInstance().SetDrawCommandSendHandleFunc(&UIObserver::HandDrawCommandSendChange);
636         isDrawCommandSendChangeSetted_ = true;
637     }
638 
639     if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
640         auto listener = std::make_shared<UIObserverListener>(env, argv[1]);
641         int32_t instanceId = ContainerScope::CurrentId();
642         UIObserver::RegisterDrawCallback(instanceId, listener);
643     }
644     if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
645         MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
646         auto context = argv[1];
647         if (context) {
648             auto listener = std::make_shared<UIObserverListener>(env, argv[2]); // 2: Param Index Two
649             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
650             UIObserver::RegisterDrawCallback(uiContextInstanceId, listener);
651         }
652     }
653     napi_value result = nullptr;
654     return result;
655 }
656 
ProcessDrawCommandSendUnRegister(napi_env env,napi_callback_info info)657 napi_value ObserverProcess::ProcessDrawCommandSendUnRegister(napi_env env, napi_callback_info info)
658 {
659     GET_PARAMS(env, info, 3); // 3: Param Size Three
660 
661     if (argc == 1) {
662         int32_t instanceId = ContainerScope::CurrentId();
663         UIObserver::UnRegisterDrawCallback(instanceId, nullptr);
664     }
665 
666     if (argc == 2 && MatchValueType(env, argv[1], napi_object)) { // 2: Param Size Two
667         napi_value context = argv[1];
668         if (context) {
669             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
670             UIObserver::UnRegisterDrawCallback(uiContextInstanceId, nullptr);
671         }
672     }
673 
674     if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
675         int32_t instanceId = ContainerScope::CurrentId();
676         UIObserver::UnRegisterDrawCallback(instanceId, argv[1]);
677     }
678 
679     if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
680         MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
681         napi_value context = argv[1];
682         if (context) {
683             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
684             UIObserver::UnRegisterDrawCallback(uiContextInstanceId, argv[2]); // 2: Param Index Two
685         }
686     }
687 
688     napi_value result = nullptr;
689     return result;
690 }
691 
ProcessLayoutDoneRegister(napi_env env,napi_callback_info info)692 napi_value ObserverProcess::ProcessLayoutDoneRegister(napi_env env, napi_callback_info info)
693 {
694     GET_PARAMS(env, info, 3); // 3: Param Size Three
695 
696     if (!isLayoutDoneChangeSetted_) {
697         NG::UIObserverHandler::GetInstance().SetLayoutDoneHandleFunc(&UIObserver::HandLayoutDoneChange);
698         isLayoutDoneChangeSetted_ = true;
699     }
700 
701     if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
702         auto listener = std::make_shared<UIObserverListener>(env, argv[1]);
703         int32_t instanceId = ContainerScope::CurrentId();
704         UIObserver::RegisterLayoutCallback(instanceId, listener);
705     }
706     if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
707         MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
708         auto context = argv[1];
709         if (context) {
710             auto listener = std::make_shared<UIObserverListener>(env, argv[2]); // 2: Param Index Two
711             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
712             UIObserver::RegisterLayoutCallback(uiContextInstanceId, listener);
713         }
714     }
715     napi_value result = nullptr;
716     return result;
717 }
718 
ProcessLayoutDoneUnRegister(napi_env env,napi_callback_info info)719 napi_value ObserverProcess::ProcessLayoutDoneUnRegister(napi_env env, napi_callback_info info)
720 {
721     GET_PARAMS(env, info, 3); // 3: Param Size Three
722 
723     if (argc == 1) {
724         int32_t instanceId = ContainerScope::CurrentId();
725         UIObserver::UnRegisterLayoutCallback(instanceId, nullptr);
726     }
727 
728     if (argc == 2 && MatchValueType(env, argv[1], napi_object)) { // 2: Param Size Two
729         napi_value context = argv[1];
730         if (context) {
731             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
732             UIObserver::UnRegisterLayoutCallback(uiContextInstanceId, nullptr);
733         }
734     }
735 
736     if (argc == 2 && MatchValueType(env, argv[1], napi_function)) { // 2: Param Size Two
737         int32_t instanceId = ContainerScope::CurrentId();
738         UIObserver::UnRegisterLayoutCallback(instanceId, argv[1]);
739     }
740 
741     if (argc == 3 && MatchValueType(env, argv[1], napi_object) && // 3: Param Size Three
742         MatchValueType(env, argv[2], napi_function)) { // 2: Param Index Two
743         napi_value context = argv[1];
744         if (context) {
745             auto uiContextInstanceId = GetUIContextInstanceId(env, context);
746             UIObserver::UnRegisterLayoutCallback(uiContextInstanceId, argv[2]); // 2: Param Index Two
747         }
748     }
749 
750     napi_value result = nullptr;
751     return result;
752 }
753 
ProcessNavDestinationSwitchRegister(napi_env env,napi_callback_info info)754 napi_value ObserverProcess::ProcessNavDestinationSwitchRegister(napi_env env, napi_callback_info info)
755 {
756     NavDestinationSwitchParams params;
757     if (!ParseNavDestSwitchRegisterParams(env, info, params)) {
758         return nullptr;
759     }
760 
761     if (!isDestinationSwitchHandleFuncSetted_) {
762         NG::UIObserverHandler::GetInstance().SetHandleNavDestinationSwitchFunc(&UIObserver::HandleNavDestinationSwitch);
763         isDestinationSwitchHandleFuncSetted_ = true;
764     }
765 
766     auto listener = std::make_shared<UIObserverListener>(env, params.callback);
767     if (params.isUIContext) {
768         UIObserver::RegisterNavDestinationSwitchCallback(params.uiContextInstanceId, params.navigationId, listener);
769     } else {
770         UIObserver::RegisterNavDestinationSwitchCallback(env, params.abilityUIContext, params.navigationId, listener);
771     }
772 
773     return nullptr;
774 }
775 
ProcessNavDestinationSwitchUnRegister(napi_env env,napi_callback_info info)776 napi_value ObserverProcess::ProcessNavDestinationSwitchUnRegister(napi_env env, napi_callback_info info)
777 {
778     NavDestinationSwitchParams params;
779     if (!ParseNavDestSwitchUnRegisterParams(env, info, params)) {
780         return nullptr;
781     }
782 
783     if (params.isUIContext) {
784         UIObserver::UnRegisterNavDestinationSwitchCallback(
785             params.uiContextInstanceId, params.navigationId, params.callback);
786     } else {
787         UIObserver::UnRegisterNavDestinationSwitchCallback(
788             env, params.abilityUIContext, params.navigationId, params.callback);
789     }
790 
791     return nullptr;
792 }
793 
ProcessWillClickRegister(napi_env env,napi_callback_info info)794 napi_value ObserverProcess::ProcessWillClickRegister(napi_env env, napi_callback_info info)
795 {
796     GET_PARAMS(env, info, PARAM_SIZE_THREE);
797 
798     if (!isWillClickFuncSetted_) {
799         NG::UIObserverHandler::GetInstance().SetWillClickFunc(&UIObserver::HandleWillClick);
800         isWillClickFuncSetted_ = true;
801     }
802 
803     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
804         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
805         UIObserver::RegisterWillClickCallback(0, listener);
806     }
807 
808     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
809         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
810         auto context = argv[PARAM_INDEX_ONE];
811         if (context) {
812             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
813             if (IsUIAbilityContext(env, context)) {
814                 UIObserver::RegisterWillClickCallback(env, context, listener);
815             } else {
816                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
817                 UIObserver::RegisterWillClickCallback(uiContextInstanceId, listener);
818             }
819         }
820     }
821 
822     return nullptr;
823 }
824 
ProcessWillClickUnRegister(napi_env env,napi_callback_info info)825 napi_value ObserverProcess::ProcessWillClickUnRegister(napi_env env, napi_callback_info info)
826 {
827     GET_PARAMS(env, info, PARAM_SIZE_THREE);
828 
829     if (argc == PARAM_SIZE_ONE) {
830         UIObserver::UnRegisterWillClickCallback(0, nullptr);
831     }
832 
833     if (argc == PARAM_SIZE_TWO) {
834         if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
835             UIObserver::UnRegisterWillClickCallback(0, argv[PARAM_INDEX_ONE]);
836         } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
837             napi_value context = argv[PARAM_INDEX_ONE];
838             if (!context) {
839                 return nullptr;
840             }
841             if (IsUIAbilityContext(env, context)) {
842                 UIObserver::UnRegisterWillClickCallback(env, context, nullptr);
843             } else {
844                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
845                 UIObserver::UnRegisterWillClickCallback(uiContextInstanceId, nullptr);
846             }
847         }
848     }
849 
850     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
851         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
852         napi_value context = argv[PARAM_INDEX_ONE];
853         if (context) {
854             if (IsUIAbilityContext(env, context)) {
855                 UIObserver::UnRegisterWillClickCallback(env, context, argv[PARAM_INDEX_TWO]);
856             } else {
857                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
858                 UIObserver::UnRegisterWillClickCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
859             }
860         }
861     }
862 
863     return nullptr;
864 }
865 
ProcessDidClickRegister(napi_env env,napi_callback_info info)866 napi_value ObserverProcess::ProcessDidClickRegister(napi_env env, napi_callback_info info)
867 {
868     GET_PARAMS(env, info, PARAM_SIZE_THREE);
869 
870     if (!isDidClickFuncSetted_) {
871         NG::UIObserverHandler::GetInstance().SetDidClickFunc(&UIObserver::HandleDidClick);
872         isDidClickFuncSetted_ = true;
873     }
874 
875     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
876         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
877         UIObserver::RegisterDidClickCallback(0, listener);
878     }
879 
880     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
881         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
882         auto context = argv[PARAM_INDEX_ONE];
883         if (context) {
884             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
885             if (IsUIAbilityContext(env, context)) {
886                 UIObserver::RegisterDidClickCallback(env, context, listener);
887             } else {
888                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
889                 UIObserver::RegisterDidClickCallback(uiContextInstanceId, listener);
890             }
891         }
892     }
893 
894     return nullptr;
895 }
896 
ProcessDidClickUnRegister(napi_env env,napi_callback_info info)897 napi_value ObserverProcess::ProcessDidClickUnRegister(napi_env env, napi_callback_info info)
898 {
899     GET_PARAMS(env, info, PARAM_SIZE_THREE);
900 
901     if (argc == PARAM_SIZE_ONE) {
902         UIObserver::UnRegisterDidClickCallback(0, nullptr);
903     }
904 
905     if (argc == PARAM_SIZE_TWO) {
906         if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
907             UIObserver::UnRegisterDidClickCallback(0, argv[PARAM_INDEX_ONE]);
908         } else if (MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
909             napi_value context = argv[PARAM_INDEX_ONE];
910             if (!context) {
911                 return nullptr;
912             }
913             if (IsUIAbilityContext(env, context)) {
914                 UIObserver::UnRegisterDidClickCallback(env, context, nullptr);
915             } else {
916                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
917                 UIObserver::UnRegisterDidClickCallback(uiContextInstanceId, nullptr);
918             }
919         }
920     }
921 
922     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object) &&
923         MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
924         napi_value context = argv[PARAM_INDEX_ONE];
925         if (context) {
926             if (IsUIAbilityContext(env, context)) {
927                 UIObserver::UnRegisterDidClickCallback(env, context, argv[PARAM_INDEX_TWO]);
928             } else {
929                 auto uiContextInstanceId = GetUIContextInstanceId(env, context);
930                 UIObserver::UnRegisterDidClickCallback(uiContextInstanceId, argv[PARAM_INDEX_TWO]);
931             }
932         }
933     }
934 
935     return nullptr;
936 }
937 
ProcessTabContentStateRegister(napi_env env,napi_callback_info info)938 napi_value ObserverProcess::ProcessTabContentStateRegister(napi_env env, napi_callback_info info)
939 {
940     GET_PARAMS(env, info, PARAM_SIZE_THREE);
941 
942     if (!isTabContentStateUpdateFuncSetted_) {
943         NG::UIObserverHandler::GetInstance().SetHandleTabContentStateUpdateFunc(
944             &UIObserver::HandleTabContentStateChange);
945         isTabContentStateUpdateFuncSetted_ = true;
946     }
947 
948     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
949         auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_ONE]);
950         UIObserver::RegisterTabContentStateCallback(listener);
951     }
952 
953     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
954         && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
955         std::string id;
956         if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
957             auto listener = std::make_shared<UIObserverListener>(env, argv[PARAM_INDEX_TWO]);
958             UIObserver::RegisterTabContentStateCallback(id, listener);
959         }
960     }
961 
962     napi_value result = nullptr;
963     return result;
964 }
965 
ProcessTabContentStateUnRegister(napi_env env,napi_callback_info info)966 napi_value ObserverProcess::ProcessTabContentStateUnRegister(napi_env env, napi_callback_info info)
967 {
968     GET_PARAMS(env, info, PARAM_SIZE_THREE);
969 
970     if (argc == PARAM_SIZE_ONE) {
971         UIObserver::UnRegisterTabContentStateCallback(nullptr);
972     }
973 
974     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_function)) {
975         UIObserver::UnRegisterTabContentStateCallback(argv[PARAM_INDEX_ONE]);
976     }
977 
978     if (argc == PARAM_SIZE_TWO && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)) {
979         std::string id;
980         if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
981             UIObserver::UnRegisterTabContentStateCallback(id, nullptr);
982         }
983     }
984 
985     if (argc == PARAM_SIZE_THREE && MatchValueType(env, argv[PARAM_INDEX_ONE], napi_object)
986         && MatchValueType(env, argv[PARAM_INDEX_TWO], napi_function)) {
987         std::string id;
988         if (ParseScrollId(env, argv[PARAM_INDEX_ONE], id)) {
989             UIObserver::UnRegisterTabContentStateCallback(id, argv[PARAM_INDEX_TWO]);
990         }
991     }
992 
993     napi_value result = nullptr;
994     return result;
995 }
996 
ObserverOn(napi_env env,napi_callback_info info)997 napi_value ObserverOn(napi_env env, napi_callback_info info)
998 {
999     return ObserverProcess::GetInstance().ProcessRegister(env, info);
1000 }
1001 
ObserverOff(napi_env env,napi_callback_info info)1002 napi_value ObserverOff(napi_env env, napi_callback_info info)
1003 {
1004     return ObserverProcess::GetInstance().ProcessUnRegister(env, info);
1005 }
1006 
AddToScrollEventType(napi_env env)1007 napi_value AddToScrollEventType(napi_env env)
1008 {
1009     napi_value scrollEventType = nullptr;
1010     napi_value prop = nullptr;
1011     napi_create_object(env, &scrollEventType);
1012     napi_create_uint32(env, SCROLL_START, &prop);
1013     napi_set_named_property(env, scrollEventType, "SCROLL_START", prop);
1014     napi_create_uint32(env, SCROLL_STOP, &prop);
1015     napi_set_named_property(env, scrollEventType, "SCROLL_STOP", prop);
1016     return scrollEventType;
1017 }
1018 
AddToRouterPageState(napi_env env)1019 napi_value AddToRouterPageState(napi_env env)
1020 {
1021     napi_value routerPageState = nullptr;
1022     napi_value prop = nullptr;
1023     napi_create_object(env, &routerPageState);
1024     napi_create_uint32(env, ABOUT_TO_APPEAR, &prop);
1025     napi_set_named_property(env, routerPageState, "ABOUT_TO_APPEAR", prop);
1026     napi_create_uint32(env, ABOUT_TO_DISAPPEAR, &prop);
1027     napi_set_named_property(env, routerPageState, "ABOUT_TO_DISAPPEAR", prop);
1028     napi_create_uint32(env, ON_PAGE_SHOW, &prop);
1029     napi_set_named_property(env, routerPageState, "ON_PAGE_SHOW", prop);
1030     napi_create_uint32(env, ON_PAGE_HIDE, &prop);
1031     napi_set_named_property(env, routerPageState, "ON_PAGE_HIDE", prop);
1032     napi_create_uint32(env, ON_BACK_PRESS, &prop);
1033     napi_set_named_property(env, routerPageState, "ON_BACK_PRESS", prop);
1034     return routerPageState;
1035 }
1036 
CreateNavDestinationState(napi_env env)1037 napi_value CreateNavDestinationState(napi_env env)
1038 {
1039     napi_value navDestinationState = nullptr;
1040     napi_create_object(env, &navDestinationState);
1041     napi_value prop = nullptr;
1042     napi_create_uint32(env, ON_SHOWN, &prop);
1043     napi_set_named_property(env, navDestinationState, "ON_SHOWN", prop);
1044     napi_create_uint32(env, ON_HIDDEN, &prop);
1045     napi_set_named_property(env, navDestinationState, "ON_HIDDEN", prop);
1046     napi_create_uint32(env, ON_APPEAR, &prop);
1047     napi_set_named_property(env, navDestinationState, "ON_APPEAR", prop);
1048     napi_create_uint32(env, ON_DISAPPEAR, &prop);
1049     napi_set_named_property(env, navDestinationState, "ON_DISAPPEAR", prop);
1050     napi_create_uint32(env, ON_WILL_SHOW, &prop);
1051     napi_set_named_property(env, navDestinationState, "ON_WILL_SHOW", prop);
1052     napi_create_uint32(env, ON_WILL_HIDE, &prop);
1053     napi_set_named_property(env, navDestinationState, "ON_WILL_HIDE", prop);
1054     napi_create_uint32(env, ON_WILL_APPEAR, &prop);
1055     napi_set_named_property(env, navDestinationState, "ON_WILL_APPEAR", prop);
1056     napi_create_uint32(env, ON_WILL_DISAPPEAR, &prop);
1057     napi_set_named_property(env, navDestinationState, "ON_WILL_DISAPPEAR", prop);
1058     napi_create_uint32(env, ON_BACKPRESS, &prop);
1059     napi_set_named_property(env, navDestinationState, "ON_BACKPRESS", prop);
1060     return navDestinationState;
1061 }
1062 
AddToTabContentState(napi_env env)1063 napi_value AddToTabContentState(napi_env env)
1064 {
1065     napi_value tabContentState = nullptr;
1066     napi_value prop = nullptr;
1067     napi_create_object(env, &tabContentState);
1068     napi_create_uint32(env, ON_SHOW, &prop);
1069     napi_set_named_property(env, tabContentState, "ON_SHOW", prop);
1070     napi_create_uint32(env, ON_HIDE, &prop);
1071     napi_set_named_property(env, tabContentState, "ON_HIDE", prop);
1072     return tabContentState;
1073 }
1074 
UIObserverExport(napi_env env,napi_value exports)1075 static napi_value UIObserverExport(napi_env env, napi_value exports)
1076 {
1077     napi_value navDestinationState = CreateNavDestinationState(env);
1078 
1079     napi_value scrollEventType = nullptr;
1080     scrollEventType = AddToScrollEventType(env);
1081 
1082     napi_value routerPageState = nullptr;
1083     routerPageState = AddToRouterPageState(env);
1084 
1085     napi_value tabContentState = nullptr;
1086     tabContentState = AddToTabContentState(env);
1087 
1088     napi_property_descriptor uiObserverDesc[] = {
1089         DECLARE_NAPI_FUNCTION("on", ObserverOn),
1090         DECLARE_NAPI_FUNCTION("off", ObserverOff),
1091         DECLARE_NAPI_PROPERTY("NavDestinationState", navDestinationState),
1092         DECLARE_NAPI_PROPERTY("ScrollEventType", scrollEventType),
1093         DECLARE_NAPI_PROPERTY("RouterPageState", routerPageState),
1094         DECLARE_NAPI_PROPERTY("TabContentState", tabContentState),
1095     };
1096     NAPI_CALL(
1097         env, napi_define_properties(env, exports, sizeof(uiObserverDesc) / sizeof(uiObserverDesc[0]), uiObserverDesc));
1098     return exports;
1099 }
1100 
1101 static napi_module uiObserverModule = {
1102     .nm_version = 1,
1103     .nm_flags = 0,
1104     .nm_filename = nullptr,
1105     .nm_register_func = UIObserverExport,
1106     .nm_modname = "arkui.observer",
1107     .nm_priv = ((void*)0),
1108     .reserved = { 0 },
1109 };
1110 
ObserverRegister()1111 extern "C" __attribute__((constructor)) void ObserverRegister()
1112 {
1113     napi_module_register(&uiObserverModule);
1114 }
1115 } // namespace OHOS::Ace::Napi
1116