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
17 bool g_usbCameraExit = false;
18
SetUpTestCase(void)19 void UtestUSBCameraTest::SetUpTestCase(void)
20 {}
TearDownTestCase(void)21 void UtestUSBCameraTest::TearDownTestCase(void)
22 {}
SetUp(void)23 void UtestUSBCameraTest::SetUp(void)
24 {
25 if (cameraBase_ == nullptr)
26 cameraBase_ = std::make_shared<TestCameraBase>();
27 cameraBase_->UsbInit();
28 }
TearDown(void)29 void 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 */
TEST_F(UtestUSBCameraTest,camera_usb_0001)41 TEST_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 // 1:number of connected cameras
69 g_usbCameraExit = cameraIds.size() > 1;
70 }
71
72 /**
73 * @tc.name: USB Camera
74 * @tc.desc: get value of OHOS_ABILITY_ZOOM_RATIO_RANGE
75 * @tc.level: Level0
76 * @tc.size: MediumTest
77 * @tc.type: Function
78 */
TEST_F(UtestUSBCameraTest,camera_usb_0002)79 TEST_F(UtestUSBCameraTest, camera_usb_0002)
80 {
81 if (!g_usbCameraExit) {
82 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
83 }
84 ability_ = cameraBase_->GetCameraAbility();
85 EXPECT_NE(ability_, nullptr);
86 common_metadata_header_t *data = ability_->get();
87 camera_metadata_item_t entry;
88 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry);
89 if (ret == CAM_META_SUCCESS) {
90 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE: count is " << (int)entry.count << std::endl;
91 std::cout << "Zoom ratio range: [" << entry.data.f[0];
92 std::cout << "," << entry.data.f[1] << "]" << std::endl;
93 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
94 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE is not support" << std::endl;
95 }
96 }
97
98 /**
99 * @tc.name: USB Camera
100 * @tc.desc: get value of OHOS_ABILITY_CAMERA_CONNECTION_TYPE
101 * @tc.level: Level0
102 * @tc.size: MediumTest
103 * @tc.type: Function
104 */
TEST_F(UtestUSBCameraTest,camera_usb_0003)105 TEST_F(UtestUSBCameraTest, camera_usb_0003)
106 {
107 if (!g_usbCameraExit) {
108 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
109 }
110 ability_ = cameraBase_->GetCameraAbility();
111 EXPECT_NE(ability_, nullptr);
112 common_metadata_header_t *data = ability_->get();
113 camera_metadata_item_t entry;
114 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
115 EXPECT_EQ(ret, CAM_META_SUCCESS);
116 std::cout << "OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is "
117 << static_cast<int>(entry.data.u8[0]) << std::endl;
118 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN);
119 }
120
121 /**
122 * @tc.name: USB Camera
123 * @tc.desc: get value of OHOS_ABILITY_CAMERA_POSITION
124 * @tc.level: Level0
125 * @tc.size: MediumTest
126 * @tc.type: Function
127 */
TEST_F(UtestUSBCameraTest,camera_usb_0004)128 TEST_F(UtestUSBCameraTest, camera_usb_0004)
129 {
130 if (!g_usbCameraExit) {
131 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
132 }
133 ability_ = cameraBase_->GetCameraAbility();
134 EXPECT_NE(ability_, nullptr);
135 common_metadata_header_t *data = ability_->get();
136 camera_metadata_item_t entry;
137 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
138 EXPECT_EQ(ret, CAM_META_SUCCESS);
139 std::cout << "OHOS_ABILITY_CAMERA_POSITION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
140 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_FRONT);
141 }
142
143 /**
144 * @tc.name: USB Camera
145 * @tc.desc: get value of OHOS_ABILITY_FLASH_AVAILABLE
146 * @tc.level: Level0
147 * @tc.size: MediumTest
148 * @tc.type: Function
149 */
TEST_F(UtestUSBCameraTest,camera_usb_0005)150 TEST_F(UtestUSBCameraTest, camera_usb_0005)
151 {
152 if (!g_usbCameraExit) {
153 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
154 }
155 ability_ = cameraBase_->GetCameraAbility();
156 EXPECT_NE(ability_, nullptr);
157 common_metadata_header_t *data = ability_->get();
158 camera_metadata_item_t entry;
159 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry);
160 EXPECT_EQ(ret, CAM_META_SUCCESS);
161 std::cout << "OHOS_ABILITY_FLASH_AVAILABLE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
162 }
163
164 /**
165 * @tc.name: USB Camera
166 * @tc.desc: get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES
167 * @tc.level: Level0
168 * @tc.size: MediumTest
169 * @tc.type: Function
170 */
TEST_F(UtestUSBCameraTest,camera_usb_0006)171 TEST_F(UtestUSBCameraTest, camera_usb_0006)
172 {
173 if (!g_usbCameraExit) {
174 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
175 }
176 ability_ = cameraBase_->GetCameraAbility();
177 EXPECT_NE(ability_, nullptr);
178 common_metadata_header_t *data = ability_->get();
179 camera_metadata_item_t entry;
180 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry);
181 if (ret == CAM_META_SUCCESS) {
182 for (int i = 0; i < entry.count; i++) {
183 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is "
184 << static_cast<int>(entry.data.u8[i]) << std::endl;
185 }
186 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
187 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support" << std::endl;
188 }
189 }
190
191 /**
192 * @tc.name: USB Camera
193 * @tc.desc: get value of OHOS_ABILITY_FLASH_MODES
194 * @tc.level: Level0
195 * @tc.size: MediumTest
196 * @tc.type: Function
197 */
TEST_F(UtestUSBCameraTest,camera_usb_007)198 TEST_F(UtestUSBCameraTest, camera_usb_007)
199 {
200 if (!g_usbCameraExit) {
201 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
202 }
203 ability_ = cameraBase_->GetCameraAbility();
204 common_metadata_header_t *data = ability_->get();
205 camera_metadata_item_t entry;
206 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
207 if (ret == CAM_META_SUCCESS) {
208 std::cout << "supported flash mode list:";
209 for (int i = 0; i < entry.count; i++) {
210 std::cout << " " << static_cast<int>(entry.data.u8[i]);
211 }
212 std::cout << std::endl;
213 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
214 std::cout << "OHOS_ABILITY_FLASH_MODES is not support" << std::endl;
215 }
216 }
217
218 /**
219 * @tc.name: USB Camera
220 * @tc.desc: get value of OHOS_ABILITY_FOCUS_MODES
221 * @tc.level: Level0
222 * @tc.size: MediumTest
223 * @tc.type: Function
224 */
TEST_F(UtestUSBCameraTest,camera_usb_008)225 TEST_F(UtestUSBCameraTest, camera_usb_008)
226 {
227 if (!g_usbCameraExit) {
228 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
229 }
230 ability_ = cameraBase_->GetCameraAbility();
231 EXPECT_NE(ability_, nullptr);
232 common_metadata_header_t *data = ability_->get();
233 camera_metadata_item_t entry;
234 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
235 if (ret == CAM_META_SUCCESS) {
236 std::cout << "supported focus mode list:";
237 for (int i = 0; i < entry.count; i++) {
238 std::cout << " " << static_cast<int>(entry.data.u8[i]);
239 }
240 std::cout << std::endl;
241 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
242 std::cout << "OHOS_ABILITY_FOCUS_MODES is not support" << std::endl;
243 }
244 }
245
246 /**
247 * @tc.name: USB Camera
248 * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_MODES
249 * @tc.level: Level0
250 * @tc.size: MediumTest
251 * @tc.type: Function
252 */
TEST_F(UtestUSBCameraTest,camera_usb_009)253 TEST_F(UtestUSBCameraTest, camera_usb_009)
254 {
255 if (!g_usbCameraExit) {
256 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
257 }
258 ability_ = cameraBase_->GetCameraAbility();
259 EXPECT_NE(ability_, nullptr);
260 common_metadata_header_t *data = ability_->get();
261 camera_metadata_item_t entry;
262 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
263 if (ret == CAM_META_SUCCESS) {
264 std::cout << "supported exposure mode list:";
265 for (int i = 0; i < entry.count; i++) {
266 std::cout << " " << static_cast<int>(entry.data.u8[i]);
267 }
268 std::cout << std::endl;
269 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
270 std::cout << "OHOS_ABILITY_EXPOSURE_MODES is not support" << std::endl;
271 }
272 }
273
274 /**
275 * @tc.name: USB Camera
276 * @tc.desc: get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED
277 * @tc.level: Level0
278 * @tc.size: MediumTest
279 * @tc.type: Function
280 */
TEST_F(UtestUSBCameraTest,camera_usb_0010)281 TEST_F(UtestUSBCameraTest, camera_usb_0010)
282 {
283 if (!g_usbCameraExit) {
284 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
285 }
286 ability_ = cameraBase_->GetCameraAbility();
287 EXPECT_NE(ability_, nullptr);
288 common_metadata_header_t *data = ability_->get();
289 camera_metadata_item_t entry;
290 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
291 EXPECT_EQ(ret, CAM_META_SUCCESS);
292 std::cout << "capture mirror supported is :";
293 for (int i = 0; i < entry.count; i++) {
294 std::cout << " " << static_cast<int>(entry.data.u8[i]);
295 }
296 std::cout << std::endl;
297 }
298
299 /**
300 * @tc.name: USB Camera
301 * @tc.desc: get value of OHOS_ABILITY_MUTE_MODES
302 * @tc.level: Level0
303 * @tc.size: MediumTest
304 * @tc.type: Function
305 */
TEST_F(UtestUSBCameraTest,camera_usb_0011)306 TEST_F(UtestUSBCameraTest, camera_usb_0011)
307 {
308 if (!g_usbCameraExit) {
309 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
310 }
311 ability_ = cameraBase_->GetCameraAbility();
312 EXPECT_NE(ability_, nullptr);
313 common_metadata_header_t *data = ability_->get();
314 camera_metadata_item_t entry;
315 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry);
316 if (ret == CAM_META_SUCCESS) {
317 std::cout << "supported mute mode is:";
318 for (int i = 0; i < entry.count; i++) {
319 std::cout << " " << static_cast<int>(entry.data.u8[i]);
320 }
321 std::cout << std::endl;
322 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
323 std::cout << "OHOS_ABILITY_MUTE_MODES is not support" << std::endl;
324 }
325 }
326
327 /**
328 * @tc.name: USB Camera
329 * @tc.desc: get value of OHOS_ABILITY_FPS_RANGES
330 * @tc.level: Level0
331 * @tc.size: MediumTest
332 * @tc.type: Function
333 */
TEST_F(UtestUSBCameraTest,camera_usb_0012)334 TEST_F(UtestUSBCameraTest, camera_usb_0012)
335 {
336 if (!g_usbCameraExit) {
337 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
338 }
339 ability_ = cameraBase_->GetCameraAbility();
340 EXPECT_NE(ability_, nullptr);
341 common_metadata_header_t *data = ability_->get();
342 camera_metadata_item_t entry;
343 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
344 EXPECT_EQ(ret, CAM_META_SUCCESS);
345 std::cout << "supported fps ranges list: [";
346 std::cout << static_cast<int>(entry.data.i32[0]) << "," << static_cast<int>(entry.data.i32[1]) << "]";
347 std::cout << std::endl;
348 }
349
350 /**
351 * @tc.name: USB Camera
352 * @tc.desc: get value of OHOS_ABILITY_CAMERA_TYPE
353 * @tc.level: Level0
354 * @tc.size: MediumTest
355 * @tc.type: Function
356 */
TEST_F(UtestUSBCameraTest,camera_usb_0013)357 TEST_F(UtestUSBCameraTest, camera_usb_0013)
358 {
359 if (!g_usbCameraExit) {
360 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
361 }
362 ability_ = cameraBase_->GetCameraAbility();
363 EXPECT_NE(ability_, nullptr);
364 common_metadata_header_t *data = ability_->get();
365 camera_metadata_item_t entry;
366 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
367 EXPECT_EQ(ret, CAM_META_SUCCESS);
368 std::cout << "OHOS_ABILITY_CAMERA_TYPE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
369 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED);
370 }
371
372 /**
373 * @tc.name: USB Camera
374 * @tc.desc: get value of OHOS_JPEG_ORIENTATION
375 * @tc.level: Level0
376 * @tc.size: MediumTest
377 * @tc.type: Function
378 */
TEST_F(UtestUSBCameraTest,camera_usb_0014)379 TEST_F(UtestUSBCameraTest, camera_usb_0014)
380 {
381 if (!g_usbCameraExit) {
382 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
383 }
384 ability_ = cameraBase_->GetCameraAbility();
385 EXPECT_NE(ability_, nullptr);
386 common_metadata_header_t *data = ability_->get();
387 camera_metadata_item_t entry;
388 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry);
389 EXPECT_EQ(ret, CAM_META_SUCCESS);
390 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.i32[0]) << std::endl;
391 }
392
393 /**
394 * @tc.name: USB Camera
395 * @tc.desc: get value of OHOS_JPEG_QUALITY
396 * @tc.level: Level0
397 * @tc.size: MediumTest
398 * @tc.type: Function
399 */
TEST_F(UtestUSBCameraTest,camera_usb_0015)400 TEST_F(UtestUSBCameraTest, camera_usb_0015)
401 {
402 if (!g_usbCameraExit) {
403 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
404 }
405 ability_ = cameraBase_->GetCameraAbility();
406 EXPECT_NE(ability_, nullptr);
407 common_metadata_header_t *data = ability_->get();
408 camera_metadata_item_t entry;
409 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry);
410 EXPECT_EQ(ret, CAM_META_SUCCESS);
411 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
412 }
413
414 /**
415 * @tc.name: USB Camera
416 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS
417 * @tc.level: Level0
418 * @tc.size: MediumTest
419 * @tc.type: Function
420 */
TEST_F(UtestUSBCameraTest,camera_usb_0016)421 TEST_F(UtestUSBCameraTest, camera_usb_0016)
422 {
423 if (!g_usbCameraExit) {
424 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
425 }
426 ability_ = cameraBase_->GetCameraAbility();
427 EXPECT_NE(ability_, nullptr);
428 common_metadata_header_t *data = ability_->get();
429 camera_metadata_item_t entry;
430 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
431 EXPECT_EQ(ret, CAM_META_SUCCESS);
432 std::cout << "OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is "
433 << static_cast<int>(entry.data.u8[0]) << std::endl;
434 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888);
435 }
436
437 /**
438 * @tc.name: USB Camera
439 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
440 * @tc.level: Level0
441 * @tc.size: MediumTest
442 * @tc.type: Function
443 */
TEST_F(UtestUSBCameraTest,camera_usb_0017)444 TEST_F(UtestUSBCameraTest, camera_usb_0017)
445 {
446 if (!g_usbCameraExit) {
447 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
448 }
449 ability_ = cameraBase_->GetCameraAbility();
450 EXPECT_NE(ability_, nullptr);
451 common_metadata_header_t *data = ability_->get();
452 EXPECT_NE(data, nullptr);
453 camera_metadata_item_t entry;
454 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
455 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
456 std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start." << std::endl;
457 const size_t STEP = 10; // print step
458 std::cout << "count" << entry.count << std::endl;
459 for (size_t i = 0; i < entry.count; i++) {
460 std::cout << entry.data.i32[i] << " ";
461 if ((i != 0) && (i % STEP == 0 || i == entry.count - 1)) {
462 std::cout << std::endl;
463 }
464 }
465 std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end." << std::endl;
466 }
467 }
468
469 /**
470 * @tc.name: USB Camera
471 * @tc.desc: Preview stream, expected success.
472 * @tc.level: Level0
473 * @tc.size: MediumTest
474 * @tc.type: Function
475 */
TEST_F(UtestUSBCameraTest,camera_usb_0018)476 TEST_F(UtestUSBCameraTest, camera_usb_0018)
477 {
478 if (!g_usbCameraExit) {
479 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
480 }
481 // Get the device manager
482 cameraBase_->OpenUsbCamera();
483 // Get the stream manager
484 cameraBase_->AchieveStreamOperator();
485 // start stream
486 cameraBase_->intents = {PREVIEW};
487 cameraBase_->StartStream(cameraBase_->intents);
488 // Get preview
489 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
490 // release stream
491 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
492 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
493 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
494 }
495
496 /**
497 * @tc.name: USB Camera
498 * @tc.desc: Preview stream, width = 1280, height = 720, expected success.
499 * @tc.level: Level0
500 * @tc.size: MediumTest
501 * @tc.type: Function
502 */
TEST_F(UtestUSBCameraTest,camera_usb_0019)503 TEST_F(UtestUSBCameraTest, camera_usb_0019)
504 {
505 if (!g_usbCameraExit) {
506 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
507 }
508 // Get the device manager
509 cameraBase_->OpenUsbCamera();
510 // Create and get streamOperator information
511 cameraBase_->AchieveStreamOperator();
512 // Create data stream
513 if (cameraBase_->streamCustomerPreview_ == nullptr) {
514 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
515 }
516 OHOS::sptr<OHOS::IBufferProducer> producer = cameraBase_->streamCustomerPreview_->CreateProducer();
517 producer->SetQueueSize(8); // 8:set bufferQueue size
518
519 std::vector<StreamInfo> streamInfos;
520 StreamInfo streamInfo = {};
521 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
522 streamInfo.width_ = 1280; // 1280:picture width
523 streamInfo.height_ = 720; // 720:picture height
524 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
525 streamInfo.dataspace_ = 8; // 8:picture dataspace
526 streamInfo.intent_ = PREVIEW;
527 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
528 streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
529 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
530 std::vector<StreamInfo>().swap(streamInfos);
531 streamInfos.push_back(streamInfo);
532 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
533 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
534 // Submit stream information
535 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
536 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
537 // capture
538 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
539 // release stream
540 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
541 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
542 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
543 }
544
545 /**
546 * @tc.name: USB Camera
547 * @tc.desc: UpdateSettings, fps.
548 * @tc.level: Level0
549 * @tc.size: MediumTest
550 * @tc.type: Function
551 */
TEST_F(UtestUSBCameraTest,camera_usb_0020)552 TEST_F(UtestUSBCameraTest, camera_usb_0020)
553 {
554 if (!g_usbCameraExit) {
555 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
556 }
557 // Get the device manager
558 cameraBase_->OpenUsbCamera();
559 // get the stream manager
560 cameraBase_->AchieveStreamOperator();
561
562 // start stream
563 cameraBase_->intents = {PREVIEW};
564 cameraBase_->StartStream(cameraBase_->intents);
565
566 // updateSettings
567 const uint32_t ITEM_CAPACITY = 100;
568 const uint32_t DATA_CAPACITY = 2000;
569 const int32_t FPS_VALUE = 10;
570 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
571 ITEM_CAPACITY, DATA_CAPACITY);
572 std::vector<int32_t> fpsRange;
573 fpsRange.push_back(FPS_VALUE);
574 fpsRange.push_back(FPS_VALUE);
575 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
576 const int32_t DEVICE_STREAM_ID = 0;
577 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
578 std::vector<uint8_t> setting;
579 MetadataUtils::ConvertMetadataToVec(meta, setting);
580 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
581 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
582
583 // get preview
584 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
585
586 // release stream
587 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
588 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
589 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
590 }
591
592 /**
593 * @tc.name: USB Camera
594 * @tc.desc: USB Camera, OnCameraStatus and OnCameraEvent.
595 * @tc.level: Level0
596 * @tc.size: MediumTest
597 * @tc.type: Function
598 */
TEST_F(UtestUSBCameraTest,camera_usb_0021)599 TEST_F(UtestUSBCameraTest, camera_usb_0021)
600 {
601 uint32_t rc = 0;
602 std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl;
603 std::vector<std::string> cameraIds;
604 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
605 cameraBase_->cameraHost->GetCameraIds(cameraIds);
606 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
607 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl;
608 for (const auto &cameraId : cameraIds) {
609 std::cout << "==========[test log] cameraId = " << cameraId << std::endl;
610 }
611 const int count = 4;
612 for (int i = 0; i < count; i++) {
613 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 3s..."<< std::endl;
614 sleep(3); // judging add or delete the usb camera, wait for 3s.
615 }
616 std::cout << "==========[test log] 3. check the cameraID again... wait for 3s..."<< std::endl;
617 sleep(3); // checking the cameraID again, wait for 3s.
618 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
619 if (cameraIds.size() == 1) {
620 cameraIds.clear();
621 }
622 rc = cameraBase_->cameraHost->GetCameraIds(cameraIds);
623 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
624 for (const auto &cameraId : cameraIds) {
625 std::cout << "cameraId = " << cameraId << std::endl;
626 }
627 // 1:number of connected cameras
628 g_usbCameraExit = cameraIds.size() > 1;
629 }
630
631 /**
632 * @tc.name: USB Camera
633 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
634 * @tc.level: Level0
635 * @tc.size: MediumTest
636 * @tc.type: Function
637 */
TEST_F(UtestUSBCameraTest,camera_usb_0022)638 TEST_F(UtestUSBCameraTest, camera_usb_0022)
639 {
640 // Get the device manager
641 cameraBase_->OpenUsbCamera();
642 if (!g_usbCameraExit) {
643 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
644 }
645 // Get the stream manager
646 cameraBase_->AchieveStreamOperator();
647 // start stream
648 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
649 cameraBase_->StartStream(cameraBase_->intents);
650 // Get preview
651 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
652 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
653 // release stream
654 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
655 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
656 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
657 }
658
659 /**
660 * @tc.name: USB Camera
661 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
662 * @tc.level: Level0
663 * @tc.size: MediumTest
664 * @tc.type: Function
665 */
TEST_F(UtestUSBCameraTest,camera_usb_0023)666 TEST_F(UtestUSBCameraTest, camera_usb_0023)
667 {
668 cameraBase_->OpenUsbCamera();
669 if (!g_usbCameraExit) {
670 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
671 }
672 cameraBase_->AchieveStreamOperator();
673 if (cameraBase_->streamCustomerPreview_ == nullptr) {
674 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
675 }
676 std::vector<StreamInfo> streamInfos;
677 StreamInfo streamInfo = {};
678 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
679 streamInfo.width_ = 1280; // 1280:picture width
680 streamInfo.height_ = 720; // 720:picture height
681 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
682 streamInfo.dataspace_ = 8; // 8:picture dataspace
683 streamInfo.intent_ = PREVIEW;
684 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
685 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
686 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
687 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
688 streamInfos.push_back(streamInfo);
689 if (cameraBase_->streamCustomerCapture_ == nullptr) {
690 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
691 }
692 StreamInfo streamInfoCapture = {};
693 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
694 streamInfoCapture.width_ = 1280; // 1280:picture width
695 streamInfoCapture.height_ = 960; // 960:picture height
696 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
697 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
698 streamInfoCapture.intent_ = STILL_CAPTURE;
699 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
700 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
701 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
702 cameraBase_->streamCustomerCapture_->CreateProducer());
703 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
704 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
705 streamInfos.push_back(streamInfoCapture);
706 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
707 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
708 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
709 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
710 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
711 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
712 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
713 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
714 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
715 }
716
717 /**
718 * @tc.name: preview and capture
719 * @tc.desc: Commit 2 streams together, Change the value OHOS_JPEG_ORIENTATION, isStreaming is true.
720 * @tc.level: Level0
721 * @tc.size: MediumTest
722 * @tc.type: Function
723 */
TEST_F(UtestUSBCameraTest,camera_usb_0024)724 TEST_F(UtestUSBCameraTest, camera_usb_0024)
725 {
726 // Get the device manager
727 cameraBase_->OpenUsbCamera();
728 if (!g_usbCameraExit) {
729 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
730 }
731 // Get the stream manager
732 cameraBase_->AchieveStreamOperator();
733 std::vector<int32_t> jpegOrientationVector;
734 jpegOrientationVector.push_back(OHOS_CAMERA_JPEG_ROTATION_270);
735 cameraBase_->ability->updateEntry(OHOS_JPEG_ORIENTATION, jpegOrientationVector.data(),
736 jpegOrientationVector.size());
737 cameraBase_->ability_.clear();
738 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_);
739 // start stream
740 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
741 cameraBase_->StartStream(cameraBase_->intents);
742
743 // Get preview
744 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
745 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
746 // release stream
747 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
748 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
749 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
750 }
751
752 /**
753 * @tc.name: preview and capture
754 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
755 * @tc.level: Level0
756 * @tc.size: MediumTest
757 * @tc.type: Function
758 */
TEST_F(UtestUSBCameraTest,camera_usb_0025)759 TEST_F(UtestUSBCameraTest, camera_usb_0025)
760 {
761 // Get the device manager
762 cameraBase_->OpenUsbCamera();
763 if (!g_usbCameraExit) {
764 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
765 }
766 // Get the stream manager
767 cameraBase_->AchieveStreamOperator();
768 std::vector<int32_t> jpegQualityVector;
769 jpegQualityVector.push_back(OHOS_CAMERA_JPEG_LEVEL_LOW);
770 cameraBase_->ability->updateEntry(OHOS_JPEG_QUALITY, jpegQualityVector.data(), jpegQualityVector.size());
771 cameraBase_->ability_.clear();
772 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_);
773 // start stream
774 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
775 cameraBase_->StartStream(cameraBase_->intents);
776
777 // Get preview
778 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
779 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
780 // release stream
781 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
782 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
783 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
784 }
785
786 /**
787 * @tc.name: Video
788 * @tc.desc: Preview + video, commit together, success.
789 * @tc.level: Level0
790 * @tc.size: MediumTest
791 * @tc.type: Function
792 */
TEST_F(UtestUSBCameraTest,camera_usb_0026)793 TEST_F(UtestUSBCameraTest, camera_usb_0026)
794 {
795 // Get the device manager
796 cameraBase_->OpenUsbCamera();
797 if (!g_usbCameraExit) {
798 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
799 }
800 // Create and get streamOperator information
801 cameraBase_->AchieveStreamOperator();
802 // start stream
803 cameraBase_->intents = {PREVIEW, VIDEO};
804 cameraBase_->StartStream(cameraBase_->intents);
805 // Get preview
806 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
807 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
808
809 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
810 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
811 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
812 }
813
814 /**
815 * @tc.name: USB Camera
816 * @tc.desc: Preview stream, width = 1280, height = 720, expected success.
817 * @tc.level: Level0
818 * @tc.size: MediumTest
819 * @tc.type: Function
820 */
TEST_F(UtestUSBCameraTest,camera_usb_0027)821 TEST_F(UtestUSBCameraTest, camera_usb_0027)
822 {
823 cameraBase_->OpenUsbCamera();
824 if (!g_usbCameraExit) {
825 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
826 }
827 cameraBase_->AchieveStreamOperator();
828 if (cameraBase_->streamCustomerPreview_ == nullptr) {
829 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
830 }
831 std::vector<StreamInfo> streamInfos;
832 StreamInfo streamInfo = {};
833 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
834 streamInfo.width_ = 1280; // 1280:picture width
835 streamInfo.height_ = 720; // 720:picture height
836 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
837 streamInfo.dataspace_ = 8; // 8:picture dataspace
838 streamInfo.intent_ = PREVIEW;
839 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
840 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
841 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
842 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
843 streamInfos.push_back(streamInfo);
844 if (cameraBase_->streamCustomerVideo_ == nullptr) {
845 cameraBase_->streamCustomerVideo_ = std::make_shared<StreamCustomer>();
846 }
847 StreamInfo streamInfoVideo = {};
848 streamInfoVideo.streamId_ = cameraBase_->STREAM_ID_VIDEO;
849 streamInfoVideo.width_ = 1280; // 1280:picture width
850 streamInfoVideo.height_ = 960; // 960:picture height
851 streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888;
852 streamInfoVideo.dataspace_ = 8; // 8:picture dataspace
853 streamInfoVideo.intent_ = VIDEO;
854 streamInfoVideo.encodeType_ = ENCODE_TYPE_H264;
855 streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode
856 streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerVideo_->CreateProducer());
857 ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr);
858 streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
859 streamInfos.push_back(streamInfoVideo);
860 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
861 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
862 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
863 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
864 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
865 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
866 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
867 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
868 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
869 }
870
871 /**
872 * @tc.name: USB Camera
873 * @tc.desc: UpdateSettings, fps.
874 * @tc.level: Level0
875 * @tc.size: MediumTest
876 * @tc.type: Function
877 */
TEST_F(UtestUSBCameraTest,camera_usb_0028)878 TEST_F(UtestUSBCameraTest, camera_usb_0028)
879 {
880 // Get the device manager
881 cameraBase_->OpenUsbCamera();
882 if (!g_usbCameraExit) {
883 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
884 }
885 // get the stream manager
886 cameraBase_->AchieveStreamOperator();
887
888 // start stream
889 cameraBase_->intents = {PREVIEW, VIDEO};
890 cameraBase_->StartStream(cameraBase_->intents);
891
892 // updateSettings
893 const uint32_t ITEM_CAPACITY = 100;
894 const uint32_t DATA_CAPACITY = 2000;
895 const int32_t FPS_VALUE = 10;
896 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
897 ITEM_CAPACITY, DATA_CAPACITY);
898 std::vector<int32_t> fpsRange;
899 fpsRange.push_back(FPS_VALUE);
900 fpsRange.push_back(FPS_VALUE);
901 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
902 const int32_t DEVICE_STREAM_ID = 0;
903 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
904 std::vector<uint8_t> setting;
905 MetadataUtils::ConvertMetadataToVec(meta, setting);
906 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
907 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
908
909 // get preview
910 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
911 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
912
913 // release stream
914 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
915 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
916 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
917 }
918
919 /**
920 * @tc.name: USB Camera
921 * @tc.desc: Commit 3 streams together, Preview,Video and still_capture streams, isStreaming is true.
922 * @tc.level: Level0
923 * @tc.size: MediumTest
924 * @tc.type: Function
925 */
TEST_F(UtestUSBCameraTest,camera_usb_0029)926 TEST_F(UtestUSBCameraTest, camera_usb_0029)
927 {
928 // Get the device manager
929 cameraBase_->OpenUsbCamera();
930 if (!g_usbCameraExit) {
931 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
932 }
933 // Get the stream manager
934 cameraBase_->AchieveStreamOperator();
935 // start stream
936 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
937 cameraBase_->StartStream(cameraBase_->intents);
938 // Get preview
939 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
940 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
941 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
942 // release stream
943 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
944 cameraBase_->CAPTURE_ID_VIDEO};
945 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
946 cameraBase_->STREAM_ID_VIDEO};
947 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
948 }
949
950 /**
951 * @tc.name: USB Camera
952 * @tc.desc: get value of OHOS_SENSOR_ORIENTATION
953 * @tc.level: Level0
954 * @tc.size: MediumTest
955 * @tc.type: Function
956 */
TEST_F(UtestUSBCameraTest,camera_usb_0030)957 TEST_F(UtestUSBCameraTest, camera_usb_0030)
958 {
959 if (!g_usbCameraExit) {
960 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
961 }
962 ability_ = cameraBase_->GetCameraAbility();
963 EXPECT_NE(ability_, nullptr);
964 common_metadata_header_t *data = ability_->get();
965 camera_metadata_item_t entry;
966 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
967 EXPECT_EQ(ret, CAM_META_SUCCESS);
968 std::cout << "OHOS_SENSOR_ORIENTATION value is " << entry.data.i32[0] << std::endl;
969 EXPECT_TRUE(entry.data.i32[0] == 0);
970 }
971
972 /**
973 * @tc.name: USB Camera
974 * @tc.desc: get value of OHOS_ABILITY_FOCAL_LENGTH
975 * @tc.level: Level0
976 * @tc.size: MediumTest
977 * @tc.type: Function
978 */
TEST_F(UtestUSBCameraTest,camera_usb_0031)979 TEST_F(UtestUSBCameraTest, camera_usb_0031)
980 {
981 if (!g_usbCameraExit) {
982 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
983 }
984 ability_ = cameraBase_->GetCameraAbility();
985 EXPECT_NE(ability_, nullptr);
986 common_metadata_header_t *data = ability_->get();
987 camera_metadata_item_t entry;
988 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
989 if (ret == CAM_META_SUCCESS) {
990 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH: count is " << (int)entry.count << std::endl;
991 std::cout << "log focal length value: " << entry.data.f[0] << std::endl;
992 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
993 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH is not support" << std::endl;
994 }
995 }
996
997 /**
998 * @tc.name: USB Camera
999 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
1000 * @tc.level: Level0
1001 * @tc.size: MediumTest
1002 * @tc.type: Function
1003 */
TEST_F(UtestUSBCameraTest,camera_usb_0032)1004 TEST_F(UtestUSBCameraTest, camera_usb_0032)
1005 {
1006 // Get the device manager
1007 std::vector<std::string> usbCameraIds;
1008 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1009 // 1:number of connected cameras
1010 g_usbCameraExit = usbCameraIds.size() > 1;
1011 for (int i = 0; i < usbCameraIds.size(); i++) {
1012 if (!g_usbCameraExit) {
1013 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1014 }
1015 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
1016 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1017 // Get the stream manager
1018 cameraBase_->AchieveStreamOperator();
1019 // start stream
1020 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
1021 cameraBase_->StartStream(cameraBase_->intents);
1022 // Get preview
1023 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1024 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1025 // release stream
1026 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1027 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1028 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1029 }
1030 }
1031
1032 /**
1033 * @tc.name: USB Camera
1034 * @tc.desc: Open the capture stream for both cameras at the same time.
1035 * @tc.level: Level0
1036 * @tc.size: MediumTest
1037 * @tc.type: Function
1038 */
TEST_F(UtestUSBCameraTest,camera_usb_0033)1039 TEST_F(UtestUSBCameraTest, camera_usb_0033)
1040 {
1041 // Get the device manager
1042 std::vector<std::string> usbCameraIds;
1043 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1044 // 1:number of connected cameras
1045 g_usbCameraExit = usbCameraIds.size() > 1;
1046 for (int i = 0; i < usbCameraIds.size(); i++) {
1047 if (!g_usbCameraExit) {
1048 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1049 }
1050 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
1051 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1052 // Get the stream manager
1053 cameraBase_->AchieveStreamOperator();
1054 // start stream
1055 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1056 cameraBase_->StartStream(cameraBase_->intents);
1057 // Get preview
1058 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1059 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1060 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1061 // release stream
1062 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
1063 cameraBase_->CAPTURE_ID_VIDEO};
1064 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
1065 cameraBase_->STREAM_ID_VIDEO};
1066 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1067 }
1068 }
1069
1070 /**
1071 * @tc.name: USB Camera
1072 * @tc.desc: One camera starts capturing and the other camera starts recording.
1073 * @tc.level: Level0
1074 * @tc.size: MediumTest
1075 * @tc.type: Function
1076 */
TEST_F(UtestUSBCameraTest,camera_usb_0034)1077 TEST_F(UtestUSBCameraTest, camera_usb_0034)
1078 {
1079 // Get the device manager
1080 std::vector<std::string> usbCameraIds;
1081 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1082 // 1:number of connected cameras
1083 g_usbCameraExit = usbCameraIds.size() > 1;
1084 if (!g_usbCameraExit) {
1085 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1086 }
1087 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]);
1088 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1089 // Get the stream manager
1090 cameraBase_->AchieveStreamOperator();
1091 // start stream
1092 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
1093 cameraBase_->StartStream(cameraBase_->intents);
1094 // Get preview
1095 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1096 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1097 // release stream
1098 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1099 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1100 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1101
1102 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[1]);
1103 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1104 // Get the stream manager
1105 cameraBase_->AchieveStreamOperator();
1106 // start stream
1107 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1108 cameraBase_->StartStream(cameraBase_->intents);
1109 // Get preview
1110 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1111 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1112 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1113 // release stream
1114 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
1115 cameraBase_->CAPTURE_ID_VIDEO};
1116 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
1117 cameraBase_->STREAM_ID_VIDEO};
1118 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1119 }
1120
1121 /**
1122 * @tc.name: USB Camera
1123 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_ZOOM_RATIO_RANGE
1124 * @tc.level: Level0
1125 * @tc.size: MediumTest
1126 * @tc.type: Function
1127 */
TEST_F(UtestUSBCameraTest,camera_usb_0035)1128 TEST_F(UtestUSBCameraTest, camera_usb_0035)
1129 {
1130 // Get the device manager
1131 std::vector<std::string> usbCameraIds;
1132 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1133 // 1:number of connected cameras
1134 g_usbCameraExit = usbCameraIds.size() > 1;
1135 for (int i = 0; i < usbCameraIds.size(); i++) {
1136 if (!g_usbCameraExit) {
1137 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1138 }
1139 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1140 EXPECT_NE(ability_, nullptr);
1141 common_metadata_header_t *data = ability_->get();
1142 camera_metadata_item_t entry;
1143 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry);
1144 if (ret == CAM_META_SUCCESS) {
1145 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE: count is %{public}d ", entry.count);
1146 CAMERA_LOGD("Zoom ratio range: [%{public}d,[%{public}d]", entry.data.f[0], entry.data.f[1]);
1147 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1148 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE is not support");
1149 }
1150 }
1151 }
1152
1153 /**
1154 * @tc.name: USB Camera
1155 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_AVAILABLE
1156 * @tc.level: Level0
1157 * @tc.size: MediumTest
1158 * @tc.type: Function
1159 */
TEST_F(UtestUSBCameraTest,camera_usb_0036)1160 TEST_F(UtestUSBCameraTest, camera_usb_0036)
1161 {
1162 // Get the device manager
1163 std::vector<std::string> usbCameraIds;
1164 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1165 // 1:number of connected cameras
1166 g_usbCameraExit = usbCameraIds.size() > 1;
1167 for (int i = 0; i < usbCameraIds.size(); i++) {
1168 if (!g_usbCameraExit) {
1169 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1170 }
1171 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1172 EXPECT_NE(ability_, nullptr);
1173 common_metadata_header_t *data = ability_->get();
1174 camera_metadata_item_t entry;
1175 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry);
1176 EXPECT_EQ(ret, CAM_META_SUCCESS);
1177 CAMERA_LOGD("OHOS_ABILITY_FLASH_AVAILABLE value is %{public}d", entry.data.u8[0]);
1178 }
1179 }
1180
1181 /**
1182 * @tc.name: USB Camera
1183 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES
1184 * @tc.level: Level0
1185 * @tc.size: MediumTest
1186 * @tc.type: Function
1187 */
TEST_F(UtestUSBCameraTest,camera_usb_0037)1188 TEST_F(UtestUSBCameraTest, camera_usb_0037)
1189 {
1190 // Get the device manager
1191 std::vector<std::string> usbCameraIds;
1192 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1193 // 1:number of connected cameras
1194 g_usbCameraExit = usbCameraIds.size() > 1;
1195 for (int i = 0; i < usbCameraIds.size(); i++) {
1196 if (!g_usbCameraExit) {
1197 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1198 }
1199 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1200 EXPECT_NE(ability_, nullptr);
1201 common_metadata_header_t *data = ability_->get();
1202 camera_metadata_item_t entry;
1203 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry);
1204 if (ret == CAM_META_SUCCESS) {
1205 for (int i = 0; i < entry.count; i++) {
1206 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is %{public}d", entry.data.u8[i]);
1207 }
1208 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1209 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support");
1210 }
1211 }
1212 }
1213
1214 /**
1215 * @tc.name: USB Camera
1216 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_MODES
1217 * @tc.level: Level0
1218 * @tc.size: MediumTest
1219 * @tc.type: Function
1220 */
TEST_F(UtestUSBCameraTest,camera_usb_0038)1221 TEST_F(UtestUSBCameraTest, camera_usb_0038)
1222 {
1223 // Get the device manager
1224 std::vector<std::string> usbCameraIds;
1225 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1226 // 1:number of connected cameras
1227 g_usbCameraExit = usbCameraIds.size() > 1;
1228 for (int i = 0; i < usbCameraIds.size(); i++) {
1229 if (!g_usbCameraExit) {
1230 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1231 }
1232 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1233 common_metadata_header_t *data = ability_->get();
1234 camera_metadata_item_t entry;
1235 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
1236 if (ret == CAM_META_SUCCESS) {
1237 CAMERA_LOGD("supported flash mode list:");
1238 for (int i = 0; i < entry.count; i++) {
1239 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1240 }
1241 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1242 CAMERA_LOGD("OHOS_ABILITY_FLASH_MODES is not support");
1243 }
1244 }
1245 }
1246
1247 /**
1248 * @tc.name: USB Camera
1249 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCUS_MODES
1250 * @tc.level: Level0
1251 * @tc.size: MediumTest
1252 * @tc.type: Function
1253 */
TEST_F(UtestUSBCameraTest,camera_usb_0039)1254 TEST_F(UtestUSBCameraTest, camera_usb_0039)
1255 {
1256 // Get the device manager
1257 std::vector<std::string> usbCameraIds;
1258 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1259 // 1:number of connected cameras
1260 g_usbCameraExit = usbCameraIds.size() > 1;
1261 for (int i = 0; i < usbCameraIds.size(); i++) {
1262 if (!g_usbCameraExit) {
1263 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1264 }
1265 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1266 EXPECT_NE(ability_, nullptr);
1267 common_metadata_header_t *data = ability_->get();
1268 camera_metadata_item_t entry;
1269 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
1270 if (ret == CAM_META_SUCCESS) {
1271 CAMERA_LOGD("supported flash mode list:");
1272 for (int i = 0; i < entry.count; i++) {
1273 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1274 }
1275 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1276 CAMERA_LOGD("OHOS_ABILITY_FOCUS_MODES is not support");
1277 }
1278 }
1279 }
1280
1281 /**
1282 * @tc.name: USB Camera
1283 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_EXPOSURE_MODES
1284 * @tc.level: Level0
1285 * @tc.size: MediumTest
1286 * @tc.type: Function
1287 */
TEST_F(UtestUSBCameraTest,camera_usb_0040)1288 TEST_F(UtestUSBCameraTest, camera_usb_0040)
1289 {
1290 // Get the device manager
1291 std::vector<std::string> usbCameraIds;
1292 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1293 // 1:number of connected cameras
1294 g_usbCameraExit = usbCameraIds.size() > 1;
1295 for (int i = 0; i < usbCameraIds.size(); i++) {
1296 if (!g_usbCameraExit) {
1297 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1298 }
1299 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1300 EXPECT_NE(ability_, nullptr);
1301 common_metadata_header_t *data = ability_->get();
1302 camera_metadata_item_t entry;
1303 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
1304 if (ret == CAM_META_SUCCESS) {
1305 CAMERA_LOGD("supported flash mode list:");
1306 for (int i = 0; i < entry.count; i++) {
1307 CAMERA_LOGD("%{public}d ", entry.data.u8[i]);
1308 }
1309 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1310 CAMERA_LOGD("OHOS_ABILITY_EXPOSURE_MODES is not support");
1311 }
1312 }
1313 }
1314
1315 /**
1316 * @tc.name: USB Camera
1317 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED
1318 * @tc.level: Level0
1319 * @tc.size: MediumTest
1320 * @tc.type: Function
1321 */
TEST_F(UtestUSBCameraTest,camera_usb_0041)1322 TEST_F(UtestUSBCameraTest, camera_usb_0041)
1323 {
1324 // Get the device manager
1325 std::vector<std::string> usbCameraIds;
1326 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1327 // 1:number of connected cameras
1328 g_usbCameraExit = usbCameraIds.size() > 1;
1329 for (int i = 0; i < usbCameraIds.size(); i++) {
1330 if (!g_usbCameraExit) {
1331 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1332 }
1333 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1334 EXPECT_NE(ability_, nullptr);
1335 common_metadata_header_t *data = ability_->get();
1336 camera_metadata_item_t entry;
1337 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
1338 EXPECT_EQ(ret, CAM_META_SUCCESS);
1339 CAMERA_LOGD("capture mirror supported is :");
1340 for (int i = 0; i < entry.count; i++) {
1341 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1342 }
1343 }
1344 }
1345
1346 /**
1347 * @tc.name: USB Camera
1348 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_MUTE_MODES
1349 * @tc.level: Level0
1350 * @tc.size: MediumTest
1351 * @tc.type: Function
1352 */
TEST_F(UtestUSBCameraTest,camera_usb_0042)1353 TEST_F(UtestUSBCameraTest, camera_usb_0042)
1354 {
1355 // Get the device manager
1356 std::vector<std::string> usbCameraIds;
1357 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1358 // 1:number of connected cameras
1359 g_usbCameraExit = usbCameraIds.size() > 1;
1360 for (int i = 0; i < usbCameraIds.size(); i++) {
1361 if (!g_usbCameraExit) {
1362 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1363 }
1364 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1365 EXPECT_NE(ability_, nullptr);
1366 common_metadata_header_t *data = ability_->get();
1367 camera_metadata_item_t entry;
1368 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry);
1369 if (ret == CAM_META_SUCCESS) {
1370 CAMERA_LOGD("supported flash mode list:");
1371 for (int i = 0; i < entry.count; i++) {
1372 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1373 }
1374 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1375 CAMERA_LOGD("OHOS_ABILITY_MUTE_MODES is not support");
1376 }
1377 }
1378 }
1379
1380 /**
1381 * @tc.name: USB Camera
1382 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FPS_RANGES
1383 * @tc.level: Level0
1384 * @tc.size: MediumTest
1385 * @tc.type: Function
1386 */
TEST_F(UtestUSBCameraTest,camera_usb_0043)1387 TEST_F(UtestUSBCameraTest, camera_usb_0043)
1388 {
1389 // Get the device manager
1390 std::vector<std::string> usbCameraIds;
1391 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1392 // 1:number of connected cameras
1393 g_usbCameraExit = usbCameraIds.size() > 1;
1394 for (int i = 0; i < usbCameraIds.size(); i++) {
1395 if (!g_usbCameraExit) {
1396 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1397 }
1398 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1399 EXPECT_NE(ability_, nullptr);
1400 common_metadata_header_t *data = ability_->get();
1401 camera_metadata_item_t entry;
1402 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
1403 EXPECT_EQ(ret, CAM_META_SUCCESS);
1404 CAMERA_LOGD("supported fps ranges list: [ %{public}d, %{public}d ]", entry.data.i32[0], entry.data.i32[1]);
1405 }
1406 }
1407
1408 /**
1409 * @tc.name: USB Camera
1410 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_ORIENTATION
1411 * @tc.level: Level0
1412 * @tc.size: MediumTest
1413 * @tc.type: Function
1414 */
TEST_F(UtestUSBCameraTest,camera_usb_0044)1415 TEST_F(UtestUSBCameraTest, camera_usb_0044)
1416 {
1417 // Get the device manager
1418 std::vector<std::string> usbCameraIds;
1419 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1420 // 1:number of connected cameras
1421 g_usbCameraExit = usbCameraIds.size() > 1;
1422 for (int i = 0; i < usbCameraIds.size(); i++) {
1423 if (!g_usbCameraExit) {
1424 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1425 }
1426 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1427 EXPECT_NE(ability_, nullptr);
1428 common_metadata_header_t *data = ability_->get();
1429 camera_metadata_item_t entry;
1430 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry);
1431 EXPECT_EQ(ret, CAM_META_SUCCESS);
1432 CAMERA_LOGD("OHOS_JPEG_ORIENTATION value is %{public}d", entry.data.i32[0]);
1433 }
1434 }
1435
1436 /**
1437 * @tc.name: USB Camera
1438 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_QUALITY
1439 * @tc.level: Level0
1440 * @tc.size: MediumTest
1441 * @tc.type: Function
1442 */
TEST_F(UtestUSBCameraTest,camera_usb_0045)1443 TEST_F(UtestUSBCameraTest, camera_usb_0045)
1444 {
1445 // Get the device manager
1446 std::vector<std::string> usbCameraIds;
1447 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1448 // 1:number of connected cameras
1449 g_usbCameraExit = usbCameraIds.size() > 1;
1450 for (int i = 0; i < usbCameraIds.size(); i++) {
1451 if (!g_usbCameraExit) {
1452 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1453 }
1454 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1455 EXPECT_NE(ability_, nullptr);
1456 common_metadata_header_t *data = ability_->get();
1457 camera_metadata_item_t entry;
1458 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry);
1459 EXPECT_EQ(ret, CAM_META_SUCCESS);
1460 CAMERA_LOGD("OHOS_JPEG_QUALITY value is %{public}d", entry.data.i32[0]);
1461 }
1462 }
1463
1464 /**
1465 * @tc.name: USB Camera
1466 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS
1467 * @tc.level: Level0
1468 * @tc.size: MediumTest
1469 * @tc.type: Function
1470 */
TEST_F(UtestUSBCameraTest,camera_usb_0046)1471 TEST_F(UtestUSBCameraTest, camera_usb_0046)
1472 {
1473 // Get the device manager
1474 std::vector<std::string> usbCameraIds;
1475 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1476 // 1:number of connected cameras
1477 g_usbCameraExit = usbCameraIds.size() > 1;
1478 for (int i = 0; i < usbCameraIds.size(); i++) {
1479 if (!g_usbCameraExit) {
1480 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1481 }
1482 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1483 EXPECT_NE(ability_, nullptr);
1484 common_metadata_header_t *data = ability_->get();
1485 camera_metadata_item_t entry;
1486 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
1487 EXPECT_EQ(ret, CAM_META_SUCCESS);
1488 CAMERA_LOGD("OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is %{public}d", entry.data.u8[0]);
1489 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888);
1490 }
1491 }
1492
1493 /**
1494 * @tc.name: USB Camera
1495 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
1496 * @tc.level: Level0
1497 * @tc.size: MediumTest
1498 * @tc.type: Function
1499 */
TEST_F(UtestUSBCameraTest,camera_usb_0047)1500 TEST_F(UtestUSBCameraTest, camera_usb_0047)
1501 {
1502 // Get the device manager
1503 std::vector<std::string> usbCameraIds;
1504 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1505 // 1:number of connected cameras
1506 g_usbCameraExit = usbCameraIds.size() > 1;
1507 for (int i = 0; i < usbCameraIds.size(); i++) {
1508 if (!g_usbCameraExit) {
1509 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1510 }
1511 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1512 EXPECT_NE(ability_, nullptr);
1513 common_metadata_header_t *data = ability_->get();
1514 EXPECT_NE(data, nullptr);
1515 camera_metadata_item_t entry;
1516 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
1517 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
1518 CAMERA_LOGD("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start.");
1519 const size_t STEP = 10; // print step
1520 CAMERA_LOGD("count: %{public}s", entry.count);
1521 for (size_t a = 0; a < entry.count; a++) {
1522 CAMERA_LOGD("%{public}d", entry.data.i32[a]);
1523 }
1524 CAMERA_LOGE("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end.");
1525 }
1526 }
1527 }
1528
1529 /**
1530 * @tc.name: USB Camera
1531 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCAL_LENGTH
1532 * @tc.level: Level0
1533 * @tc.size: MediumTest
1534 * @tc.type: Function
1535 */
TEST_F(UtestUSBCameraTest,camera_usb_0048)1536 TEST_F(UtestUSBCameraTest, camera_usb_0048)
1537 {
1538 // Get the device manager
1539 std::vector<std::string> usbCameraIds;
1540 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1541 // 1:number of connected cameras
1542 g_usbCameraExit = usbCameraIds.size() > 1;
1543 for (int i = 0; i < usbCameraIds.size(); i++) {
1544 if (!g_usbCameraExit) {
1545 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1546 }
1547 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1548 EXPECT_NE(ability_, nullptr);
1549 common_metadata_header_t *data = ability_->get();
1550 camera_metadata_item_t entry;
1551 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
1552 if (ret == CAM_META_SUCCESS) {
1553 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH: count is %{public}s", entry.count);
1554 CAMERA_LOGD("log focal length value: %{pubilc}d", entry.data.f[0]);
1555 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1556 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH is not support");
1557 }
1558 }
1559 }
1560
1561 /**
1562 * @tc.name: USB Camera
1563 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_SENSOR_ORIENTATION
1564 * @tc.level: Level0
1565 * @tc.size: MediumTest
1566 * @tc.type: Function
1567 */
TEST_F(UtestUSBCameraTest,camera_usb_0049)1568 TEST_F(UtestUSBCameraTest, camera_usb_0049)
1569 {
1570 // Get the device manager
1571 std::vector<std::string> usbCameraIds;
1572 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1573 // 1:number of connected cameras
1574 g_usbCameraExit = usbCameraIds.size() > 1;
1575 for (int i = 0; i < usbCameraIds.size(); i++) {
1576 if (!g_usbCameraExit) {
1577 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1578 }
1579 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1580 EXPECT_NE(ability_, nullptr);
1581 common_metadata_header_t *data = ability_->get();
1582 camera_metadata_item_t entry;
1583 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
1584 EXPECT_EQ(ret, CAM_META_SUCCESS);
1585 CAMERA_LOGD("OHOS_SENSOR_ORIENTATION value is %{pubilc}d", entry.data.i32[0]);
1586 EXPECT_TRUE(entry.data.i32[0] == 0);
1587 }
1588 }
1589
1590 /**
1591 * @tc.name: USB Camera
1592 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_TYPE_UNSPECIFIED
1593 * @tc.level: Level0
1594 * @tc.size: MediumTest
1595 * @tc.type: Function
1596 */
TEST_F(UtestUSBCameraTest,camera_usb_0050)1597 TEST_F(UtestUSBCameraTest, camera_usb_0050)
1598 {
1599 // Get the device manager
1600 std::vector<std::string> usbCameraIds;
1601 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1602 // 1:number of connected cameras
1603 g_usbCameraExit = usbCameraIds.size() > 1;
1604 for (int i = 0; i < usbCameraIds.size(); i++) {
1605 if (!g_usbCameraExit) {
1606 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1607 }
1608 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1609 EXPECT_NE(ability_, nullptr);
1610 common_metadata_header_t *data = ability_->get();
1611 camera_metadata_item_t entry;
1612 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
1613 EXPECT_EQ(ret, CAM_META_SUCCESS);
1614 CAMERA_LOGD("OHOS_ABILITY_CAMERA_TYPE value is %{pubilc}d", entry.data.u8[0]);
1615 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED);
1616 }
1617 }
1618
1619 /**
1620 * @tc.name: USB Camera
1621 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN
1622 * @tc.level: Level0
1623 * @tc.size: MediumTest
1624 * @tc.type: Function
1625 */
TEST_F(UtestUSBCameraTest,camera_usb_0051)1626 TEST_F(UtestUSBCameraTest, camera_usb_0051)
1627 {
1628 // Get the device manager
1629 std::vector<std::string> usbCameraIds;
1630 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1631 // 1:number of connected cameras
1632 g_usbCameraExit = usbCameraIds.size() > 1;
1633 for (int i = 0; i < usbCameraIds.size(); i++) {
1634 if (!g_usbCameraExit) {
1635 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1636 }
1637 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1638 EXPECT_NE(ability_, nullptr);
1639 common_metadata_header_t *data = ability_->get();
1640 camera_metadata_item_t entry;
1641 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
1642 EXPECT_EQ(ret, CAM_META_SUCCESS);
1643 CAMERA_LOGD("OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is %{pubilc}d", entry.data.u8[0]);
1644 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN);
1645 }
1646 }
1647
1648 /**
1649 * @tc.name: USB Camera
1650 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_CAMERA_POSITION
1651 * @tc.level: Level0
1652 * @tc.size: MediumTest
1653 * @tc.type: Function
1654 */
TEST_F(UtestUSBCameraTest,camera_usb_0052)1655 TEST_F(UtestUSBCameraTest, camera_usb_0052)
1656 {
1657 // Get the device manager
1658 std::vector<std::string> usbCameraIds;
1659 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1660 // 1:number of connected cameras
1661 g_usbCameraExit = usbCameraIds.size() > 1;
1662 for (int i = 0; i < usbCameraIds.size(); i++) {
1663 if (!g_usbCameraExit) {
1664 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1665 }
1666 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1667 EXPECT_NE(ability_, nullptr);
1668 common_metadata_header_t *data = ability_->get();
1669 camera_metadata_item_t entry;
1670 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
1671 CAMERA_LOGD("OHOS_ABILITY_CAMERA_POSITION value is %{pubilc}d", entry.data.u8[0]);
1672 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_FRONT);
1673 }
1674 }
1675
1676 /**
1677 * @tc.name: USB Camera
1678 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
1679 * @tc.level: Level0
1680 * @tc.size: MediumTest
1681 * @tc.type: Function
1682 */
TEST_F(UtestUSBCameraTest,camera_usb_0053)1683 TEST_F(UtestUSBCameraTest, camera_usb_0053)
1684 {
1685 cameraBase_->OpenUsbCamera();
1686 if (!g_usbCameraExit) {
1687 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1688 }
1689 cameraBase_->AchieveStreamOperator();
1690 if (cameraBase_->streamCustomerPreview_ == nullptr) {
1691 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1692 }
1693 std::vector<StreamInfo> streamInfos;
1694 StreamInfo streamInfo = {};
1695 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
1696 streamInfo.width_ = 1280; // 1280:picture width
1697 streamInfo.height_ = 720; // 720:picture height
1698 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1699 streamInfo.dataspace_ = 8; // 8:picture dataspace
1700 streamInfo.intent_ = PREVIEW;
1701 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1702 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
1703 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1704 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1705 streamInfos.push_back(streamInfo);
1706 if (cameraBase_->streamCustomerCapture_ == nullptr) {
1707 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
1708 }
1709 StreamInfo streamInfoCapture = {};
1710 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
1711 streamInfoCapture.width_ = 1280; // 1280:picture width
1712 streamInfoCapture.height_ = 720; // 720:picture height
1713 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
1714 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
1715 streamInfoCapture.intent_ = STILL_CAPTURE;
1716 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
1717 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
1718 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
1719 cameraBase_->streamCustomerCapture_->CreateProducer());
1720 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
1721 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1722 streamInfos.push_back(streamInfoCapture);
1723 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1724 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1725 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1726 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1727 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1728 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1729 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1730 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1731 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1732 }
1733
StoreFile(const unsigned char * bufStart,const uint32_t size,const char * suffix)1734 void StoreFile(const unsigned char *bufStart, const uint32_t size, const char* suffix)
1735 {
1736 static int count = 0;
1737 constexpr uint32_t pathLen = 128;
1738 char path[pathLen] = {0};
1739 char prefix[] = "/data/";
1740 struct timeval start = {};
1741 gettimeofday(&start, nullptr);
1742 std::cout << "suffix = " << suffix << std::endl;
1743 if (sprintf_s(path, sizeof(path), "%sfile_%d_%lld_%s", prefix, count++, start.tv_usec, suffix) < 0) {
1744 CAMERA_LOGE("%{public}s:StoreFile sprintf failed", __func__);
1745 return;
1746 }
1747 int fd = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
1748 if (fd < 0) {
1749 CAMERA_LOGE("demo test:StoreFile open %s %{public}s failed", path, strerror(errno));
1750 return;
1751 }
1752 int ret = write(fd, bufStart, size);
1753 if (ret == -1) {
1754 CAMERA_LOGE("demo test:StoreFile write video file error %{public}s.....\n", strerror(errno));
1755 }
1756 CAMERA_LOGD("demo test:StoreFile size == %{public}d\n", size);
1757 std::cout << "Strore File , Path = " << path << ", size = " << size << std::endl;
1758 close(fd);
1759 }
1760
1761 /**
1762 * @tc.name: USB Camera
1763 * @tc.desc: single video stream, output nv21, expected success.
1764 * @tc.level: Level0
1765 * @tc.size: MediumTest
1766 * @tc.type: Function
1767 */
TEST_F(UtestUSBCameraTest,camera_usb_0054)1768 TEST_F(UtestUSBCameraTest, camera_usb_0054)
1769 {
1770 cameraBase_->OpenUsbCamera();
1771 cameraBase_->AchieveStreamOperator();
1772 auto streamCustomerVideo = std::make_shared<StreamCustomer>();
1773
1774 uint32_t captureIdVideo = 1;
1775 uint32_t streamIdVideo = 1;
1776 std::vector<StreamInfo> streamInfos;
1777 StreamInfo streamInfo = {};
1778 streamInfo.streamId_ = streamIdVideo;
1779 streamInfo.width_ = 1280; // 1280:picture width
1780 streamInfo.height_ = 720; // 720:picture height
1781 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP;
1782 streamInfo.encodeType_ = ENCODE_TYPE_NULL;
1783 streamInfo.dataspace_ = 8; // 8:picture dataspace
1784 streamInfo.intent_ = VIDEO;
1785 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1786 streamInfo.bufferQueue_ = new BufferProducerSequenceable(streamCustomerVideo->CreateProducer());
1787 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1788 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1789 streamInfos.push_back(streamInfo);
1790
1791 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1792 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1793 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1794 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1795
1796 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1797 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
1798 StoreFile(addr, size, "_single_video.yuv");
1799 });
1800
1801 CaptureInfo captureInfoVideo = {
1802 .streamIds_ = {streamIdVideo},
1803 .captureSetting_ = cameraBase_->ability_,
1804 .enableShutterCallback_ = false,
1805 };
1806 std::cout << "start capture video" << std::endl;
1807 CAMERA_LOGE("start capture video");
1808 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1809 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1810 sleep(1);
1811
1812 std::cout << "cancel capture video" << std::endl;
1813 CAMERA_LOGE("cancel capture video");
1814 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdVideo);
1815 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1816 sleep(1);
1817
1818 std::cout << "start capture video" << std::endl;
1819 CAMERA_LOGE("start capture video");
1820 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1821 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1822 sleep(1);
1823
1824 streamCustomerVideo->ReceiveFrameOff();
1825
1826 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdVideo});
1827 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1828 sleep(1);
1829 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdVideo});
1830 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1831 }
1832
1833 /**
1834 * @tc.name: USB Camera
1835 * @tc.desc: single video stream, output jpeg, expected success.
1836 * @tc.level: Level0
1837 * @tc.size: MediumTest
1838 * @tc.type: Function
1839 */
TEST_F(UtestUSBCameraTest,camera_usb_0055)1840 TEST_F(UtestUSBCameraTest, camera_usb_0055)
1841 {
1842 cameraBase_->OpenUsbCamera();
1843 cameraBase_->AchieveStreamOperator();
1844 auto streamCustomerVideo = std::make_shared<StreamCustomer>();
1845
1846 uint32_t captureIdVideo = 1;
1847 uint32_t streamIdVideo = 1;
1848 std::vector<StreamInfo> streamInfos;
1849 StreamInfo streamInfo = {};
1850 streamInfo.streamId_ = streamIdVideo;
1851 streamInfo.width_ = 1280; // 1280:picture width
1852 streamInfo.height_ = 720; // 720:picture height
1853 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP;
1854 streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
1855 streamInfo.dataspace_ = 8; // 8:picture dataspace
1856 streamInfo.intent_ = VIDEO;
1857 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1858 streamInfo.bufferQueue_ = new (std::nothrow) BufferProducerSequenceable(streamCustomerVideo->CreateProducer());
1859 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1860 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1861 streamInfos.push_back(streamInfo);
1862
1863 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1864 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1865 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1866 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1867
1868 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1869 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
1870 StoreFile(addr, size, "_single_video.jpeg");
1871 });
1872
1873 CaptureInfo captureInfoVideo = {
1874 .streamIds_ = {streamIdVideo},
1875 .captureSetting_ = cameraBase_->ability_,
1876 .enableShutterCallback_ = false,
1877 };
1878 std::cout << "start capture video" << std::endl;
1879 CAMERA_LOGE("start capture video");
1880 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1881 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1882 sleep(1);
1883
1884 std::cout << "cancel capture video" << std::endl;
1885 CAMERA_LOGE("cancel capture video");
1886 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdVideo);
1887 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1888 sleep(1);
1889
1890 std::cout << "start capture video" << std::endl;
1891 CAMERA_LOGE("start capture video");
1892 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1893 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1894 sleep(1);
1895
1896 streamCustomerVideo->ReceiveFrameOff();
1897
1898 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdVideo});
1899 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1900 sleep(1);
1901 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdVideo});
1902 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1903 }