1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <cstdio>
16 #include "napi/native_api.h"
17 #include "window_manager/oh_window_comm.h"
18 #include "window_manager/oh_window.h"
19 #include "window_manager/oh_window_event_filter.h"
20 #include "multimodalinput/oh_input_manager.h"
21 #include "multimodalinput/oh_key_code.h"
22 #include <bits/alltypes.h>
23 #include <hilog/log.h>
24 #include <string>
25 #include <type_traits>
26 #include "multimedia/image_framework/image/pixelmap_native.h"
27 #include "multimedia/image_framework/image/image_packer_native.h"
28 #include "native_drawing/drawing_pixel_map.h"
29 #include <cstdint>
30 #include <memory>
31 #include <unistd.h>
32 #include <future>
33 #define Check_Napi_Create_Object_Return_If_Null(env,objValue)\
34 do{ \
35 napi_create_object((env),&(objValue)); \
36 if((objValue) == nullptr){ \
37 return nullptr; \
38 } \
39 }while (0)
40
41 static int keyCode1 = -1;
filterESC(Input_KeyEvent * event)42 static bool filterESC(Input_KeyEvent *event){
43 auto keyCode = OH_Input_GetKeyEventKeyCode(event);
44 auto actionTime = OH_Input_GetKeyEventActionTime(event);
45 auto action = OH_Input_GetKeyEventAction(event);
46 return keyCode == keyCode1;
47 }
48
49 constexpr int32_t TWO = 2;
50 constexpr int32_t THREE = 3;
51 constexpr int32_t FOUR = 4;
52 constexpr int32_t FIVE = 5;
53 constexpr int32_t SIX = 6;
54 constexpr int32_t TEN = 10;
55
filterKeyCode(napi_env env,napi_callback_info info)56 static napi_value filterKeyCode(napi_env env, napi_callback_info info){
57 size_t argc = 2;
58 napi_value args[2] = {nullptr};
59 napi_get_cb_info(env, info, &argc, args,nullptr, nullptr);
60
61 napi_valuetype valuetype0;
62 napi_typeof(env, args[0], &valuetype0);
63
64 int32_t windowId;
65 napi_get_value_int32(env, args[0], &windowId);
66 int32_t keyCode;
67 napi_get_value_int32(env, args[1], &keyCode);
68 keyCode1 = keyCode;
69 auto result = OH_NativeWindowManager_RegisterKeyEventFilter(windowId, filterESC);
70 napi_value res;
71 napi_create_int32(env, result, &res);
72 return res;
73 }
unFilterKeyCode(napi_env env,napi_callback_info info)74 static napi_value unFilterKeyCode(napi_env env, napi_callback_info info) {
75 size_t argc = 1;
76 napi_value args[1] = {nullptr};
77 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
78 napi_valuetype valuetype0;
79 napi_typeof(env, args[0], &valuetype0);
80
81 int32_t windowId;
82 napi_get_value_int32(env, args[0], &windowId);
83
84 auto result = OH_NativeWindowManager_UnregisterKeyEventFilter(windowId);
85 napi_value res;
86 napi_create_int32(env, result, &res);
87 return res;
88 }
89
IsWindowShown(napi_env env,napi_callback_info info)90 static napi_value IsWindowShown(napi_env env, napi_callback_info info) {
91 size_t argc = 1;
92 napi_value args[1] = {nullptr};
93 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
94 napi_valuetype valuetype0;
95 napi_typeof(env, args[0], &valuetype0);
96
97 int32_t windowId;
98 napi_get_value_int32(env, args[0], &windowId);
99
100 napi_value retValue;
101 napi_create_object(env,&retValue);
102 napi_value resultCode;
103 napi_value isShowWindow;
104
105 bool isShow = false;
106 int32_t resultInt32 = OH_WindowManager_IsWindowShown(static_cast<int>(windowId),&isShow);
107 napi_create_int32(env,resultInt32,&resultCode);
108 napi_create_int32(env,(int)isShow,&isShowWindow);
109 napi_set_named_property(env,retValue,"isShow",isShowWindow);
110 napi_set_named_property(env,retValue,"resultCode",resultCode);
111 return retValue;
112 }
113
ShowWindow(napi_env env,napi_callback_info info)114 static napi_value ShowWindow(napi_env env, napi_callback_info info) {
115 size_t argc = 1;
116 napi_value args[1] = {nullptr};
117 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
118 napi_valuetype valuetype0;
119 napi_typeof(env, args[0], &valuetype0);
120
121 int32_t windowId;
122 napi_get_value_int32(env, args[0], &windowId);
123
124 napi_value retValue;
125 napi_create_object(env,&retValue);
126 napi_value resultCode;
127
128 int32_t resultInt32 = OH_WindowManager_ShowWindow(static_cast<int>(windowId));
129 napi_create_int32(env,resultInt32,&resultCode);
130 napi_set_named_property(env,retValue,"resultCode",resultCode);
131 return retValue;
132 }
133
SetWindowStatusBarEnabled(napi_env env,napi_callback_info info)134 static napi_value SetWindowStatusBarEnabled(napi_env env, napi_callback_info info) {
135 size_t argc = 4;
136 napi_value args[4] = {nullptr};
137 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
138
139 int32_t windowId;
140 napi_get_value_int32(env, args[0], &windowId);
141
142 bool enabled = false;
143 napi_get_value_bool(env, args[1], &enabled);
144
145 bool enableAnimation = false;
146 napi_get_value_bool(env, args[2], &enableAnimation);
147
148 napi_value resultCode;
149
150 auto res = OH_WindowManager_SetWindowStatusBarEnabled(windowId,enabled,enableAnimation);
151 napi_create_int32(env,res,&resultCode);
152 return resultCode;
153 }
154
SetWindowNavigationBarEnabled(napi_env env,napi_callback_info info)155 static napi_value SetWindowNavigationBarEnabled(napi_env env, napi_callback_info info) {
156 size_t argc = 4;
157 napi_value args[4] = {nullptr};
158 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
159
160 int32_t windowId;
161 napi_get_value_int32(env, args[0], &windowId);
162
163 bool enabled = false;
164 napi_get_value_bool(env, args[1], &enabled);
165
166 bool enableAnimation = false;
167 napi_get_value_bool(env, args[2], &enableAnimation);
168
169 napi_value resultCode;
170
171 auto res = OH_WindowManager_SetWindowNavigationBarEnabled(windowId,enabled,enableAnimation);
172 napi_create_int32(env,res,&resultCode);
173 return resultCode;
174 }
175
SetWindowStatusBarColor(napi_env env,napi_callback_info info)176 static napi_value SetWindowStatusBarColor(napi_env env, napi_callback_info info) {
177 size_t argc = 4;
178 napi_value args[4] = {nullptr};
179 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
180
181 int32_t windowId;
182 napi_get_value_int32(env, args[0], &windowId);
183
184 int32_t color;
185 napi_get_value_int32(env, args[1], &color);
186
187 napi_value resultCode;
188
189 auto res = OH_WindowManager_SetWindowStatusBarColor(windowId,color);
190 napi_create_int32(env,res,&resultCode);
191 return resultCode;
192 }
193
CreateJsNumber(napi_env env,double value)194 inline napi_value CreateJsNumber(napi_env env,double value){
195 napi_value result = nullptr;
196 napi_create_double(env,value,&result);
197 return result;
198 }
199
200 template<class T>
ConvertFromJsValue(napi_env env,napi_value jsValue,T & value)201 bool ConvertFromJsValue(napi_env env,napi_value jsValue,T& value){
202 if(jsValue == nullptr){
203 return false;
204 }
205
206 using ValueType = std::remove_cv_t<std::remove_reference_t<T>>;
207 napi_value result = nullptr;
208 if constexpr (std::is_same_v<ValueType,bool>){
209 return napi_get_value_bool(env,jsValue,nullptr) == napi_ok;
210 }else if constexpr(std::is_arithmetic_v<ValueType>){
211 return ConvertFromJsNumber(env,jsValue,value);
212 }else if constexpr(std::is_same_v<ValueType,std::string>){
213 size_t len = 0;
214 if(napi_get_value_string_utf8(env,jsValue,nullptr,0,&len)!=napi_ok){
215 return false;
216 }
217 auto buffer = std::make_unique<char[]>(len + 1);
218 size_t strLength = 0;
219 if(napi_get_value_string_utf8(env,jsValue,buffer.get(),len+1,&strLength)==napi_ok){
220 value = buffer.get();
221 return true;
222 }
223 return false;
224 }else if constexpr(std::is_enum_v<ValueType>){
225 std::make_signed_t<ValueType> numberValue = 0;
226 if(!ConvertFromJsNumber(env,jsValue,numberValue)){
227 return true;
228 }
229 value = static_cast<ValueType>(numberValue);
230 return true;
231 }
232 return false;
233 }
234
235 template<class T>
CreateJsValue(napi_env env,const T & value)236 napi_value CreateJsValue(napi_env env,const T& value){
237 using ValueType = std::remove_cv_t<std::remove_reference_t<T>>;
238 napi_value result = nullptr;
239 if constexpr (std::is_same_v<ValueType,bool>){
240 napi_get_boolean(env,value,&result);
241 return result;
242 }else if constexpr(std::is_arithmetic_v<ValueType>){
243 return CreateJsNumber(env,value);
244 }else if constexpr(std::is_same_v<ValueType,std::string>){
245 napi_create_string_utf8(env,value.c_str(),value.length(),&result);
246 return result;
247 }else if constexpr(std::is_enum_v<ValueType>){
248 return CreateJsNumber(env,static_cast<std::make_signed_t<ValueType>>(value));
249 }else if constexpr(std::is_same_v<ValueType,const char*>){
250 (value != nullptr)?napi_create_string_utf8(env,value,strlen(value),&result):
251 napi_get_undefined(env,&result);
252 return result;
253 }else {
254 return result;
255 }
256 }
257
GetRectAndConvertToJsValue(napi_env env,const WindowManager_Rect & rect)258 napi_value GetRectAndConvertToJsValue(napi_env env, const WindowManager_Rect& rect){
259 napi_value objValue = nullptr;
260 Check_Napi_Create_Object_Return_If_Null(env,objValue);
261
262 napi_set_named_property(env,objValue,"left",CreateJsValue(env,rect.posX));
263 napi_set_named_property(env,objValue,"top",CreateJsValue(env,rect.posY));
264 napi_set_named_property(env,objValue,"width",CreateJsValue(env,rect.width));
265 napi_set_named_property(env,objValue,"height",CreateJsValue(env,rect.height));
266 return objValue;
267 }
268
ConvertAvoidAreaToJsValue(napi_env env,WindowManager_AvoidArea * avoidArea)269 napi_value ConvertAvoidAreaToJsValue(napi_env env, WindowManager_AvoidArea* avoidArea){
270 napi_value objValue = nullptr;
271 Check_Napi_Create_Object_Return_If_Null(env,objValue);
272
273 napi_set_named_property(env,objValue,"leftRect",GetRectAndConvertToJsValue(env,avoidArea->leftRect));
274 napi_set_named_property(env,objValue,"topRect",GetRectAndConvertToJsValue(env,avoidArea->topRect));
275 napi_set_named_property(env,objValue,"rightRect",GetRectAndConvertToJsValue(env,avoidArea->rightRect));
276 napi_set_named_property(env,objValue,"bottomRect",GetRectAndConvertToJsValue(env,avoidArea->bottomRect));
277 return objValue;
278 }
279
GetAvoidAreaByType(napi_env env,napi_callback_info info)280 static napi_value GetAvoidAreaByType(napi_env env, napi_callback_info info) {
281 size_t argc = 2;
282 napi_value args[2] = {nullptr};
283 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
284
285 int32_t windowId;
286 napi_get_value_int32(env, args[0], &windowId);
287
288 int32_t resultValue = 0;
289 napi_get_value_int32(env, args[1], &resultValue);
290
291 WindowManager_AvoidAreaType avoidAreaType = static_cast<WindowManager_AvoidAreaType>(resultValue);
292 WindowManager_AvoidArea* avoidArea = new WindowManager_AvoidArea();
293
294 auto res = OH_WindowManager_GetWindowAvoidArea(windowId,avoidAreaType,avoidArea);
295 if(res == 0){
296 napi_value avoidAreaObj = ConvertAvoidAreaToJsValue(env,avoidArea);
297 return avoidAreaObj;
298 }else{
299 napi_value resultValue;
300 napi_create_int32(env,res,&resultValue);
301 return resultValue;
302 }
303
304 }
305
SetBackgroundColor(napi_env env,napi_callback_info info)306 static napi_value SetBackgroundColor(napi_env env, napi_callback_info info) {
307 size_t argc = 4;
308 napi_value args[4] = {nullptr};
309 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
310
311 int32_t windowId;
312 napi_get_value_int32(env, args[0], &windowId);
313
314 std::string color;
315 ConvertFromJsValue(env,args[1],color);
316
317 auto res = OH_WindowManager_SetWindowBackgroundColor(windowId,color.c_str());
318 napi_value resultValue;
319 napi_create_int32(env,res,&resultValue);
320 return resultValue;
321 }
322
SetBrightness(napi_env env,napi_callback_info info)323 static napi_value SetBrightness(napi_env env, napi_callback_info info) {
324 size_t argc = 4;
325 napi_value args[4] = {nullptr};
326 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
327
328 int32_t windowId;
329 napi_get_value_int32(env, args[0], &windowId);
330
331 double brightness;
332 napi_get_value_double(env,args[1],&brightness);
333
334 auto res = OH_WindowManager_SetWindowBrightness(windowId,brightness);
335 napi_value resultValue;
336 napi_create_int32(env,res,&resultValue);
337 return resultValue;
338 }
339
SetKeepScreenOn(napi_env env,napi_callback_info info)340 static napi_value SetKeepScreenOn(napi_env env, napi_callback_info info) {
341 size_t argc = 4;
342 napi_value args[4] = {nullptr};
343 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
344
345 int32_t windowId;
346 napi_get_value_int32(env, args[0], &windowId);
347
348 bool isKeepScreenOn;
349 napi_get_value_bool(env,args[1],&isKeepScreenOn);
350
351 auto res = OH_WindowManager_SetWindowKeepScreenOn(windowId,isKeepScreenOn);
352 napi_value resultValue;
353 napi_create_int32(env,res,&resultValue);
354 return resultValue;
355 }
356
SetWindowPrivacyMode(napi_env env,napi_callback_info info)357 static napi_value SetWindowPrivacyMode(napi_env env, napi_callback_info info) {
358 size_t argc = 4;
359 napi_value args[4] = {nullptr};
360 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
361
362 int32_t windowId;
363 napi_get_value_int32(env, args[0], &windowId);
364
365 bool isPrivacy;
366 napi_get_value_bool(env,args[1],&isPrivacy);
367
368 auto res = OH_WindowManager_SetWindowPrivacyMode(windowId,isPrivacy);
369 napi_value resultValue;
370 napi_create_int32(env,res,&resultValue);
371 return resultValue;
372 }
373
Snapshot(napi_env env,napi_callback_info info)374 static napi_value Snapshot(napi_env env, napi_callback_info info) {
375 size_t argc = 1;
376 napi_value args[1] = {nullptr};
377 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
378
379 int32_t windowId;
380 napi_get_value_int32(env, args[0], &windowId);
381 OH_PixelmapNative* pixelMap;
382
383 OH_Pixelmap_InitializationOptions* createOpts;
384 OH_PixelmapInitializationOptions_Create(&createOpts);
385 OH_PixelmapInitializationOptions_SetWidth(createOpts,6);
386 OH_PixelmapInitializationOptions_SetHeight(createOpts,4);
387 OH_PixelmapInitializationOptions_SetPixelFormat(createOpts,PIXEL_FORMAT_RGBA_8888);
388 OH_PixelmapInitializationOptions_SetAlphaType(createOpts,PIXELMAP_ALPHA_TYPE_UNKNOWN);
389
390 auto d = OH_PixelmapNative_CreateEmptyPixelmap(createOpts,&pixelMap);
391 OH_LOG_INFO(LOG_APP,"OH_PixelmapNative_CreateEmptyPixelmap pixelMap %{public}d",pixelMap);
392
393 auto res = OH_WindowManager_Snapshot(windowId,pixelMap);
394 OH_LOG_INFO(LOG_APP,"OH_WindowManager_Snapshot res=%{public}d.",res);
395 if(res == 0){
396 napi_value pixelValue;
397 Image_ErrorCode ans = OH_PixelmapNative_ConvertPixelmapNativeToNapi(env,pixelMap,&pixelValue);
398 OH_PixelmapNative_Release(pixelMap);
399 return pixelValue;
400
401 }else{
402 napi_value resultValue;
403 napi_create_int32(env,res,&resultValue);
404 return resultValue;
405 }
406 }
407
SetWindowFocusable(napi_env env,napi_callback_info info)408 static napi_value SetWindowFocusable(napi_env env, napi_callback_info info) {
409 size_t argc = 4;
410 napi_value args[4] = {nullptr};
411 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
412
413 int32_t windowId;
414 napi_get_value_int32(env, args[0], &windowId);
415
416 bool isFocusable;
417 napi_get_value_bool(env,args[1],&isFocusable);
418
419 auto res = OH_WindowManager_SetWindowFocusable(windowId,isFocusable);
420 napi_value resultValue;
421 napi_create_int32(env,res,&resultValue);
422 return resultValue;
423 }
424
SetWindowTouchable(napi_env env,napi_callback_info info)425 static napi_value SetWindowTouchable(napi_env env, napi_callback_info info) {
426 size_t argc = 4;
427 napi_value args[4] = {nullptr};
428 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
429
430 int32_t windowId;
431 napi_get_value_int32(env, args[0], &windowId);
432
433 bool isTouchable;
434 napi_get_value_bool(env,args[1],&isTouchable);
435
436 auto res = OH_WindowManager_SetWindowTouchable(windowId,isTouchable);
437 napi_value resultValue;
438 napi_create_int32(env,res,&resultValue);
439 return resultValue;
440 }
441
CreateJsWindowPropertiesObject(napi_env env,WindowManager_WindowProperties * windowProperties)442 napi_value CreateJsWindowPropertiesObject(napi_env env, WindowManager_WindowProperties* windowProperties){
443 napi_value objValue = nullptr;
444 Check_Napi_Create_Object_Return_If_Null(env,objValue);
445
446 napi_value windowRectObj = GetRectAndConvertToJsValue(env,windowProperties->windowRect);
447 napi_set_named_property(env,objValue,"windowRect",windowRectObj);
448 napi_value drawableRectObj = GetRectAndConvertToJsValue(env,windowProperties->drawableRect);
449 napi_set_named_property(env,objValue,"drawableRect",drawableRectObj);
450 napi_set_named_property(env,objValue,"type",CreateJsValue(env,windowProperties->type));
451 napi_set_named_property(env,objValue,"isLayoutFullScreen",CreateJsValue(env,windowProperties->isLayoutFullScreen));
452 napi_set_named_property(env,objValue,"isFullScreen",CreateJsValue(env,windowProperties->isFullScreen));
453 napi_set_named_property(env,objValue,"touchable",CreateJsValue(env,windowProperties->touchable));
454 napi_set_named_property(env,objValue,"focusable",CreateJsValue(env,windowProperties->focusable));
455 napi_set_named_property(env,objValue,"isPrivacyMode",CreateJsValue(env,windowProperties->isPrivacyMode));
456 napi_set_named_property(env,objValue,"isKeepScreenOn",CreateJsValue(env,windowProperties->isKeepScreenOn));
457 napi_set_named_property(env,objValue,"brightness",CreateJsValue(env,windowProperties->brightness));
458 napi_set_named_property(env,objValue,"isTransparent",CreateJsValue(env,windowProperties->isTransparent));
459 napi_set_named_property(env,objValue,"id",CreateJsValue(env,windowProperties->id));
460 napi_set_named_property(env,objValue,"displayId",CreateJsValue(env,static_cast<int64_t>(windowProperties->displayId)));
461 return objValue;
462 }
463
GetWindowPorperties(napi_env env,napi_callback_info info)464 static napi_value GetWindowPorperties(napi_env env, napi_callback_info info) {
465 size_t argc = 4;
466 napi_value args[4] = {nullptr};
467 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
468
469 int32_t windowId;
470 napi_get_value_int32(env, args[0], &windowId);
471 WindowManager_WindowProperties* windowProperties = new WindowManager_WindowProperties();
472
473 auto res = OH_WindowManager_GetWindowProperties(windowId,windowProperties);
474 if(res == 0){
475 auto objValue = CreateJsWindowPropertiesObject(env,windowProperties);
476 return objValue;
477 }else{
478 napi_value resultValue;
479 napi_create_int32(env,res,&resultValue);
480 return resultValue;
481 }
482 }
483
484 //设置鼠标过滤函数
filterMouseEvent(Input_MouseEvent * mouseEvent)485 static bool filterMouseEvent(Input_MouseEvent* mouseEvent){
486 int32_t action = OH_Input_GetMouseEventAction(mouseEvent);
487 int32_t displayX = OH_Input_GetMouseEventDisplayX(mouseEvent);
488 int32_t displayY = OH_Input_GetMouseEventDisplayY(mouseEvent);
489 int32_t mouseButton = OH_Input_GetMouseEventButton(mouseEvent);
490 int32_t actionTime = OH_Input_GetMouseEventActionTime(mouseEvent);
491 static bool flag = false;
492 OH_LOG_INFO(LogType::LOG_APP,"testTag filterMouseEvent in action=%{public}d displayX=%{public}d "
493 "displayY=%{public}d mouseButton=%{public}d actionTime=%{public}ld ",action,displayX,displayY,mouseButton,actionTime);
494 //过滤鼠标右键按下
495 if(mouseButton == Input_MouseEventButton::MOUSE_BUTTON_RIGHT){
496 flag = true;
497
498 }else{
499 flag = false;
500 }
501 return flag;
502 }
503
registerMouseFilter(napi_env env,napi_callback_info info)504 static napi_value registerMouseFilter(napi_env env, napi_callback_info info){
505 size_t argc = 1;
506 napi_value args[1] = {nullptr};
507 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
508
509 int32_t windowId;
510 napi_get_value_int32(env, args[0], &windowId);
511
512 auto res = OH_NativeWindowManager_RegisterMouseEventFilter(windowId,filterMouseEvent);
513 napi_value resultValue;
514 napi_create_int32(env,res,&resultValue);
515 return resultValue;
516 }
517
clearMouseFilter(napi_env env,napi_callback_info info)518 static napi_value clearMouseFilter(napi_env env, napi_callback_info info){
519 size_t argc = 1;
520 napi_value args[1] = {nullptr};
521 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
522
523 int32_t windowId;
524 napi_get_value_int32(env, args[0], &windowId);
525
526 auto res = OH_NativeWindowManager_UnregisterMouseEventFilter(windowId);
527 napi_value resultValue;
528 napi_create_int32(env,res,&resultValue);
529 return resultValue;
530 }
531
532 //设置触摸过滤函数
filterTouchEvent(Input_TouchEvent * touchEvent)533 static bool filterTouchEvent(Input_TouchEvent* touchEvent){
534 int32_t action = OH_Input_GetTouchEventAction(touchEvent);
535 int32_t displayX = OH_Input_GetTouchEventDisplayX(touchEvent);
536 int32_t displayY = OH_Input_GetTouchEventDisplayY(touchEvent);
537 int32_t id = OH_Input_GetTouchEventFingerId(touchEvent);
538 int32_t actionTime = OH_Input_GetTouchEventActionTime(touchEvent);
539 static bool flag = false;
540 OH_LOG_INFO(LogType::LOG_APP,"testTag filterTouchEvent in action=%{public}d displayX=%{public}d "
541 "displayY=%{public}d mouseButton=%{public}d actionTime=%{public}ld ",action,displayX,displayY,id,actionTime);
542 //过滤触摸移动事件
543 if(action == Input_TouchEventAction::TOUCH_ACTION_MOVE){
544 flag = true;
545
546 }else{
547 flag = false;
548 }
549 return flag;
550 }
551
registerTouchFilter(napi_env env,napi_callback_info info)552 static napi_value registerTouchFilter(napi_env env, napi_callback_info info){
553 size_t argc = 1;
554 napi_value args[1] = {nullptr};
555 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
556
557 int32_t windowId;
558 napi_get_value_int32(env, args[0], &windowId);
559
560 auto res = OH_NativeWindowManager_RegisterTouchEventFilter(windowId,filterTouchEvent);
561 napi_value resultValue;
562 napi_create_int32(env,res,&resultValue);
563 return resultValue;
564 }
565
clearTouchFilter(napi_env env,napi_callback_info info)566 static napi_value clearTouchFilter(napi_env env, napi_callback_info info){
567 size_t argc = 1;
568 napi_value args[1] = {nullptr};
569 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
570
571 int32_t windowId;
572 napi_get_value_int32(env, args[0], &windowId);
573
574 auto res = OH_NativeWindowManager_UnregisterTouchEventFilter(windowId);
575 napi_value resultValue;
576 napi_create_int32(env,res,&resultValue);
577 return resultValue;
578 }
579
580
CreateJsWindowLayoutInfoObject(napi_env env,const WindowManager_Rect & rect)581 napi_value CreateJsWindowLayoutInfoObject(napi_env env,const WindowManager_Rect& rect){
582 napi_value objValue = nullptr;
583 Check_Napi_Create_Object_Return_If_Null(env,objValue);
584 napi_set_named_property(env,objValue,"rect",GetRectAndConvertToJsValue(env,rect));
585 return objValue;
586 }
587
getAllWIndowLayOutInfo(napi_env env,napi_callback_info info)588 static napi_value getAllWIndowLayOutInfo(napi_env env, napi_callback_info info){
589 size_t argc = 4;
590 napi_value args[4] = {nullptr};
591 napi_get_cb_info(env, info, &argc, args,nullptr,nullptr);
592
593 int32_t displayId;
594 napi_get_value_int32(env, args[0], &displayId);
595 WindowManager_Rect** windowLayoutInfo = (WindowManager_Rect**)malloc(sizeof(WindowManager_Rect));
596 size_t* windowLayoutInfoSize = (size_t*)malloc(sizeof(size_t));
597 auto res = OH_WindowManager_GetAllWindowLayoutInfoList(displayId,windowLayoutInfo,windowLayoutInfoSize);
598
599 if(res != 0){
600 napi_value resultValue;
601 napi_create_int32(env,res,&resultValue);
602 return resultValue;
603 }else{
604 napi_value arrayValue = nullptr;
605 napi_create_array_with_length(env,*windowLayoutInfoSize,&arrayValue);
606 for(size_t i = 0;i < *windowLayoutInfoSize;i++){
607 OH_LOG_INFO(LOG_APP,"*windowLayoutInfoSize : %{public}d",*windowLayoutInfoSize);
608 napi_set_element(env,arrayValue,i,CreateJsWindowLayoutInfoObject(env,*(windowLayoutInfo[0]+i)));
609 }
610 OH_WindowManager_ReleaseAllWindowLayoutInfoList(*windowLayoutInfo);
611 *windowLayoutInfo = NULL;
612 windowLayoutInfo = NULL;
613 return arrayValue;
614 }
615
616 }
617
TestInjectTouchEventwithTouchEventNullptr(napi_env env,napi_callback_info info)618 static napi_value TestInjectTouchEventwithTouchEventNullptr(napi_env env, napi_callback_info info)
619 {
620 size_t argc = 1;
621 napi_value args[1] = {nullptr};
622 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
623
624 int32_t windowId;
625 napi_get_value_int32(env, args[0], &windowId);
626
627 auto res = OH_WindowManager_InjectTouchEvent(windowId, nullptr, 0, 0);
628 napi_value resultValue;
629 napi_create_int32(env, res, &resultValue);
630 return resultValue;
631 }
632
TestInjectTouchEventwithTouchEventActionOutofRange(napi_env env,napi_callback_info info)633 static napi_value TestInjectTouchEventwithTouchEventActionOutofRange(napi_env env, napi_callback_info info)
634 {
635 size_t argc = 1;
636 napi_value args[1] = {nullptr};
637 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
638
639 int32_t windowId;
640 napi_get_value_int32(env, args[0], &windowId);
641
642 int32_t windowX = 0;
643 int32_t windowY = 0;
644
645 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
646 OH_Input_SetTouchEventAction(touchEvent1, TEN);
647 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
648 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
649 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
650 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
651 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
652
653 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
654 napi_value resultValue;
655 napi_create_int32(env, res, &resultValue);
656 return resultValue;
657 }
658
TestInjectTouchEventwithWindowidNotloadcontent(napi_env env,napi_callback_info info)659 static napi_value TestInjectTouchEventwithWindowidNotloadcontent(napi_env env, napi_callback_info info)
660 {
661 size_t argc = 1;
662 napi_value args[1] = {nullptr};
663 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
664
665 int32_t windowId;
666 napi_get_value_int32(env, args[0], &windowId);
667
668 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
669 OH_Input_SetTouchEventAction(touchEvent1, 1);
670 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
671 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
672 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
673 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
674 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
675 int32_t windowX = 0;
676 int32_t windowY = 0;
677 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
678 napi_value resultValue;
679 napi_create_int32(env, res, &resultValue);
680 return resultValue;
681 }
682
TestInjectTouchEventwithDestoryedSubwindow(napi_env env,napi_callback_info info)683 static napi_value TestInjectTouchEventwithDestoryedSubwindow(napi_env env, napi_callback_info info)
684 {
685 size_t argc = 1;
686 napi_value args[1] = {nullptr};
687 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
688
689 int32_t windowId;
690 napi_get_value_int32(env, args[0], &windowId);
691
692 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
693 OH_Input_SetTouchEventAction(touchEvent1, 1);
694 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
695 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
696 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
697 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
698 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
699 int32_t windowX = 0;
700 int32_t windowY = 0;
701 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
702 napi_value resultValue;
703 napi_create_int32(env, res, &resultValue);
704 return resultValue;
705 }
706
TestInjectTouchEventwithWindowXWindowYBeyondScreen(napi_env env,napi_callback_info info)707 static napi_value TestInjectTouchEventwithWindowXWindowYBeyondScreen(napi_env env, napi_callback_info info)
708 {
709 size_t argc = THREE;
710 napi_value args[THREE] = {nullptr};
711 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
712
713 int32_t windowId;
714 napi_get_value_int32(env, args[0], &windowId);
715 int32_t windowX = 0;
716 int32_t windowY = 0;
717 napi_get_value_int32(env, args[1], &windowX);
718 napi_get_value_int32(env, args[TWO], &windowY);
719
720 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
721 OH_Input_SetTouchEventAction(touchEvent1, THREE);
722 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
723 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
724 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
725 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
726 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
727
728 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
729 napi_value resultValue;
730 napi_create_int32(env, res, &resultValue);
731 return resultValue;
732 }
733
TestInjectTouchEventwithFloatWindowXWindowY(napi_env env,napi_callback_info info)734 static napi_value TestInjectTouchEventwithFloatWindowXWindowY(napi_env env, napi_callback_info info)
735 {
736 size_t argc = THREE;
737 napi_value args[THREE] = {nullptr};
738 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
739
740 int32_t windowId;
741 napi_get_value_int32(env, args[0], &windowId);
742 double windowX = 0;
743 double windowY = 0;
744 napi_get_value_double(env, args[1], &windowX);
745 napi_get_value_double(env, args[TWO], &windowY);
746
747 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
748 OH_Input_SetTouchEventAction(touchEvent1, THREE);
749 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
750 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
751 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
752 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
753 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
754
755 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
756 napi_value resultValue;
757 napi_create_int32(env, res, &resultValue);
758 return resultValue;
759 }
760
TestInjectTouchEventwithNonExistedWindowID(napi_env env,napi_callback_info info)761 static napi_value TestInjectTouchEventwithNonExistedWindowID(napi_env env, napi_callback_info info)
762 {
763 size_t argc = 1;
764 napi_value args[1] = {nullptr};
765 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
766
767 int32_t windowId;
768 napi_get_value_int32(env, args[0], &windowId);
769 int32_t windowX = 0;
770 int32_t windowY = 0;
771
772 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
773 OH_Input_SetTouchEventAction(touchEvent1, THREE);
774 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
775 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
776 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
777 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
778 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
779 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
780 napi_value resultValue;
781 napi_create_int32(env, res, &resultValue);
782 return resultValue;
783 }
784
TestInjectTouchEventwithFloatWindowID(napi_env env,napi_callback_info info)785 static napi_value TestInjectTouchEventwithFloatWindowID(napi_env env, napi_callback_info info)
786 {
787 size_t argc = THREE;
788 napi_value args[THREE] = {nullptr};
789 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
790
791 double windowId;
792 napi_get_value_double(env, args[0], &windowId);
793 int32_t windowX = 0;
794 int32_t windowY = 0;
795 napi_get_value_int32(env, args[1], &windowX);
796 napi_get_value_int32(env, args[TWO], &windowY);
797
798 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
799 // OH_WindowManager_InjectTouchEvent中触屏事件为1、3，触屏抬起 ?
800 OH_Input_SetTouchEventAction(touchEvent1, 1);
801 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
802 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
803 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
804 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
805 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
806 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
807 OH_Input_SetTouchEventAction(touchEvent1, THREE);
808 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
809 napi_value resultValue;
810 napi_create_int32(env, res, &resultValue);
811 return resultValue;
812 }
813
TestInjectTouchEventwithNegativeWindowID(napi_env env,napi_callback_info info)814 static napi_value TestInjectTouchEventwithNegativeWindowID(napi_env env, napi_callback_info info)
815 {
816 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
817 OH_Input_SetTouchEventAction(touchEvent1, THREE);
818 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
819 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
820 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
821 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
822 OH_Input_SetTouchEventWindowId(touchEvent1, -1);
823 int32_t windowX = 0;
824 int32_t windowY = 0;
825 auto res = OH_WindowManager_InjectTouchEvent(-1, touchEvent1, windowX, windowY);
826 napi_value resultValue;
827 napi_create_int32(env, res, &resultValue);
828 return resultValue;
829 }
830
TestInjectTouchEventwithTouchActionCancel(napi_env env,napi_callback_info info)831 static napi_value TestInjectTouchEventwithTouchActionCancel(napi_env env, napi_callback_info info)
832 {
833 size_t argc = THREE;
834 napi_value args[THREE] = {nullptr};
835 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
836
837 int32_t windowId;
838 napi_get_value_int32(env, args[0], &windowId);
839 double windowX = 0;
840 double windowY = 0;
841 napi_get_value_double(env, args[1], &windowX);
842 napi_get_value_double(env, args[TWO], &windowY);
843
844 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
845 OH_Input_SetTouchEventAction(touchEvent1, 0);
846 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
847 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
848 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
849 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
850 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
851 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
852 napi_value resultValue;
853 napi_create_int32(env, res, &resultValue);
854 return resultValue;
855 }
856
TestInjectTouchEventwithTouchActionDown(napi_env env,napi_callback_info info)857 static napi_value TestInjectTouchEventwithTouchActionDown(napi_env env, napi_callback_info info)
858 {
859 size_t argc = THREE;
860 napi_value args[THREE] = {nullptr};
861 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
862
863 int32_t windowId;
864 napi_get_value_int32(env, args[0], &windowId);
865 double windowX = 0;
866 double windowY = 0;
867 napi_get_value_double(env, args[1], &windowX);
868 napi_get_value_double(env, args[TWO], &windowY);
869
870 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
871 OH_Input_SetTouchEventAction(touchEvent1, 1);
872 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
873 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
874 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
875 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
876 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
877 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
878 napi_value resultValue;
879 napi_create_int32(env, res, &resultValue);
880 return resultValue;
881 }
882
TestInjectTouchEventwithTouchActionMove(napi_env env,napi_callback_info info)883 static napi_value TestInjectTouchEventwithTouchActionMove(napi_env env, napi_callback_info info)
884 {
885 size_t argc = THREE;
886 napi_value args[THREE] = {nullptr};
887 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
888
889 int32_t windowId;
890 napi_get_value_int32(env, args[0], &windowId);
891 double windowX = 0;
892 double windowY = 0;
893 napi_get_value_double(env, args[1], &windowX);
894 napi_get_value_double(env, args[TWO], &windowY);
895
896 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
897 OH_Input_SetTouchEventAction(touchEvent1, TWO);
898 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
899 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
900 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
901 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
902 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
903 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
904 napi_value resultValue;
905 napi_create_int32(env, res, &resultValue);
906 return resultValue;
907 }
908
TestInjectTouchEventwithTouchActionUp(napi_env env,napi_callback_info info)909 static napi_value TestInjectTouchEventwithTouchActionUp(napi_env env, napi_callback_info info)
910 {
911 size_t argc = THREE;
912 napi_value args[THREE] = {nullptr};
913 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
914
915 int32_t windowId;
916 napi_get_value_int32(env, args[0], &windowId);
917 double windowX = 0;
918 double windowY = 0;
919 napi_get_value_double(env, args[1], &windowX);
920 napi_get_value_double(env, args[TWO], &windowY);
921
922 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
923 OH_Input_SetTouchEventAction(touchEvent1, THREE);
924 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
925 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
926 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
927 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
928 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
929 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
930 napi_value resultValue;
931 napi_create_int32(env, res, &resultValue);
932 return resultValue;
933 }
934
TestInjectTouchEventwithMainWindowClick(napi_env env,napi_callback_info info)935 static napi_value TestInjectTouchEventwithMainWindowClick(napi_env env, napi_callback_info info)
936 {
937 size_t argc = THREE;
938 napi_value args[THREE] = {nullptr};
939 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
940
941 int32_t windowId;
942 napi_get_value_int32(env, args[0], &windowId);
943 double windowX = 0;
944 double windowY = 0;
945 napi_get_value_double(env, args[1], &windowX);
946 napi_get_value_double(env, args[TWO], &windowY);
947
948 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
949 OH_Input_SetTouchEventAction(touchEvent1, 1);
950 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
951 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
952 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
953 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
954 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
955 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
956 OH_Input_SetTouchEventAction(touchEvent1, THREE);
957 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
958 napi_value resultValue;
959 napi_create_int32(env, res, &resultValue);
960 return resultValue;
961 }
962
TestInjectTouchEventwithSubWindowClick(napi_env env,napi_callback_info info)963 static napi_value TestInjectTouchEventwithSubWindowClick(napi_env env, napi_callback_info info)
964 {
965 size_t argc = THREE;
966 napi_value args[THREE] = {nullptr};
967 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
968
969 int32_t windowId;
970 napi_get_value_int32(env, args[0], &windowId);
971 double windowX = 0;
972 double windowY = 0;
973 napi_get_value_double(env, args[1], &windowX);
974 napi_get_value_double(env, args[TWO], &windowY);
975
976 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
977 OH_Input_SetTouchEventAction(touchEvent1, 1);
978 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
979 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
980 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
981 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
982 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
983 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
984 OH_Input_SetTouchEventAction(touchEvent1, THREE);
985 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
986 napi_value resultValue;
987 napi_create_int32(env, res, &resultValue);
988 return resultValue;
989 }
990
TestInjectTouchEventwithDialogWindowClick(napi_env env,napi_callback_info info)991 static napi_value TestInjectTouchEventwithDialogWindowClick(napi_env env, napi_callback_info info)
992 {
993 size_t argc = THREE;
994 napi_value args[THREE] = {nullptr};
995 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
996
997 int32_t windowId;
998 napi_get_value_int32(env, args[0], &windowId);
999 double windowX = 0;
1000 double windowY = 0;
1001 napi_get_value_double(env, args[1], &windowX);
1002 napi_get_value_double(env, args[TWO], &windowY);
1003
1004 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
1005 OH_Input_SetTouchEventAction(touchEvent1, 1);
1006 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
1007 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
1008 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
1009 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
1010 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
1011 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1012 OH_Input_SetTouchEventAction(touchEvent1, THREE);
1013 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1014 napi_value resultValue;
1015 napi_create_int32(env, res, &resultValue);
1016 return resultValue;
1017 }
1018
TestInjectTouchEventwithSubWindowSlide(napi_env env,napi_callback_info info)1019 static napi_value TestInjectTouchEventwithSubWindowSlide(napi_env env, napi_callback_info info)
1020 {
1021 size_t argc = THREE;
1022 napi_value args[THREE] = {nullptr};
1023 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1024
1025 int32_t windowId;
1026 napi_get_value_int32(env, args[0], &windowId);
1027 double windowX = 0;
1028 double windowY = 0;
1029 napi_get_value_double(env, args[1], &windowX);
1030 napi_get_value_double(env, args[TWO], &windowY);
1031
1032 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
1033 OH_Input_SetTouchEventAction(touchEvent1, 1);
1034 OH_Input_SetTouchEventFingerId(touchEvent1, 0);
1035 OH_Input_SetTouchEventDisplayX(touchEvent1, windowX);
1036 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
1037 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
1038 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
1039 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1040
1041 Input_TouchEvent *touchEvent2 = OH_Input_CreateTouchEvent();
1042 OH_Input_SetTouchEventAction(touchEvent2, 2);
1043 OH_Input_SetTouchEventFingerId(touchEvent2, 0);
1044 OH_Input_SetTouchEventDisplayX(touchEvent2, windowX+20);
1045 OH_Input_SetTouchEventDisplayY(touchEvent2, 0);
1046 OH_Input_SetTouchEventActionTime(touchEvent2, 0);
1047 OH_Input_SetTouchEventWindowId(touchEvent2, windowId);
1048 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent2, windowX+20, windowY);
1049
1050 Input_TouchEvent *touchEvent3 = OH_Input_CreateTouchEvent();
1051 OH_Input_SetTouchEventAction(touchEvent3, 3);
1052 OH_Input_SetTouchEventFingerId(touchEvent3, 0);
1053 OH_Input_SetTouchEventDisplayX(touchEvent3, windowX+30);
1054 OH_Input_SetTouchEventDisplayY(touchEvent3, 0);
1055 OH_Input_SetTouchEventActionTime(touchEvent3, 0);
1056 OH_Input_SetTouchEventWindowId(touchEvent3, windowId);
1057 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent3, windowX+30, windowY);
1058 napi_value resultValue;
1059 napi_create_int32(env, res, &resultValue);
1060 return resultValue;
1061 }
1062
TestInjectTouchEventwithSubWindowEdgeSlide(napi_env env,napi_callback_info info)1063 static napi_value TestInjectTouchEventwithSubWindowEdgeSlide(napi_env env, napi_callback_info info)
1064 {
1065 size_t argc = THREE;
1066 napi_value args[THREE] = {nullptr};
1067 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1068
1069 int32_t windowId;
1070 napi_get_value_int32(env, args[0], &windowId);
1071 double windowX = 0;
1072 double windowY = 0;
1073 napi_get_value_double(env, args[1], &windowX);
1074 napi_get_value_double(env, args[TWO], &windowY);
1075
1076 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
1077 OH_Input_SetTouchEventAction(touchEvent1, 1);
1078 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
1079 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
1080 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
1081 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
1082 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
1083 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1084 OH_Input_SetTouchEventAction(touchEvent1, TWO);
1085 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1086 OH_Input_SetTouchEventAction(touchEvent1, THREE);
1087 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1088 napi_value resultValue;
1089 napi_create_int32(env, res, &resultValue);
1090 return resultValue;
1091 }
1092
1093
TestInjectTouchEventwithSubWindowButtonDownCancle(napi_env env,napi_callback_info info)1094 static napi_value TestInjectTouchEventwithSubWindowButtonDownCancle(napi_env env, napi_callback_info info)
1095 {
1096 size_t argc = THREE;
1097 napi_value args[THREE] = {nullptr};
1098 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1099
1100 int32_t windowId;
1101 napi_get_value_int32(env, args[0], &windowId);
1102 double windowX = 0;
1103 double windowY = 0;
1104 napi_get_value_double(env, args[1], &windowX);
1105 napi_get_value_double(env, args[TWO], &windowY);
1106
1107 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
1108 OH_Input_SetTouchEventAction(touchEvent1, 1);
1109 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
1110 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
1111 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
1112 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
1113 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
1114 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1115 OH_Input_SetTouchEventAction(touchEvent1, 0);
1116 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1117 napi_value resultValue;
1118 napi_create_int32(env, res, &resultValue);
1119 return resultValue;
1120 }
1121
TestInjectTouchEventwithSubWindowSlideDownCancle(napi_env env,napi_callback_info info)1122 static napi_value TestInjectTouchEventwithSubWindowSlideDownCancle(napi_env env, napi_callback_info info)
1123 {
1124 size_t argc = THREE;
1125 napi_value args[THREE] = {nullptr};
1126 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1127
1128 int32_t windowId;
1129 napi_get_value_int32(env, args[0], &windowId);
1130 double windowX = 0;
1131 double windowY = 0;
1132 napi_get_value_double(env, args[1], &windowX);
1133 napi_get_value_double(env, args[TWO], &windowY);
1134
1135 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
1136 OH_Input_SetTouchEventAction(touchEvent1, 1);
1137 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
1138 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
1139 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
1140 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
1141 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
1142 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1143 OH_Input_SetTouchEventAction(touchEvent1, 0);
1144 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1145 napi_value resultValue;
1146 napi_create_int32(env, res, &resultValue);
1147 return resultValue;
1148 }
1149
TestInjectTouchEventwithHideSubWindowDown(napi_env env,napi_callback_info info)1150 static napi_value TestInjectTouchEventwithHideSubWindowDown(napi_env env, napi_callback_info info)
1151 {
1152 size_t argc = THREE;
1153 napi_value args[THREE] = {nullptr};
1154 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1155
1156 int32_t windowId;
1157 napi_get_value_int32(env, args[0], &windowId);
1158 double windowX = 0;
1159 double windowY = 0;
1160 napi_get_value_double(env, args[1], &windowX);
1161 napi_get_value_double(env, args[TWO], &windowY);
1162
1163 Input_TouchEvent *touchEvent1 = OH_Input_CreateTouchEvent();
1164 OH_Input_SetTouchEventAction(touchEvent1, 1);
1165 OH_Input_SetTouchEventFingerId(touchEvent1, 1);
1166 OH_Input_SetTouchEventDisplayX(touchEvent1, 0);
1167 OH_Input_SetTouchEventDisplayY(touchEvent1, 0);
1168 OH_Input_SetTouchEventActionTime(touchEvent1, 0);
1169 OH_Input_SetTouchEventWindowId(touchEvent1, windowId);
1170 auto res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1171 OH_Input_SetTouchEventAction(touchEvent1, THREE);
1172 res = OH_WindowManager_InjectTouchEvent(windowId, touchEvent1, windowX, windowY);
1173 napi_value resultValue;
1174 napi_create_int32(env, res, &resultValue);
1175 return resultValue;
1176 }
1177
injectTouchEventInit(napi_env env,napi_value exports)1178 static napi_value injectTouchEventInit(napi_env env, napi_value exports)
1179 {
1180 napi_property_descriptor desc[] = {
1181 {"testInjectTouchEventwithWindowXWindowYBeyondScreen", nullptr,
1182 TestInjectTouchEventwithWindowXWindowYBeyondScreen, nullptr, nullptr, nullptr, napi_default, nullptr},
1183 {"testInjectTouchEventwithFloatWindowXWindowY", nullptr,
1184 TestInjectTouchEventwithFloatWindowXWindowY, nullptr, nullptr, nullptr, napi_default, nullptr},
1185 {"testInjectTouchEventwithNonExistedWindowID", nullptr, TestInjectTouchEventwithNonExistedWindowID,
1186 nullptr, nullptr, nullptr, napi_default, nullptr},
1187 {"testInjectTouchEventwithFloatWindowID", nullptr, TestInjectTouchEventwithFloatWindowID,
1188 nullptr, nullptr, nullptr, napi_default, nullptr},
1189 {"testInjectTouchEventwithNegativeWindowID", nullptr, TestInjectTouchEventwithNegativeWindowID,
1190 nullptr, nullptr, nullptr, napi_default, nullptr},
1191 {"testInjectTouchEventwithTouchActionCancel", nullptr, TestInjectTouchEventwithTouchActionCancel,
1192 nullptr, nullptr, nullptr, napi_default, nullptr},
1193 {"testInjectTouchEventwithTouchActionDown", nullptr, TestInjectTouchEventwithTouchActionDown,
1194 nullptr, nullptr, nullptr, napi_default, nullptr},
1195 {"testInjectTouchEventwithTouchActionMove", nullptr, TestInjectTouchEventwithTouchActionMove,
1196 nullptr, nullptr, nullptr, napi_default, nullptr},
1197 {"testInjectTouchEventwithTouchActionUp", nullptr, TestInjectTouchEventwithTouchActionUp,
1198 nullptr, nullptr, nullptr, napi_default, nullptr},
1199 {"testInjectTouchEventwithMainWindowClick", nullptr, TestInjectTouchEventwithMainWindowClick,
1200 nullptr, nullptr, nullptr, napi_default, nullptr},
1201 {"testInjectTouchEventwithSubWindowClick", nullptr, TestInjectTouchEventwithSubWindowClick,
1202 nullptr, nullptr, nullptr, napi_default, nullptr},
1203 {"testInjectTouchEventwithDialogWindowClick", nullptr, TestInjectTouchEventwithDialogWindowClick,
1204 nullptr, nullptr, nullptr, napi_default, nullptr},
1205 {"testInjectTouchEventwithSubWindowSlide", nullptr, TestInjectTouchEventwithSubWindowSlide,
1206 nullptr, nullptr, nullptr, napi_default, nullptr},
1207 {"testInjectTouchEventwithSubWindowEdgeSlide", nullptr, TestInjectTouchEventwithSubWindowEdgeSlide,
1208 nullptr, nullptr, nullptr, napi_default, nullptr},
1209 {"testInjectTouchEventwithSubWindowButtonDownCancle", nullptr,
1210 TestInjectTouchEventwithSubWindowButtonDownCancle, nullptr, nullptr, nullptr, napi_default, nullptr},
1211 {"testInjectTouchEventwithSubWindowSlideDownCancle", nullptr, TestInjectTouchEventwithSubWindowSlideDownCancle,
1212 nullptr, nullptr, nullptr, napi_default, nullptr},
1213 {"testInjectTouchEventwithHideSubWindowDown", nullptr, TestInjectTouchEventwithHideSubWindowDown,
1214 nullptr, nullptr, nullptr, napi_default, nullptr},
1215 };
1216 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1217 return exports;
1218 }
1219
1220 EXTERN_C_START
Init(napi_env env,napi_value exports)1221 static napi_value Init(napi_env env, napi_value exports)
1222 {
1223 injectTouchEventInit(env, exports);
1224 napi_property_descriptor desc[] = {
1225 {"filterKeyCode", nullptr, filterKeyCode, nullptr, nullptr, nullptr, napi_default, nullptr},
1226 {"unFilterKeyCode", nullptr, unFilterKeyCode, nullptr, nullptr, nullptr, napi_default, nullptr},
1227 {"isWindowShown", nullptr, IsWindowShown, nullptr, nullptr, nullptr, napi_default, nullptr},
1228 {"showWindow", nullptr, ShowWindow, nullptr, nullptr, nullptr, napi_default, nullptr},
1229 {"setWindowStatusBarEnabled", nullptr, SetWindowStatusBarEnabled, nullptr, nullptr, nullptr, napi_default, nullptr},
1230 {"setWindowNavigationBarEnabled", nullptr, SetWindowNavigationBarEnabled, nullptr, nullptr, nullptr, napi_default, nullptr},
1231 {"setWindowStatusBarColor", nullptr, SetWindowStatusBarColor, nullptr, nullptr, nullptr, napi_default, nullptr},
1232 {"getAvoidAreaByType", nullptr, GetAvoidAreaByType, nullptr, nullptr, nullptr, napi_default, nullptr},
1233 {"setBackgroundColor", nullptr, SetBackgroundColor, nullptr, nullptr, nullptr, napi_default, nullptr},
1234 {"setBrightness", nullptr, SetBrightness, nullptr, nullptr, nullptr, napi_default, nullptr},
1235 {"setKeepScreenOn", nullptr, SetKeepScreenOn, nullptr, nullptr, nullptr, napi_default, nullptr},
1236 {"setWindowPrivacyMode", nullptr, SetWindowPrivacyMode, nullptr, nullptr, nullptr, napi_default, nullptr},
1237 {"snapshot", nullptr, Snapshot, nullptr, nullptr, nullptr, napi_default, nullptr},
1238 {"setWindowFocusable", nullptr, SetWindowFocusable, nullptr, nullptr, nullptr, napi_default, nullptr},
1239 {"setWindowTouchable", nullptr, SetWindowTouchable, nullptr, nullptr, nullptr, napi_default, nullptr},
1240 {"getWindowPorperties", nullptr, GetWindowPorperties, nullptr, nullptr, nullptr, napi_default, nullptr},
1241 {"registerMouseFilter", nullptr, registerMouseFilter, nullptr, nullptr, nullptr, napi_default, nullptr},
1242 {"clearMouseFilter", nullptr, clearMouseFilter, nullptr, nullptr, nullptr, napi_default, nullptr},
1243 {"registerTouchFilter", nullptr, registerTouchFilter, nullptr, nullptr, nullptr, napi_default, nullptr},
1244 {"clearTouchFilter", nullptr, clearTouchFilter, nullptr, nullptr, nullptr, napi_default, nullptr},
1245 {"getAllWIndowLayOutInfo", nullptr, getAllWIndowLayOutInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
1246 {"testInjectTouchEventwithTouchEventNullptr", nullptr, TestInjectTouchEventwithTouchEventNullptr,
1247 nullptr, nullptr, nullptr, napi_default, nullptr},
1248 {"testInjectTouchEventwithTouchEventActionOutofRange", nullptr,
1249 TestInjectTouchEventwithTouchEventActionOutofRange, nullptr, nullptr, nullptr, napi_default, nullptr},
1250 {"testInjectTouchEventwithWindowidNotloadcontent", nullptr, TestInjectTouchEventwithWindowidNotloadcontent,
1251 nullptr, nullptr, nullptr, napi_default, nullptr},
1252 {"testInjectTouchEventwithDestoryedSubwindow", nullptr, TestInjectTouchEventwithDestoryedSubwindow,
1253 nullptr, nullptr, nullptr, napi_default, nullptr},
1254 };
1255 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1256 return exports;
1257 }
1258 EXTERN_C_END
1259
1260 static napi_module demoModule = {
1261 .nm_version = 1,
1262 .nm_flags = 0,
1263 .nm_filename = nullptr,
1264 .nm_register_func = Init,
1265 .nm_modname = "entry",
1266 .nm_priv = ((void*)0),
1267 .reserved = { 0 },
1268 };
1269
RegisterEntryModule(void)1270 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
1271 {
1272 napi_module_register(&demoModule);
1273 }
1274