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 if (cameraIds.size() > 0) {
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 */
TEST_F(UtestUSBCameraTest,camera_usb_0002)80 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0003)106 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0004)129 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0005)151 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0006)172 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_007)199 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_008)226 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_009)254 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0010)282 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0011)307 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0012)335 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0013)358 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0014)380 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0015)401 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0016)422 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0017)445 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0018)477 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0019)504 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0020)553 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0021)600 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0022)637 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0023)665 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0024)723 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0025)758 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0026)792 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0027)820 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0028)877 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0029)925 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0030)956 TEST_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 */
TEST_F(UtestUSBCameraTest,camera_usb_0031)978 TEST_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: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
999 * @tc.level: Level0
1000 * @tc.size: MediumTest
1001 * @tc.type: Function
1002 */
TEST_F(UtestUSBCameraTest,camera_usb_0032)1003 TEST_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() > 1) {
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: Open the capture stream for both cameras at the same time.
1037 * @tc.level: Level0
1038 * @tc.size: MediumTest
1039 * @tc.type: Function
1040 */
TEST_F(UtestUSBCameraTest,camera_usb_0033)1041 TEST_F(UtestUSBCameraTest, camera_usb_0033)
1042 {
1043 // Get the device manager
1044 std::vector<std::string> usbCameraIds;
1045 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1046 if (usbCameraIds.size() > 1) {
1047 g_usbCameraExit = true;
1048 } else {
1049 g_usbCameraExit = false;
1050 }
1051 for (int i = 0; i < usbCameraIds.size(); i++) {
1052 if (!g_usbCameraExit) {
1053 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1054 }
1055 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
1056 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1057 // Get the stream manager
1058 cameraBase_->AchieveStreamOperator();
1059 // start stream
1060 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1061 cameraBase_->StartStream(cameraBase_->intents);
1062 // Get preview
1063 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1064 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1065 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1066 // release stream
1067 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
1068 cameraBase_->CAPTURE_ID_VIDEO};
1069 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
1070 cameraBase_->STREAM_ID_VIDEO};
1071 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1072 }
1073 }
1074
1075 /**
1076 * @tc.name: USB Camera
1077 * @tc.desc: One camera starts capturing and the other camera starts recording.
1078 * @tc.level: Level0
1079 * @tc.size: MediumTest
1080 * @tc.type: Function
1081 */
TEST_F(UtestUSBCameraTest,camera_usb_0034)1082 TEST_F(UtestUSBCameraTest, camera_usb_0034)
1083 {
1084 // Get the device manager
1085 std::vector<std::string> usbCameraIds;
1086 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1087 if (usbCameraIds.size() > 1) {
1088 g_usbCameraExit = true;
1089 } else {
1090 g_usbCameraExit = false;
1091 }
1092
1093 if (!g_usbCameraExit) {
1094 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1095 }
1096 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]);
1097 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1098 // Get the stream manager
1099 cameraBase_->AchieveStreamOperator();
1100 // start stream
1101 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
1102 cameraBase_->StartStream(cameraBase_->intents);
1103 // Get preview
1104 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1105 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1106 // release stream
1107 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1108 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1109 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1110
1111 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[1]);
1112 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1113 // Get the stream manager
1114 cameraBase_->AchieveStreamOperator();
1115 // start stream
1116 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1117 cameraBase_->StartStream(cameraBase_->intents);
1118 // Get preview
1119 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1120 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1121 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1122 // release stream
1123 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
1124 cameraBase_->CAPTURE_ID_VIDEO};
1125 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
1126 cameraBase_->STREAM_ID_VIDEO};
1127 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1128 }
1129
1130 /**
1131 * @tc.name: USB Camera
1132 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_ZOOM_RATIO_RANGE
1133 * @tc.level: Level0
1134 * @tc.size: MediumTest
1135 * @tc.type: Function
1136 */
TEST_F(UtestUSBCameraTest,camera_usb_0035)1137 TEST_F(UtestUSBCameraTest, camera_usb_0035)
1138 {
1139 // Get the device manager
1140 std::vector<std::string> usbCameraIds;
1141 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1142 if (usbCameraIds.size() > 1) {
1143 g_usbCameraExit = true;
1144 } else {
1145 g_usbCameraExit = false;
1146 }
1147 for (int i = 0; i < usbCameraIds.size(); i++) {
1148 if (!g_usbCameraExit) {
1149 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1150 }
1151 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
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_ZOOM_RATIO_RANGE, &entry);
1156 if (ret == CAM_META_SUCCESS) {
1157 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE: count is %{public}d ", entry.count);
1158 CAMERA_LOGD("Zoom ratio range: [%{public}d,[%{public}d]", entry.data.f[0], entry.data.f[1]);
1159 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1160 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE is not support");
1161 }
1162 }
1163 }
1164
1165 /**
1166 * @tc.name: USB Camera
1167 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_AVAILABLE
1168 * @tc.level: Level0
1169 * @tc.size: MediumTest
1170 * @tc.type: Function
1171 */
TEST_F(UtestUSBCameraTest,camera_usb_0036)1172 TEST_F(UtestUSBCameraTest, camera_usb_0036)
1173 {
1174 // Get the device manager
1175 std::vector<std::string> usbCameraIds;
1176 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1177 if (usbCameraIds.size() > 1) {
1178 g_usbCameraExit = true;
1179 } else {
1180 g_usbCameraExit = false;
1181 }
1182 for (int i = 0; i < usbCameraIds.size(); i++) {
1183 if (!g_usbCameraExit) {
1184 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1185 }
1186 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
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_FLASH_AVAILABLE, &entry);
1191 EXPECT_EQ(ret, CAM_META_SUCCESS);
1192 CAMERA_LOGD("OHOS_ABILITY_FLASH_AVAILABLE value is %{public}d", entry.data.u8[0]);
1193 }
1194 }
1195
1196 /**
1197 * @tc.name: USB Camera
1198 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES
1199 * @tc.level: Level0
1200 * @tc.size: MediumTest
1201 * @tc.type: Function
1202 */
TEST_F(UtestUSBCameraTest,camera_usb_0037)1203 TEST_F(UtestUSBCameraTest, camera_usb_0037)
1204 {
1205 // Get the device manager
1206 std::vector<std::string> usbCameraIds;
1207 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1208 if (usbCameraIds.size() > 1) {
1209 g_usbCameraExit = true;
1210 } else {
1211 g_usbCameraExit = false;
1212 }
1213 for (int i = 0; i < usbCameraIds.size(); i++) {
1214 if (!g_usbCameraExit) {
1215 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1216 }
1217 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1218 EXPECT_NE(ability_, nullptr);
1219 common_metadata_header_t *data = ability_->get();
1220 camera_metadata_item_t entry;
1221 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry);
1222 if (ret == CAM_META_SUCCESS) {
1223 for (int i = 0; i < entry.count; i++) {
1224 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is %{public}d", entry.data.u8[i]);
1225 }
1226 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1227 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support");
1228 }
1229 }
1230 }
1231
1232 /**
1233 * @tc.name: USB Camera
1234 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_MODES
1235 * @tc.level: Level0
1236 * @tc.size: MediumTest
1237 * @tc.type: Function
1238 */
TEST_F(UtestUSBCameraTest,camera_usb_0038)1239 TEST_F(UtestUSBCameraTest, camera_usb_0038)
1240 {
1241 // Get the device manager
1242 std::vector<std::string> usbCameraIds;
1243 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1244 if (usbCameraIds.size() > 1) {
1245 g_usbCameraExit = true;
1246 } else {
1247 g_usbCameraExit = false;
1248 }
1249 for (int i = 0; i < usbCameraIds.size(); i++) {
1250 if (!g_usbCameraExit) {
1251 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1252 }
1253 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1254 common_metadata_header_t *data = ability_->get();
1255 camera_metadata_item_t entry;
1256 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
1257 if (ret == CAM_META_SUCCESS) {
1258 CAMERA_LOGD("supported flash mode list:");
1259 for (int i = 0; i < entry.count; i++) {
1260 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1261 }
1262 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1263 CAMERA_LOGD("OHOS_ABILITY_FLASH_MODES is not support");
1264 }
1265 }
1266 }
1267
1268 /**
1269 * @tc.name: USB Camera
1270 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCUS_MODES
1271 * @tc.level: Level0
1272 * @tc.size: MediumTest
1273 * @tc.type: Function
1274 */
TEST_F(UtestUSBCameraTest,camera_usb_0039)1275 TEST_F(UtestUSBCameraTest, camera_usb_0039)
1276 {
1277 // Get the device manager
1278 std::vector<std::string> usbCameraIds;
1279 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1280 if (usbCameraIds.size() > 1) {
1281 g_usbCameraExit = true;
1282 } else {
1283 g_usbCameraExit = false;
1284 }
1285 for (int i = 0; i < usbCameraIds.size(); i++) {
1286 if (!g_usbCameraExit) {
1287 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1288 }
1289 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1290 EXPECT_NE(ability_, nullptr);
1291 common_metadata_header_t *data = ability_->get();
1292 camera_metadata_item_t entry;
1293 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
1294 if (ret == CAM_META_SUCCESS) {
1295 CAMERA_LOGD("supported flash mode list:");
1296 for (int i = 0; i < entry.count; i++) {
1297 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1298 }
1299 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1300 CAMERA_LOGD("OHOS_ABILITY_FOCUS_MODES is not support");
1301 }
1302 }
1303 }
1304
1305 /**
1306 * @tc.name: USB Camera
1307 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_EXPOSURE_MODES
1308 * @tc.level: Level0
1309 * @tc.size: MediumTest
1310 * @tc.type: Function
1311 */
TEST_F(UtestUSBCameraTest,camera_usb_0040)1312 TEST_F(UtestUSBCameraTest, camera_usb_0040)
1313 {
1314 // Get the device manager
1315 std::vector<std::string> usbCameraIds;
1316 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1317 if (usbCameraIds.size() > 1) {
1318 g_usbCameraExit = true;
1319 } else {
1320 g_usbCameraExit = false;
1321 }
1322 for (int i = 0; i < usbCameraIds.size(); i++) {
1323 if (!g_usbCameraExit) {
1324 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1325 }
1326 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1327 EXPECT_NE(ability_, nullptr);
1328 common_metadata_header_t *data = ability_->get();
1329 camera_metadata_item_t entry;
1330 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
1331 if (ret == CAM_META_SUCCESS) {
1332 CAMERA_LOGD("supported flash mode list:");
1333 for (int i = 0; i < entry.count; i++) {
1334 CAMERA_LOGD("%{public}d ", entry.data.u8[i]);
1335 }
1336 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1337 CAMERA_LOGD("OHOS_ABILITY_EXPOSURE_MODES is not support");
1338 }
1339 }
1340 }
1341
1342 /**
1343 * @tc.name: USB Camera
1344 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED
1345 * @tc.level: Level0
1346 * @tc.size: MediumTest
1347 * @tc.type: Function
1348 */
TEST_F(UtestUSBCameraTest,camera_usb_0041)1349 TEST_F(UtestUSBCameraTest, camera_usb_0041)
1350 {
1351 // Get the device manager
1352 std::vector<std::string> usbCameraIds;
1353 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1354 if (usbCameraIds.size() > 1) {
1355 g_usbCameraExit = true;
1356 } else {
1357 g_usbCameraExit = false;
1358 }
1359 for (int i = 0; i < usbCameraIds.size(); i++) {
1360 if (!g_usbCameraExit) {
1361 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1362 }
1363 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1364 EXPECT_NE(ability_, nullptr);
1365 common_metadata_header_t *data = ability_->get();
1366 camera_metadata_item_t entry;
1367 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
1368 EXPECT_EQ(ret, CAM_META_SUCCESS);
1369 CAMERA_LOGD("capture mirror supported is :");
1370 for (int i = 0; i < entry.count; i++) {
1371 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1372 }
1373 }
1374 }
1375
1376 /**
1377 * @tc.name: USB Camera
1378 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_MUTE_MODES
1379 * @tc.level: Level0
1380 * @tc.size: MediumTest
1381 * @tc.type: Function
1382 */
TEST_F(UtestUSBCameraTest,camera_usb_0042)1383 TEST_F(UtestUSBCameraTest, camera_usb_0042)
1384 {
1385 // Get the device manager
1386 std::vector<std::string> usbCameraIds;
1387 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1388 if (usbCameraIds.size() > 1) {
1389 g_usbCameraExit = true;
1390 } else {
1391 g_usbCameraExit = false;
1392 }
1393 for (int i = 0; i < usbCameraIds.size(); i++) {
1394 if (!g_usbCameraExit) {
1395 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1396 }
1397 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1398 EXPECT_NE(ability_, nullptr);
1399 common_metadata_header_t *data = ability_->get();
1400 camera_metadata_item_t entry;
1401 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry);
1402 if (ret == CAM_META_SUCCESS) {
1403 CAMERA_LOGD("supported flash mode list:");
1404 for (int i = 0; i < entry.count; i++) {
1405 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1406 }
1407 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1408 CAMERA_LOGD("OHOS_ABILITY_MUTE_MODES is not support");
1409 }
1410 }
1411 }
1412
1413 /**
1414 * @tc.name: USB Camera
1415 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FPS_RANGES
1416 * @tc.level: Level0
1417 * @tc.size: MediumTest
1418 * @tc.type: Function
1419 */
TEST_F(UtestUSBCameraTest,camera_usb_0043)1420 TEST_F(UtestUSBCameraTest, camera_usb_0043)
1421 {
1422 // Get the device manager
1423 std::vector<std::string> usbCameraIds;
1424 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1425 if (usbCameraIds.size() > 1) {
1426 g_usbCameraExit = true;
1427 } else {
1428 g_usbCameraExit = false;
1429 }
1430 for (int i = 0; i < usbCameraIds.size(); i++) {
1431 if (!g_usbCameraExit) {
1432 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1433 }
1434 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1435 EXPECT_NE(ability_, nullptr);
1436 common_metadata_header_t *data = ability_->get();
1437 camera_metadata_item_t entry;
1438 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
1439 EXPECT_EQ(ret, CAM_META_SUCCESS);
1440 CAMERA_LOGD("supported fps ranges list: [ %{public}d, %{public}d ]", entry.data.i32[0], entry.data.i32[1]);
1441 }
1442 }
1443
1444 /**
1445 * @tc.name: USB Camera
1446 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_ORIENTATION
1447 * @tc.level: Level0
1448 * @tc.size: MediumTest
1449 * @tc.type: Function
1450 */
TEST_F(UtestUSBCameraTest,camera_usb_0044)1451 TEST_F(UtestUSBCameraTest, camera_usb_0044)
1452 {
1453 // Get the device manager
1454 std::vector<std::string> usbCameraIds;
1455 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1456 if (usbCameraIds.size() > 1) {
1457 g_usbCameraExit = true;
1458 } else {
1459 g_usbCameraExit = false;
1460 }
1461 for (int i = 0; i < usbCameraIds.size(); i++) {
1462 if (!g_usbCameraExit) {
1463 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1464 }
1465 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1466 EXPECT_NE(ability_, nullptr);
1467 common_metadata_header_t *data = ability_->get();
1468 camera_metadata_item_t entry;
1469 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry);
1470 EXPECT_EQ(ret, CAM_META_SUCCESS);
1471 CAMERA_LOGD("OHOS_JPEG_ORIENTATION value is %{public}d", entry.data.i32[0]);
1472 }
1473 }
1474
1475 /**
1476 * @tc.name: USB Camera
1477 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_QUALITY
1478 * @tc.level: Level0
1479 * @tc.size: MediumTest
1480 * @tc.type: Function
1481 */
TEST_F(UtestUSBCameraTest,camera_usb_0045)1482 TEST_F(UtestUSBCameraTest, camera_usb_0045)
1483 {
1484 // Get the device manager
1485 std::vector<std::string> usbCameraIds;
1486 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1487 if (usbCameraIds.size() > 1) {
1488 g_usbCameraExit = true;
1489 } else {
1490 g_usbCameraExit = false;
1491 }
1492 for (int i = 0; i < usbCameraIds.size(); i++) {
1493 if (!g_usbCameraExit) {
1494 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1495 }
1496 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1497 EXPECT_NE(ability_, nullptr);
1498 common_metadata_header_t *data = ability_->get();
1499 camera_metadata_item_t entry;
1500 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry);
1501 EXPECT_EQ(ret, CAM_META_SUCCESS);
1502 CAMERA_LOGD("OHOS_JPEG_QUALITY value is %{public}d", entry.data.i32[0]);
1503 }
1504 }
1505
1506 /**
1507 * @tc.name: USB Camera
1508 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS
1509 * @tc.level: Level0
1510 * @tc.size: MediumTest
1511 * @tc.type: Function
1512 */
TEST_F(UtestUSBCameraTest,camera_usb_0046)1513 TEST_F(UtestUSBCameraTest, camera_usb_0046)
1514 {
1515 // Get the device manager
1516 std::vector<std::string> usbCameraIds;
1517 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1518 if (usbCameraIds.size() > 1) {
1519 g_usbCameraExit = true;
1520 } else {
1521 g_usbCameraExit = false;
1522 }
1523 for (int i = 0; i < usbCameraIds.size(); i++) {
1524 if (!g_usbCameraExit) {
1525 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1526 }
1527 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1528 EXPECT_NE(ability_, nullptr);
1529 common_metadata_header_t *data = ability_->get();
1530 camera_metadata_item_t entry;
1531 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
1532 EXPECT_EQ(ret, CAM_META_SUCCESS);
1533 CAMERA_LOGD("OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is %{public}d", entry.data.u8[0]);
1534 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888);
1535 }
1536 }
1537
1538 /**
1539 * @tc.name: USB Camera
1540 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
1541 * @tc.level: Level0
1542 * @tc.size: MediumTest
1543 * @tc.type: Function
1544 */
TEST_F(UtestUSBCameraTest,camera_usb_0047)1545 TEST_F(UtestUSBCameraTest, camera_usb_0047)
1546 {
1547 // Get the device manager
1548 std::vector<std::string> usbCameraIds;
1549 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1550 if (usbCameraIds.size() > 1) {
1551 g_usbCameraExit = true;
1552 } else {
1553 g_usbCameraExit = false;
1554 }
1555 for (int i = 0; i < usbCameraIds.size(); i++) {
1556 if (!g_usbCameraExit) {
1557 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1558 }
1559 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1560 EXPECT_NE(ability_, nullptr);
1561 common_metadata_header_t *data = ability_->get();
1562 EXPECT_NE(data, nullptr);
1563 camera_metadata_item_t entry;
1564 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
1565 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
1566 CAMERA_LOGD("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start.");
1567 const size_t STEP = 10; // print step
1568 CAMERA_LOGD("count: %{public}s", entry.count);
1569 for (size_t a = 0; a < entry.count; a++) {
1570 CAMERA_LOGD("%{public}d", entry.data.i32[a]);
1571 }
1572 CAMERA_LOGE("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end.");
1573 }
1574 }
1575 }
1576
1577 /**
1578 * @tc.name: USB Camera
1579 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCAL_LENGTH
1580 * @tc.level: Level0
1581 * @tc.size: MediumTest
1582 * @tc.type: Function
1583 */
TEST_F(UtestUSBCameraTest,camera_usb_0048)1584 TEST_F(UtestUSBCameraTest, camera_usb_0048)
1585 {
1586 // Get the device manager
1587 std::vector<std::string> usbCameraIds;
1588 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1589 if (usbCameraIds.size() > 1) {
1590 g_usbCameraExit = true;
1591 } else {
1592 g_usbCameraExit = false;
1593 }
1594 for (int i = 0; i < usbCameraIds.size(); i++) {
1595 if (!g_usbCameraExit) {
1596 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1597 }
1598 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1599 EXPECT_NE(ability_, nullptr);
1600 common_metadata_header_t *data = ability_->get();
1601 camera_metadata_item_t entry;
1602 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
1603 if (ret == CAM_META_SUCCESS) {
1604 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH: count is %{public}s", entry.count);
1605 CAMERA_LOGD("log focal length value: %{pubilc}d", entry.data.f[0]);
1606 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1607 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH is not support");
1608 }
1609 }
1610 }
1611
1612 /**
1613 * @tc.name: USB Camera
1614 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_SENSOR_ORIENTATION
1615 * @tc.level: Level0
1616 * @tc.size: MediumTest
1617 * @tc.type: Function
1618 */
TEST_F(UtestUSBCameraTest,camera_usb_0049)1619 TEST_F(UtestUSBCameraTest, camera_usb_0049)
1620 {
1621 // Get the device manager
1622 std::vector<std::string> usbCameraIds;
1623 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1624 if (usbCameraIds.size() > 1) {
1625 g_usbCameraExit = true;
1626 } else {
1627 g_usbCameraExit = false;
1628 }
1629 for (int i = 0; i < usbCameraIds.size(); i++) {
1630 if (!g_usbCameraExit) {
1631 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1632 }
1633 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1634 EXPECT_NE(ability_, nullptr);
1635 common_metadata_header_t *data = ability_->get();
1636 camera_metadata_item_t entry;
1637 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
1638 EXPECT_EQ(ret, CAM_META_SUCCESS);
1639 CAMERA_LOGD("OHOS_SENSOR_ORIENTATION value is %{pubilc}d", entry.data.u8[0]);
1640 EXPECT_TRUE(entry.data.u8[0] == 0);
1641 }
1642 }
1643
1644 /**
1645 * @tc.name: USB Camera
1646 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_TYPE_UNSPECIFIED
1647 * @tc.level: Level0
1648 * @tc.size: MediumTest
1649 * @tc.type: Function
1650 */
TEST_F(UtestUSBCameraTest,camera_usb_0050)1651 TEST_F(UtestUSBCameraTest, camera_usb_0050)
1652 {
1653 // Get the device manager
1654 std::vector<std::string> usbCameraIds;
1655 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1656 if (usbCameraIds.size() > 1) {
1657 g_usbCameraExit = true;
1658 } else {
1659 g_usbCameraExit = false;
1660 }
1661 for (int i = 0; i < usbCameraIds.size(); i++) {
1662 if (!g_usbCameraExit) {
1663 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1664 }
1665 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1666 EXPECT_NE(ability_, nullptr);
1667 common_metadata_header_t *data = ability_->get();
1668 camera_metadata_item_t entry;
1669 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
1670 EXPECT_EQ(ret, CAM_META_SUCCESS);
1671 CAMERA_LOGD("OHOS_ABILITY_CAMERA_TYPE value is %{pubilc}d", entry.data.u8[0]);
1672 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED);
1673 }
1674 }
1675
1676 /**
1677 * @tc.name: USB Camera
1678 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN
1679 * @tc.level: Level0
1680 * @tc.size: MediumTest
1681 * @tc.type: Function
1682 */
TEST_F(UtestUSBCameraTest,camera_usb_0051)1683 TEST_F(UtestUSBCameraTest, camera_usb_0051)
1684 {
1685 // Get the device manager
1686 std::vector<std::string> usbCameraIds;
1687 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1688 if (usbCameraIds.size() > 1) {
1689 g_usbCameraExit = true;
1690 } else {
1691 g_usbCameraExit = false;
1692 }
1693 for (int i = 0; i < usbCameraIds.size(); i++) {
1694 if (!g_usbCameraExit) {
1695 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1696 }
1697 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1698 EXPECT_NE(ability_, nullptr);
1699 common_metadata_header_t *data = ability_->get();
1700 camera_metadata_item_t entry;
1701 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
1702 EXPECT_EQ(ret, CAM_META_SUCCESS);
1703 CAMERA_LOGD("OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is %{pubilc}d", entry.data.u8[0]);
1704 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN);
1705 }
1706 }
1707
1708 /**
1709 * @tc.name: USB Camera
1710 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_CAMERA_POSITION
1711 * @tc.level: Level0
1712 * @tc.size: MediumTest
1713 * @tc.type: Function
1714 */
TEST_F(UtestUSBCameraTest,camera_usb_0052)1715 TEST_F(UtestUSBCameraTest, camera_usb_0052)
1716 {
1717 // Get the device manager
1718 std::vector<std::string> usbCameraIds;
1719 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1720 if (usbCameraIds.size() > 1) {
1721 g_usbCameraExit = true;
1722 } else {
1723 g_usbCameraExit = false;
1724 }
1725 for (int i = 0; i < usbCameraIds.size(); i++) {
1726 if (!g_usbCameraExit) {
1727 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1728 }
1729 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1730 EXPECT_NE(ability_, nullptr);
1731 common_metadata_header_t *data = ability_->get();
1732 camera_metadata_item_t entry;
1733 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
1734 CAMERA_LOGD("OHOS_ABILITY_CAMERA_POSITION value is %{pubilc}d", entry.data.u8[0]);
1735 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_OTHER);
1736 }
1737 }
1738
1739 /**
1740 * @tc.name: USB Camera
1741 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
1742 * @tc.level: Level0
1743 * @tc.size: MediumTest
1744 * @tc.type: Function
1745 */
TEST_F(UtestUSBCameraTest,camera_usb_0053)1746 TEST_F(UtestUSBCameraTest, camera_usb_0053)
1747 {
1748 cameraBase_->OpenUsbCamera();
1749 if (!g_usbCameraExit) {
1750 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1751 }
1752 cameraBase_->AchieveStreamOperator();
1753 if (cameraBase_->streamCustomerPreview_ == nullptr) {
1754 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1755 }
1756 std::vector<StreamInfo> streamInfos;
1757 StreamInfo streamInfo = {};
1758 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
1759 streamInfo.width_ = 1280; // 1280:picture width
1760 streamInfo.height_ = 720; // 720:picture height
1761 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1762 streamInfo.dataspace_ = 8; // 8:picture dataspace
1763 streamInfo.intent_ = PREVIEW;
1764 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1765 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
1766 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1767 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1768 streamInfos.push_back(streamInfo);
1769 if (cameraBase_->streamCustomerCapture_ == nullptr) {
1770 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
1771 }
1772 StreamInfo streamInfoCapture = {};
1773 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
1774 streamInfoCapture.width_ = 1280; // 1280:picture width
1775 streamInfoCapture.height_ = 720; // 720:picture height
1776 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
1777 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
1778 streamInfoCapture.intent_ = STILL_CAPTURE;
1779 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
1780 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
1781 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
1782 cameraBase_->streamCustomerCapture_->CreateProducer());
1783 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
1784 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1785 streamInfos.push_back(streamInfoCapture);
1786 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1787 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1788 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1789 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1790 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1791 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1792 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1793 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1794 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1795 }
1796