1 /*
2 * Copyright (C) 2021 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 "key_event_handler.h"
17
InjectEvent(napi_env env,napi_callback_info info)18 static napi_value InjectEvent(napi_env env, napi_callback_info info)
19 {
20 size_t argc = 2;
21 napi_value args[2] = { 0 };
22 napi_value thisArg = nullptr;
23 void* data = nullptr;
24 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisArg, &data));
25 napi_value eventObject = args[0];
26 int32_t ret = IsMatchType(eventObject, napi_object, env);
27 AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo {
28 .env = env,
29 .asyncWork = nullptr,
30 .deferred = nullptr,
31 };
32 if (argc >= 1) {
33 napi_create_reference(env, args[1], 1, &asyncCallbackInfo->callback[0]);
34 if (ret != 0) {
35 asyncCallbackInfo->callbackData = GetNapiInt32_t(-1, env);
36 EmitAsyncCallbackWork(env, asyncCallbackInfo);
37 napi_value undefined;
38 napi_get_undefined(env, &undefined);
39 return undefined;
40 }
41 napi_value isPressed, keyCode, keyDownDuration;
42 napi_get_named_property(env, eventObject, "isPressed", &isPressed);
43 napi_get_named_property(env, eventObject, "keyDownDuration", &keyDownDuration);
44 napi_get_named_property(env, eventObject, "keyCode", &keyCode);
45 if (IsMatchType(isPressed, napi_boolean, env) || IsMatchType(keyCode, napi_number, env)
46 || IsMatchType(keyDownDuration, napi_number, env)) {
47 asyncCallbackInfo->callbackData = GetNapiInt32_t(-1, env);
48 EmitAsyncCallbackWork(env, asyncCallbackInfo);
49 napi_value undefined;
50 napi_get_undefined(env, &undefined);
51 return undefined;
52 }
53 OHOS::KeyProperty keyProperty = {
54 .isPressed = GetCppBool(isPressed, env),
55 .keyCode = GetCppInt32_t(keyCode, env),
56 .keyDownDuration = GetCppInt32_t(keyDownDuration, env),
57 };
58 OHOS::MultimodalProperty multimodalProperty {
59 .highLevelEvent = 1,
60 .uuid = "11111",
61 .sourceType = 1,
62 .occurredTime = 1,
63 .deviceId = "11111",
64 .inputDeviceId = 1,
65 .isHighLevelEvent = true,
66 };
67 OHOS::sptr<OHOS::KeyEvent> event = new OHOS::KeyEvent();
68 event->Initialize(multimodalProperty, keyProperty);
69 std::shared_ptr<OHOS::InjectManager> injectManager = OHOS::InjectManager::GetInstance();
70 bool isSucceed = injectManager->InjectEvent(event);
71 if (!isSucceed) {
72 asyncCallbackInfo->callbackData = GetNapiInt32_t(-1, env);
73 EmitAsyncCallbackWork(env, asyncCallbackInfo);
74 napi_value undefined;
75 napi_get_undefined(env, &undefined);
76 return undefined;
77 }
78 asyncCallbackInfo->callbackData = GetNapiInt32_t(0, env);
79 EmitAsyncCallbackWork(env, asyncCallbackInfo);
80 napi_value undefined;
81 napi_get_undefined(env, &undefined);
82 return undefined;
83 } else {
84 napi_deferred deferred;
85 napi_value promise;
86 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
87 asyncCallbackInfo->deferred = deferred;
88 if (ret != 0) {
89 asyncCallbackInfo->callbackData = GetNapiInt32_t(-1, env);
90 EmitPromiseWork(env, asyncCallbackInfo);
91 napi_value undefined;
92 napi_get_undefined(env, &undefined);
93 return undefined;
94 }
95 napi_value isPressed, keyCode, keyDownDuration;
96 napi_get_named_property(env, eventObject, "isPressed", &isPressed);
97 napi_get_named_property(env, eventObject, "keyDownDuration", &keyDownDuration);
98 napi_get_named_property(env, eventObject, "keyCode", &keyCode);
99 if (IsMatchType(isPressed, napi_boolean, env) || IsMatchType(keyCode, napi_number, env)
100 || IsMatchType(keyDownDuration, napi_number, env)) {
101 asyncCallbackInfo->callbackData = GetNapiInt32_t(-1, env);
102 EmitPromiseWork(env, asyncCallbackInfo);
103 napi_value undefined;
104 napi_get_undefined(env, &undefined);
105 return undefined;
106 }
107 OHOS::KeyProperty keyProperty = {
108 .isPressed = GetCppBool(isPressed, env),
109 .keyCode = GetCppInt32_t(keyCode, env),
110 .keyDownDuration = GetCppInt32_t(keyDownDuration, env),
111 };
112 OHOS::MultimodalProperty multimodalProperty {
113 .highLevelEvent = 1,
114 .uuid = "11111",
115 .sourceType = 1,
116 .occurredTime = 1,
117 .deviceId = "11111",
118 .inputDeviceId = 1,
119 .isHighLevelEvent = true,
120 };
121 OHOS::sptr<OHOS::KeyEvent> event = new OHOS::KeyEvent();
122 event->Initialize(multimodalProperty, keyProperty);
123 std::shared_ptr<OHOS::InjectManager> injectManager = OHOS::InjectManager::GetInstance();
124 bool isSucceed = injectManager->InjectEvent(event);
125 if (!isSucceed) {
126 asyncCallbackInfo->callbackData = GetNapiInt32_t(-1, env);
127 EmitPromiseWork(env, asyncCallbackInfo);
128 napi_value undefined;
129 napi_get_undefined(env, &undefined);
130 return undefined;
131 }
132 asyncCallbackInfo->callbackData = GetNapiInt32_t(0, env);
133 EmitPromiseWork(env, asyncCallbackInfo);
134 return promise;
135 }
136 }
137
InjectEventSync(napi_env env,napi_callback_info info)138 static napi_value InjectEventSync(napi_env env, napi_callback_info info)
139 {
140 size_t argc = 2;
141 napi_value args[2] = { 0 };
142 napi_value thisArg = nullptr;
143 void* data = nullptr;
144 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisArg, &data));
145 napi_value eventObject = args[0];
146 int32_t ret = IsMatchType(eventObject, napi_object, env);
147 if (ret) {
148 return GetNapiInt32_t(ret, env);
149 }
150 napi_value isPressed, keyCode, keyDownDuration;
151 napi_get_named_property(env, eventObject, "isPressed", &isPressed);
152 napi_get_named_property(env, eventObject, "keyDownDuration", &keyDownDuration);
153 napi_get_named_property(env, eventObject, "keyCode", &keyCode);
154 if (IsMatchType(isPressed, napi_boolean, env) || IsMatchType(keyCode, napi_number, env)
155 || IsMatchType(keyDownDuration, napi_number, env)) {
156 return GetNapiInt32_t(-1, env);
157 }
158 OHOS::KeyProperty keyProperty = {
159 .isPressed = GetCppBool(isPressed, env),
160 .keyCode = GetCppInt32_t(keyCode, env),
161 .keyDownDuration = GetCppInt32_t(keyDownDuration, env),
162 };
163 OHOS::MultimodalProperty multimodalProperty {
164 .highLevelEvent = 1,
165 .uuid = "11111",
166 .sourceType = 1,
167 .occurredTime = 1,
168 .deviceId = "11111",
169 .inputDeviceId = 1,
170 .isHighLevelEvent = true,
171 };
172 OHOS::sptr<OHOS::KeyEvent> event = new OHOS::KeyEvent();
173 if (!event) {
174 return GetNapiInt32_t(-1, env);
175 }
176 event->Initialize(multimodalProperty, keyProperty);
177 std::shared_ptr<OHOS::InjectManager> injectManager = OHOS::InjectManager::GetInstance();
178 bool isSucceed = injectManager->InjectEvent(event);
179 if (!isSucceed) {
180 return GetNapiInt32_t(-1, env);
181 }
182 return GetNapiInt32_t(0, env);
183 }
184
185 EXTERN_C_START
186
Init(napi_env env,napi_value exports)187 static napi_value Init(napi_env env, napi_value exports)
188 {
189 napi_property_descriptor desc[] = {
190 DECLARE_NAPI_FUNCTION("injectEvent", InjectEvent),
191 DECLARE_NAPI_FUNCTION("injectEventSync", InjectEventSync)
192 };
193 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
194 return exports;
195 }
196 EXTERN_C_END
197
198 static napi_module _module = {
199 .nm_version = 1,
200 .nm_flags = 0,
201 .nm_filename = nullptr,
202 .nm_register_func = Init,
203 .nm_modname = "injectEventHandler",
204 .nm_priv = ((void*)0),
205 .reserved = { 0 }
206 };
207
RegisterModule(void)208 extern "C" __attribute__((constructor)) void RegisterModule(void)
209 {
210 napi_module_register(&_module);
211 }
212