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#include "usb_camera_test.h" 16 17bool g_usbCameraExit = false; 18 19void UtestUSBCameraTest::SetUpTestCase(void) 20{} 21void UtestUSBCameraTest::TearDownTestCase(void) 22{} 23void UtestUSBCameraTest::SetUp(void) 24{ 25 if (cameraBase_ == nullptr) 26 cameraBase_ = std::make_shared<TestCameraBase>(); 27 cameraBase_->UsbInit(); 28} 29void UtestUSBCameraTest::TearDown(void) 30{ 31 cameraBase_->Close(); 32} 33 34/** 35 * @tc.name: USB Camera 36 * @tc.desc: USB Camera, getCameraID success. 37 * @tc.level: Level0 38 * @tc.size: MediumTest 39 * @tc.type: Function 40 */ 41TEST_F(UtestUSBCameraTest, camera_usb_0001) 42{ 43 uint32_t rc = 0; 44 std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl; 45 std::vector<std::string> cameraIds; 46 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl; 47 cameraBase_->cameraHost->GetCameraIds(cameraIds); 48 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl; 49 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl; 50 for (const auto &cameraId : cameraIds) { 51 std::cout << "==========[test log] cameraId = " << cameraId << std::endl; 52 } 53 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 10s..."<< std::endl; 54 sleep(3); // judging add or delete the usb camera, wait for 3s. 55 std::cout << "==========[test log] r u ready? wait for 10s..."<< std::endl; 56 sleep(3); // judging r u ready, wait for 3s. 57 std::cout << "==========[test log] 3. check the cameraID again... wait for 10s..."<< std::endl; 58 sleep(3); // checking the cameraID again, wait for 3s. 59 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl; 60 if (cameraIds.size() == 1) { 61 cameraIds.clear(); 62 } 63 rc = cameraBase_->cameraHost->GetCameraIds(cameraIds); 64 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR); 65 for (const auto &cameraId : cameraIds) { 66 std::cout << "cameraId = " << cameraId << std::endl; 67 } 68 if (cameraIds.size() > 1) { 69 g_usbCameraExit = true; 70 } 71} 72 73/** 74 * @tc.name: USB Camera 75 * @tc.desc: get value of OHOS_ABILITY_ZOOM_RATIO_RANGE 76 * @tc.level: Level0 77 * @tc.size: MediumTest 78 * @tc.type: Function 79 */ 80TEST_F(UtestUSBCameraTest, camera_usb_0002) 81{ 82 if (!g_usbCameraExit) { 83 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 84 } 85 ability_ = cameraBase_->GetCameraAbility(); 86 EXPECT_NE(ability_, nullptr); 87 common_metadata_header_t *data = ability_->get(); 88 camera_metadata_item_t entry; 89 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry); 90 if (ret == CAM_META_SUCCESS) { 91 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE: count is " << (int)entry.count << std::endl; 92 std::cout << "Zoom ratio range: [" << entry.data.f[0]; 93 std::cout << "," << entry.data.f[1] << "]" << std::endl; 94 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 95 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE is not support" << std::endl; 96 } 97} 98 99/** 100 * @tc.name: USB Camera 101 * @tc.desc: get value of OHOS_ABILITY_CAMERA_CONNECTION_TYPE 102 * @tc.level: Level0 103 * @tc.size: MediumTest 104 * @tc.type: Function 105 */ 106TEST_F(UtestUSBCameraTest, camera_usb_0003) 107{ 108 if (!g_usbCameraExit) { 109 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 110 } 111 ability_ = cameraBase_->GetCameraAbility(); 112 EXPECT_NE(ability_, nullptr); 113 common_metadata_header_t *data = ability_->get(); 114 camera_metadata_item_t entry; 115 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry); 116 EXPECT_EQ(ret, CAM_META_SUCCESS); 117 std::cout << "OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is " 118 << static_cast<int>(entry.data.u8[0]) << std::endl; 119 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN); 120} 121 122/** 123 * @tc.name: USB Camera 124 * @tc.desc: get value of OHOS_ABILITY_CAMERA_POSITION 125 * @tc.level: Level0 126 * @tc.size: MediumTest 127 * @tc.type: Function 128 */ 129TEST_F(UtestUSBCameraTest, camera_usb_0004) 130{ 131 if (!g_usbCameraExit) { 132 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 133 } 134 ability_ = cameraBase_->GetCameraAbility(); 135 EXPECT_NE(ability_, nullptr); 136 common_metadata_header_t *data = ability_->get(); 137 camera_metadata_item_t entry; 138 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry); 139 EXPECT_EQ(ret, CAM_META_SUCCESS); 140 std::cout << "OHOS_ABILITY_CAMERA_POSITION value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 141 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_OTHER); 142} 143 144/** 145 * @tc.name: USB Camera 146 * @tc.desc: get value of OHOS_ABILITY_FLASH_AVAILABLE 147 * @tc.level: Level0 148 * @tc.size: MediumTest 149 * @tc.type: Function 150 */ 151TEST_F(UtestUSBCameraTest, camera_usb_0005) 152{ 153 if (!g_usbCameraExit) { 154 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 155 } 156 ability_ = cameraBase_->GetCameraAbility(); 157 EXPECT_NE(ability_, nullptr); 158 common_metadata_header_t *data = ability_->get(); 159 camera_metadata_item_t entry; 160 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry); 161 EXPECT_EQ(ret, CAM_META_SUCCESS); 162 std::cout << "OHOS_ABILITY_FLASH_AVAILABLE value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 163} 164 165/** 166 * @tc.name: USB Camera 167 * @tc.desc: get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES 168 * @tc.level: Level0 169 * @tc.size: MediumTest 170 * @tc.type: Function 171 */ 172TEST_F(UtestUSBCameraTest, camera_usb_0006) 173{ 174 if (!g_usbCameraExit) { 175 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 176 } 177 ability_ = cameraBase_->GetCameraAbility(); 178 EXPECT_NE(ability_, nullptr); 179 common_metadata_header_t *data = ability_->get(); 180 camera_metadata_item_t entry; 181 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry); 182 if (ret == CAM_META_SUCCESS) { 183 for (int i = 0; i < entry.count; i++) { 184 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is " 185 << static_cast<int>(entry.data.u8[i]) << std::endl; 186 } 187 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 188 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support" << std::endl; 189 } 190} 191 192/** 193 * @tc.name: USB Camera 194 * @tc.desc: get value of OHOS_ABILITY_FLASH_MODES 195 * @tc.level: Level0 196 * @tc.size: MediumTest 197 * @tc.type: Function 198 */ 199TEST_F(UtestUSBCameraTest, camera_usb_007) 200{ 201 if (!g_usbCameraExit) { 202 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 203 } 204 ability_ = cameraBase_->GetCameraAbility(); 205 common_metadata_header_t *data = ability_->get(); 206 camera_metadata_item_t entry; 207 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry); 208 if (ret == CAM_META_SUCCESS) { 209 std::cout << "supported flash mode list:"; 210 for (int i = 0; i < entry.count; i++) { 211 std::cout << " " << static_cast<int>(entry.data.u8[i]); 212 } 213 std::cout << std::endl; 214 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 215 std::cout << "OHOS_ABILITY_FLASH_MODES is not support" << std::endl; 216 } 217} 218 219/** 220 * @tc.name: USB Camera 221 * @tc.desc: get value of OHOS_ABILITY_FOCUS_MODES 222 * @tc.level: Level0 223 * @tc.size: MediumTest 224 * @tc.type: Function 225 */ 226TEST_F(UtestUSBCameraTest, camera_usb_008) 227{ 228 if (!g_usbCameraExit) { 229 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 230 } 231 ability_ = cameraBase_->GetCameraAbility(); 232 EXPECT_NE(ability_, nullptr); 233 common_metadata_header_t *data = ability_->get(); 234 camera_metadata_item_t entry; 235 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry); 236 if (ret == CAM_META_SUCCESS) { 237 std::cout << "supported focus mode list:"; 238 for (int i = 0; i < entry.count; i++) { 239 std::cout << " " << static_cast<int>(entry.data.u8[i]); 240 } 241 std::cout << std::endl; 242 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 243 std::cout << "OHOS_ABILITY_FOCUS_MODES is not support" << std::endl; 244 } 245} 246 247/** 248 * @tc.name: USB Camera 249 * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_MODES 250 * @tc.level: Level0 251 * @tc.size: MediumTest 252 * @tc.type: Function 253 */ 254TEST_F(UtestUSBCameraTest, camera_usb_009) 255{ 256 if (!g_usbCameraExit) { 257 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 258 } 259 ability_ = cameraBase_->GetCameraAbility(); 260 EXPECT_NE(ability_, nullptr); 261 common_metadata_header_t *data = ability_->get(); 262 camera_metadata_item_t entry; 263 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry); 264 if (ret == CAM_META_SUCCESS) { 265 std::cout << "supported exposure mode list:"; 266 for (int i = 0; i < entry.count; i++) { 267 std::cout << " " << static_cast<int>(entry.data.u8[i]); 268 } 269 std::cout << std::endl; 270 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 271 std::cout << "OHOS_ABILITY_EXPOSURE_MODES is not support" << std::endl; 272 } 273} 274 275/** 276 * @tc.name: USB Camera 277 * @tc.desc: get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED 278 * @tc.level: Level0 279 * @tc.size: MediumTest 280 * @tc.type: Function 281 */ 282TEST_F(UtestUSBCameraTest, camera_usb_0010) 283{ 284 if (!g_usbCameraExit) { 285 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 286 } 287 ability_ = cameraBase_->GetCameraAbility(); 288 EXPECT_NE(ability_, nullptr); 289 common_metadata_header_t *data = ability_->get(); 290 camera_metadata_item_t entry; 291 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry); 292 EXPECT_EQ(ret, CAM_META_SUCCESS); 293 std::cout << "capture mirror supported is :"; 294 for (int i = 0; i < entry.count; i++) { 295 std::cout << " " << static_cast<int>(entry.data.u8[i]); 296 } 297 std::cout << std::endl; 298} 299 300/** 301 * @tc.name: USB Camera 302 * @tc.desc: get value of OHOS_ABILITY_MUTE_MODES 303 * @tc.level: Level0 304 * @tc.size: MediumTest 305 * @tc.type: Function 306 */ 307TEST_F(UtestUSBCameraTest, camera_usb_0011) 308{ 309 if (!g_usbCameraExit) { 310 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 311 } 312 ability_ = cameraBase_->GetCameraAbility(); 313 EXPECT_NE(ability_, nullptr); 314 common_metadata_header_t *data = ability_->get(); 315 camera_metadata_item_t entry; 316 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry); 317 if (ret == CAM_META_SUCCESS) { 318 std::cout << "supported mute mode is:"; 319 for (int i = 0; i < entry.count; i++) { 320 std::cout << " " << static_cast<int>(entry.data.u8[i]); 321 } 322 std::cout << std::endl; 323 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 324 std::cout << "OHOS_ABILITY_MUTE_MODES is not support" << std::endl; 325 } 326} 327 328/** 329 * @tc.name: USB Camera 330 * @tc.desc: get value of OHOS_ABILITY_FPS_RANGES 331 * @tc.level: Level0 332 * @tc.size: MediumTest 333 * @tc.type: Function 334 */ 335TEST_F(UtestUSBCameraTest, camera_usb_0012) 336{ 337 if (!g_usbCameraExit) { 338 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 339 } 340 ability_ = cameraBase_->GetCameraAbility(); 341 EXPECT_NE(ability_, nullptr); 342 common_metadata_header_t *data = ability_->get(); 343 camera_metadata_item_t entry; 344 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry); 345 EXPECT_EQ(ret, CAM_META_SUCCESS); 346 std::cout << "supported fps ranges list: ["; 347 std::cout << static_cast<int>(entry.data.i32[0]) << "," << static_cast<int>(entry.data.i32[1]) << "]"; 348 std::cout << std::endl; 349} 350 351/** 352 * @tc.name: USB Camera 353 * @tc.desc: get value of OHOS_ABILITY_CAMERA_TYPE 354 * @tc.level: Level0 355 * @tc.size: MediumTest 356 * @tc.type: Function 357 */ 358TEST_F(UtestUSBCameraTest, camera_usb_0013) 359{ 360 if (!g_usbCameraExit) { 361 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 362 } 363 ability_ = cameraBase_->GetCameraAbility(); 364 EXPECT_NE(ability_, nullptr); 365 common_metadata_header_t *data = ability_->get(); 366 camera_metadata_item_t entry; 367 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry); 368 EXPECT_EQ(ret, CAM_META_SUCCESS); 369 std::cout << "OHOS_ABILITY_CAMERA_TYPE value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 370 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED); 371} 372 373/** 374 * @tc.name: USB Camera 375 * @tc.desc: get value of OHOS_JPEG_ORIENTATION 376 * @tc.level: Level0 377 * @tc.size: MediumTest 378 * @tc.type: Function 379 */ 380TEST_F(UtestUSBCameraTest, camera_usb_0014) 381{ 382 if (!g_usbCameraExit) { 383 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 384 } 385 ability_ = cameraBase_->GetCameraAbility(); 386 EXPECT_NE(ability_, nullptr); 387 common_metadata_header_t *data = ability_->get(); 388 camera_metadata_item_t entry; 389 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry); 390 EXPECT_EQ(ret, CAM_META_SUCCESS); 391 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.i32[0]) << std::endl; 392} 393 394/** 395 * @tc.name: USB Camera 396 * @tc.desc: get value of OHOS_JPEG_QUALITY 397 * @tc.level: Level0 398 * @tc.size: MediumTest 399 * @tc.type: Function 400 */ 401TEST_F(UtestUSBCameraTest, camera_usb_0015) 402{ 403 if (!g_usbCameraExit) { 404 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 405 } 406 ability_ = cameraBase_->GetCameraAbility(); 407 EXPECT_NE(ability_, nullptr); 408 common_metadata_header_t *data = ability_->get(); 409 camera_metadata_item_t entry; 410 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry); 411 EXPECT_EQ(ret, CAM_META_SUCCESS); 412 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 413} 414 415/** 416 * @tc.name: USB Camera 417 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS 418 * @tc.level: Level0 419 * @tc.size: MediumTest 420 * @tc.type: Function 421 */ 422TEST_F(UtestUSBCameraTest, camera_usb_0016) 423{ 424 if (!g_usbCameraExit) { 425 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 426 } 427 ability_ = cameraBase_->GetCameraAbility(); 428 EXPECT_NE(ability_, nullptr); 429 common_metadata_header_t *data = ability_->get(); 430 camera_metadata_item_t entry; 431 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry); 432 EXPECT_EQ(ret, CAM_META_SUCCESS); 433 std::cout << "OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is " 434 << static_cast<int>(entry.data.u8[0]) << std::endl; 435 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888); 436} 437 438/** 439 * @tc.name: USB Camera 440 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS 441 * @tc.level: Level0 442 * @tc.size: MediumTest 443 * @tc.type: Function 444 */ 445TEST_F(UtestUSBCameraTest, camera_usb_0017) 446{ 447 if (!g_usbCameraExit) { 448 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 449 } 450 ability_ = cameraBase_->GetCameraAbility(); 451 EXPECT_NE(ability_, nullptr); 452 common_metadata_header_t *data = ability_->get(); 453 EXPECT_NE(data, nullptr); 454 camera_metadata_item_t entry; 455 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry); 456 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) { 457 std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start." << std::endl; 458 const size_t STEP = 10; // print step 459 std::cout << "count" << entry.count << std::endl; 460 for (size_t i = 0; i < entry.count; i++) { 461 std::cout << entry.data.i32[i] << " "; 462 if ((i != 0) && (i % STEP == 0 || i == entry.count - 1)) { 463 std::cout << std::endl; 464 } 465 } 466 std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end." << std::endl; 467 } 468} 469 470/** 471 * @tc.name: USB Camera 472 * @tc.desc: Preview stream, expected success. 473 * @tc.level: Level0 474 * @tc.size: MediumTest 475 * @tc.type: Function 476 */ 477TEST_F(UtestUSBCameraTest, camera_usb_0018) 478{ 479 if (!g_usbCameraExit) { 480 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 481 } 482 // Get the device manager 483 cameraBase_->OpenUsbCamera(); 484 // Get the stream manager 485 cameraBase_->AchieveStreamOperator(); 486 // start stream 487 cameraBase_->intents = {PREVIEW}; 488 cameraBase_->StartStream(cameraBase_->intents); 489 // Get preview 490 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 491 // release stream 492 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW}; 493 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW}; 494 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 495} 496 497/** 498 * @tc.name: USB Camera 499 * @tc.desc: Preview stream, width = 1280, height = 720, expected success. 500 * @tc.level: Level0 501 * @tc.size: MediumTest 502 * @tc.type: Function 503 */ 504TEST_F(UtestUSBCameraTest, camera_usb_0019) 505{ 506 if (!g_usbCameraExit) { 507 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 508 } 509 // Get the device manager 510 cameraBase_->OpenUsbCamera(); 511 // Create and get streamOperator information 512 cameraBase_->AchieveStreamOperator(); 513 // Create data stream 514 if (cameraBase_->streamCustomerPreview_ == nullptr) { 515 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 516 } 517 OHOS::sptr<OHOS::IBufferProducer> producer = cameraBase_->streamCustomerPreview_->CreateProducer(); 518 producer->SetQueueSize(8); // 8:set bufferQueue size 519 520 std::vector<StreamInfo> streamInfos; 521 StreamInfo streamInfo = {}; 522 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 523 streamInfo.width_ = 1280; // 1280:picture width 524 streamInfo.height_ = 720; // 720:picture height 525 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 526 streamInfo.dataspace_ = 8; // 8:picture dataspace 527 streamInfo.intent_ = PREVIEW; 528 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 529 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer); 530 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 531 std::vector<StreamInfo>().swap(streamInfos); 532 streamInfos.push_back(streamInfo); 533 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 534 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 535 // Submit stream information 536 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 537 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 538 // capture 539 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 540 // release stream 541 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW}; 542 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW}; 543 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 544} 545 546/** 547 * @tc.name: USB Camera 548 * @tc.desc: UpdateSettings, fps. 549 * @tc.level: Level0 550 * @tc.size: MediumTest 551 * @tc.type: Function 552 */ 553TEST_F(UtestUSBCameraTest, camera_usb_0020) 554{ 555 if (!g_usbCameraExit) { 556 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 557 } 558 // Get the device manager 559 cameraBase_->OpenUsbCamera(); 560 // get the stream manager 561 cameraBase_->AchieveStreamOperator(); 562 563 // start stream 564 cameraBase_->intents = {PREVIEW}; 565 cameraBase_->StartStream(cameraBase_->intents); 566 567 // updateSettings 568 const uint32_t ITEM_CAPACITY = 100; 569 const uint32_t DATA_CAPACITY = 2000; 570 const int32_t FPS_VALUE = 10; 571 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>( 572 ITEM_CAPACITY, DATA_CAPACITY); 573 std::vector<int32_t> fpsRange; 574 fpsRange.push_back(FPS_VALUE); 575 fpsRange.push_back(FPS_VALUE); 576 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size()); 577 const int32_t DEVICE_STREAM_ID = 0; 578 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1); 579 std::vector<uint8_t> setting; 580 MetadataUtils::ConvertMetadataToVec(meta, setting); 581 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting); 582 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 583 584 // get preview 585 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 586 587 // release stream 588 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW}; 589 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW}; 590 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 591} 592 593/** 594 * @tc.name: USB Camera 595 * @tc.desc: USB Camera, OnCameraStatus and OnCameraEvent. 596 * @tc.level: Level0 597 * @tc.size: MediumTest 598 * @tc.type: Function 599 */ 600TEST_F(UtestUSBCameraTest, camera_usb_0021) 601{ 602 uint32_t rc = 0; 603 std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl; 604 std::vector<std::string> cameraIds; 605 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl; 606 cameraBase_->cameraHost->GetCameraIds(cameraIds); 607 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl; 608 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl; 609 for (const auto &cameraId : cameraIds) { 610 std::cout << "==========[test log] cameraId = " << cameraId << std::endl; 611 } 612 const int count = 4; 613 for (int i = 0; i < count; i++) { 614 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 3s..."<< std::endl; 615 sleep(3); // judging add or delete the usb camera, wait for 3s. 616 } 617 std::cout << "==========[test log] 3. check the cameraID again... wait for 3s..."<< std::endl; 618 sleep(3); // checking the cameraID again, wait for 3s. 619 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl; 620 if (cameraIds.size() == 1) { 621 cameraIds.clear(); 622 } 623 rc = cameraBase_->cameraHost->GetCameraIds(cameraIds); 624 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR); 625 for (const auto &cameraId : cameraIds) { 626 std::cout << "cameraId = " << cameraId << std::endl; 627 } 628} 629 630/** 631 * @tc.name: USB Camera 632 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true. 633 * @tc.level: Level0 634 * @tc.size: MediumTest 635 * @tc.type: Function 636 */ 637TEST_F(UtestUSBCameraTest, camera_usb_0022) 638{ 639 // Get the device manager 640 cameraBase_->OpenUsbCamera(); 641 if (!g_usbCameraExit) { 642 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 643 } 644 // Get the stream manager 645 cameraBase_->AchieveStreamOperator(); 646 // start stream 647 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 648 cameraBase_->StartStream(cameraBase_->intents); 649 // Get preview 650 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 651 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 652 // release stream 653 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 654 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 655 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 656} 657 658/** 659 * @tc.name: USB Camera 660 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success. 661 * @tc.level: Level0 662 * @tc.size: MediumTest 663 * @tc.type: Function 664 */ 665TEST_F(UtestUSBCameraTest, camera_usb_0023) 666{ 667 cameraBase_->OpenUsbCamera(); 668 if (!g_usbCameraExit) { 669 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 670 } 671 cameraBase_->AchieveStreamOperator(); 672 if (cameraBase_->streamCustomerPreview_ == nullptr) { 673 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 674 } 675 std::vector<StreamInfo> streamInfos; 676 StreamInfo streamInfo = {}; 677 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 678 streamInfo.width_ = 1280; // 1280:picture width 679 streamInfo.height_ = 720; // 720:picture height 680 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 681 streamInfo.dataspace_ = 8; // 8:picture dataspace 682 streamInfo.intent_ = PREVIEW; 683 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 684 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer()); 685 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 686 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 687 streamInfos.push_back(streamInfo); 688 if (cameraBase_->streamCustomerCapture_ == nullptr) { 689 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>(); 690 } 691 StreamInfo streamInfoCapture = {}; 692 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE; 693 streamInfoCapture.width_ = 1280; // 1280:picture width 694 streamInfoCapture.height_ = 960; // 960:picture height 695 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888; 696 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace 697 streamInfoCapture.intent_ = STILL_CAPTURE; 698 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG; 699 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode 700 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable( 701 cameraBase_->streamCustomerCapture_->CreateProducer()); 702 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr); 703 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 704 streamInfos.push_back(streamInfoCapture); 705 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 706 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 707 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 708 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 709 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 710 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 711 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 712 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 713 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 714} 715 716/** 717 * @tc.name: preview and capture 718 * @tc.desc: Commit 2 streams together, Change the value OHOS_JPEG_ORIENTATION, isStreaming is true. 719 * @tc.level: Level0 720 * @tc.size: MediumTest 721 * @tc.type: Function 722 */ 723TEST_F(UtestUSBCameraTest, camera_usb_0024) 724{ 725 // Get the device manager 726 cameraBase_->OpenUsbCamera(); 727 if (!g_usbCameraExit) { 728 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 729 } 730 // Get the stream manager 731 cameraBase_->AchieveStreamOperator(); 732 std::vector<int32_t> jpegOrientationVector; 733 jpegOrientationVector.push_back(OHOS_CAMERA_JPEG_ROTATION_270); 734 cameraBase_->ability->updateEntry(OHOS_JPEG_ORIENTATION, jpegOrientationVector.data(), 735 jpegOrientationVector.size()); 736 cameraBase_->ability_.clear(); 737 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_); 738 // start stream 739 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 740 cameraBase_->StartStream(cameraBase_->intents); 741 742 // Get preview 743 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 744 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 745 // release stream 746 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 747 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 748 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 749} 750 751/** 752 * @tc.name: preview and capture 753 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true. 754 * @tc.level: Level0 755 * @tc.size: MediumTest 756 * @tc.type: Function 757 */ 758TEST_F(UtestUSBCameraTest, camera_usb_0025) 759{ 760 // Get the device manager 761 cameraBase_->OpenUsbCamera(); 762 if (!g_usbCameraExit) { 763 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 764 } 765 // Get the stream manager 766 cameraBase_->AchieveStreamOperator(); 767 std::vector<int32_t> jpegQualityVector; 768 jpegQualityVector.push_back(OHOS_CAMERA_JPEG_LEVEL_LOW); 769 cameraBase_->ability->updateEntry(OHOS_JPEG_QUALITY, jpegQualityVector.data(), jpegQualityVector.size()); 770 cameraBase_->ability_.clear(); 771 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_); 772 // start stream 773 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 774 cameraBase_->StartStream(cameraBase_->intents); 775 776 // Get preview 777 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 778 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 779 // release stream 780 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 781 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 782 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 783} 784 785/** 786 * @tc.name: Video 787 * @tc.desc: Preview + video, commit together, success. 788 * @tc.level: Level0 789 * @tc.size: MediumTest 790 * @tc.type: Function 791 */ 792TEST_F(UtestUSBCameraTest, camera_usb_0026) 793{ 794 // Get the device manager 795 cameraBase_->OpenUsbCamera(); 796 if (!g_usbCameraExit) { 797 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 798 } 799 // Create and get streamOperator information 800 cameraBase_->AchieveStreamOperator(); 801 // start stream 802 cameraBase_->intents = {PREVIEW, VIDEO}; 803 cameraBase_->StartStream(cameraBase_->intents); 804 // Get preview 805 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 806 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 807 808 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO}; 809 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO}; 810 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 811} 812 813/** 814 * @tc.name: USB Camera 815 * @tc.desc: Preview stream, width = 1280, height = 720, expected success. 816 * @tc.level: Level0 817 * @tc.size: MediumTest 818 * @tc.type: Function 819 */ 820TEST_F(UtestUSBCameraTest, camera_usb_0027) 821{ 822 cameraBase_->OpenUsbCamera(); 823 if (!g_usbCameraExit) { 824 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 825 } 826 cameraBase_->AchieveStreamOperator(); 827 if (cameraBase_->streamCustomerPreview_ == nullptr) { 828 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 829 } 830 std::vector<StreamInfo> streamInfos; 831 StreamInfo streamInfo = {}; 832 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 833 streamInfo.width_ = 1280; // 1280:picture width 834 streamInfo.height_ = 720; // 720:picture height 835 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 836 streamInfo.dataspace_ = 8; // 8:picture dataspace 837 streamInfo.intent_ = PREVIEW; 838 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 839 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer()); 840 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 841 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 842 streamInfos.push_back(streamInfo); 843 if (cameraBase_->streamCustomerVideo_ == nullptr) { 844 cameraBase_->streamCustomerVideo_ = std::make_shared<StreamCustomer>(); 845 } 846 StreamInfo streamInfoVideo = {}; 847 streamInfoVideo.streamId_ = cameraBase_->STREAM_ID_VIDEO; 848 streamInfoVideo.width_ = 1280; // 1280:picture width 849 streamInfoVideo.height_ = 960; // 960:picture height 850 streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888; 851 streamInfoVideo.dataspace_ = 8; // 8:picture dataspace 852 streamInfoVideo.intent_ = VIDEO; 853 streamInfoVideo.encodeType_ = ENCODE_TYPE_H264; 854 streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode 855 streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerVideo_->CreateProducer()); 856 ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr); 857 streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 858 streamInfos.push_back(streamInfoVideo); 859 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 860 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 861 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 862 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 863 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 864 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 865 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO}; 866 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO}; 867 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 868} 869 870/** 871 * @tc.name: USB Camera 872 * @tc.desc: UpdateSettings, fps. 873 * @tc.level: Level0 874 * @tc.size: MediumTest 875 * @tc.type: Function 876 */ 877TEST_F(UtestUSBCameraTest, camera_usb_0028) 878{ 879 // Get the device manager 880 cameraBase_->OpenUsbCamera(); 881 if (!g_usbCameraExit) { 882 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 883 } 884 // get the stream manager 885 cameraBase_->AchieveStreamOperator(); 886 887 // start stream 888 cameraBase_->intents = {PREVIEW, VIDEO}; 889 cameraBase_->StartStream(cameraBase_->intents); 890 891 // updateSettings 892 const uint32_t ITEM_CAPACITY = 100; 893 const uint32_t DATA_CAPACITY = 2000; 894 const int32_t FPS_VALUE = 10; 895 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>( 896 ITEM_CAPACITY, DATA_CAPACITY); 897 std::vector<int32_t> fpsRange; 898 fpsRange.push_back(FPS_VALUE); 899 fpsRange.push_back(FPS_VALUE); 900 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size()); 901 const int32_t DEVICE_STREAM_ID = 0; 902 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1); 903 std::vector<uint8_t> setting; 904 MetadataUtils::ConvertMetadataToVec(meta, setting); 905 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting); 906 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 907 908 // get preview 909 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 910 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 911 912 // release stream 913 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO}; 914 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO}; 915 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 916} 917 918/** 919 * @tc.name: USB Camera 920 * @tc.desc: Commit 3 streams together, Preview,Video and still_capture streams, isStreaming is true. 921 * @tc.level: Level0 922 * @tc.size: MediumTest 923 * @tc.type: Function 924 */ 925TEST_F(UtestUSBCameraTest, camera_usb_0029) 926{ 927 // Get the device manager 928 cameraBase_->OpenUsbCamera(); 929 if (!g_usbCameraExit) { 930 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 931 } 932 // Get the stream manager 933 cameraBase_->AchieveStreamOperator(); 934 // start stream 935 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO}; 936 cameraBase_->StartStream(cameraBase_->intents); 937 // Get preview 938 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 939 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 940 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true); 941 // release stream 942 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE, 943 cameraBase_->CAPTURE_ID_VIDEO}; 944 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE, 945 cameraBase_->STREAM_ID_VIDEO}; 946 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 947} 948 949/** 950 * @tc.name: USB Camera 951 * @tc.desc: get value of OHOS_SENSOR_ORIENTATION 952 * @tc.level: Level0 953 * @tc.size: MediumTest 954 * @tc.type: Function 955 */ 956TEST_F(UtestUSBCameraTest, camera_usb_0030) 957{ 958 if (!g_usbCameraExit) { 959 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 960 } 961 ability_ = cameraBase_->GetCameraAbility(); 962 EXPECT_NE(ability_, nullptr); 963 common_metadata_header_t *data = ability_->get(); 964 camera_metadata_item_t entry; 965 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry); 966 EXPECT_EQ(ret, CAM_META_SUCCESS); 967 std::cout << "OHOS_SENSOR_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl; 968 EXPECT_TRUE(entry.data.u8[0] == 0); 969} 970 971/** 972 * @tc.name: USB Camera 973 * @tc.desc: get value of OHOS_ABILITY_FOCAL_LENGTH 974 * @tc.level: Level0 975 * @tc.size: MediumTest 976 * @tc.type: Function 977 */ 978TEST_F(UtestUSBCameraTest, camera_usb_0031) 979{ 980 if (!g_usbCameraExit) { 981 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 982 } 983 ability_ = cameraBase_->GetCameraAbility(); 984 EXPECT_NE(ability_, nullptr); 985 common_metadata_header_t *data = ability_->get(); 986 camera_metadata_item_t entry; 987 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry); 988 if (ret == CAM_META_SUCCESS) { 989 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH: count is " << (int)entry.count << std::endl; 990 std::cout << "log focal length value: " << entry.data.f[0] << std::endl; 991 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 992 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH is not support" << std::endl; 993 } 994} 995 996/** 997 * @tc.name: USB Camera 998 * @tc.desc: USB Camera, Select the camera according to the cameraId 999 * @tc.level: Level0 1000 * @tc.size: MediumTest 1001 * @tc.type: Function 1002 */ 1003TEST_F(UtestUSBCameraTest, camera_usb_0032) 1004{ 1005 // Get the device manager 1006 std::vector<std::string> usbCameraIds; 1007 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1008 if (usbCameraIds.size() > 2) { // 2:usb camera quantity 1009 g_usbCameraExit = true; 1010 } else { 1011 g_usbCameraExit = false; 1012 } 1013 for (int i = 0; i < usbCameraIds.size(); i++) { 1014 if (!g_usbCameraExit) { 1015 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1016 } 1017 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]); 1018 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR); 1019 // Get the stream manager 1020 cameraBase_->AchieveStreamOperator(); 1021 // start stream 1022 cameraBase_->intents = {PREVIEW, STILL_CAPTURE}; 1023 cameraBase_->StartStream(cameraBase_->intents); 1024 // Get preview 1025 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1026 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1027 // release stream 1028 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 1029 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 1030 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1031 } 1032} 1033 1034/** 1035 * @tc.name: USB Camera 1036 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success. 1037 * @tc.level: Level0 1038 * @tc.size: MediumTest 1039 * @tc.type: Function 1040 */ 1041TEST_F(UtestUSBCameraTest, camera_usb_0033) 1042{ 1043 std::vector<std::string> usbCameraIds; 1044 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1045 if (usbCameraIds.size() > 1) { // 2:usb camera quantity 1046 g_usbCameraExit = true; 1047 } else { 1048 g_usbCameraExit = false; 1049 } 1050 cameraBase_->OpenUsbCamera(); 1051 if (!g_usbCameraExit) { 1052 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1053 } 1054 cameraBase_->AchieveStreamOperator(); 1055 if (cameraBase_->streamCustomerPreview_ == nullptr) { 1056 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>(); 1057 } 1058 std::vector<StreamInfo> streamInfos; 1059 StreamInfo streamInfo = {}; 1060 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW; 1061 streamInfo.width_ = 1280; // 1280:picture width 1062 streamInfo.height_ = 960; // 720:picture height 1063 streamInfo.format_ = PIXEL_FMT_RGBA_8888; 1064 streamInfo.dataspace_ = 8; // 8:picture dataspace 1065 streamInfo.intent_ = PREVIEW; 1066 streamInfo.tunneledMode_ = 5; // 5:tunnel mode 1067 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer()); 1068 ASSERT_NE(streamInfo.bufferQueue_, nullptr); 1069 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 1070 streamInfos.push_back(streamInfo); 1071 if (cameraBase_->streamCustomerCapture_ == nullptr) { 1072 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>(); 1073 } 1074 StreamInfo streamInfoCapture = {}; 1075 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE; 1076 streamInfoCapture.width_ = 640; // 1280:picture width 1077 streamInfoCapture.height_ = 480; // 960:picture height 1078 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888; 1079 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace 1080 streamInfoCapture.intent_ = STILL_CAPTURE; 1081 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG; 1082 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode 1083 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable( 1084 cameraBase_->streamCustomerCapture_->CreateProducer()); 1085 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr); 1086 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size 1087 streamInfos.push_back(streamInfoCapture); 1088 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos); 1089 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1090 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_); 1091 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR); 1092 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true); 1093 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true); 1094 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE}; 1095 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE}; 1096 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds); 1097} 1098 1099/** 1100 * @tc.name: USB Camera 1101 * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_TIME 1102 * @tc.level: Level0 1103 * @tc.size: MediumTest 1104 * @tc.type: Function 1105 */ 1106TEST_F(UtestUSBCameraTest, camera_usb_0034) 1107{ 1108 std::vector<std::string> usbCameraIds; 1109 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1110 if (usbCameraIds.size() > 1) { // 2:usb camera quantity 1111 g_usbCameraExit = true; 1112 } else { 1113 g_usbCameraExit = false; 1114 } 1115 if (!g_usbCameraExit) { 1116 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1117 } 1118 ability_ = cameraBase_->GetCameraAbility(); 1119 EXPECT_NE(ability_, nullptr); 1120 common_metadata_header_t *data = ability_->get(); 1121 camera_metadata_item_t entry; 1122 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_TIME, &entry); 1123 if (ret == CAM_META_SUCCESS) { 1124 std::cout << "log OHOS_ABILITY_EXPOSURE_TIME: count is " << (int)entry.count << std::endl; 1125 std::cout << "log exposure time value: [" << entry.data.i32[0] << ", " << entry.data.i32[1] << "]" <<std::endl; 1126 std::cout << std::endl; 1127 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1128 std::cout << "OHOS_ABILITY_EXPOSURE_TIME is not support" << std::endl; 1129 } 1130} 1131 1132/** 1133 * @tc.name: USB Camera 1134 * @tc.desc: get value of OHOS_ABILITY_AE_LOCK 1135 * @tc.level: Level0 1136 * @tc.size: MediumTest 1137 * @tc.type: Function 1138 */ 1139TEST_F(UtestUSBCameraTest, camera_usb_0035) 1140{ 1141 std::vector<std::string> usbCameraIds; 1142 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1143 if (usbCameraIds.size() > 1) { // 2:usb camera quantity 1144 g_usbCameraExit = true; 1145 } else { 1146 g_usbCameraExit = false; 1147 } 1148 if (!g_usbCameraExit) { 1149 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1150 } 1151 ability_ = cameraBase_->GetCameraAbility(); 1152 EXPECT_NE(ability_, nullptr); 1153 common_metadata_header_t *data = ability_->get(); 1154 camera_metadata_item_t entry; 1155 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AE_LOCK, &entry); 1156 if (ret == CAM_META_SUCCESS) { 1157 std::cout << "supported ae lock list:"; 1158 for (int i = 0; i < entry.count; i++) { 1159 std::cout << " " << static_cast<int>(entry.data.u8[i]); 1160 } 1161 std::cout << std::endl; 1162 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1163 std::cout << "OHOS_ABILITY_AE_LOCK is not support" << std::endl; 1164 } 1165} 1166 1167/** 1168 * @tc.name: USB Camera 1169 * @tc.desc: get value of OHOS_ABILITY_AWB_MODES 1170 * @tc.level: Level0 1171 * @tc.size: MediumTest 1172 * @tc.type: Function 1173 */ 1174TEST_F(UtestUSBCameraTest, camera_usb_0036) 1175{ 1176 std::vector<std::string> usbCameraIds; 1177 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1178 if (usbCameraIds.size() > 1) { // 2:usb camera quantity 1179 g_usbCameraExit = true; 1180 } else { 1181 g_usbCameraExit = false; 1182 } 1183 if (!g_usbCameraExit) { 1184 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1185 } 1186 ability_ = cameraBase_->GetCameraAbility(); 1187 EXPECT_NE(ability_, nullptr); 1188 common_metadata_header_t *data = ability_->get(); 1189 camera_metadata_item_t entry; 1190 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AWB_MODES, &entry); 1191 if (ret == CAM_META_SUCCESS) { 1192 std::cout << "supported awb mode list:"; 1193 for (int i = 0; i < entry.count; i++) { 1194 std::cout << " " << static_cast<int>(entry.data.u8[i]); 1195 } 1196 std::cout << std::endl; 1197 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1198 std::cout << "OHOS_ABILITY_AWB_MODES is not support" << std::endl; 1199 } 1200} 1201 1202/** 1203 * @tc.name: USB Camera 1204 * @tc.desc: get value of OHOS_ABILITY_AWB_LOCK 1205 * @tc.level: Level0 1206 * @tc.size: MediumTest 1207 * @tc.type: Function 1208 */ 1209TEST_F(UtestUSBCameraTest, camera_usb_0037) 1210{ 1211 std::vector<std::string> usbCameraIds; 1212 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1213 if (usbCameraIds.size() > 1) { // 2:usb camera quantity 1214 g_usbCameraExit = true; 1215 } else { 1216 g_usbCameraExit = false; 1217 } 1218 if (!g_usbCameraExit) { 1219 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1220 } 1221 ability_ = cameraBase_->GetCameraAbility(); 1222 EXPECT_NE(ability_, nullptr); 1223 common_metadata_header_t *data = ability_->get(); 1224 camera_metadata_item_t entry; 1225 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AWB_LOCK, &entry); 1226 if (ret == CAM_META_SUCCESS) { 1227 std::cout << "supported awb list list:"; 1228 for (int i = 0; i < entry.count; i++) { 1229 std::cout << " " << static_cast<int>(entry.data.u8[i]); 1230 } 1231 std::cout << std::endl; 1232 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1233 std::cout << "OHOS_ABILITY_AWB_LOCK is not support" << std::endl; 1234 } 1235} 1236 1237/** 1238 * @tc.name: USB Camera 1239 * @tc.desc: get value of OHOS_ABILITY_METER_MODES 1240 * @tc.level: Level0 1241 * @tc.size: MediumTest 1242 * @tc.type: Function 1243 */ 1244TEST_F(UtestUSBCameraTest, camera_usb_0038) 1245{ 1246 std::vector<std::string> usbCameraIds; 1247 cameraBase_->cameraHost->GetCameraIds(usbCameraIds); 1248 if (usbCameraIds.size() > 1) { // 2:usb camera quantity 1249 g_usbCameraExit = true; 1250 } else { 1251 g_usbCameraExit = false; 1252 } 1253 if (!g_usbCameraExit) { 1254 GTEST_SKIP() << "No usb camera plugged in" << std::endl; 1255 } 1256 ability_ = cameraBase_->GetCameraAbility(); 1257 EXPECT_NE(ability_, nullptr); 1258 common_metadata_header_t *data = ability_->get(); 1259 camera_metadata_item_t entry; 1260 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry); 1261 if (ret == CAM_META_SUCCESS) { 1262 std::cout << "supported meter list list:"; 1263 for (int i = 0; i < entry.count; i++) { 1264 std::cout << " " << static_cast<int>(entry.data.u8[i]); 1265 } 1266 std::cout << std::endl; 1267 } else if (ret == CAM_META_ITEM_NOT_FOUND) { 1268 std::cout << "OHOS_ABILITY_METER_MODES is not support" << std::endl; 1269 } 1270} 1271