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 "napi/native_api.h"
17#include <EGL/egl.h>
18#include <EGL/eglext.h>
19#include <GLES3/gl32.h>
20#include <bits/alltypes.h>
21#include <cstring>
22#include <native_buffer/native_buffer.h>
23#include <native_image/native_image.h>
24#include <native_window/external_window.h>
25#include <sys/mman.h>
26#include <chrono>
27
28#define SUCCESS 0
29#define PARAM_0 0
30#define PARAM_8 8
31#define PARAM_1 1
32#define PARAM_16 16
33#define PARAM_800 800
34#define PARAM_600 600
35#define FAIL (-1)
36#define ONEVAL 1
37#define NUMMAX 16
38#define TWOVAL 2
39#define ARR_NUMBER_0 0
40#define ARR_NUMBER_1 1
41#define ARR_NUMBER_2 2
42#define ARR_NUMBER_3 3
43#define ARR_NUMBER_4 4
44#define NUMBER_99999 99999
45#define NUMBER_500 500
46
47using GetPlatformDisplayExt = PFNEGLGETPLATFORMDISPLAYEXTPROC;
48constexpr const char *EGL_EXT_PLATFORM_WAYLAND = "EGL_EXT_platform_wayland";
49constexpr const char *EGL_KHR_PLATFORM_WAYLAND = "EGL_KHR_platform_wayland";
50constexpr int32_t EGL_CONTEXT_CLIENT_VERSION_NUM = 2;
51constexpr char CHARACTER_WHITESPACE = ' ';
52constexpr const char *CHARACTER_STRING_WHITESPACE = " ";
53constexpr const char *EGL_GET_PLATFORM_DISPLAY_EXT = "eglGetPlatformDisplayEXT";
54EGLContext eglContext_ = EGL_NO_CONTEXT;
55EGLDisplay eglDisplay_ = EGL_NO_DISPLAY;
56static inline EGLConfig config_;
57
58static bool CheckEglExtension(const char *extensions, const char *extension)
59{
60    size_t extlen = strlen(extension);
61    const char *end = extensions + strlen(extensions);
62
63    while (extensions < end) {
64        size_t n = PARAM_0;
65        if (*extensions == CHARACTER_WHITESPACE) {
66            extensions++;
67            continue;
68        }
69        n = strcspn(extensions, CHARACTER_STRING_WHITESPACE);
70        if (n == extlen && strncmp(extension, extensions, n) == PARAM_0) {
71            return true;
72        }
73        extensions += n;
74    }
75    return false;
76}
77
78static EGLDisplay GetPlatformEglDisplay(EGLenum platform, void *native_display, const EGLint *attrib_list)
79{
80    static GetPlatformDisplayExt eglGetPlatformDisplayExt = nullptr;
81
82    if (!eglGetPlatformDisplayExt) {
83        const char *extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
84        if (extensions && (CheckEglExtension(extensions, EGL_EXT_PLATFORM_WAYLAND) ||
85                           CheckEglExtension(extensions, EGL_KHR_PLATFORM_WAYLAND))) {
86            eglGetPlatformDisplayExt = (GetPlatformDisplayExt)eglGetProcAddress(EGL_GET_PLATFORM_DISPLAY_EXT);
87        }
88    }
89
90    if (eglGetPlatformDisplayExt) {
91        return eglGetPlatformDisplayExt(platform, native_display, attrib_list);
92    }
93
94    return eglGetDisplay((EGLNativeDisplayType)native_display);
95}
96
97static void InitEGLEnv()
98{
99    eglDisplay_ = GetPlatformEglDisplay(EGL_PLATFORM_OHOS_KHR, EGL_DEFAULT_DISPLAY, nullptr);
100    EGLint major, minor;
101    eglInitialize(eglDisplay_, &major, &minor);
102    eglBindAPI(EGL_OPENGL_ES_API);
103    unsigned int ret;
104    EGLint count;
105    EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE,        PARAM_8,
106                               EGL_GREEN_SIZE,   PARAM_8,        EGL_BLUE_SIZE,       PARAM_8,
107                               EGL_ALPHA_SIZE,   PARAM_8,        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
108                               EGL_NONE};
109
110    ret = eglChooseConfig(eglDisplay_, config_attribs, &config_, PARAM_1, &count);
111    static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, EGL_CONTEXT_CLIENT_VERSION_NUM, EGL_NONE};
112    eglContext_ = eglCreateContext(eglDisplay_, config_, EGL_NO_CONTEXT, context_attribs);
113    eglMakeCurrent(eglDisplay_, EGL_NO_SURFACE, EGL_NO_SURFACE, eglContext_);
114}
115
116static OH_NativeImage *getNativeImage()
117{
118    GLuint textureId = SUCCESS;
119    glGenTextures(ONEVAL, &textureId);
120    OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
121    return image;
122}
123
124static napi_value OHNativeImageCreate(napi_env env, napi_callback_info info)
125{
126    napi_value result = nullptr;
127    OH_NativeImage *image = getNativeImage();
128    int backInfo = FAIL;
129    if (image != nullptr) {
130        backInfo = SUCCESS;
131        OH_NativeImage_Destroy(&image);
132    }
133
134    napi_create_int32(env, backInfo, &result);
135    return result;
136}
137
138static napi_value OHNativeImageAcquireNativeWindow(napi_env env, napi_callback_info info)
139{
140    napi_value result = nullptr;
141    int backInfo = FAIL;
142    OH_NativeImage *image = getNativeImage();
143
144    if (image != nullptr) {
145        OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
146        if (nativeWindow != nullptr) {
147            backInfo = SUCCESS;
148        }
149        OH_NativeImage_Destroy(&image);
150    }
151    napi_create_int32(env, backInfo, &result);
152    return result;
153}
154
155static napi_value OHNativeImageAcquireNativeWindowAbnormal(napi_env env, napi_callback_info info)
156{
157    napi_value result = nullptr;
158    int backInfo = FAIL;
159    OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(nullptr);
160    if (nativeWindow != nullptr) {
161        backInfo = SUCCESS;
162    }
163    napi_create_int32(env, backInfo, &result);
164    return result;
165}
166
167static napi_value OHNativeImageAttachContext(napi_env env, napi_callback_info info)
168{
169    int backInfo = FAIL;
170    InitEGLEnv();
171    GLuint textureId;
172    glGenTextures(PARAM_1, &textureId);
173    OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
174    OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
175    int code = SET_BUFFER_GEOMETRY;
176    int32_t width = PARAM_800;
177    int32_t height = PARAM_600;
178    OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
179    OHNativeWindowBuffer *buffer = nullptr;
180    int fenceFd;
181    OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
182    BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
183    void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
184    static uint32_t value = 0x00;
185    value++;
186    uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
187    for (uint32_t x = PARAM_0; x < width; x++) {
188        for (uint32_t y = PARAM_0; y < height; y++) {
189            *pixel++ = value;
190        }
191    }
192    munmap(mappedAddr, handle->size);
193
194    Region region{nullptr, PARAM_0};
195    OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
196    OH_NativeImage_UpdateSurfaceImage(image);
197    OH_NativeImage_GetTimestamp(image);
198    float matrix[16];
199    OH_NativeImage_GetTransformMatrix(image, matrix);
200    OH_NativeWindow_DestroyNativeWindow(nativeWindow);
201    OH_NativeImage_DetachContext(image);
202    GLuint textureId2;
203    glGenTextures(PARAM_1, &textureId2);
204    backInfo = OH_NativeImage_AttachContext(image, textureId2);
205    napi_value result = nullptr;
206    napi_create_int32(env, backInfo, &result);
207    OH_NativeImage_Destroy(&image);
208    return result;
209}
210
211static napi_value OHNativeImageAttachContextAbnormal(napi_env env, napi_callback_info info)
212{
213    GLuint textureId2;
214    glGenTextures(ONEVAL, &textureId2);
215    int backInfo = OH_NativeImage_AttachContext(nullptr, textureId2);
216    if (backInfo != SUCCESS) {
217        backInfo = FAIL;
218    }
219    napi_value result = nullptr;
220    napi_create_int32(env, backInfo, &result);
221    return result;
222}
223
224static napi_value OHNativeImageDetachContext(napi_env env, napi_callback_info info)
225{
226    int backInfo = FAIL;
227    InitEGLEnv();
228    GLuint textureId;
229    glGenTextures(PARAM_1, &textureId);
230    OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
231    OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
232    int code = SET_BUFFER_GEOMETRY;
233    int32_t width = PARAM_800;
234    int32_t height = PARAM_600;
235    OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
236    OHNativeWindowBuffer *buffer = nullptr;
237    int fenceFd;
238    OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
239    BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
240    void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
241    static uint32_t value = 0x00;
242    value++;
243    uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
244    for (uint32_t x = PARAM_0; x < width; x++) {
245        for (uint32_t y = PARAM_0; y < height; y++) {
246            *pixel++ = value;
247        }
248    }
249    munmap(mappedAddr, handle->size);
250
251    Region region{nullptr, PARAM_0};
252    OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
253    OH_NativeImage_UpdateSurfaceImage(image);
254    OH_NativeImage_GetTimestamp(image);
255    float matrix[16];
256    OH_NativeImage_GetTransformMatrix(image, matrix);
257    OH_NativeWindow_DestroyNativeWindow(nativeWindow);
258    backInfo = OH_NativeImage_DetachContext(image);
259    GLuint textureId2;
260    glGenTextures(PARAM_1, &textureId2);
261    OH_NativeImage_AttachContext(image, textureId2);
262    OH_NativeImage_Destroy(&image);
263    napi_value result = nullptr;
264    napi_create_int32(env, backInfo, &result);
265    return result;
266}
267
268static napi_value OHNativeImageDetachContextAbnormal(napi_env env, napi_callback_info info)
269{
270    int backInfo = OH_NativeImage_DetachContext(nullptr);
271    if (backInfo != SUCCESS) {
272        backInfo = FAIL;
273    }
274    napi_value result = nullptr;
275    napi_create_int32(env, backInfo, &result);
276    return result;
277}
278
279static napi_value OHNativeImageUpdateSurfaceImage(napi_env env, napi_callback_info info)
280{
281    InitEGLEnv();
282    GLuint textureId;
283    glGenTextures(PARAM_1, &textureId);
284    OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
285    OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
286    int code = SET_BUFFER_GEOMETRY;
287    int32_t width = PARAM_800;
288    int32_t height = PARAM_600;
289    OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
290    OHNativeWindowBuffer *buffer = nullptr;
291    int fenceFd;
292    OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
293    BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
294    void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
295    static uint32_t value = 0x00;
296    value++;
297    uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
298    for (uint32_t x = PARAM_0; x < width; x++) {
299        for (uint32_t y = PARAM_0; y < height; y++) {
300            *pixel++ = value;
301        }
302    }
303    munmap(mappedAddr, handle->size);
304    Region region{nullptr, PARAM_0};
305    OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
306    int backInfo = OH_NativeImage_UpdateSurfaceImage(image);
307    OH_NativeImage_GetTimestamp(image);
308    float matrix[16];
309    OH_NativeImage_GetTransformMatrix(image, matrix);
310    OH_NativeWindow_DestroyNativeWindow(nativeWindow);
311    OH_NativeImage_DetachContext(image);
312    GLuint textureId2;
313    glGenTextures(PARAM_1, &textureId2);
314    OH_NativeImage_AttachContext(image, textureId2);
315    OH_NativeImage_Destroy(&image);
316    napi_value result = nullptr;
317    napi_create_int32(env, backInfo, &result);
318    return result;
319}
320
321static napi_value OHNativeImageUpdateSurfaceImageBoundary(napi_env env, napi_callback_info info)
322{
323    InitEGLEnv();
324    GLuint textureId;
325    glGenTextures(PARAM_1, &textureId);
326    OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
327    OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
328    int code = SET_BUFFER_GEOMETRY;
329    int32_t width = 4096;
330    int32_t height = 2160;
331    OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
332    OHNativeWindowBuffer *buffer = nullptr;
333    int fenceFd;
334    OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
335    BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
336    void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
337    static uint32_t value = 0x00;
338    value++;
339    uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
340    for (uint32_t x = PARAM_0; x < width; x++) {
341        for (uint32_t y = PARAM_0; y < height; y++) {
342            *pixel++ = value;
343        }
344    }
345    munmap(mappedAddr, handle->size);
346    Region region{nullptr, PARAM_0};
347    OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
348    int backInfo = OH_NativeImage_UpdateSurfaceImage(image);
349    OH_NativeImage_GetTimestamp(image);
350    float matrix[16];
351    OH_NativeImage_GetTransformMatrix(image, matrix);
352    OH_NativeWindow_DestroyNativeWindow(nativeWindow);
353    OH_NativeImage_DetachContext(image);
354    GLuint textureId2;
355    glGenTextures(PARAM_1, &textureId2);
356    OH_NativeImage_AttachContext(image, textureId2);
357    OH_NativeImage_Destroy(&image);
358    napi_value result = nullptr;
359    napi_create_int32(env, backInfo, &result);
360    return result;
361}
362
363static napi_value OHNativeImageUpdateSurfaceImageAbnormal(napi_env env, napi_callback_info info)
364{
365    int backInfo = OH_NativeImage_UpdateSurfaceImage(nullptr);
366    if (backInfo != SUCCESS) {
367        backInfo = FAIL;
368    }
369    napi_value result = nullptr;
370    napi_create_int32(env, backInfo, &result);
371    return result;
372}
373
374static napi_value OHNativeImageGetTimestamp(napi_env env, napi_callback_info info)
375{
376    int backInfo = FAIL;
377    OH_NativeImage *image = getNativeImage();
378    if (image != nullptr) {
379        backInfo = OH_NativeImage_GetTimestamp(image);
380        OH_NativeImage_Destroy(&image);
381    }
382    napi_value result = nullptr;
383    napi_create_int32(env, backInfo, &result);
384    return result;
385}
386
387static napi_value OHNativeImageGetTransformMatrix(napi_env env, napi_callback_info info)
388{
389    int backInfo = FAIL;
390    OH_NativeImage *image = getNativeImage();
391    if (image != nullptr) {
392        float matrix[NUMMAX];
393        backInfo = OH_NativeImage_GetTransformMatrix(image, matrix);
394        OH_NativeImage_Destroy(&image);
395    }
396    napi_value result = nullptr;
397    napi_create_int32(env, backInfo, &result);
398    return result;
399}
400
401static napi_value OHNativeImageGetTransformMatrixAbnormal(napi_env env, napi_callback_info info)
402{
403    int backInfo = FAIL;
404    float matrix[NUMMAX];
405    int ret = OH_NativeImage_GetTransformMatrix(nullptr, matrix);
406    if (ret != SUCCESS) {
407        backInfo = FAIL;
408    }
409
410    napi_value result = nullptr;
411    napi_create_int32(env, backInfo, &result);
412    return result;
413}
414
415static napi_value OHNativeImageDestroy(napi_env env, napi_callback_info info)
416{
417    int backInfo = FAIL;
418    OH_NativeImage *image = getNativeImage();
419    OH_NativeImage_Destroy(&image);
420    if (image == nullptr) {
421        backInfo = SUCCESS;
422    }
423
424    napi_value result = nullptr;
425    napi_create_int32(env, backInfo, &result);
426    return result;
427}
428
429static napi_value OHNativeImageCreateNormal(napi_env env, napi_callback_info info)
430{
431    int backInfo = FAIL;
432    OH_NativeImage *image = nullptr;
433    InitEGLEnv();
434    GLuint textureId;
435    glGenTextures(PARAM_1, &textureId);
436    GLuint textureTarget = GL_TEXTURE_2D;
437    image = OH_NativeImage_Create(textureId, textureTarget);
438    if (image != nullptr) {
439        backInfo = SUCCESS;
440    }
441    napi_value result = nullptr;
442    napi_create_int32(env, backInfo, &result);
443    OH_NativeImage_Destroy(&image);
444    return result;
445}
446
447static napi_value OHNativeImageCreateAbnormal(napi_env env, napi_callback_info info)
448{
449    int backInfo = FAIL;
450
451    OH_NativeImage *image = OH_NativeImage_Create(0, 1);
452    if (image != nullptr) {
453        backInfo = SUCCESS;
454    }
455    napi_value result = nullptr;
456    napi_create_int32(env, backInfo, &result);
457    OH_NativeImage_Destroy(&image);
458    return result;
459}
460
461static napi_value OHNativeImageDestroy1(napi_env env, napi_callback_info info)
462{
463    int backInfo = FAIL;
464    OH_NativeImage *image = nullptr;
465    GLenum nativeImageTexId_;
466    GLuint GL_TEXTURE_EXTERNAL_OES;
467    glGenTextures(1, &nativeImageTexId_);
468    glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
469    image = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
470    if (image != nullptr) {
471        OH_NativeImage_Destroy(&image);
472        if (image == nullptr) {
473            backInfo = SUCCESS;
474        }
475    }
476    napi_value result = nullptr;
477    napi_create_int32(env, backInfo, &result);
478    return result;
479}
480
481static napi_value OHNativeImageCreateMuch(napi_env env, napi_callback_info info)
482{
483    int backInfo = SUCCESS;
484    const int count = NUMBER_500;
485    OH_NativeImage *imageArray[500] = {nullptr};
486    for (int i = 0; i < count; ++i) {
487        GLuint GL_TEXTURE_EXTERNAL_OES;
488        glBindTexture(GL_TEXTURE_EXTERNAL_OES, 1);
489        imageArray[i] = OH_NativeImage_Create(1, GL_TEXTURE_EXTERNAL_OES);
490        if (imageArray[i] == nullptr) {
491            backInfo = FAIL;
492            break;
493        }
494    }
495
496    for (int i = 0; i < count; ++i) {
497        if (imageArray[i] != nullptr) {
498            OH_NativeImage_Destroy(&imageArray[i]); // 销毁单个图像
499            if (imageArray[i] != nullptr) {
500                backInfo = FAIL;
501                break;
502            }
503        }
504    }
505
506    napi_value result = nullptr;
507    if (backInfo == FAIL) {
508        napi_create_int32(env, backInfo, &result);
509    } else {
510        napi_create_int32(env, SUCCESS, &result);
511    }
512
513    return result;
514}
515
516static napi_value OHNativeImageAcquireNativeWindowNullptr(napi_env env, napi_callback_info info)
517{
518    OHNativeWindow *nativeWindow = nullptr;
519    nativeWindow = OH_NativeImage_AcquireNativeWindow(nullptr);
520    napi_value result = nullptr;
521    if (nativeWindow != nullptr) {
522        napi_create_int32(env, SUCCESS, &result);
523    } else {
524        napi_create_int32(env, FAIL, &result);
525    }
526    return result;
527}
528
529static napi_value OHNativeImageAcquireNativeWindowNormal(napi_env env, napi_callback_info info)
530{
531    int backInfo = FAIL;
532    OHNativeWindow *nativeWindow1 = nullptr;
533    OHNativeWindow *nativeWindow2 = nullptr;
534    OH_NativeImage *nativeImage = getNativeImage();
535    nativeWindow1 = OH_NativeImage_AcquireNativeWindow(nativeImage);
536    if (nativeWindow1 != nullptr) {
537        nativeWindow2 = OH_NativeImage_AcquireNativeWindow(nativeImage);
538        if (nativeWindow1 == nativeWindow2) {
539            backInfo = SUCCESS;
540        }
541    }
542
543    napi_value result = nullptr;
544    napi_create_int32(env, backInfo, &result);
545    OH_NativeImage_Destroy(&nativeImage);
546    return result;
547}
548
549static napi_value OHNativeImageAttachContextNullptr(napi_env env, napi_callback_info info)
550{
551    OH_NativeImage *nativeImage = getNativeImage();
552    InitEGLEnv();
553    GLuint textureId;
554    glGenTextures(PARAM_1, &textureId);
555    napi_value result = nullptr;
556    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
557    napi_value result1 = nullptr;
558    napi_value result2 = nullptr;
559    int res1 = OH_NativeImage_AttachContext(nullptr, textureId);
560    if (res1 != 0) {
561        napi_create_int32(env, FAIL, &result1);
562    } else {
563        napi_create_int32(env, SUCCESS, &result1);
564    }
565    napi_set_element(env, result, ARR_NUMBER_0, result1);
566
567    int res2 = OH_NativeImage_AttachContext(nativeImage, NULL);
568    if (res2 != 0) {
569        napi_create_int32(env, FAIL, &result2);
570    } else {
571        napi_create_int32(env, SUCCESS, &result2);
572    }
573    napi_set_element(env, result, ARR_NUMBER_1, result2);
574    OH_NativeImage_Destroy(&nativeImage);
575    return result;
576}
577
578static napi_value OHNativeImageDetachContextNullptr(napi_env env, napi_callback_info info)
579{
580    OH_NativeImage *nativeImage = getNativeImage();
581    InitEGLEnv();
582    GLuint textureId;
583    glGenTextures(PARAM_1, &textureId);
584    napi_value result = nullptr;
585    int res = OH_NativeImage_DetachContext(nullptr);
586    if (res != 0) {
587        napi_create_int32(env, FAIL, &result);
588    } else {
589        napi_create_int32(env, SUCCESS, &result);
590    }
591    OH_NativeImage_Destroy(&nativeImage);
592    return result;
593}
594
595static napi_value OHNativeImageAttachContextNormal(napi_env env, napi_callback_info info)
596{
597    OH_NativeImage *nativeImage = getNativeImage();
598    InitEGLEnv();
599    GLuint textureId;
600    glGenTextures(PARAM_1, &textureId);
601    napi_value result = nullptr;
602    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
603    napi_value result1 = nullptr;
604    napi_value result2 = nullptr;
605    int res1 = OH_NativeImage_AttachContext(nativeImage, textureId);
606    if (res1 == 0) {
607        napi_create_int32(env, SUCCESS, &result1);
608    } else {
609        napi_create_int32(env, FAIL, &result1);
610    }
611    napi_set_element(env, result, ARR_NUMBER_0, result1);
612
613    int res2 = OH_NativeImage_AttachContext(nativeImage, textureId);
614    if (res2 == 0) {
615        napi_create_int32(env, SUCCESS, &result2);
616    } else {
617        napi_create_int32(env, FAIL, &result2);
618    }
619    napi_set_element(env, result, ARR_NUMBER_1, result2);
620
621    OH_NativeImage_Destroy(&nativeImage);
622    return result;
623}
624
625static napi_value OHNativeImageDetachContextNormal(napi_env env, napi_callback_info info)
626{
627    OH_NativeImage *nativeImage = getNativeImage();
628    InitEGLEnv();
629    GLuint textureId;
630    glGenTextures(PARAM_1, &textureId);
631    napi_value result = nullptr;
632    napi_create_array_with_length(env, ARR_NUMBER_3, &result);
633    napi_value result1 = nullptr;
634    napi_value result2 = nullptr;
635    napi_value result3 = nullptr;
636    int res1 = OH_NativeImage_DetachContext(nativeImage);
637    if (res1 != 0) {
638        napi_create_int32(env, FAIL, &result1);
639    } else {
640        napi_create_int32(env, SUCCESS, &result1);
641    }
642    napi_set_element(env, result, ARR_NUMBER_0, result1);
643
644    int res2 = OH_NativeImage_AttachContext(nativeImage, textureId);
645    if (res2 == 0) {
646        napi_create_int32(env, SUCCESS, &result2);
647    } else {
648        napi_create_int32(env, FAIL, &result2);
649    }
650    napi_set_element(env, result, ARR_NUMBER_1, result2);
651
652    int res3 = OH_NativeImage_DetachContext(nativeImage);
653    if (res3 == 0) {
654        napi_create_int32(env, SUCCESS, &result3);
655    } else {
656        napi_create_int32(env, FAIL, &result3);
657    }
658    napi_set_element(env, result, ARR_NUMBER_2, result3);
659
660    OH_NativeImage_Destroy(&nativeImage);
661    return result;
662}
663
664static napi_value OHNativeImageGetSurfaceIdNullptr(napi_env env, napi_callback_info info)
665{
666    OH_NativeImage *nativeImage = getNativeImage();
667    napi_value result = nullptr;
668    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
669    napi_value result1 = nullptr;
670    napi_value result2 = nullptr;
671    uint64_t surfaceId = NUMBER_99999;
672    int res1 = OH_NativeImage_GetSurfaceId(nullptr, &surfaceId);
673    if (res1 != 0 && surfaceId == NUMBER_99999) {
674        napi_create_int32(env, FAIL, &result1);
675    } else {
676        napi_create_int32(env, SUCCESS, &result1);
677    }
678    napi_set_element(env, result, ARR_NUMBER_0, result1);
679
680    int res2 = OH_NativeImage_GetSurfaceId(nullptr, NULL);
681    if (res2 != 0 && surfaceId == NUMBER_99999) {
682        napi_create_int32(env, FAIL, &result2);
683    } else {
684        napi_create_int32(env, SUCCESS, &result2);
685    }
686    napi_set_element(env, result, ARR_NUMBER_1, result2);
687
688    OH_NativeImage_Destroy(&nativeImage);
689    return result;
690}
691
692static napi_value OHNativeGetSurfaceIdNormal(napi_env env, napi_callback_info info)
693{
694    OH_NativeImage *nativeImage = getNativeImage();
695    napi_value result = nullptr;
696    uint64_t surfaceId = NUMBER_99999;
697    int res = OH_NativeImage_GetSurfaceId(nativeImage, &surfaceId);
698    if (res == 0 && surfaceId != NUMBER_99999) {
699        napi_create_int32(env, SUCCESS, &result);
700    } else {
701        napi_create_int32(env, FAIL, &result);
702    }
703
704    return result;
705}
706
707static napi_value OHNativeImageUpdateSurfaceImageNullptr(napi_env env, napi_callback_info info)
708{
709    OH_NativeImage *nativeImage = getNativeImage();
710    napi_value result = nullptr;
711    int res = OH_NativeImage_UpdateSurfaceImage(nullptr);
712    if (res != 0) {
713        napi_create_int32(env, FAIL, &result);
714    } else {
715        napi_create_int32(env, SUCCESS, &result);
716    }
717    OH_NativeImage_Destroy(&nativeImage);
718    return result;
719}
720
721static napi_value OHNativeImageGetTimestampNullptr(napi_env env, napi_callback_info info)
722{
723    OH_NativeImage *nativeImage = getNativeImage();
724    napi_value result = nullptr;
725    int64_t timestamp = 0;
726    timestamp = OH_NativeImage_GetTimestamp(nullptr);
727    if (timestamp == 0) {
728        napi_create_int32(env, FAIL, &result);
729    } else {
730        napi_create_int32(env, SUCCESS, &result);
731    }
732    OH_NativeImage_Destroy(&nativeImage);
733    return result;
734}
735
736static napi_value OHNativeImageGetTransformMatrixNullptr(napi_env env, napi_callback_info info)
737{
738    OH_NativeImage *nativeImage = getNativeImage();
739    napi_value result = nullptr;
740    float matrix[16];
741    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
742    napi_value result1 = nullptr;
743    napi_value result2 = nullptr;
744    int res1 = OH_NativeImage_GetTransformMatrix(nullptr, matrix);
745    if (res1 == 0) {
746        napi_create_int32(env, SUCCESS, &result1);
747    } else {
748        napi_create_int32(env, FAIL, &result1);
749    }
750    napi_set_element(env, result, ARR_NUMBER_0, result1);
751
752    int res2 = OH_NativeImage_GetTransformMatrix(nativeImage, NULL);
753    if (res2 == 0) {
754        napi_create_int32(env, SUCCESS, &result2);
755    } else {
756        napi_create_int32(env, FAIL, &result2);
757    }
758    napi_set_element(env, result, ARR_NUMBER_1, result2);
759
760    OH_NativeImage_Destroy(&nativeImage);
761    return result;
762}
763
764static napi_value OHNativeImageGetTransformMatrixV2Nullptr(napi_env env, napi_callback_info info)
765{
766    OH_NativeImage *nativeImage = getNativeImage();
767    napi_value result = nullptr;
768    float matrix[16];
769    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
770    napi_value result1 = nullptr;
771    napi_value result2 = nullptr;
772    int res1 = OH_NativeImage_GetTransformMatrixV2(nullptr, matrix);
773    if (res1 == 0) {
774        napi_create_int32(env, SUCCESS, &result1);
775    } else {
776        napi_create_int32(env, FAIL, &result1);
777    }
778    napi_set_element(env, result, ARR_NUMBER_0, result1);
779
780    int res2 = OH_NativeImage_GetTransformMatrixV2(nativeImage, NULL);
781    if (res2 == 0) {
782        napi_create_int32(env, SUCCESS, &result2);
783    } else {
784        napi_create_int32(env, FAIL, &result2);
785    }
786    napi_set_element(env, result, ARR_NUMBER_1, result2);
787
788    OH_NativeImage_Destroy(&nativeImage);
789    return result;
790}
791
792static napi_value OHNativeImageUpdateSurfaceImageNormal(napi_env env, napi_callback_info info)
793{
794    OH_NativeImage *nativeImage = nullptr;
795    napi_value result = nullptr;
796    GLenum nativeImageTexId_;
797    GLuint GL_TEXTURE_EXTERNAL_OES;
798    glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
799    nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
800    int res = OH_NativeImage_UpdateSurfaceImage(nativeImage);
801    if (res == 0) {
802        napi_create_int32(env, SUCCESS, &result);
803    } else {
804        napi_create_int32(env, FAIL, &result);
805    }
806    OH_NativeImage_Destroy(&nativeImage);
807    return result;
808}
809
810static napi_value OHNativeImageGetTimestampNormal(napi_env env, napi_callback_info info)
811{
812    OH_NativeImage *nativeImage = nullptr;
813    napi_value result = nullptr;
814    napi_create_array_with_length(env, ARR_NUMBER_3, &result);
815    napi_value result1 = nullptr;
816    napi_value result2 = nullptr;
817    GLenum nativeImageTexId_;
818    GLuint GL_TEXTURE_EXTERNAL_OES;
819    glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
820    nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
821    int res = OH_NativeImage_UpdateSurfaceImage(nativeImage);
822
823    // 使用chrono获取当前时间点
824    auto now = std::chrono::system_clock::now();
825    // 将当前时间点转换为自1970年1月1日以来的毫秒数
826    auto duration = now.time_since_epoch();
827    auto current_timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
828    // 将chrono库获取的时间戳存储在int64_t类型的变量中
829    int64_t time = static_cast<int64_t>(current_timestamp);
830
831    int64_t timestamp = 0;
832    timestamp = OH_NativeImage_GetTimestamp(nativeImage);
833
834    if (res == 0) {
835        napi_create_int32(env, SUCCESS, &result1);
836    } else {
837        napi_create_int32(env, FAIL, &result1);
838    }
839    napi_set_element(env, result, ARR_NUMBER_0, result1);
840
841    if (timestamp == time) {
842        napi_create_int32(env, SUCCESS, &result2);
843    } else {
844        napi_create_int32(env, FAIL, &result2);
845    }
846    napi_set_element(env, result, ARR_NUMBER_1, result2);
847
848    napi_value result3 = nullptr;
849    int res1 = OH_NativeImage_UpdateSurfaceImage(nativeImage);
850
851    auto now1 = std::chrono::system_clock::now();
852    auto duration1 = now1.time_since_epoch();
853    auto current_timestamp1 = std::chrono::duration_cast<std::chrono::milliseconds>(duration1).count();
854    int64_t time1 = static_cast<int64_t>(current_timestamp);
855
856    int64_t timestamp1 = 0;
857    timestamp1 = OH_NativeImage_GetTimestamp(nativeImage);
858
859    if (res1 == 0 && current_timestamp1 == time1) {
860        napi_create_int32(env, SUCCESS, &result3);
861    } else {
862        napi_create_int32(env, FAIL, &result3);
863    }
864    napi_set_element(env, result, ARR_NUMBER_2, result3);
865
866    OH_NativeImage_Destroy(&nativeImage);
867    return result;
868}
869
870static napi_value OHNativeImageGetTransformMatrixNormal(napi_env env, napi_callback_info info)
871{
872    OH_NativeImage *nativeImage = nullptr;
873    GLenum nativeImageTexId_;
874    GLuint GL_TEXTURE_EXTERNAL_OES;
875    glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
876    nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
877    float matrix[16];
878    float matrixNull[16] = {};
879    napi_value result = nullptr;
880    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
881    napi_value result1 = nullptr;
882    napi_value result2 = nullptr;
883
884    int res1 = OH_NativeImage_UpdateSurfaceImage(nativeImage);
885    if (res1 == 0) {
886        napi_create_int32(env, SUCCESS, &result1);
887    } else {
888        napi_create_int32(env, FAIL, &result1);
889    }
890    napi_set_element(env, result, ARR_NUMBER_0, result1);
891
892    OH_NativeImage_GetTransformMatrix(nativeImage, matrix);
893    if (memcmp(matrix, matrixNull, sizeof(matrix)) == 0) {
894        napi_create_int32(env, FAIL, &result2);
895    } else {
896        napi_create_int32(env, SUCCESS, &result2);
897    }
898    napi_set_element(env, result, ARR_NUMBER_1, result2);
899
900    OH_NativeImage_Destroy(&nativeImage);
901    return result;
902}
903
904static napi_value OHNativeImageGetTransformMatrixV2Normal(napi_env env, napi_callback_info info)
905{
906    OH_NativeImage *nativeImage = nullptr;
907    GLenum nativeImageTexId_;
908    GLuint GL_TEXTURE_EXTERNAL_OES;
909    glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
910    nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
911    float matrixV2[16];
912    float matrixNull[16] = {};
913    napi_value result = nullptr;
914    napi_create_array_with_length(env, ARR_NUMBER_2, &result);
915    napi_value result1 = nullptr;
916    napi_value result2 = nullptr;
917
918    int res1 = OH_NativeImage_UpdateSurfaceImage(nativeImage);
919    if (res1 == 0) {
920        napi_create_int32(env, SUCCESS, &result1);
921    } else {
922        napi_create_int32(env, FAIL, &result1);
923    }
924    napi_set_element(env, result, ARR_NUMBER_0, result1);
925
926    OH_NativeImage_GetTransformMatrixV2(nativeImage, matrixV2);
927    if (memcmp(matrixV2, matrixNull, sizeof(matrixV2)) == 0) {
928        napi_create_int32(env, FAIL, &result2);
929    } else {
930        napi_create_int32(env, SUCCESS, &result2);
931    }
932    napi_set_element(env, result, ARR_NUMBER_1, result2);
933
934    OH_NativeImage_Destroy(&nativeImage);
935    return result;
936}
937
938static napi_value OHNativeImageSetOnFrameAvailableListenerNullptr(napi_env env, napi_callback_info info)
939{
940    class NativeImageAdaptor {
941    public:
942        ~NativeImageAdaptor();
943        static NativeImageAdaptor *GetInstance();
944        static void OnFrameAvailable(void *context);
945    };
946    OH_NativeImage *nativeImage = nullptr;
947    napi_value result = nullptr;
948    OH_OnFrameAvailableListener listener;
949    int res = OH_NativeImage_SetOnFrameAvailableListener(nullptr, listener);
950    if (res == 0) {
951        napi_create_int32(env, SUCCESS, &result);
952    } else {
953        napi_create_int32(env, FAIL, &result);
954    }
955    return result;
956}
957
958static napi_value OHNativeImageUnSetOnFrameAvailableListenerNullptr(napi_env env, napi_callback_info info)
959{
960    napi_value result = nullptr;
961    int res = OH_NativeImage_UnsetOnFrameAvailableListener(nullptr);
962    if (res == 0) {
963        napi_create_int32(env, SUCCESS, &result);
964    } else {
965        napi_create_int32(env, FAIL, &result);
966    }
967
968    return result;
969}
970
971static napi_value OHNativeImageSetOnFrameAvailableListenerNormal(napi_env env, napi_callback_info info)
972{
973    class NativeImageAdaptor {
974    public:
975        ~NativeImageAdaptor();
976        static NativeImageAdaptor *GetInstance();
977        static void OnFrameAvailable(void *context);
978    };
979
980    OH_NativeImage *nativeImage1 = getNativeImage();
981    OH_OnFrameAvailableListener listener1;
982    napi_value result = nullptr;
983    napi_create_array_with_length(env, ARR_NUMBER_4, &result);
984    napi_value result1 = nullptr;
985
986    int res1 = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener1);
987    if (res1 == 0) {
988        napi_create_int32(env, SUCCESS, &result1);
989    } else {
990        napi_create_int32(env, FAIL, &result1);
991    }
992    napi_set_element(env, result, ARR_NUMBER_0, result1);
993
994    napi_value result2 = nullptr;
995    int res2 = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener1);
996    if (res2 == 0) {
997        napi_create_int32(env, SUCCESS, &result2);
998    } else {
999        napi_create_int32(env, FAIL, &result2);
1000    }
1001    napi_set_element(env, result, ARR_NUMBER_1, result2);
1002
1003    OH_NativeImage *nativeImage2 = getNativeImage();
1004    OH_OnFrameAvailableListener listener2;
1005    napi_value result3 = nullptr;
1006    int res3 = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener2);
1007    if (res3 == 0) {
1008        napi_create_int32(env, SUCCESS, &result3);
1009    } else {
1010        napi_create_int32(env, FAIL, &result3);
1011    }
1012    napi_set_element(env, result, ARR_NUMBER_2, result3);
1013
1014    napi_value result4 = nullptr;
1015    int res4 = OH_NativeImage_SetOnFrameAvailableListener(nativeImage2, listener1);
1016    if (res4 == 0) {
1017        napi_create_int32(env, SUCCESS, &result4);
1018    } else {
1019        napi_create_int32(env, FAIL, &result4);
1020    }
1021    napi_set_element(env, result, ARR_NUMBER_3, result4);
1022    OH_NativeImage_Destroy(&nativeImage1);
1023    OH_NativeImage_Destroy(&nativeImage2);
1024    return result;
1025}
1026
1027static napi_value OHNativeImageUnsetOnFrameAvailableListenerNormal(napi_env env, napi_callback_info info)
1028{
1029    class NativeImageAdaptor {
1030    public:
1031        ~NativeImageAdaptor();
1032        static NativeImageAdaptor *GetInstance();
1033        static void OnFrameAvailable(void *context);
1034    };
1035
1036    OH_NativeImage *nativeImage1 = getNativeImage();
1037    OH_OnFrameAvailableListener listener1;
1038    napi_value result = nullptr;
1039    napi_create_array_with_length(env, ARR_NUMBER_3, &result);
1040    napi_value result1 = nullptr;
1041
1042    int res1 = OH_NativeImage_UnsetOnFrameAvailableListener(nativeImage1);
1043    if (res1 == 0) {
1044        napi_create_int32(env, SUCCESS, &result1);
1045    } else {
1046        napi_create_int32(env, FAIL, &result1);
1047    }
1048    napi_set_element(env, result, ARR_NUMBER_0, result1);
1049
1050    napi_value result2 = nullptr;
1051    int res2 = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener1);
1052    if (res2 == 0) {
1053        napi_create_int32(env, SUCCESS, &result2);
1054    } else {
1055        napi_create_int32(env, FAIL, &result2);
1056    }
1057    napi_set_element(env, result, ARR_NUMBER_1, result2);
1058
1059    napi_value result3 = nullptr;
1060    int res3 = OH_NativeImage_UnsetOnFrameAvailableListener(nativeImage1);
1061    if (res3 == 0) {
1062        napi_create_int32(env, SUCCESS, &result3);
1063    } else {
1064        napi_create_int32(env, FAIL, &result3);
1065    }
1066    napi_set_element(env, result, ARR_NUMBER_2, result3);
1067    OH_NativeImage_Destroy(&nativeImage1);
1068    return result;
1069}
1070
1071napi_value NativeImageInit(napi_env env, napi_value exports)
1072{
1073    napi_property_descriptor desc[] = {
1074        {"oHNativeImageCreate", nullptr, OHNativeImageCreate, nullptr, nullptr, nullptr, napi_default, nullptr},
1075        {"oHNativeImageAcquireNativeWindow", nullptr, OHNativeImageAcquireNativeWindow, nullptr, nullptr, nullptr,
1076         napi_default, nullptr},
1077        {"oHNativeImageAcquireNativeWindowAbnormal", nullptr, OHNativeImageAcquireNativeWindowAbnormal, nullptr,
1078         nullptr, nullptr, napi_default, nullptr},
1079        {"oHNativeImageAttachContext", nullptr, OHNativeImageAttachContext, nullptr, nullptr, nullptr, napi_default,
1080         nullptr},
1081        {"oHNativeImageAttachContextAbnormal", nullptr, OHNativeImageAttachContextAbnormal, nullptr, nullptr, nullptr,
1082         napi_default, nullptr},
1083        {"oHNativeImageDetachContext", nullptr, OHNativeImageDetachContext, nullptr, nullptr, nullptr, napi_default,
1084         nullptr},
1085        {"oHNativeImageDetachContextAbnormal", nullptr, OHNativeImageDetachContextAbnormal, nullptr, nullptr, nullptr,
1086         napi_default, nullptr},
1087        {"oHNativeImageUpdateSurfaceImage", nullptr, OHNativeImageUpdateSurfaceImage, nullptr, nullptr, nullptr,
1088         napi_default, nullptr},
1089        {"oHNativeImageUpdateSurfaceImageBoundary", nullptr, OHNativeImageUpdateSurfaceImageBoundary, nullptr,
1090         nullptr, nullptr, napi_default, nullptr},
1091        {"oHNativeImageUpdateSurfaceImageAbnormal", nullptr, OHNativeImageUpdateSurfaceImageAbnormal, nullptr, nullptr,
1092         nullptr, napi_default, nullptr},
1093        {"oHNativeImageGetTimestamp", nullptr, OHNativeImageGetTimestamp, nullptr, nullptr, nullptr, napi_default,
1094         nullptr},
1095        {"oHNativeImageGetTransformMatrix", nullptr, OHNativeImageGetTransformMatrix, nullptr, nullptr, nullptr,
1096         napi_default, nullptr},
1097        {"oHNativeImageGetTransformMatrixAbnormal", nullptr, OHNativeImageGetTransformMatrixAbnormal, nullptr, nullptr,
1098         nullptr, napi_default, nullptr},
1099        {"oHNativeImageDestroy", nullptr, OHNativeImageDestroy, nullptr, nullptr, nullptr, napi_default, nullptr},
1100        {"oHNativeImageCreateNormal", nullptr, OHNativeImageCreateNormal, nullptr, nullptr, nullptr, napi_default,
1101         nullptr},
1102        {"oHNativeImageCreateAbnormal", nullptr, OHNativeImageCreateAbnormal, nullptr, nullptr, nullptr, napi_default,
1103         nullptr},
1104        {"oHNativeImageDestroy1", nullptr, OHNativeImageDestroy1, nullptr, nullptr, nullptr, napi_default, nullptr},
1105        {"oHNativeImageCreateMuch", nullptr, OHNativeImageCreateMuch, nullptr, nullptr, nullptr, napi_default, nullptr},
1106    };
1107    napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
1108    return exports;
1109}
1110
1111EXTERN_C_START
1112static napi_value Init(napi_env env, napi_value exports)
1113{
1114    NativeImageInit(env, exports);
1115    napi_property_descriptor desc[] = {
1116        {"oHNativeImageAcquireNativeWindowNullptr", nullptr, OHNativeImageAcquireNativeWindowNullptr, nullptr, nullptr,
1117         nullptr, napi_default, nullptr},
1118        {"oHNativeImageAcquireNativeWindowNormal", nullptr, OHNativeImageAcquireNativeWindowNormal, nullptr, nullptr,
1119         nullptr, napi_default, nullptr},
1120        {"oHNativeImageAttachContextNullptr", nullptr, OHNativeImageAttachContextNullptr, nullptr, nullptr, nullptr,
1121         napi_default, nullptr},
1122        {"oHNativeImageDetachContextNullptr", nullptr, OHNativeImageDetachContextNullptr, nullptr, nullptr, nullptr,
1123         napi_default, nullptr},
1124        {"oHNativeImageAttachContextNormal", nullptr, OHNativeImageAttachContextNormal, nullptr, nullptr, nullptr,
1125         napi_default, nullptr},
1126        {"oHNativeImageDetachContextNormal", nullptr, OHNativeImageDetachContextNormal, nullptr, nullptr, nullptr,
1127         napi_default, nullptr},
1128        {"oHNativeImageGetSurfaceIdNullptr", nullptr, OHNativeImageGetSurfaceIdNullptr, nullptr, nullptr, nullptr,
1129         napi_default, nullptr},
1130        {"oHNativeGetSurfaceIdNormal", nullptr, OHNativeGetSurfaceIdNormal, nullptr, nullptr, nullptr, napi_default,
1131         nullptr},
1132        {"oHNativeImageUpdateSurfaceImageNullptr", nullptr, OHNativeImageUpdateSurfaceImageNullptr, nullptr, nullptr,
1133         nullptr, napi_default, nullptr},
1134        {"oHNativeImageGetTimestampNullptr", nullptr, OHNativeImageGetTimestampNullptr, nullptr, nullptr, nullptr,
1135         napi_default, nullptr},
1136        {"oHNativeImageGetTransformMatrixNullptr", nullptr, OHNativeImageGetTransformMatrixNullptr, nullptr, nullptr,
1137         nullptr, napi_default, nullptr},
1138        {"oHNativeImageGetTransformMatrixV2Nullptr", nullptr, OHNativeImageGetTransformMatrixV2Nullptr, nullptr,
1139         nullptr, nullptr, napi_default, nullptr},
1140        {"oHNativeImageUpdateSurfaceImageNormal", nullptr, OHNativeImageUpdateSurfaceImageNormal, nullptr, nullptr,
1141         nullptr, napi_default, nullptr},
1142        {"oHNativeImageGetTimestampNormal", nullptr, OHNativeImageGetTimestampNormal, nullptr, nullptr, nullptr,
1143         napi_default, nullptr},
1144        {"oHNativeImageGetTransformMatrixNormal", nullptr, OHNativeImageGetTransformMatrixNormal, nullptr, nullptr,
1145         nullptr, napi_default, nullptr},
1146        {"oHNativeImageGetTransformMatrixV2Normal", nullptr, OHNativeImageGetTransformMatrixV2Normal, nullptr, nullptr,
1147         nullptr, napi_default, nullptr},
1148        {"oHNativeImageSetOnFrameAvailableListenerNullptr", nullptr, OHNativeImageSetOnFrameAvailableListenerNullptr,
1149         nullptr, nullptr, nullptr, napi_default, nullptr},
1150        {"oHNativeImageUnSetOnFrameAvailableListenerNullptr", nullptr,
1151         OHNativeImageUnSetOnFrameAvailableListenerNullptr, nullptr, nullptr, nullptr, napi_default, nullptr},
1152        {"oHNativeImageSetOnFrameAvailableListenerNormal", nullptr, OHNativeImageSetOnFrameAvailableListenerNormal,
1153         nullptr, nullptr, nullptr, napi_default, nullptr},
1154        {"oHNativeImageUnsetOnFrameAvailableListenerNormal", nullptr, OHNativeImageUnsetOnFrameAvailableListenerNormal,
1155         nullptr, nullptr, nullptr, napi_default, nullptr},
1156    };
1157    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1158    return exports;
1159}
1160EXTERN_C_END
1161
1162static napi_module demoModule = {
1163    .nm_version = 1,
1164    .nm_flags = 0,
1165    .nm_filename = nullptr,
1166    .nm_register_func = Init,
1167    .nm_modname = "nativeimage",
1168    .nm_priv = ((void *)0),
1169    .reserved = {0},
1170};
1171
1172extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); };
1173