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 <iostream>
17 #include <stdexcept>
18 #include "napi/native_api.h"
19 #include <bits/alltypes.h>
20 #include <ctime>
21 #include <native_vsync/native_vsync.h>
22 #include <stdexcept>
23 #include <cstdio>
24 #include <zconf.h>
25 
26 #define SUCCESS 0
27 #define FAIL (-1)
28 #define PARAM_0 0
29 #define NUMBER_2 2
30 #define NUMBER_3 3
31 #define TIMEOUT_FIVE 10
32 #define NUMBER_254 254
33 #define NUMBER_256 256
34 #define NUMBER_500 500
35 #define NUMBER_40001000 40001000
36 static bool g_flag = false;
OnVSync(long long timestamp, void *data)37 static void OnVSync(long long timestamp, void *data) { g_flag = true; }
38 
OHNativeVSyncCreate(napi_env env, napi_callback_info info)39 static napi_value OHNativeVSyncCreate(napi_env env, napi_callback_info info)
40 {
41     napi_value result = nullptr;
42     char name[] = "test";
43     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, sizeof(name));
44     if (nativeVSync != nullptr) {
45         napi_create_int32(env, SUCCESS, &result);
46         OH_NativeVSync_Destroy(nativeVSync);
47     } else {
48         napi_create_int32(env, FAIL, &result);
49     }
50     return result;
51 }
52 
OHNativeVSyncCreateFOne(napi_env env, napi_callback_info info)53 static napi_value OHNativeVSyncCreateFOne(napi_env env, napi_callback_info info)
54 {
55     napi_value result = nullptr;
56     unsigned int length = 0;
57     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(nullptr, length);
58     if (nativeVSync != nullptr) {
59         napi_create_int32(env, FAIL, &result);
60     } else {
61         napi_create_int32(env, SUCCESS, &result);
62     }
63     return result;
64 }
65 
OHNativeVSyncRequestFrame(napi_env env, napi_callback_info info)66 static napi_value OHNativeVSyncRequestFrame(napi_env env, napi_callback_info info)
67 {
68     napi_value result = nullptr;
69     char name[] = "test";
70     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, sizeof(name));
71     OH_NativeVSync_FrameCallback callback = OnVSync;
72     int ret = OH_NativeVSync_RequestFrame(nativeVSync, callback, nullptr);
73     if (ret == SUCCESS) {
74         napi_create_int32(env, SUCCESS, &result);
75     } else {
76         napi_create_int32(env, FAIL, &result);
77     }
78     if (nativeVSync) {
79         OH_NativeVSync_Destroy(nativeVSync);
80     }
81     return result;
82 }
83 
OHNativeVSyncRequestFrameFOne(napi_env env, napi_callback_info info)84 static napi_value OHNativeVSyncRequestFrameFOne(napi_env env, napi_callback_info info)
85 {
86     napi_value result = nullptr;
87     int ret = OH_NativeVSync_RequestFrame(nullptr, nullptr, nullptr);
88     if (ret != SUCCESS) {
89         napi_create_int32(env, SUCCESS, &result);
90     } else {
91         napi_create_int32(env, FAIL, &result);
92     }
93     return result;
94 }
95 
OHNativeVSyncRequestFrameFTwo(napi_env env, napi_callback_info info)96 static napi_value OHNativeVSyncRequestFrameFTwo(napi_env env, napi_callback_info info)
97 {
98     napi_value result = nullptr;
99     char name[] = "test";
100     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, sizeof(name));
101     int ret = OH_NativeVSync_RequestFrame(nativeVSync, nullptr, nullptr);
102     if (ret != SUCCESS) {
103         napi_create_int32(env, SUCCESS, &result);
104     } else {
105         napi_create_int32(env, FAIL, &result);
106     }
107     if (nativeVSync) {
108         OH_NativeVSync_Destroy(nativeVSync);
109     }
110     return result;
111 }
112 
OHNativeVSyncGetPeriod(napi_env env, napi_callback_info info)113 static napi_value OHNativeVSyncGetPeriod(napi_env env, napi_callback_info info)
114 {
115     napi_value result = nullptr;
116     char name[] = "test";
117     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, sizeof(name));
118     OH_NativeVSync_FrameCallback callback = OnVSync;
119     OH_NativeVSync_RequestFrame(nativeVSync, callback, nullptr);
120     time_t startTime = time(PARAM_0);
121     double diffTime = 0;
122     while (!g_flag && diffTime < TIMEOUT_FIVE) {
123         time_t curTime = time(PARAM_0);
124         diffTime = difftime(curTime, startTime);
125     }
126     long long period;
127     int ret = OH_NativeVSync_GetPeriod(nativeVSync, &period);
128     if (ret == SUCCESS) {
129         napi_create_int32(env, SUCCESS, &result);
130     } else {
131         napi_create_int32(env, FAIL, &result);
132     }
133     if (nativeVSync) {
134         OH_NativeVSync_Destroy(nativeVSync);
135     }
136     return result;
137 }
138 
OHNativeVSyncGetPeriodFOne(napi_env env, napi_callback_info info)139 static napi_value OHNativeVSyncGetPeriodFOne(napi_env env, napi_callback_info info)
140 {
141     napi_value result = nullptr;
142     long long period;
143     int ret = OH_NativeVSync_GetPeriod(nullptr, &period);
144     if (ret != SUCCESS) {
145         napi_create_int32(env, SUCCESS, &result);
146     } else {
147         napi_create_int32(env, FAIL, &result);
148     }
149     return result;
150 }
151 
OHNativeVSyncCreateNull(napi_env env, napi_callback_info info)152 static napi_value OHNativeVSyncCreateNull(napi_env env, napi_callback_info info)
153 {
154     napi_value result = nullptr;
155     unsigned int length = 0;
156     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(nullptr, length);
157     if (nativeVSync == nullptr) {
158         napi_create_int32(env, FAIL, &result);
159     } else {
160         napi_create_int32(env, SUCCESS, &result);
161     }
162     return result;
163 }
164 
OHNativeVSyncCreateNotEq(napi_env env, napi_callback_info info)165 static napi_value OHNativeVSyncCreateNotEq(napi_env env, napi_callback_info info)
166 {
167     napi_value result = nullptr;
168     char name[] = "testCase";
169     unsigned int length = NUMBER_2;
170     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, length);
171     if (nativeVSync == nullptr) {
172         napi_create_int32(env, FAIL, &result);
173     } else {
174         napi_create_int32(env, SUCCESS, &result);
175     }
176     OH_NativeVSync_Destroy(nativeVSync);
177     return result;
178 }
179 
OHNativeVSyncCreateNormal(napi_env env, napi_callback_info info)180 static napi_value OHNativeVSyncCreateNormal(napi_env env, napi_callback_info info)
181 {
182     napi_value result = nullptr;
183     char name[] = "testCase";
184     unsigned int length = strlen(name);
185     OH_NativeVSync *nativeVSync1 = OH_NativeVSync_Create(name, length);
186     napi_create_array_with_length(env, NUMBER_2, &result);
187     napi_value result1 = nullptr;
188     napi_value result2 = nullptr;
189     if (nativeVSync1 == nullptr) {
190         napi_create_int32(env, FAIL, &result1);
191     } else {
192         napi_create_int32(env, SUCCESS, &result1);
193     }
194     napi_set_element(env, result, 0, result1);
195 
196     OH_NativeVSync *nativeVSync2 = OH_NativeVSync_Create(name, length);
197     if (nativeVSync2 == nullptr) {
198         napi_create_int32(env, FAIL, &result2);
199     } else {
200         napi_create_int32(env, SUCCESS, &result2);
201     }
202 
203     napi_set_element(env, result, 1, result2);
204     OH_NativeVSync_Destroy(nativeVSync1);
205     OH_NativeVSync_Destroy(nativeVSync2);
206     return result;
207 }
208 
OHNativeVSyncCreateAbnormal(napi_env env, napi_callback_info info)209 static napi_value OHNativeVSyncCreateAbnormal(napi_env env, napi_callback_info info)
210 {
211     napi_value result = nullptr;
212     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(NULL, 0);
213     if (nativeVSync == nullptr) {
214         napi_create_int32(env, SUCCESS, &result);
215     } else {
216         napi_create_int32(env, FAIL, &result);
217         return result;
218     }
219     nativeVSync = OH_NativeVSync_Create(0, 0);
220     if (nativeVSync == nullptr) {
221         napi_create_int32(env, SUCCESS, &result);
222     } else {
223         napi_create_int32(env, FAIL, &result);
224         return result;
225     }
226     OH_NativeVSync_Destroy(nativeVSync);
227     return result;
228 }
229 
MyFrameCallback(long long timestamp, void *data)230 void MyFrameCallback(long long timestamp, void *data)
231 {
232     int *myData = static_cast<int *>(data);
233     return;
234 }
235 
OHNativeVSyncCreateDifLenth(napi_env env, napi_callback_info info)236 static napi_value OHNativeVSyncCreateDifLenth(napi_env env, napi_callback_info info)
237 {
238     napi_value result = nullptr;
239     std::vector<std::string> myArray = {
240         "0",
241         "a",
242         "你",
243         "!@#￥%^&*()_+",
244         " ",
245         "  ",
246         "这里有好多好多字符qazwsxedcrfvtgbyhnujqazwsxedcrfvtgbyhnujqazwsxedcrfvtgbyhnujqazwsxedcrfvtgbyhnuj",
247         "ab_cdefghijklmnopqrstuvwxyz",
248         "abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde"};
249     napi_create_array_with_length(env, myArray.size(), &result);
250 
251     for (uint32_t index = 0; index < myArray.size(); index++) {
252         unsigned int len = strlen(myArray[index].c_str());
253         OH_NativeVSync *nativeVSync = nullptr;
254         napi_value resultIndex = nullptr;
255         nativeVSync = OH_NativeVSync_Create(myArray[index].c_str(), len);
256         if (nativeVSync == nullptr) {
257             napi_create_int32(env, FAIL+index, &result);
258             OH_NativeVSync_Destroy(nativeVSync);
259             return result;
260         } else {
261             napi_create_int32(env, SUCCESS, &result);
262             OH_NativeVSync_Destroy(nativeVSync);
263             continue;
264         }
265     }
266     return result;
267 }
268 
OHNativeVSyncCreateMuch(napi_env env, napi_callback_info info)269 static napi_value OHNativeVSyncCreateMuch(napi_env env, napi_callback_info info)
270 {
271     napi_value result = nullptr;
272     char name[] = "testcase";
273     unsigned int length = strlen(name);
274     OH_NativeVSync *nativeVSyncArr[NUMBER_500];
275     int success = 0;
276     for (uint32_t i = 0; i < NUMBER_500; i++) {
277         nativeVSyncArr[i] = OH_NativeVSync_Create(name, length);
278         if (nativeVSyncArr[i] != nullptr) {
279             success = success + 1;
280             continue;
281         }
282     }
283     if (success == NUMBER_254) {
284         napi_create_int32(env, SUCCESS, &result);
285     } else {
286         napi_create_int32(env, success, &result);
287     }
288     for (uint32_t i = 0; i < NUMBER_500; i++) {
289         OH_NativeVSync_Destroy(nativeVSyncArr[i]);
290     }
291     return result;
292 }
293 
OHNativeVSyncGetPeriodNullptr(napi_env env, napi_callback_info info)294 static napi_value OHNativeVSyncGetPeriodNullptr(napi_env env, napi_callback_info info)
295 {
296     napi_value result = nullptr;
297     long long period;
298     int res = OH_NativeVSync_GetPeriod(nullptr, &period);
299     napi_create_int32(env, res, &result);
300     return result;
301 }
302 
OHNativeVSyncRequestFrameNullptr(napi_env env, napi_callback_info info)303 static napi_value OHNativeVSyncRequestFrameNullptr(napi_env env, napi_callback_info info)
304 {
305     napi_value result = nullptr;
306     char name[] = "testcase";
307     unsigned int length = strlen(name);
308     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, length);
309     napi_create_array_with_length(env, NUMBER_3, &result);
310     int param = 0;
311     int res = OH_NativeVSync_RequestFrame(nullptr, MyFrameCallback, &param);
312     if (res != NUMBER_40001000) {
313         napi_create_int32(env, FAIL, &result);
314         return result;
315     }
316     res = OH_NativeVSync_RequestFrame(nativeVSync, nullptr, &param);
317     if (res != NUMBER_40001000) {
318         napi_create_int32(env, FAIL, &result);
319         return result;
320     }
321     res = OH_NativeVSync_RequestFrame(nativeVSync, MyFrameCallback, nullptr);
322     if (res != 0) {
323         napi_create_int32(env, FAIL, &result);
324         return result;
325     }
326     napi_create_int32(env, SUCCESS, &result);
327     return result;
328 }
329 
OHNativeVSyncRequestFrameNormal(napi_env env, napi_callback_info info)330 static napi_value OHNativeVSyncRequestFrameNormal(napi_env env, napi_callback_info info)
331 {
332     napi_value result = nullptr;
333     char name[] = "testcase";
334     unsigned int length = strlen(name);
335     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, length);
336     int *param = nullptr;
337     int res = OH_NativeVSync_RequestFrame(nativeVSync, MyFrameCallback, param);
338     napi_create_int32(env, res, &result);
339     OH_NativeVSync_Destroy(nativeVSync);
340     return result;
341 }
342 
OHNativeVSyncRequestFrameParamErr(napi_env env, napi_callback_info info)343 static napi_value OHNativeVSyncRequestFrameParamErr(napi_env env, napi_callback_info info)
344 {
345     napi_value result = nullptr;
346     char name[] = "testcase";
347     unsigned int length = strlen(name);
348     OH_NativeVSync *nativeVSync = OH_NativeVSync_Create(name, length);
349     char param[] = "test";
350     int res = OH_NativeVSync_RequestFrame(nativeVSync, MyFrameCallback, &param);
351     napi_create_int32(env, res, &result);
352     OH_NativeVSync_Destroy(nativeVSync);
353     return result;
354 }
355 
356 EXTERN_C_START
Init(napi_env env, napi_value exports)357 static napi_value Init(napi_env env, napi_value exports)
358 {
359     napi_property_descriptor desc[] = {
360         {"oHNativeVSyncCreate", nullptr, OHNativeVSyncCreate, nullptr, nullptr, nullptr, napi_default, nullptr},
361         {"oHNativeVSyncCreateFOne", nullptr, OHNativeVSyncCreateFOne, nullptr, nullptr, nullptr, napi_default, nullptr},
362         {"oHNativeVSyncRequestFrame", nullptr, OHNativeVSyncRequestFrame, nullptr, nullptr, nullptr, napi_default,
363          nullptr},
364         {"oHNativeVSyncRequestFrameFOne", nullptr, OHNativeVSyncRequestFrameFOne, nullptr, nullptr, nullptr,
365          napi_default, nullptr},
366         {"oHNativeVSyncRequestFrameFTwo", nullptr, OHNativeVSyncRequestFrameFTwo, nullptr, nullptr, nullptr,
367          napi_default, nullptr},
368         {"oHNativeVSyncGetPeriod", nullptr, OHNativeVSyncGetPeriod, nullptr, nullptr, nullptr, napi_default, nullptr},
369         {"oHNativeVSyncGetPeriodFOne", nullptr, OHNativeVSyncGetPeriodFOne, nullptr, nullptr, nullptr, napi_default,
370          nullptr},
371         {"oHNativeVSyncCreateNull", nullptr, OHNativeVSyncCreateNull, nullptr, nullptr, nullptr, napi_default, nullptr},
372         {"oHNativeVSyncCreateNotEq", nullptr, OHNativeVSyncCreateNotEq, nullptr, nullptr, nullptr, napi_default,
373          nullptr},
374         {"oHNativeVSyncCreateNormal", nullptr, OHNativeVSyncCreateNormal, nullptr, nullptr, nullptr, napi_default,
375          nullptr},
376         {"oHNativeVSyncCreateAbnormal", nullptr, OHNativeVSyncCreateAbnormal, nullptr, nullptr, nullptr, napi_default,
377          nullptr},
378         {"oHNativeVSyncCreateDifLenth", nullptr, OHNativeVSyncCreateDifLenth, nullptr, nullptr, nullptr, napi_default,
379          nullptr},
380         {"oHNativeVSyncCreateMuch", nullptr, OHNativeVSyncCreateMuch, nullptr, nullptr, nullptr, napi_default, nullptr},
381         {"oHNativeVSyncGetPeriodNullptr", nullptr, OHNativeVSyncGetPeriodNullptr, nullptr, nullptr, nullptr,
382          napi_default, nullptr},
383         {"oHNativeVSyncRequestFrameNullptr", nullptr, OHNativeVSyncRequestFrameNullptr, nullptr, nullptr, nullptr,
384          napi_default, nullptr},
385         {"oHNativeVSyncRequestFrameNormal", nullptr, OHNativeVSyncRequestFrameNormal, nullptr, nullptr, nullptr,
386          napi_default, nullptr},
387         {"oHNativeVSyncRequestFrameParamErr", nullptr, OHNativeVSyncRequestFrameParamErr, nullptr, nullptr, nullptr,
388          napi_default, nullptr},
389     };
390     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
391     return exports;
392 }
393 EXTERN_C_END
394 
395 static napi_module demoModule = {
396     .nm_version = 1,
397     .nm_flags = 0,
398     .nm_filename = nullptr,
399     .nm_register_func = Init,
400     .nm_modname = "nativevsync",
401     .nm_priv = ((void *)0),
402     .reserved = {0},
403 };
404 
RegisterModule(void)405 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); };
406