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// 17// Created on 2024/8/6. 18// 19// Node APIs are not fully supported. To solve the compilation error of the interface cannot be found, 20// please include "napi/native_api.h". 21#include "napi/native_api.h" 22#include <IPCKit/ipc_cparcel.h> 23#include <bits/alltypes.h> 24#include <GLES2/gl2.h> 25#include <multimedia/player_framework/native_avcodec_base.h> 26#include <native_image/native_image.h> 27#include <native_window/external_window.h> 28#include <native_buffer/native_buffer.h> 29 30 31#define SUCCESS 0 32#define FAIL (-1) 33 34#define CONSTANT_0 0 35#define CONSTANT_1 1 36#define CONSTANT_2 2 37#define CONSTANT_3 3 38#define CONSTANT_4 4 39#define CONSTANT_5 5 40#define CONSTANT_6 6 41#define CONSTANT_7 7 42#define CONSTANT_8 8 43 44#define CONSTANT_500 500 45#define CONSTANT_1000 1000 46#define CONSTANT_10000 10000 47 48#define CONSTANT_40001000 40001000 49#define CONSTANT_41207000 41207000 50#define CONSTANT_41208000 41208000 51#define CONSTANT_41210000 41210000 52 53#define CONSTANT_50002000 50002000 54#define CONSTANT_50102000 50102000 55 56#define CONSTANT_999999999 999999999 57#define CONSTANT_9999999999999999999 9999999999999999999 58 59struct result { 60 OH_NativeImage *image; 61 OHNativeWindow *nativeWindow; 62 int32_t width_; 63 int32_t height_; 64}; 65 66static result InitNativeWindow() 67{ 68 struct result result1; 69 GLuint textureId; 70 glGenTextures(1, &textureId); 71 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D); 72 result1.image = _image; 73 OHNativeWindow *_nativeWindow = OH_NativeImage_AcquireNativeWindow(_image); 74 result1.nativeWindow = _nativeWindow; 75 int code = SET_BUFFER_GEOMETRY; 76 result1.width_ = 0x100; 77 result1.height_ = 0x100; 78 int32_t ret = OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, code, result1.width_, result1.height_); 79 code = SET_USAGE; 80 int32_t usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA; 81 ret = OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, code, usage); 82 return result1; 83} 84 85static void DestroyNativeWindowImage(OH_NativeImage *image, OHNativeWindow *window) 86{ 87 OH_NativeImage_Destroy(&image); 88 OH_NativeWindow_DestroyNativeWindow(window); 89} 90 91napi_value testNativeWindowCreateNativeWindowNullptr(napi_env env, napi_callback_info info) 92{ 93 napi_value result = nullptr; 94 auto p = OH_NativeWindow_CreateNativeWindow(nullptr); 95 if (p == nullptr) { 96 napi_create_int32(env, SUCCESS, &result); 97 } else { 98 napi_create_int32(env, FAIL, &result); 99 } 100 return result; 101} 102 103napi_value testNativeWindowDestroyNativeWindowNullptr(napi_env env, napi_callback_info info) 104{ 105 napi_value result = nullptr; 106 OH_NativeWindow_DestroyNativeWindow(nullptr); 107 napi_create_int32(env, SUCCESS, &result); 108 return result; 109} 110 111napi_value testNativeWindowGetSurfaceIdNullptr(napi_env env, napi_callback_info info) 112{ 113 napi_value result = nullptr; 114 auto r = OH_NativeWindow_GetSurfaceId(nullptr, 0); 115 if (CONSTANT_40001000 == r) { 116 napi_create_int32(env, SUCCESS, &result); 117 } else { 118 napi_create_int32(env, FAIL, &result); 119 } 120 return result; 121} 122 123 124napi_value testNativeWindowCreateNativeWindowFromSurfaceIdNullptr(napi_env env, napi_callback_info info) 125{ 126 napi_value result = nullptr; 127 128 // 设置OH_NativeWindow_CreateNativeWindowFromSurfaceId()的surfaceId=nullptr，其他参数正常调用该接口 129 OHNativeWindow *nativeWindow = nullptr; 130 auto flag = OH_NativeWindow_CreateNativeWindowFromSurfaceId(0, &nativeWindow); 131 if (flag != CONSTANT_40001000) { 132 napi_create_int32(env, 1, &result); 133 return result; 134 } 135 136 GLuint textureId; 137 glGenTextures(1, &textureId); 138 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D); 139 auto _nativeWindow = OH_NativeImage_AcquireNativeWindow(_image); 140 uint64_t surfaceId; 141 OH_NativeWindow_GetSurfaceId(_nativeWindow, &surfaceId); 142 // 设置OH_NativeWindow_CreateNativeWindowFromSurfaceId()的window=nullptr,，其他参数正常调用该接口 143 flag = OH_NativeWindow_CreateNativeWindowFromSurfaceId(surfaceId, nullptr); 144 if (flag != CONSTANT_40001000) { 145 napi_create_int32(env, CONSTANT_2, &result); 146 return result; 147 } 148 OH_NativeImage_Destroy(&_image); 149 OH_NativeWindow_DestroyNativeWindow(_nativeWindow); 150 napi_create_int32(env, SUCCESS, &result); 151 return result; 152} 153 154 155napi_value testNativeWindowCreateNativeWindowFromSurfaceIdNormal(napi_env env, napi_callback_info info) 156{ 157 napi_value result = nullptr; 158 159 // 创建surface实例 获取id 160 GLuint textureId; 161 glGenTextures(1, &textureId); 162 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D); 163 auto _nativeWindow = OH_NativeImage_AcquireNativeWindow(_image); 164 uint64_t surfaceId; 165 OH_NativeWindow_GetSurfaceId(_nativeWindow, &surfaceId); 166 167 // 声明nativeWindow空指针为window 168 OHNativeWindow *nativeWindow = nullptr; 169 auto flag = OH_NativeWindow_CreateNativeWindowFromSurfaceId(surfaceId, &nativeWindow); 170 // 接口执行成功，返回错误码0 | 声明的window指针指向NativeWindow实例 171 if (flag != 0 || nativeWindow == nullptr) { 172 napi_create_int32(env, 1, &result); 173 return result; 174 } 175 176 // 声明一个surfaceId2 177 uint64_t surfaceId2; 178 flag = OH_NativeWindow_GetSurfaceId(nativeWindow, &surfaceId2); 179 // 接口调用成功，返回错误码0 | get获取surfaceId2与surfaceId一致 180 if (flag != 0 || surfaceId2 != surfaceId) { 181 napi_create_int32(env, CONSTANT_2, &result); 182 return result; 183 } 184 185 OH_NativeImage_Destroy(&_image); 186 OH_NativeWindow_DestroyNativeWindow(nativeWindow); 187 188 napi_create_int32(env, SUCCESS, &result); 189 return result; 190} 191 192 193napi_value testNativeWindowCreateNativeWindowFromSurfaceIdSurfaceId(napi_env env, napi_callback_info info) 194{ 195 napi_value result = nullptr; 196 197 // 创建surface实例 获取一个正常的id 198 GLuint textureId; 199 glGenTextures(1, &textureId); 200 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D); 201 auto _nativeWindow = OH_NativeImage_AcquireNativeWindow(_image); 202 uint64_t surfaceId; 203 OH_NativeWindow_GetSurfaceId(_nativeWindow, &surfaceId); 204 205 // 调用该接口，查看执行结果 206 uint64_t ids[] = {0, 1, surfaceId, 0xFFFFFFFF}; 207 for (int i = 0; i < sizeof(ids) / sizeof(uint64_t); i += 1) { 208 uint64_t tmpId = ids[i]; 209 OHNativeWindow *nativeWindow = nullptr; 210 auto flag = OH_NativeWindow_CreateNativeWindowFromSurfaceId(tmpId, &nativeWindow); 211 // 只有样例3成功 212 if (i == CONSTANT_2) { 213 if (flag != SUCCESS) { 214 napi_create_int32(env, i + 1, &result); 215 return result; 216 } 217 } else { 218 OH_NativeWindow_DestroyNativeWindow(nativeWindow); 219 if (flag == SUCCESS) { 220 napi_create_int32(env, 1 + 1, &result); 221 return result; 222 } 223 } 224 } 225 OH_NativeImage_Destroy(&_image); 226 OH_NativeWindow_DestroyNativeWindow(_nativeWindow); 227 napi_create_int32(env, SUCCESS, &result); 228 return result; 229} 230 231 232napi_value testNativeWindowCreateNativeWindowBufferFromNativeBufferNullptr(napi_env env, napi_callback_info info) 233{ 234 napi_value result = nullptr; 235 auto buffer = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(nullptr); 236 if (buffer == nullptr) { 237 napi_create_int32(env, SUCCESS, &result); 238 } else { 239 napi_create_int32(env, FAIL, &result); 240 } 241 return result; 242} 243 244 245napi_value testNativeWindowCreateNativeWindowBufferFromSurfaceBufferNullptr(napi_env env, napi_callback_info info) 246{ 247 napi_value result = nullptr; 248 auto buffer = OH_NativeWindow_CreateNativeWindowBufferFromSurfaceBuffer(nullptr); 249 if (buffer == nullptr) { 250 napi_create_int32(env, SUCCESS, &result); 251 } else { 252 napi_create_int32(env, FAIL, &result); 253 } 254 return result; 255} 256 257 258napi_value testNativeWindowDestroyNativeWindowBufferNullptr(napi_env env, napi_callback_info info) 259{ 260 napi_value result = nullptr; 261 OH_NativeWindow_DestroyNativeWindowBuffer(nullptr); 262 napi_create_int32(env, SUCCESS, &result); 263 return result; 264} 265 266napi_value testNativeWindowGetBufferHandleFromNativeNullptr(napi_env env, napi_callback_info info) 267{ 268 napi_value result = nullptr; 269 auto ptr = OH_NativeWindow_GetBufferHandleFromNative(nullptr); 270 if (ptr == nullptr) { 271 napi_create_int32(env, SUCCESS, &result); 272 } else { 273 napi_create_int32(env, FAIL, &result); 274 } 275 napi_create_int32(env, SUCCESS, &result); 276 return result; 277} 278 279 280napi_value testNativeWindowCreateNativeWindowBufferFromNativeBufferNormal(napi_env env, napi_callback_info info) 281{ 282 napi_value result = nullptr; 283 284 // 0. 创建 native buffer 实例 285 OH_NativeBuffer_Config config{ 286 .width = 0x100, 287 .height = 0x100, 288 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 289 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA, 290 }; 291 OH_NativeBuffer *buffer = OH_NativeBuffer_Alloc(&config); 292 if (buffer == nullptr) { 293 napi_create_int32(env, -1, &result); 294 return result; 295 } 296 297 // 1. 298 auto nativeWindowBuffer = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(buffer); 299 // 接口执行成功，返回非空指针 300 if (nativeWindowBuffer == nullptr) { 301 napi_create_int32(env, CONSTANT_1, &result); 302 return result; 303 } 304 305 // 2. 306 auto bufferHandle = OH_NativeWindow_GetBufferHandleFromNative(nativeWindowBuffer); 307 if (bufferHandle == nullptr) { 308 napi_create_int32(env, CONSTANT_2, &result); 309 return result; 310 } 311 312 // 3. 313 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 314 315 // 4. 316 bufferHandle = OH_NativeWindow_GetBufferHandleFromNative(nativeWindowBuffer); 317 if (bufferHandle != nullptr) { 318 napi_create_int32(env, CONSTANT_4, &result); 319 return result; 320 } 321 322 napi_create_int32(env, SUCCESS, &result); 323 return result; 324} 325 326 327napi_value testNativeWindowCreateNativeWindowBufferFromNativeBufferMuch(napi_env env, napi_callback_info info) 328{ 329 napi_value result = nullptr; 330 331 // 0. 创建 native buffer 实例 332 OH_NativeBuffer_Config config{ 333 .width = 0x100, 334 .height = 0x100, 335 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 336 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA, 337 }; 338 OH_NativeBuffer *buffer = OH_NativeBuffer_Alloc(&config); 339 if (buffer == nullptr) { 340 napi_create_int32(env, -1, &result); 341 return result; 342 } 343 344 for (int i = 0; i < CONSTANT_500; i += 1) { 345 auto ptr = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(buffer); 346 if (ptr == nullptr) { 347 napi_create_int32(env, i + 1, &result); 348 return result; 349 } 350 } 351 352 napi_create_int32(env, SUCCESS, &result); 353 return result; 354} 355 356 357napi_value testNativeWindowNativeWindowRequestBufferNullptr(napi_env env, napi_callback_info info) 358{ 359 napi_value result = nullptr; 360 361 OHNativeWindowBuffer *oHNativeWindowBuffer; 362 int fenceFd; 363 364 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nullptr, &oHNativeWindowBuffer, &fenceFd); 365 if (flag != CONSTANT_40001000) { 366 napi_create_int32(env, FAIL, &result); 367 return result; 368 } 369 370 napi_create_int32(env, SUCCESS, &result); 371 return result; 372} 373 374 375napi_value testNativeWindowNativeWindowAbortBufferNullptr(napi_env env, napi_callback_info info) 376{ 377 napi_value result = nullptr; 378 379 // 0. 创建 native window 实例 380 struct result result1 = InitNativeWindow(); 381 OH_NativeImage *image = result1.image; 382 OHNativeWindow *nativeWindow = result1.nativeWindow; 383 OHNativeWindowBuffer *oHNativeWindowBuffer; 384 385 // 1. window 为空指针 386 auto flag = OH_NativeWindow_NativeWindowAbortBuffer(nullptr, oHNativeWindowBuffer); 387 if (flag != CONSTANT_40001000) { 388 napi_create_int32(env, 1, &result); 389 return result; 390 } 391 392 // 2. buffer 为空指针 393 flag = OH_NativeWindow_NativeWindowAbortBuffer(nativeWindow, nullptr); 394 if (flag != CONSTANT_40001000) { 395 napi_create_int32(env, CONSTANT_2, &result); 396 return result; 397 } 398 DestroyNativeWindowImage(image, nativeWindow); 399 napi_create_int32(env, SUCCESS, &result); 400 return result; 401} 402 403napi_value testNativeWindowNativeWindowRequestAbortBufferNormal(napi_env env, napi_callback_info info) 404{ 405 napi_value result = nullptr; 406 407 // 0. 创建 native window 实例 408 struct result result1 = InitNativeWindow(); 409 OH_NativeImage *image = result1.image; 410 OHNativeWindow *nativeWindow = result1.nativeWindow; 411 412 // 0. 新建 native window buffer 指针 413 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 414 415 // 1. 416 int fenceFd = -1; 417 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 418 if (flag != 0 || nativeWindowBuffer == nullptr) { 419 napi_create_int32(env, 1, &result); 420 return result; 421 } 422 423 // 2. 424 flag = OH_NativeWindow_NativeWindowAbortBuffer(nativeWindow, nativeWindowBuffer); 425 if (flag != 0) { 426 napi_create_int32(env, CONSTANT_2, &result); 427 return result; 428 } 429 DestroyNativeWindowImage(image, nativeWindow); 430 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 431 napi_create_int32(env, SUCCESS, &result); 432 return result; 433} 434 435napi_value testNativeWindowNativeWindowRequestAbortBufferAbnormal(napi_env env, napi_callback_info info) 436{ 437 napi_value result = nullptr; 438 439 // 0. 创建 native window 实例 440 struct result result1 = InitNativeWindow(); 441 OH_NativeImage *image = result1.image; 442 OHNativeWindow *nativeWindow = result1.nativeWindow; 443 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 444 445 // 1. 446 int fenceFd = 0; 447 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 448 if (flag != 0 || nativeWindowBuffer == nullptr) { 449 napi_create_int32(env, 1, &result); 450 return result; 451 } 452 453 // 2. 454 flag = OH_NativeWindow_NativeWindowAbortBuffer(nativeWindow, nativeWindowBuffer); 455 if (flag != 0) { 456 napi_create_int32(env, CONSTANT_2, &result); 457 return result; 458 } 459 460 // 3. 461 flag = OH_NativeWindow_NativeWindowAbortBuffer(nativeWindow, nativeWindowBuffer); 462 if (flag == 0) { 463 napi_create_int32(env, CONSTANT_3, &result); 464 } 465 DestroyNativeWindowImage(image, nativeWindow); 466 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 467 napi_create_int32(env, SUCCESS, &result); 468 return result; 469} 470 471 472napi_value testNativeWindowNativeWindowRequestBufferFenceFdNormal(napi_env env, napi_callback_info info) 473{ 474 napi_value result = nullptr; 475 476 // 0. 创建 native window 实例 477 struct result result1 = InitNativeWindow(); 478 OH_NativeImage *image = result1.image; 479 OHNativeWindow *nativeWindow = result1.nativeWindow; 480 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 481 482 int32_t ls[] = {-CONSTANT_5, -CONSTANT_1, CONSTANT_0, CONSTANT_1, CONSTANT_10000, CONSTANT_999999999}; 483 for (int i = 0; i < sizeof(ls) / sizeof(int); i += 1) { 484 int fenceFd = ls[i]; 485 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 486 if (flag != 0) { 487 napi_create_int32(env, 1, &result); 488 return result; 489 } 490 flag = OH_NativeWindow_NativeWindowAbortBuffer(nativeWindow, nativeWindowBuffer); 491 if (flag != 0) { 492 napi_create_int32(env, CONSTANT_2, &result); 493 return result; 494 } 495 } 496 DestroyNativeWindowImage(image, nativeWindow); 497 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 498 napi_create_int32(env, SUCCESS, &result); 499 return result; 500} 501 502 503napi_value testNativeWindowNativeWindowRequestBufferFenceFdAbnormal(napi_env env, napi_callback_info info) 504{ 505 napi_value result = nullptr; 506 507 // 0. 创建 native window 实例 508 struct result result1 = InitNativeWindow(); 509 OH_NativeImage *image = result1.image; 510 OHNativeWindow *nativeWindow = result1.nativeWindow; 511 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 512 513 int32_t *fenceFd1 = NULL; 514 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, fenceFd1); 515 if (flag == 0) { 516 napi_create_int32(env, 1, &result); 517 return result; 518 } 519 520 int32_t *fenceFd2 = nullptr; 521 flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, fenceFd2); 522 if (flag == 0) { 523 napi_create_int32(env, 1, &result); 524 return result; 525 } 526 DestroyNativeWindowImage(image, nativeWindow); 527 napi_create_int32(env, SUCCESS, &result); 528 return result; 529} 530 531 532napi_value testNativeWindowNativeWindowRequestAbortBufferMax(napi_env env, napi_callback_info info) 533{ 534 napi_value result = nullptr; 535 536 // 0. 创建 native window 实例 537 struct result result1 = InitNativeWindow(); 538 OH_NativeImage *image = result1.image; 539 OHNativeWindow *nativeWindow = result1.nativeWindow; 540 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 541 542 for (int i = 0; i < CONSTANT_4; ++i) { 543 int fenceFd = -1; 544 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 545 if (i >= CONSTANT_3) { 546 if (flag == 0) { 547 napi_create_int32(env, FAIL, &result); 548 return result; 549 } 550 } else { 551 if (flag != 0) { 552 napi_create_int32(env, i + 1, &result); 553 return result; 554 } 555 } 556 } 557 DestroyNativeWindowImage(image, nativeWindow); 558 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 559 napi_create_int32(env, SUCCESS, &result); 560 return result; 561} 562 563 564napi_value testNativeWindowNativeWindowRequestAbortBufferErrorCode(napi_env env, napi_callback_info info) 565{ 566 napi_value result = nullptr; 567 struct result result1 = InitNativeWindow(); 568 OH_NativeImage *image = result1.image; 569 OHNativeWindow *nativeWindow = result1.nativeWindow; 570 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 571 int requestFenceFd; 572 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &requestFenceFd); 573 if (flag != 0) { 574 napi_create_int32(env, 1, &result); 575 return result; 576 } 577 if (nativeWindowBuffer == nullptr || requestFenceFd != -1) { 578 napi_create_int32(env, CONSTANT_2, &result); 579 return result; 580 } 581 Region::Rect rect{ 582 .x = 0x100, 583 .y = 0x100, 584 .w = 0x100, 585 .h = 0x100, 586 }; 587 Region region{.rects = &rect}; 588 flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, requestFenceFd, region); 589 if (flag != 0) { 590 napi_create_int32(env, CONSTANT_3, &result); 591 return result; 592 } 593 flag = OH_NativeWindow_NativeWindowAbortBuffer(nativeWindow, nativeWindowBuffer); 594 if (flag == 0) { 595 napi_create_int32(env, CONSTANT_4, &result); 596 } 597 598 DestroyNativeWindowImage(image, nativeWindow); 599 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 600 napi_create_int32(env, SUCCESS, &result); 601 return result; 602} 603 604 605napi_value testNativeWindowWriteToParcelErrptr(napi_env env, napi_callback_info info) 606{ 607 napi_value result = nullptr; 608 609 // 0. 创建 native window 实例 610 struct result result1 = InitNativeWindow(); 611 OH_NativeImage *image = result1.image; 612 OHNativeWindow *nativeWindow = result1.nativeWindow; 613 // 0. 已存在OHIPCParcel 614 OHIPCParcel *parcel = OH_IPCParcel_Create(); 615 616 // 1. 617 auto flag = OH_NativeWindow_WriteToParcel(nullptr, parcel); 618 if (flag != CONSTANT_40001000) { 619 napi_create_int32(env, 1, &result); 620 return result; 621 } 622 623 // 2. 624 flag = OH_NativeWindow_WriteToParcel(nativeWindow, nullptr); 625 if (flag != CONSTANT_40001000) { 626 napi_create_int32(env, CONSTANT_2, &result); 627 return result; 628 } 629 DestroyNativeWindowImage(image, nativeWindow); 630 napi_create_int32(env, SUCCESS, &result); 631 return result; 632} 633 634 635napi_value testNativeWindowReadFromParcelErrptr(napi_env env, napi_callback_info info) 636{ 637 napi_value result = nullptr; 638 639 OHNativeWindow *nativeWindow = nullptr; 640 // 0. 已存在OHIPCParcel 641 OHIPCParcel *parcel = OH_IPCParcel_Create(); 642 643 // 1. 644 auto flag = OH_NativeWindow_ReadFromParcel(parcel, nullptr); 645 if (flag != CONSTANT_40001000) { 646 napi_create_int32(env, 1, &result); 647 return result; 648 } 649 650 // 2. 651 flag = OH_NativeWindow_ReadFromParcel(nullptr, &nativeWindow); 652 if (flag != CONSTANT_40001000) { 653 napi_create_int32(env, CONSTANT_2, &result); 654 return result; 655 } 656 657 napi_create_int32(env, SUCCESS, &result); 658 return result; 659} 660 661napi_value testNativeWindowWRParcelNormal(napi_env env, napi_callback_info info) 662{ 663 napi_value result = nullptr; 664 665 // 0. 创建 native window 实例 666 GLuint textureId; 667 glGenTextures(1, &textureId); 668 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D); 669 auto nativeWindow1 = OH_NativeImage_AcquireNativeWindow(_image); 670 // 0. 已存在OHIPCParcel 671 OHIPCParcel *parcel1 = OH_IPCParcel_Create(); 672 673 auto flag = OH_NativeWindow_WriteToParcel(nativeWindow1, parcel1); 674 if (flag != 0) { 675 napi_create_int32(env, CONSTANT_1, &result); 676 return result; 677 } 678 OHNativeWindow *nativeWindow2; 679 flag = OH_NativeWindow_ReadFromParcel(parcel1, &nativeWindow2); 680 if (flag != 0) { 681 napi_create_int32(env, CONSTANT_2, &result); 682 return result; 683 } 684 if (nativeWindow1 != nativeWindow2) { 685 napi_create_int32(env, CONSTANT_3, &result); 686 return result; 687 } 688 689 OH_NativeImage_Destroy(&_image); 690 OH_NativeWindow_DestroyNativeWindow(nativeWindow1); 691 OH_NativeWindow_DestroyNativeWindow(nativeWindow2); 692 napi_create_int32(env, SUCCESS, &result); 693 return result; 694} 695 696 697napi_value testNativeWindowWriteToParcelAbNormal(napi_env env, napi_callback_info info) 698{ 699 napi_value result = nullptr; 700 701 // 0. 702 GLuint textureId; 703 glGenTextures(1, &textureId); 704 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D); 705 OHNativeWindow *window1 = nullptr; 706 OHIPCParcel *parcel1 = OH_IPCParcel_Create(); 707 708 // 1. 709 auto flag = OH_NativeWindow_ReadFromParcel(parcel1, &window1); 710 if (window1 != nullptr) { 711 napi_create_int32(env, CONSTANT_1, &result); 712 return result; 713 } 714 OH_NativeImage_Destroy(&_image); 715 OH_NativeWindow_DestroyNativeWindow(window1); 716 napi_create_int32(env, SUCCESS, &result); 717 return result; 718} 719 720napi_value testNativeWindowReadFromParcelAbNormal(napi_env env, napi_callback_info info) 721{ 722 napi_value result = nullptr; 723 724 // 0. 725 struct result result1 = InitNativeWindow(); 726 OH_NativeImage *image = result1.image; 727 OHNativeWindow *window1 = result1.nativeWindow; 728 OHIPCParcel *parcel1 = OH_IPCParcel_Create(); 729 730 // 1. 731 auto flag = OH_NativeWindow_WriteToParcel(window1, parcel1); 732 if (flag != 0) { 733 napi_create_int32(env, CONSTANT_1, &result); 734 return result; 735 } 736 737 // 2. 738 flag = OH_NativeWindow_WriteToParcel(window1, parcel1); 739 if (flag != 0) { 740 napi_create_int32(env, CONSTANT_2, &result); 741 return result; 742 } 743 DestroyNativeWindowImage(image, window1); 744 napi_create_int32(env, SUCCESS, &result); 745 return result; 746} 747 748napi_value testNativeWindowWRParcelDifferent(napi_env env, napi_callback_info info) 749{ 750 napi_value result = nullptr; 751 struct result result1, result2; 752 result1 = InitNativeWindow(); 753 result2 = InitNativeWindow(); 754 OH_NativeImage *image1 = result1.image; 755 OHNativeWindow *window1 = result1.nativeWindow; 756 OH_NativeImage *image2 = result2.image; 757 OHNativeWindow *window2 = result2.nativeWindow; 758 OHIPCParcel *parcel1 = OH_IPCParcel_Create(); 759 OHIPCParcel *parcel2 = OH_IPCParcel_Create(); 760 761 // 1. 762 auto flag = OH_NativeWindow_WriteToParcel(window1, parcel1); 763 if (flag != 0) { 764 napi_create_int32(env, CONSTANT_1, &result); 765 return result; 766 } 767 // 2. 768 flag = OH_NativeWindow_WriteToParcel(window1, parcel2); 769 if (flag != 0) { 770 napi_create_int32(env, CONSTANT_2, &result); 771 return result; 772 } 773 // 3. 774 flag = OH_NativeWindow_WriteToParcel(window2, parcel1); 775 if (flag != 0) { 776 napi_create_int32(env, CONSTANT_3, &result); 777 return result; 778 } 779 DestroyNativeWindowImage(image1, window1); 780 DestroyNativeWindowImage(image2, window2); 781 napi_create_int32(env, SUCCESS, &result); 782 return result; 783} 784 785 786napi_value testNativeWindowNativeWindowFlushBufferNullptr(napi_env env, napi_callback_info info) 787{ 788 napi_value result = nullptr; 789 790 // 0. 791 struct result result1 = InitNativeWindow(); 792 OH_NativeImage *image = result1.image; 793 OHNativeWindow *nativeWindow = result1.nativeWindow; 794 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 795 int fenceFd = -1; 796 Region::Rect rect{ 797 .x = 0x100, 798 .y = 0x100, 799 .w = 0x100, 800 .h = 0x100, 801 }; 802 Region region{.rects = &rect}; 803 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 804 805 // 1. 806 auto flag = OH_NativeWindow_NativeWindowFlushBuffer(nullptr, nativeWindowBuffer, fenceFd, region); 807 if (flag != CONSTANT_40001000) { 808 napi_create_int32(env, 1, &result); 809 return result; 810 } 811 // 2. 812 flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nullptr, fenceFd, region); 813 if (flag != CONSTANT_40001000) { 814 napi_create_int32(env, CONSTANT_2, &result); 815 return result; 816 } 817 DestroyNativeWindowImage(image, nativeWindow); 818 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 819 napi_create_int32(env, SUCCESS, &result); 820 return result; 821} 822 823 824napi_value testNativeWindowNativeWindowFlushBufferNormal(napi_env env, napi_callback_info info) 825{ 826 napi_value result = nullptr; 827 828 // 0. 829 struct result result1 = InitNativeWindow(); 830 OH_NativeImage *image = result1.image; 831 OHNativeWindow *nativeWindow = result1.nativeWindow; 832 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 833 int fenceFd = -1; 834 Region::Rect rect{ 835 .x = 0x100, 836 .y = 0x100, 837 .w = 0x100, 838 .h = 0x100, 839 }; 840 Region region{.rects = &rect}; 841 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 842 843 // 1. 844 auto flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region); 845 if (flag != 0) { 846 napi_create_int32(env, CONSTANT_1, &result); 847 return result; 848 } 849 850 // 2. 851 flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region); 852 if (flag != CONSTANT_41207000) { 853 napi_create_int32(env, CONSTANT_2, &result); 854 return result; 855 } 856 857 DestroyNativeWindowImage(image, nativeWindow); 858 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 859 napi_create_int32(env, SUCCESS, &result); 860 return result; 861} 862 863napi_value testNativeWindowNativeWindowFlushBufferAbnormal(napi_env env, napi_callback_info info) 864{ 865 napi_value result = nullptr; 866 // 1. 867 int fenceFdList[] = {-CONSTANT_999999999, -CONSTANT_1000, -CONSTANT_1, CONSTANT_0, 868 CONSTANT_1, CONSTANT_1000, CONSTANT_999999999}; 869 for (int i = 0; i < sizeof(fenceFdList) / sizeof(int); ++i) { 870 struct result result1 = InitNativeWindow(); 871 OH_NativeImage *image = result1.image; 872 OHNativeWindow *nativeWindow = result1.nativeWindow; 873 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 874 int fenceFd = -1; 875 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 876 Region::Rect rect{ 877 .x = 0x100, 878 .y = 0x100, 879 .w = 0x100, 880 .h = 0x100, 881 }; 882 Region region{.rects = &rect}; 883 auto flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFdList[i], region); 884 if (flag != 0) { 885 napi_create_int32(env, i + 1, &result); 886 return result; 887 } 888 889 DestroyNativeWindowImage(image, nativeWindow); 890 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 891 napi_create_int32(env, SUCCESS, &result); 892 } 893 return result; 894} 895 896napi_value testNativeWindowNativeWindowFlushBufferErrorCode(napi_env env, napi_callback_info info) 897{ 898 napi_value result = nullptr; 899 struct result result1 = InitNativeWindow(); 900 OH_NativeImage *image = result1.image; 901 OHNativeWindow *nativeWindow = result1.nativeWindow; 902 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 903 int fenceFd = -1; 904 Region::Rect rect{ 905 .x = 0x100, 906 .y = 0x100, 907 .w = 0x100, 908 .h = 0x100, 909 }; 910 Region region{.rects = &rect}; 911 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 912 913 OH_NativeBuffer_Config config{ 914 .width = 0x100, 915 .height = 0x100, 916 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 917 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA, 918 }; 919 OH_NativeBuffer *newBuffer = OH_NativeBuffer_Alloc(&config); 920 nativeWindowBuffer = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(newBuffer); 921 922 // 1. 923 auto flag = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, -1, region); 924 if (flag != CONSTANT_41210000) { 925 napi_create_int32(env, FAIL, &result); 926 return result; 927 } 928 DestroyNativeWindowImage(image, nativeWindow); 929 OH_NativeBuffer_Unreference(newBuffer); 930 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 931 napi_create_int32(env, SUCCESS, &result); 932 return result; 933} 934 935 936napi_value testNativeWindowGetLastFlushedBufferV2Nullptr(napi_env env, napi_callback_info info) 937{ 938 napi_value result = nullptr; 939 struct result result1 = InitNativeWindow(); 940 OH_NativeImage *image = result1.image; 941 OHNativeWindow *nativeWindow = result1.nativeWindow; 942 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 943 int fenceFd; 944 float matrix[16]; 945 946 // 1. 947 auto flag = OH_NativeWindow_GetLastFlushedBufferV2(nullptr, &nativeWindowBuffer, &fenceFd, matrix); 948 if (flag != CONSTANT_40001000) { 949 napi_create_int32(env, CONSTANT_1, &result); 950 return result; 951 } 952 // 2. 953 flag = OH_NativeWindow_GetLastFlushedBufferV2(nativeWindow, nullptr, &fenceFd, matrix); 954 if (flag != CONSTANT_40001000) { 955 napi_create_int32(env, CONSTANT_2, &result); 956 return result; 957 } 958 DestroyNativeWindowImage(image, nativeWindow); 959 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 960 napi_create_int32(env, SUCCESS, &result); 961 return result; 962} 963 964 965napi_value testNativeWindowGetLastFlushedBufferNullptr(napi_env env, napi_callback_info info) 966{ 967 napi_value result = nullptr; 968 struct result result1 = InitNativeWindow(); 969 OH_NativeImage *image = result1.image; 970 OHNativeWindow *nativeWindow = result1.nativeWindow; 971 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 972 int fenceFd; 973 float matrix[16]; 974 975 // 1. 976 auto flag = OH_NativeWindow_GetLastFlushedBuffer(nullptr, &nativeWindowBuffer, &fenceFd, matrix); 977 if (flag != CONSTANT_40001000) { 978 napi_create_int32(env, 1, &result); 979 return result; 980 } 981 // 2. 982 flag = OH_NativeWindow_GetLastFlushedBuffer(nativeWindow, nullptr, &fenceFd, matrix); 983 if (flag != CONSTANT_40001000) { 984 napi_create_int32(env, CONSTANT_2, &result); 985 return result; 986 } 987 DestroyNativeWindowImage(image, nativeWindow); 988 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 989 napi_create_int32(env, SUCCESS, &result); 990 return result; 991} 992 993napi_value testNativeWindowGetLastFlushedBufferV2Normal(napi_env env, napi_callback_info info) 994{ 995 napi_value result = nullptr; 996 struct result result1 = InitNativeWindow(); 997 OH_NativeImage *image = result1.image; 998 OHNativeWindow *nativeWindow = result1.nativeWindow; 999 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1000 int fenceFd; 1001 float matrix[16]; 1002 Region::Rect rect{ 1003 .x = 0x100, 1004 .y = 0x100, 1005 .w = 0x100, 1006 .h = 0x100, 1007 }; 1008 Region region{.rects = &rect}; 1009 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1010 ret = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region); 1011 auto flag = OH_NativeWindow_GetLastFlushedBufferV2(nativeWindow, &nativeWindowBuffer, &fenceFd, matrix); 1012 if (flag != 0) { 1013 napi_create_int32(env, 1, &result); 1014 return result; 1015 } 1016 DestroyNativeWindowImage(image, nativeWindow); 1017 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1018 napi_create_int32(env, SUCCESS, &result); 1019 return result; 1020} 1021 1022napi_value testNativeWindowGetLastFlushedBufferNormal(napi_env env, napi_callback_info info) 1023{ 1024 napi_value result = nullptr; 1025 struct result result1 = InitNativeWindow(); 1026 OH_NativeImage *image = result1.image; 1027 OHNativeWindow *nativeWindow = result1.nativeWindow; 1028 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1029 int fenceFd; 1030 float matrix[16]; 1031 Region::Rect rect{ 1032 .x = 0x100, 1033 .y = 0x100, 1034 .w = 0x100, 1035 .h = 0x100, 1036 }; 1037 Region region{.rects = &rect}; 1038 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1039 ret = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region); 1040 auto flag = OH_NativeWindow_GetLastFlushedBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd, matrix); 1041 if (flag != 0) { 1042 napi_create_int32(env, 1, &result); 1043 return result; 1044 } 1045 DestroyNativeWindowImage(image, nativeWindow); 1046 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1047 napi_create_int32(env, SUCCESS, &result); 1048 return result; 1049} 1050 1051 1052napi_value testNativeWindowSetBufferHold(napi_env env, napi_callback_info info) 1053{ 1054 napi_value result = nullptr; 1055 struct result result1 = InitNativeWindow(); 1056 OH_NativeImage *image = result1.image; 1057 OHNativeWindow *nativeWindow = result1.nativeWindow; 1058 1059 OH_NativeWindow_SetBufferHold(nullptr); 1060 OH_NativeWindow_SetBufferHold(nativeWindow); 1061 1062 DestroyNativeWindowImage(image, nativeWindow); 1063 napi_create_int32(env, SUCCESS, &result); 1064 return result; 1065} 1066 1067napi_value testNativeWindowGetNativeObjectMagicNullptr(napi_env env, napi_callback_info info) 1068{ 1069 napi_value result = nullptr; 1070 auto flag = OH_NativeWindow_GetNativeObjectMagic(nullptr); 1071 if (flag != -1) { 1072 napi_create_int32(env, FAIL, &result); 1073 return result; 1074 } 1075 napi_create_int32(env, SUCCESS, &result); 1076 return result; 1077} 1078 1079napi_value testNativeWindowGetNativeObjectMagicNormal(napi_env env, napi_callback_info info) 1080{ 1081 napi_value result = nullptr; 1082 1083 struct result result1 = InitNativeWindow(); 1084 OH_NativeImage *image = result1.image; 1085 OHNativeWindow *nativeWindow = result1.nativeWindow; 1086 OHNativeWindowBuffer *nativeWindowBuffer; 1087 int fenceFd = -1; 1088 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1089 1090 auto magicId = OH_NativeWindow_GetNativeObjectMagic(nativeWindow); 1091 if (magicId == -1) { 1092 napi_create_int32(env, CONSTANT_1, &result); 1093 return result; 1094 } 1095 auto magicId2 = OH_NativeWindow_GetNativeObjectMagic(nativeWindow); 1096 if (magicId2 == -1) { 1097 napi_create_int32(env, CONSTANT_1, &result); 1098 return result; 1099 } 1100 if (magicId != magicId2) { 1101 napi_create_int32(env, CONSTANT_3, &result); 1102 return result; 1103 } 1104 auto magicId3 = OH_NativeWindow_GetNativeObjectMagic(nativeWindowBuffer); 1105 if (magicId3 == -1) { 1106 napi_create_int32(env, CONSTANT_2, &result); 1107 return result; 1108 } 1109 auto magicId4 = OH_NativeWindow_GetNativeObjectMagic(nativeWindowBuffer); 1110 if (magicId4 == -1) { 1111 napi_create_int32(env, CONSTANT_2, &result); 1112 return result; 1113 } 1114 1115 if (magicId3 != magicId4) { 1116 napi_create_int32(env, CONSTANT_3, &result); 1117 return result; 1118 } 1119 DestroyNativeWindowImage(image, nativeWindow); 1120 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1121 napi_create_int32(env, SUCCESS, &result); 1122 return result; 1123} 1124 1125napi_value testNativeWindowNativeObjectReferenceNullptr(napi_env env, napi_callback_info info) 1126{ 1127 napi_value result = nullptr; 1128 1129 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1130 1131 auto magicId = OH_NativeWindow_NativeObjectReference(nullptr); 1132 if (magicId != CONSTANT_40001000) { 1133 napi_create_int32(env, CONSTANT_1, &result); 1134 return result; 1135 } 1136 1137 magicId = OH_NativeWindow_NativeObjectReference(nativeWindowBuffer); 1138 if (magicId != CONSTANT_40001000) { 1139 napi_create_int32(env, CONSTANT_2, &result); 1140 return result; 1141 } 1142 1143 napi_create_int32(env, SUCCESS, &result); 1144 return result; 1145} 1146 1147 1148napi_value testNativeWindowNativeObjectReferenceNormal(napi_env env, napi_callback_info info) 1149{ 1150 napi_value result = nullptr; 1151 1152 struct result result1 = InitNativeWindow(); 1153 OH_NativeImage *image = result1.image; 1154 OHNativeWindow *nativeWindow = result1.nativeWindow; 1155 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1156 int fenceFd = -1; 1157 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1158 1159 auto magicId = OH_NativeWindow_NativeObjectReference(nativeWindow); 1160 if (magicId != 0) { 1161 napi_create_int32(env, CONSTANT_1, &result); 1162 return result; 1163 } 1164 1165 magicId = OH_NativeWindow_NativeObjectReference(nativeWindowBuffer); 1166 if (magicId != 0) { 1167 napi_create_int32(env, CONSTANT_2, &result); 1168 return result; 1169 } 1170 DestroyNativeWindowImage(image, nativeWindow); 1171 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1172 napi_create_int32(env, SUCCESS, &result); 1173 return result; 1174} 1175 1176napi_value testNativeWindowNativeObjectUnreferenceNullptr(napi_env env, napi_callback_info info) 1177{ 1178 napi_value result = nullptr; 1179 1180 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1181 1182 auto magicId = OH_NativeWindow_NativeObjectUnreference(nullptr); 1183 if (magicId != CONSTANT_40001000) { 1184 napi_create_int32(env, CONSTANT_1, &result); 1185 return result; 1186 } 1187 1188 magicId = OH_NativeWindow_NativeObjectUnreference(nativeWindowBuffer); 1189 if (magicId != CONSTANT_40001000) { 1190 napi_create_int32(env, CONSTANT_2, &result); 1191 return result; 1192 } 1193 1194 napi_create_int32(env, SUCCESS, &result); 1195 return result; 1196} 1197 1198napi_value testNativeWindowNativeObjectUnreferenceNormal(napi_env env, napi_callback_info info) 1199{ 1200 napi_value result = nullptr; 1201 1202 struct result result1 = InitNativeWindow(); 1203 OH_NativeImage *image = result1.image; 1204 OHNativeWindow *nativeWindow = result1.nativeWindow; 1205 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1206 int fenceFd = -1; 1207 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1208 1209 auto magicId = OH_NativeWindow_NativeObjectUnreference(nativeWindow); 1210 if (magicId != 0) { 1211 napi_create_int32(env, CONSTANT_1, &result); 1212 return result; 1213 } 1214 1215 magicId = OH_NativeWindow_NativeObjectUnreference(nativeWindowBuffer); 1216 if (magicId != 0) { 1217 napi_create_int32(env, CONSTANT_2, &result); 1218 return result; 1219 } 1220 DestroyNativeWindowImage(image, nativeWindow); 1221 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1222 napi_create_int32(env, SUCCESS, &result); 1223 return result; 1224} 1225 1226 1227napi_value testNativeWindowNativeWindowAttachBufferNullptr(napi_env env, napi_callback_info info) 1228{ 1229 napi_value result = nullptr; 1230 1231 struct result result1 = InitNativeWindow(); 1232 OH_NativeImage *image = result1.image; 1233 OHNativeWindow *nativeWindow = result1.nativeWindow; 1234 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1235 int fenceFd = -1; 1236 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1237 1238 auto flag = OH_NativeWindow_NativeWindowAttachBuffer(nullptr, nativeWindowBuffer); 1239 if (flag != CONSTANT_40001000) { 1240 napi_create_int32(env, CONSTANT_1, &result); 1241 return result; 1242 } 1243 1244 flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nullptr); 1245 if (flag != CONSTANT_40001000) { 1246 napi_create_int32(env, CONSTANT_1, &result); 1247 return result; 1248 } 1249 DestroyNativeWindowImage(image, nativeWindow); 1250 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1251 napi_create_int32(env, SUCCESS, &result); 1252 return result; 1253} 1254 1255napi_value testNativeWindowNativeWindowDetachBufferNullptr(napi_env env, napi_callback_info info) 1256{ 1257 napi_value result = nullptr; 1258 1259 struct result result1 = InitNativeWindow(); 1260 OH_NativeImage *image = result1.image; 1261 OHNativeWindow *nativeWindow = result1.nativeWindow; 1262 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1263 int fenceFd = -1; 1264 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1265 1266 auto flag = OH_NativeWindow_NativeWindowDetachBuffer(nullptr, nativeWindowBuffer); 1267 if (flag != CONSTANT_40001000) { 1268 napi_create_int32(env, CONSTANT_1, &result); 1269 return result; 1270 } 1271 1272 flag = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindow, nullptr); 1273 if (flag != CONSTANT_40001000) { 1274 napi_create_int32(env, CONSTANT_2, &result); 1275 return result; 1276 } 1277 DestroyNativeWindowImage(image, nativeWindow); 1278 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1279 napi_create_int32(env, SUCCESS, &result); 1280 return result; 1281} 1282 1283 1284napi_value testNativeWindowNativeWindowDetachBufferNormal(napi_env env, napi_callback_info info) 1285{ 1286 napi_value result = nullptr; 1287 1288 struct result result1 = InitNativeWindow(); 1289 OH_NativeImage *image = result1.image; 1290 OHNativeWindow *nativeWindow = result1.nativeWindow; 1291 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1292 int fenceFd = -1; 1293 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1294 if (flag != 0) { 1295 napi_create_int32(env, FAIL, &result); 1296 return result; 1297 } 1298 1299 flag = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindow, nativeWindowBuffer); 1300 if (flag != 0) { 1301 napi_create_int32(env, 1, &result); 1302 return result; 1303 } 1304 1305 flag = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindow, nativeWindowBuffer); 1306 if (flag != CONSTANT_41210000) { 1307 napi_create_int32(env, CONSTANT_2, &result); 1308 return result; 1309 } 1310 1311 DestroyNativeWindowImage(image, nativeWindow); 1312 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1313 1314 napi_create_int32(env, SUCCESS, &result); 1315 return result; 1316} 1317 1318 1319napi_value testNativeWindowNativeWindowAttachBufferErrorCode(napi_env env, napi_callback_info info) 1320{ 1321 napi_value result = nullptr; 1322 1323 struct result result1 = InitNativeWindow(); 1324 OH_NativeImage *image = result1.image; 1325 OHNativeWindow *nativeWindow = result1.nativeWindow; 1326 OHNativeWindowBuffer *nwb1, *nwb2, *nwb3, *nwb4; 1327 int fenceFd = -1; 1328 OH_NativeBuffer_Config config{ 1329 .width = 0x100, 1330 .height = 0x100, 1331 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 1332 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA, 1333 }; 1334 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&config); 1335 OHNativeWindowBuffer **arr[] = {&nwb1, &nwb2, &nwb3, &nwb4}; 1336 nwb1 = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(nativeBuffer); 1337 nwb2 = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(nativeBuffer); 1338 nwb3 = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(nativeBuffer); 1339 nwb4 = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(nativeBuffer); 1340 1341 auto flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nwb1); 1342 flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nwb2); 1343 flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nwb3); 1344 flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nwb4); 1345 DestroyNativeWindowImage(image, nativeWindow); 1346 OH_NativeBuffer_Unreference(nativeBuffer); 1347 napi_create_int32(env, SUCCESS, &result); 1348 return result; 1349} 1350 1351 1352napi_value testNativeWindowNativeWindowAttachBufferNormal(napi_env env, napi_callback_info info) 1353{ 1354 napi_value result = nullptr; 1355 1356 struct result result1 = InitNativeWindow(); 1357 OH_NativeImage *image = result1.image; 1358 OHNativeWindow *nativeWindow = result1.nativeWindow; 1359 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1360 int fenceFd = -1; 1361 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1362 if (flag != 0) { 1363 napi_create_int32(env, FAIL, &result); 1364 return result; 1365 } 1366 1367 flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nativeWindowBuffer); 1368 if (flag != CONSTANT_41208000) { 1369 napi_create_int32(env, CONSTANT_1, &result); 1370 return result; 1371 } 1372 1373 flag = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindow, nativeWindowBuffer); 1374 if (flag != 0) { 1375 napi_create_int32(env, CONSTANT_2, &result); 1376 return result; 1377 } 1378 1379 flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nativeWindowBuffer); 1380 if (flag != 0) { 1381 napi_create_int32(env, CONSTANT_3, &result); 1382 return result; 1383 } 1384 1385 DestroyNativeWindowImage(image, nativeWindow); 1386 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1387 1388 napi_create_int32(env, SUCCESS, &result); 1389 return result; 1390} 1391 1392 1393napi_value testNativeWindowNativeWindowDetachBufferErrorCode(napi_env env, napi_callback_info info) 1394{ 1395 napi_value result = nullptr; 1396 1397 struct result result1 = InitNativeWindow(); 1398 OH_NativeImage *image = result1.image; 1399 OHNativeWindow *nativeWindow = result1.nativeWindow; 1400 OHNativeWindowBuffer *nativeWindowBuffer = nullptr; 1401 int fenceFd; 1402 Region::Rect rect{ 1403 .x = 0x100, 1404 .y = 0x100, 1405 .w = 0x100, 1406 .h = 0x100, 1407 }; 1408 Region region{.rects = &rect}; 1409 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd); 1410 ret = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, fenceFd, region); 1411 if (ret != 0) { 1412 napi_create_int32(env, FAIL, &result); 1413 return result; 1414 } 1415 // 3. 1416 auto flag = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindow, nativeWindowBuffer); 1417 if (flag != CONSTANT_41207000) { 1418 napi_create_int32(env, FAIL, &result); 1419 return result; 1420 } 1421 1422 DestroyNativeWindowImage(image, nativeWindow); 1423 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer); 1424 1425 napi_create_int32(env, SUCCESS, &result); 1426 return result; 1427} 1428 1429 1430napi_value testNativeWindowNativeWindowAtDetachDifferentBufferNormal(napi_env env, napi_callback_info info) 1431{ 1432 napi_value result = nullptr; 1433 1434 struct result result1 = InitNativeWindow(); 1435 OH_NativeImage *image = result1.image; 1436 OHNativeWindow *nativeWindow = result1.nativeWindow; 1437 OHNativeWindowBuffer *nativeWindowBuffer1, *nativeWindowBuffer2, *nativeWindowBuffer3; 1438 int fenceFd = -1; 1439 OHNativeWindowBuffer **nativeWindowBuffers[] = {&nativeWindowBuffer1, &nativeWindowBuffer2, &nativeWindowBuffer3}; 1440 for (int i = 0; i < CONSTANT_3; ++i) { 1441 auto flag = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, nativeWindowBuffers[i], &fenceFd); 1442 if (flag != 0) { 1443 napi_create_int32(env, CONSTANT_1000 + i + 1, &result); 1444 return result; 1445 } 1446 } 1447 1448 for (int i = 0; i < CONSTANT_3; ++i) { 1449 auto flag = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindow, *nativeWindowBuffers[i]); 1450 if (flag != 0) { 1451 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + i + 1, &result); 1452 return result; 1453 } 1454 } 1455 1456 for (int i = 0; i < CONSTANT_3; ++i) { 1457 auto flag = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, *nativeWindowBuffers[i]); 1458 if (flag != 0) { 1459 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + i + 1, &result); 1460 return result; 1461 } 1462 } 1463 1464 DestroyNativeWindowImage(image, nativeWindow); 1465 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer1); 1466 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer2); 1467 OH_NativeWindow_DestroyNativeWindowBuffer(nativeWindowBuffer3); 1468 1469 napi_create_int32(env, SUCCESS, &result); 1470 return result; 1471} 1472 1473struct Paramater { 1474 OHNativeWindow *nativeWindow1 = nullptr; 1475 OHNativeWindow *nativeWindow2 = nullptr; 1476 OHNativeWindowBuffer *nativeWindowBuffer1 = nullptr; 1477 OHNativeWindowBuffer *nativeWindowBuffer2 = nullptr; 1478 OH_NativeBuffer *nativeBuffer1 = nullptr; 1479 OH_NativeBuffer *nativeBuffer2 = nullptr; 1480}; 1481 1482napi_value testNativeWindowNativeWindowAtDetachDifferentBufferAbnormal1( 1483 napi_env env, napi_callback_info info, Paramater paramater) 1484{ 1485 napi_value result = nullptr; 1486 int32_t flag = OH_NativeWindow_NativeWindowAttachBuffer(paramater.nativeWindow1, paramater.nativeWindowBuffer1); 1487 if (flag != 0) { 1488 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_1, &result); 1489 return result; 1490 } 1491 flag = OH_NativeWindow_NativeWindowAttachBuffer(paramater.nativeWindow2, paramater.nativeWindowBuffer2); 1492 if (flag != 0) { 1493 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_2, &result); 1494 return result; 1495 } 1496 return result; 1497} 1498 1499 1500napi_value testNativeWindowNativeWindowAtDetachDifferentBufferAbnormal2(napi_env env, napi_callback_info info, 1501 Paramater paramater) 1502{ 1503 napi_value result = nullptr; 1504 auto flag = OH_NativeWindow_NativeWindowAttachBuffer(paramater.nativeWindow2, paramater.nativeWindowBuffer1); 1505 if (flag != 0) { 1506 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_1, &result); 1507 return result; 1508 } 1509 flag = OH_NativeWindow_NativeWindowAttachBuffer(paramater.nativeWindow1, paramater.nativeWindowBuffer2); 1510 if (flag != 0) { 1511 napi_create_int32(env, CONSTANT_3 * CONSTANT_1000 + CONSTANT_2, &result); 1512 return result; 1513 } 1514 // 4. 1515 flag = OH_NativeWindow_NativeWindowDetachBuffer(paramater.nativeWindow1, paramater.nativeWindowBuffer1); 1516 if (flag != 0) { 1517 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_1, &result); 1518 return result; 1519 } 1520 flag = OH_NativeWindow_NativeWindowDetachBuffer(paramater.nativeWindow2, paramater.nativeWindowBuffer2); 1521 if (flag != 0) { 1522 napi_create_int32(env, CONSTANT_4 * CONSTANT_1000 + CONSTANT_2, &result); 1523 return result; 1524 } 1525 // 5. 1526 flag = OH_NativeWindow_NativeWindowAttachBuffer(paramater.nativeWindow2, paramater.nativeWindowBuffer1); 1527 if (flag == 0) { 1528 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_1, &result); 1529 return result; 1530 } 1531 flag = OH_NativeWindow_NativeWindowAttachBuffer(paramater.nativeWindow1, paramater.nativeWindowBuffer2); 1532 if (flag == 0) { 1533 napi_create_int32(env, CONSTANT_5 * CONSTANT_1000 + CONSTANT_2, &result); 1534 return result; 1535 } 1536 return result; 1537} 1538 1539napi_value testNativeWindowNativeWindowAtDetachDifferentBufferAbnormal(napi_env env, napi_callback_info info) 1540{ 1541 napi_value result = nullptr; 1542 struct Paramater paramater; 1543 struct result result1 = InitNativeWindow(); 1544 struct result result2 = InitNativeWindow(); 1545 OH_NativeImage *image1 = result1.image; 1546 paramater.nativeWindow1 = result1.nativeWindow; 1547 OH_NativeImage *image2 = result2.image; 1548 paramater.nativeWindow2 = result2.nativeWindow; 1549 OH_NativeBuffer_Config config{ 1550 .width = 0x100, 1551 .height = 0x100, 1552 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 1553 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA, 1554 }; 1555 paramater.nativeBuffer1 = OH_NativeBuffer_Alloc(&config); 1556 paramater.nativeBuffer2 = OH_NativeBuffer_Alloc(&config); 1557 paramater.nativeWindowBuffer1 = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(paramater.nativeBuffer1); 1558 if (paramater.nativeWindowBuffer1 == nullptr) { 1559 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result); 1560 return result; 1561 } 1562 paramater.nativeWindowBuffer2 = OH_NativeWindow_CreateNativeWindowBufferFromNativeBuffer(paramater.nativeBuffer2); 1563 if (paramater.nativeWindowBuffer2 == nullptr) { 1564 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result); 1565 return result; 1566 } 1567 result = testNativeWindowNativeWindowAtDetachDifferentBufferAbnormal1(env, info, paramater); 1568 if (result != nullptr) { 1569 return result; 1570 } 1571 result = testNativeWindowNativeWindowAtDetachDifferentBufferAbnormal2(env, info, paramater); 1572 if (result != nullptr) { 1573 return result; 1574 } 1575 DestroyNativeWindowImage(image1, paramater.nativeWindow1); 1576 DestroyNativeWindowImage(image2, paramater.nativeWindow2); 1577 OH_NativeWindow_DestroyNativeWindowBuffer(paramater.nativeWindowBuffer1); 1578 OH_NativeWindow_DestroyNativeWindowBuffer(paramater.nativeWindowBuffer2); 1579 OH_NativeBuffer_Unreference(paramater.nativeBuffer1); 1580 OH_NativeBuffer_Unreference(paramater.nativeBuffer2); 1581 napi_create_int32(env, SUCCESS, &result); 1582 return result; 1583} 1584 1585napi_value testNativeWindowNativeWindowHandleOptNullptr(napi_env env, napi_callback_info info) 1586{ 1587 napi_value result = nullptr; 1588 1589 int code = SET_BUFFER_GEOMETRY; 1590 auto flag = OH_NativeWindow_NativeWindowHandleOpt(nullptr, code, 100, 100); 1591 if (flag != CONSTANT_40001000) { 1592 napi_create_int32(env, FAIL, &result); 1593 return result; 1594 } 1595 1596 napi_create_int32(env, SUCCESS, &result); 1597 return result; 1598} 1599 1600 1601napi_value testNativeWindowNativeWindowHandleOptSetGetBufferGeometryNormal(napi_env env, napi_callback_info info) 1602{ 1603 napi_value result = nullptr; 1604 1605 struct result result1 = InitNativeWindow(); 1606 OH_NativeImage *image = result1.image; 1607 OHNativeWindow *nativeWindow = result1.nativeWindow; 1608 1609 int arr[][2] = {{0, 0}, {2147483647, 2147483647}, {100, 100}, {-1000, -1000}, {-1000, 1000}, 1610 {1000, -1000}, {-2147483647, -2147483647}, {-1, -1}}; 1611 int width1, height1; 1612 auto ret = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_BUFFER_GEOMETRY, &width1, &height1); 1613 if (ret != 0) { 1614 napi_create_int32(env, CONSTANT_1, &result); 1615 return result; 1616 } 1617 1618 for (int i = 0; i < sizeof(arr) / sizeof(int[2]); ++i) { 1619 int width = arr[i][0]; 1620 int height = arr[i][1]; 1621 auto flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_BUFFER_GEOMETRY, width, height); 1622 if (flag != 0) { 1623 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_1, &result); 1624 return result; 1625 } 1626 int width2, height2; 1627 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_BUFFER_GEOMETRY, &height2, &width2); 1628 if (flag != 0) { 1629 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_2, &result); 1630 return result; 1631 } 1632 if (width != width2 || height != height2) { 1633 napi_create_int32(env, (i + 1) * CONSTANT_1000 + CONSTANT_3, &result); 1634 return result; 1635 } 1636 } 1637 1638 DestroyNativeWindowImage(image, nativeWindow); 1639 napi_create_int32(env, SUCCESS, &result); 1640 return result; 1641} 1642 1643napi_value testNativeWindowNativeWindowHandleOptSetGetBufferGeometryAbnormal(napi_env env, napi_callback_info info) 1644{ 1645 napi_value result = nullptr; 1646 OH_NativeImage *image1 = InitNativeWindow().image; 1647 OHNativeWindow *nativeWindow = InitNativeWindow().nativeWindow; 1648 1649 int32_t width, height; 1650 1651 // 1. 1652 auto flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_BUFFER_GEOMETRY, NULL, NULL); 1653 if (flag != 0) { // 应为 非0 1654 napi_create_int32(env, CONSTANT_1000 + CONSTANT_1, &result); 1655 return result; 1656 } 1657 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_BUFFER_GEOMETRY, &height, &width); 1658 if (flag != 0) { // 应为 成功 1659 napi_create_int32(env, CONSTANT_1000 + CONSTANT_2, &result); 1660 return result; 1661 } 1662 if (width != 0 || height != 0) { 1663 napi_create_int32(env, CONSTANT_1000 + CONSTANT_3, &result); 1664 return result; 1665 } 1666 // 2.2147483648 1667 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_BUFFER_GEOMETRY, CONSTANT_9999999999999999999, 1668 CONSTANT_9999999999999999999); 1669 if (flag != 0) { // 应为 非0 1670 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_1, &result); 1671 return result; 1672 } 1673 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, GET_BUFFER_GEOMETRY, &height, &width); 1674 if (flag != 0) { // 应为 成功 1675 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_2, &result); 1676 return result; 1677 } 1678 // 3. 1679 flag = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, SET_BUFFER_GEOMETRY, "abc", "abc"); 1680 if (flag != 0) { // 应为 失败 1681 napi_create_int32(env, CONSTANT_2 * CONSTANT_1000 + CONSTANT_3, &result); 1682 return result; 1683 } 1684 1685 DestroyNativeWindowImage(image1, nativeWindow); 1686 napi_create_int32(env, SUCCESS, &result); 1687 return result; 1688} 1689