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 ASSERT_NE(cameraBase_->cameraHost, nullptr);
29 }
TearDown(void)30 void UtestUSBCameraTest::TearDown(void)
31 {
32 cameraBase_->Close();
33 }
34
35 /**
36 * @tc.name: USB Camera
37 * @tc.desc: USB Camera, getCameraID success.
38 * @tc.level: Level0
39 * @tc.size: MediumTest
40 * @tc.type: Function
41 */
TEST_F(UtestUSBCameraTest,camera_usb_0001)42 TEST_F(UtestUSBCameraTest, camera_usb_0001)
43 {
44 uint32_t rc = 0;
45 std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl;
46 std::vector<std::string> cameraIds;
47 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
48 cameraBase_->cameraHost->GetCameraIds(cameraIds);
49 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
50 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl;
51 for (const auto &cameraId : cameraIds) {
52 std::cout << "==========[test log] cameraId = " << cameraId << std::endl;
53 }
54 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 10s..."<< std::endl;
55 sleep(3); // judging add or delete the usb camera, wait for 3s.
56 std::cout << "==========[test log] r u ready? wait for 10s..."<< std::endl;
57 sleep(3); // judging r u ready, wait for 3s.
58 std::cout << "==========[test log] 3. check the cameraID again... wait for 10s..."<< std::endl;
59 sleep(3); // checking the cameraID again, wait for 3s.
60 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
61 if (cameraIds.size() == 1) {
62 cameraIds.clear();
63 }
64 rc = cameraBase_->cameraHost->GetCameraIds(cameraIds);
65 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
66 for (const auto &cameraId : cameraIds) {
67 std::cout << "cameraId = " << cameraId << std::endl;
68 }
69 // 1:number of connected cameras
70 g_usbCameraExit = cameraIds.size() > 1;
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_FRONT);
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 // 1:number of connected cameras
629 g_usbCameraExit = cameraIds.size() > 1;
630 }
631
632 /**
633 * @tc.name: USB Camera
634 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
635 * @tc.level: Level0
636 * @tc.size: MediumTest
637 * @tc.type: Function
638 */
TEST_F(UtestUSBCameraTest,camera_usb_0022)639 TEST_F(UtestUSBCameraTest, camera_usb_0022)
640 {
641 // Get the device manager
642 cameraBase_->OpenUsbCamera();
643 if (!g_usbCameraExit) {
644 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
645 }
646 // Get the stream manager
647 cameraBase_->AchieveStreamOperator();
648 // start stream
649 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
650 cameraBase_->StartStream(cameraBase_->intents);
651 // Get preview
652 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
653 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
654 // release stream
655 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
656 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
657 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
658 }
659
660 /**
661 * @tc.name: USB Camera
662 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
663 * @tc.level: Level0
664 * @tc.size: MediumTest
665 * @tc.type: Function
666 */
TEST_F(UtestUSBCameraTest,camera_usb_0023)667 TEST_F(UtestUSBCameraTest, camera_usb_0023)
668 {
669 cameraBase_->OpenUsbCamera();
670 if (!g_usbCameraExit) {
671 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
672 }
673 cameraBase_->AchieveStreamOperator();
674 if (cameraBase_->streamCustomerPreview_ == nullptr) {
675 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
676 }
677 std::vector<StreamInfo> streamInfos;
678 StreamInfo streamInfo = {};
679 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
680 streamInfo.width_ = 1280; // 1280:picture width
681 streamInfo.height_ = 720; // 720:picture height
682 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
683 streamInfo.dataspace_ = 8; // 8:picture dataspace
684 streamInfo.intent_ = PREVIEW;
685 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
686 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
687 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
688 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
689 streamInfos.push_back(streamInfo);
690 if (cameraBase_->streamCustomerCapture_ == nullptr) {
691 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
692 }
693 StreamInfo streamInfoCapture = {};
694 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
695 streamInfoCapture.width_ = 1280; // 1280:picture width
696 streamInfoCapture.height_ = 720; // 720:picture height
697 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
698 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
699 streamInfoCapture.intent_ = STILL_CAPTURE;
700 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
701 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
702 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
703 cameraBase_->streamCustomerCapture_->CreateProducer());
704 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
705 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
706 streamInfos.push_back(streamInfoCapture);
707 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
708 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
709 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
710 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
711 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
712 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
713 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
714 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
715 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
716 }
717
718 /**
719 * @tc.name: preview and capture
720 * @tc.desc: Commit 2 streams together, Change the value OHOS_JPEG_ORIENTATION, isStreaming is true.
721 * @tc.level: Level0
722 * @tc.size: MediumTest
723 * @tc.type: Function
724 */
TEST_F(UtestUSBCameraTest,camera_usb_0024)725 TEST_F(UtestUSBCameraTest, camera_usb_0024)
726 {
727 // Get the device manager
728 cameraBase_->OpenUsbCamera();
729 if (!g_usbCameraExit) {
730 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
731 }
732 // Get the stream manager
733 cameraBase_->AchieveStreamOperator();
734 std::vector<int32_t> jpegOrientationVector;
735 jpegOrientationVector.push_back(OHOS_CAMERA_JPEG_ROTATION_270);
736 cameraBase_->ability->updateEntry(OHOS_JPEG_ORIENTATION, jpegOrientationVector.data(),
737 jpegOrientationVector.size());
738 cameraBase_->ability_.clear();
739 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_);
740 // start stream
741 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
742 cameraBase_->StartStream(cameraBase_->intents);
743
744 // Get preview
745 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
746 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
747 // release stream
748 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
749 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
750 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
751 }
752
753 /**
754 * @tc.name: preview and capture
755 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
756 * @tc.level: Level0
757 * @tc.size: MediumTest
758 * @tc.type: Function
759 */
TEST_F(UtestUSBCameraTest,camera_usb_0025)760 TEST_F(UtestUSBCameraTest, camera_usb_0025)
761 {
762 // Get the device manager
763 cameraBase_->OpenUsbCamera();
764 if (!g_usbCameraExit) {
765 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
766 }
767 // Get the stream manager
768 cameraBase_->AchieveStreamOperator();
769 std::vector<int32_t> jpegQualityVector;
770 jpegQualityVector.push_back(OHOS_CAMERA_JPEG_LEVEL_LOW);
771 cameraBase_->ability->updateEntry(OHOS_JPEG_QUALITY, jpegQualityVector.data(), jpegQualityVector.size());
772 cameraBase_->ability_.clear();
773 MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_);
774 // start stream
775 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
776 cameraBase_->StartStream(cameraBase_->intents);
777
778 // Get preview
779 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
780 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
781 // release stream
782 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
783 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
784 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
785 }
786
787 /**
788 * @tc.name: Video
789 * @tc.desc: Preview + video, commit together, success.
790 * @tc.level: Level0
791 * @tc.size: MediumTest
792 * @tc.type: Function
793 */
TEST_F(UtestUSBCameraTest,camera_usb_0026)794 TEST_F(UtestUSBCameraTest, camera_usb_0026)
795 {
796 // Get the device manager
797 cameraBase_->OpenUsbCamera();
798 if (!g_usbCameraExit) {
799 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
800 }
801 // Create and get streamOperator information
802 cameraBase_->AchieveStreamOperator();
803 // start stream
804 cameraBase_->intents = {PREVIEW, VIDEO};
805 cameraBase_->StartStream(cameraBase_->intents);
806 // Get preview
807 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
808 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
809
810 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
811 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
812 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
813 }
814
815 /**
816 * @tc.name: USB Camera
817 * @tc.desc: Preview stream, width = 1280, height = 720, expected success.
818 * @tc.level: Level0
819 * @tc.size: MediumTest
820 * @tc.type: Function
821 */
TEST_F(UtestUSBCameraTest,camera_usb_0027)822 TEST_F(UtestUSBCameraTest, camera_usb_0027)
823 {
824 cameraBase_->OpenUsbCamera();
825 if (!g_usbCameraExit) {
826 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
827 }
828 cameraBase_->AchieveStreamOperator();
829 if (cameraBase_->streamCustomerPreview_ == nullptr) {
830 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
831 }
832 std::vector<StreamInfo> streamInfos;
833 StreamInfo streamInfo = {};
834 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
835 streamInfo.width_ = 1280; // 1280:picture width
836 streamInfo.height_ = 720; // 720:picture height
837 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
838 streamInfo.dataspace_ = 8; // 8:picture dataspace
839 streamInfo.intent_ = PREVIEW;
840 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
841 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
842 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
843 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
844 streamInfos.push_back(streamInfo);
845 if (cameraBase_->streamCustomerVideo_ == nullptr) {
846 cameraBase_->streamCustomerVideo_ = std::make_shared<StreamCustomer>();
847 }
848 StreamInfo streamInfoVideo = {};
849 streamInfoVideo.streamId_ = cameraBase_->STREAM_ID_VIDEO;
850 streamInfoVideo.width_ = 1280; // 1280:picture width
851 streamInfoVideo.height_ = 720; // 720:picture height
852 streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888;
853 streamInfoVideo.dataspace_ = 8; // 8:picture dataspace
854 streamInfoVideo.intent_ = VIDEO;
855 streamInfoVideo.encodeType_ = ENCODE_TYPE_H264;
856 streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode
857 streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerVideo_->CreateProducer());
858 ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr);
859 streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
860 streamInfos.push_back(streamInfoVideo);
861 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
862 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
863 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
864 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
865 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
866 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
867 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
868 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
869 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
870 }
871
872 /**
873 * @tc.name: USB Camera
874 * @tc.desc: UpdateSettings, fps.
875 * @tc.level: Level0
876 * @tc.size: MediumTest
877 * @tc.type: Function
878 */
TEST_F(UtestUSBCameraTest,camera_usb_0028)879 TEST_F(UtestUSBCameraTest, camera_usb_0028)
880 {
881 // Get the device manager
882 cameraBase_->OpenUsbCamera();
883 if (!g_usbCameraExit) {
884 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
885 }
886 // get the stream manager
887 cameraBase_->AchieveStreamOperator();
888
889 // start stream
890 cameraBase_->intents = {PREVIEW, VIDEO};
891 cameraBase_->StartStream(cameraBase_->intents);
892
893 // updateSettings
894 const uint32_t ITEM_CAPACITY = 100;
895 const uint32_t DATA_CAPACITY = 2000;
896 const int32_t FPS_VALUE = 10;
897 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
898 ITEM_CAPACITY, DATA_CAPACITY);
899 std::vector<int32_t> fpsRange;
900 fpsRange.push_back(FPS_VALUE);
901 fpsRange.push_back(FPS_VALUE);
902 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
903 const int32_t DEVICE_STREAM_ID = 0;
904 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
905 std::vector<uint8_t> setting;
906 MetadataUtils::ConvertMetadataToVec(meta, setting);
907 cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
908 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
909
910 // get preview
911 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
912 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
913
914 // release stream
915 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
916 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
917 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
918 }
919
920 /**
921 * @tc.name: USB Camera
922 * @tc.desc: Commit 3 streams together, Preview,Video and still_capture streams, isStreaming is true.
923 * @tc.level: Level0
924 * @tc.size: MediumTest
925 * @tc.type: Function
926 */
TEST_F(UtestUSBCameraTest,camera_usb_0029)927 TEST_F(UtestUSBCameraTest, camera_usb_0029)
928 {
929 // Get the device manager
930 cameraBase_->OpenUsbCamera();
931 if (!g_usbCameraExit) {
932 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
933 }
934 // Get the stream manager
935 cameraBase_->AchieveStreamOperator();
936 // start stream
937 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
938 cameraBase_->StartStream(cameraBase_->intents);
939 // Get preview
940 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
941 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
942 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
943 // release stream
944 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
945 cameraBase_->CAPTURE_ID_VIDEO};
946 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
947 cameraBase_->STREAM_ID_VIDEO};
948 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
949 }
950
951 /**
952 * @tc.name: USB Camera
953 * @tc.desc: get value of OHOS_SENSOR_ORIENTATION
954 * @tc.level: Level0
955 * @tc.size: MediumTest
956 * @tc.type: Function
957 */
TEST_F(UtestUSBCameraTest,camera_usb_0030)958 TEST_F(UtestUSBCameraTest, camera_usb_0030)
959 {
960 if (!g_usbCameraExit) {
961 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
962 }
963 ability_ = cameraBase_->GetCameraAbility();
964 EXPECT_NE(ability_, nullptr);
965 common_metadata_header_t *data = ability_->get();
966 camera_metadata_item_t entry;
967 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
968 EXPECT_EQ(ret, CAM_META_SUCCESS);
969 std::cout << "OHOS_SENSOR_ORIENTATION value is " << entry.data.i32[0] << std::endl;
970 EXPECT_TRUE(entry.data.i32[0] == 0);
971 }
972
973 /**
974 * @tc.name: USB Camera
975 * @tc.desc: get value of OHOS_ABILITY_FOCAL_LENGTH
976 * @tc.level: Level0
977 * @tc.size: MediumTest
978 * @tc.type: Function
979 */
TEST_F(UtestUSBCameraTest,camera_usb_0031)980 TEST_F(UtestUSBCameraTest, camera_usb_0031)
981 {
982 if (!g_usbCameraExit) {
983 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
984 }
985 ability_ = cameraBase_->GetCameraAbility();
986 EXPECT_NE(ability_, nullptr);
987 common_metadata_header_t *data = ability_->get();
988 camera_metadata_item_t entry;
989 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
990 if (ret == CAM_META_SUCCESS) {
991 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH: count is " << (int)entry.count << std::endl;
992 std::cout << "log focal length value: " << entry.data.f[0] << std::endl;
993 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
994 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH is not support" << std::endl;
995 }
996 }
997
998 /**
999 * @tc.name: USB Camera
1000 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
1001 * @tc.level: Level0
1002 * @tc.size: MediumTest
1003 * @tc.type: Function
1004 */
TEST_F(UtestUSBCameraTest,camera_usb_0032)1005 TEST_F(UtestUSBCameraTest, camera_usb_0032)
1006 {
1007 // Get the device manager
1008 std::vector<std::string> usbCameraIds;
1009 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1010 // 1:number of connected cameras
1011 g_usbCameraExit = usbCameraIds.size() > 1;
1012 for (int i = 0; i < usbCameraIds.size(); i++) {
1013 if (!g_usbCameraExit) {
1014 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1015 }
1016 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
1017 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1018 // Get the stream manager
1019 cameraBase_->AchieveStreamOperator();
1020 // start stream
1021 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
1022 cameraBase_->StartStream(cameraBase_->intents);
1023 // Get preview
1024 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1025 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1026 // release stream
1027 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1028 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1029 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1030 }
1031 }
1032
1033 /**
1034 * @tc.name: USB Camera
1035 * @tc.desc: Open the capture stream for both cameras at the same time.
1036 * @tc.level: Level0
1037 * @tc.size: MediumTest
1038 * @tc.type: Function
1039 */
TEST_F(UtestUSBCameraTest,camera_usb_0033)1040 TEST_F(UtestUSBCameraTest, camera_usb_0033)
1041 {
1042 // Get the device manager
1043 std::vector<std::string> usbCameraIds;
1044 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1045 // 1:number of connected cameras
1046 g_usbCameraExit = usbCameraIds.size() > 1;
1047 for (int i = 0; i < usbCameraIds.size(); i++) {
1048 if (!g_usbCameraExit) {
1049 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1050 }
1051 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
1052 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1053 // Get the stream manager
1054 cameraBase_->AchieveStreamOperator();
1055 // start stream
1056 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1057 cameraBase_->StartStream(cameraBase_->intents);
1058 // Get preview
1059 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1060 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1061 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1062 // release stream
1063 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
1064 cameraBase_->CAPTURE_ID_VIDEO};
1065 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
1066 cameraBase_->STREAM_ID_VIDEO};
1067 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1068 }
1069 }
1070
1071 /**
1072 * @tc.name: USB Camera
1073 * @tc.desc: One camera starts capturing and the other camera starts recording.
1074 * @tc.level: Level0
1075 * @tc.size: MediumTest
1076 * @tc.type: Function
1077 */
TEST_F(UtestUSBCameraTest,camera_usb_0034)1078 TEST_F(UtestUSBCameraTest, camera_usb_0034)
1079 {
1080 // Get the device manager
1081 std::vector<std::string> usbCameraIds;
1082 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1083 // 1:number of connected cameras
1084 g_usbCameraExit = usbCameraIds.size() > 1;
1085 if (!g_usbCameraExit) {
1086 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1087 }
1088 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]);
1089 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1090 // Get the stream manager
1091 cameraBase_->AchieveStreamOperator();
1092 // start stream
1093 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
1094 cameraBase_->StartStream(cameraBase_->intents);
1095 // Get preview
1096 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1097 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1098 // release stream
1099 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1100 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1101 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1102
1103 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[1]);
1104 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1105 // Get the stream manager
1106 cameraBase_->AchieveStreamOperator();
1107 // start stream
1108 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1109 cameraBase_->StartStream(cameraBase_->intents);
1110 // Get preview
1111 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1112 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1113 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1114 // release stream
1115 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
1116 cameraBase_->CAPTURE_ID_VIDEO};
1117 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
1118 cameraBase_->STREAM_ID_VIDEO};
1119 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1120 }
1121
1122 /**
1123 * @tc.name: USB Camera
1124 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_ZOOM_RATIO_RANGE
1125 * @tc.level: Level0
1126 * @tc.size: MediumTest
1127 * @tc.type: Function
1128 */
TEST_F(UtestUSBCameraTest,camera_usb_0035)1129 TEST_F(UtestUSBCameraTest, camera_usb_0035)
1130 {
1131 // Get the device manager
1132 std::vector<std::string> usbCameraIds;
1133 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1134 // 1:number of connected cameras
1135 g_usbCameraExit = usbCameraIds.size() > 1;
1136 for (int i = 0; i < usbCameraIds.size(); i++) {
1137 if (!g_usbCameraExit) {
1138 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1139 }
1140 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1141 EXPECT_NE(ability_, nullptr);
1142 common_metadata_header_t *data = ability_->get();
1143 camera_metadata_item_t entry;
1144 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry);
1145 if (ret == CAM_META_SUCCESS) {
1146 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE: count is %{public}d ", entry.count);
1147 CAMERA_LOGD("Zoom ratio range: [%{public}d,[%{public}d]", entry.data.f[0], entry.data.f[1]);
1148 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1149 CAMERA_LOGD("OHOS_ABILITY_ZOOM_RATIO_RANGE is not support");
1150 }
1151 }
1152 }
1153
1154 /**
1155 * @tc.name: USB Camera
1156 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_AVAILABLE
1157 * @tc.level: Level0
1158 * @tc.size: MediumTest
1159 * @tc.type: Function
1160 */
TEST_F(UtestUSBCameraTest,camera_usb_0036)1161 TEST_F(UtestUSBCameraTest, camera_usb_0036)
1162 {
1163 // Get the device manager
1164 std::vector<std::string> usbCameraIds;
1165 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1166 // 1:number of connected cameras
1167 g_usbCameraExit = usbCameraIds.size() > 1;
1168 for (int i = 0; i < usbCameraIds.size(); i++) {
1169 if (!g_usbCameraExit) {
1170 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1171 }
1172 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1173 EXPECT_NE(ability_, nullptr);
1174 common_metadata_header_t *data = ability_->get();
1175 camera_metadata_item_t entry;
1176 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry);
1177 EXPECT_EQ(ret, CAM_META_SUCCESS);
1178 CAMERA_LOGD("OHOS_ABILITY_FLASH_AVAILABLE value is %{public}d", entry.data.u8[0]);
1179 }
1180 }
1181
1182 /**
1183 * @tc.name: USB Camera
1184 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES
1185 * @tc.level: Level0
1186 * @tc.size: MediumTest
1187 * @tc.type: Function
1188 */
TEST_F(UtestUSBCameraTest,camera_usb_0037)1189 TEST_F(UtestUSBCameraTest, camera_usb_0037)
1190 {
1191 // Get the device manager
1192 std::vector<std::string> usbCameraIds;
1193 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1194 // 1:number of connected cameras
1195 g_usbCameraExit = usbCameraIds.size() > 1;
1196 for (int i = 0; i < usbCameraIds.size(); i++) {
1197 if (!g_usbCameraExit) {
1198 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1199 }
1200 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1201 EXPECT_NE(ability_, nullptr);
1202 common_metadata_header_t *data = ability_->get();
1203 camera_metadata_item_t entry;
1204 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry);
1205 if (ret == CAM_META_SUCCESS) {
1206 for (int i = 0; i < entry.count; i++) {
1207 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is %{public}d", entry.data.u8[i]);
1208 }
1209 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1210 CAMERA_LOGD("OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support");
1211 }
1212 }
1213 }
1214
1215 /**
1216 * @tc.name: USB Camera
1217 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FLASH_MODES
1218 * @tc.level: Level0
1219 * @tc.size: MediumTest
1220 * @tc.type: Function
1221 */
TEST_F(UtestUSBCameraTest,camera_usb_0038)1222 TEST_F(UtestUSBCameraTest, camera_usb_0038)
1223 {
1224 // Get the device manager
1225 std::vector<std::string> usbCameraIds;
1226 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1227 // 1:number of connected cameras
1228 g_usbCameraExit = usbCameraIds.size() > 1;
1229 for (int i = 0; i < usbCameraIds.size(); i++) {
1230 if (!g_usbCameraExit) {
1231 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1232 }
1233 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1234 common_metadata_header_t *data = ability_->get();
1235 camera_metadata_item_t entry;
1236 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
1237 if (ret == CAM_META_SUCCESS) {
1238 CAMERA_LOGD("supported flash mode list:");
1239 for (int i = 0; i < entry.count; i++) {
1240 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1241 }
1242 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1243 CAMERA_LOGD("OHOS_ABILITY_FLASH_MODES is not support");
1244 }
1245 }
1246 }
1247
1248 /**
1249 * @tc.name: USB Camera
1250 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCUS_MODES
1251 * @tc.level: Level0
1252 * @tc.size: MediumTest
1253 * @tc.type: Function
1254 */
TEST_F(UtestUSBCameraTest,camera_usb_0039)1255 TEST_F(UtestUSBCameraTest, camera_usb_0039)
1256 {
1257 // Get the device manager
1258 std::vector<std::string> usbCameraIds;
1259 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1260 // 1:number of connected cameras
1261 g_usbCameraExit = usbCameraIds.size() > 1;
1262 for (int i = 0; i < usbCameraIds.size(); i++) {
1263 if (!g_usbCameraExit) {
1264 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1265 }
1266 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1267 EXPECT_NE(ability_, nullptr);
1268 common_metadata_header_t *data = ability_->get();
1269 camera_metadata_item_t entry;
1270 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
1271 if (ret == CAM_META_SUCCESS) {
1272 CAMERA_LOGD("supported flash mode list:");
1273 for (int i = 0; i < entry.count; i++) {
1274 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1275 }
1276 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1277 CAMERA_LOGD("OHOS_ABILITY_FOCUS_MODES is not support");
1278 }
1279 }
1280 }
1281
1282 /**
1283 * @tc.name: USB Camera
1284 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_EXPOSURE_MODES
1285 * @tc.level: Level0
1286 * @tc.size: MediumTest
1287 * @tc.type: Function
1288 */
TEST_F(UtestUSBCameraTest,camera_usb_0040)1289 TEST_F(UtestUSBCameraTest, camera_usb_0040)
1290 {
1291 // Get the device manager
1292 std::vector<std::string> usbCameraIds;
1293 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1294 // 1:number of connected cameras
1295 g_usbCameraExit = usbCameraIds.size() > 1;
1296 for (int i = 0; i < usbCameraIds.size(); i++) {
1297 if (!g_usbCameraExit) {
1298 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1299 }
1300 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1301 EXPECT_NE(ability_, nullptr);
1302 common_metadata_header_t *data = ability_->get();
1303 camera_metadata_item_t entry;
1304 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
1305 if (ret == CAM_META_SUCCESS) {
1306 CAMERA_LOGD("supported flash mode list:");
1307 for (int i = 0; i < entry.count; i++) {
1308 CAMERA_LOGD("%{public}d ", entry.data.u8[i]);
1309 }
1310 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1311 CAMERA_LOGD("OHOS_ABILITY_EXPOSURE_MODES is not support");
1312 }
1313 }
1314 }
1315
1316 /**
1317 * @tc.name: USB Camera
1318 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED
1319 * @tc.level: Level0
1320 * @tc.size: MediumTest
1321 * @tc.type: Function
1322 */
TEST_F(UtestUSBCameraTest,camera_usb_0041)1323 TEST_F(UtestUSBCameraTest, camera_usb_0041)
1324 {
1325 // Get the device manager
1326 std::vector<std::string> usbCameraIds;
1327 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1328 // 1:number of connected cameras
1329 g_usbCameraExit = usbCameraIds.size() > 1;
1330 for (int i = 0; i < usbCameraIds.size(); i++) {
1331 if (!g_usbCameraExit) {
1332 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1333 }
1334 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1335 EXPECT_NE(ability_, nullptr);
1336 common_metadata_header_t *data = ability_->get();
1337 camera_metadata_item_t entry;
1338 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
1339 EXPECT_EQ(ret, CAM_META_SUCCESS);
1340 CAMERA_LOGD("capture mirror supported is :");
1341 for (int i = 0; i < entry.count; i++) {
1342 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1343 }
1344 }
1345 }
1346
1347 /**
1348 * @tc.name: USB Camera
1349 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_MUTE_MODES
1350 * @tc.level: Level0
1351 * @tc.size: MediumTest
1352 * @tc.type: Function
1353 */
TEST_F(UtestUSBCameraTest,camera_usb_0042)1354 TEST_F(UtestUSBCameraTest, camera_usb_0042)
1355 {
1356 // Get the device manager
1357 std::vector<std::string> usbCameraIds;
1358 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1359 // 1:number of connected cameras
1360 g_usbCameraExit = usbCameraIds.size() > 1;
1361 for (int i = 0; i < usbCameraIds.size(); i++) {
1362 if (!g_usbCameraExit) {
1363 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1364 }
1365 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1366 EXPECT_NE(ability_, nullptr);
1367 common_metadata_header_t *data = ability_->get();
1368 camera_metadata_item_t entry;
1369 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry);
1370 if (ret == CAM_META_SUCCESS) {
1371 CAMERA_LOGD("supported flash mode list:");
1372 for (int i = 0; i < entry.count; i++) {
1373 CAMERA_LOGD("%{public}d", entry.data.u8[i]);
1374 }
1375 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1376 CAMERA_LOGD("OHOS_ABILITY_MUTE_MODES is not support");
1377 }
1378 }
1379 }
1380
1381 /**
1382 * @tc.name: USB Camera
1383 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FPS_RANGES
1384 * @tc.level: Level0
1385 * @tc.size: MediumTest
1386 * @tc.type: Function
1387 */
TEST_F(UtestUSBCameraTest,camera_usb_0043)1388 TEST_F(UtestUSBCameraTest, camera_usb_0043)
1389 {
1390 // Get the device manager
1391 std::vector<std::string> usbCameraIds;
1392 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1393 // 1:number of connected cameras
1394 g_usbCameraExit = usbCameraIds.size() > 1;
1395 for (int i = 0; i < usbCameraIds.size(); i++) {
1396 if (!g_usbCameraExit) {
1397 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1398 }
1399 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1400 EXPECT_NE(ability_, nullptr);
1401 common_metadata_header_t *data = ability_->get();
1402 camera_metadata_item_t entry;
1403 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
1404 EXPECT_EQ(ret, CAM_META_SUCCESS);
1405 CAMERA_LOGD("supported fps ranges list: [ %{public}d, %{public}d ]", entry.data.i32[0], entry.data.i32[1]);
1406 }
1407 }
1408
1409 /**
1410 * @tc.name: USB Camera
1411 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_ORIENTATION
1412 * @tc.level: Level0
1413 * @tc.size: MediumTest
1414 * @tc.type: Function
1415 */
TEST_F(UtestUSBCameraTest,camera_usb_0044)1416 TEST_F(UtestUSBCameraTest, camera_usb_0044)
1417 {
1418 // Get the device manager
1419 std::vector<std::string> usbCameraIds;
1420 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1421 // 1:number of connected cameras
1422 g_usbCameraExit = usbCameraIds.size() > 1;
1423 for (int i = 0; i < usbCameraIds.size(); i++) {
1424 if (!g_usbCameraExit) {
1425 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1426 }
1427 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1428 EXPECT_NE(ability_, nullptr);
1429 common_metadata_header_t *data = ability_->get();
1430 camera_metadata_item_t entry;
1431 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry);
1432 EXPECT_EQ(ret, CAM_META_SUCCESS);
1433 CAMERA_LOGD("OHOS_JPEG_ORIENTATION value is %{public}d", entry.data.i32[0]);
1434 }
1435 }
1436
1437 /**
1438 * @tc.name: USB Camera
1439 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_JPEG_QUALITY
1440 * @tc.level: Level0
1441 * @tc.size: MediumTest
1442 * @tc.type: Function
1443 */
TEST_F(UtestUSBCameraTest,camera_usb_0045)1444 TEST_F(UtestUSBCameraTest, camera_usb_0045)
1445 {
1446 // Get the device manager
1447 std::vector<std::string> usbCameraIds;
1448 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1449 // 1:number of connected cameras
1450 g_usbCameraExit = usbCameraIds.size() > 1;
1451 for (int i = 0; i < usbCameraIds.size(); i++) {
1452 if (!g_usbCameraExit) {
1453 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1454 }
1455 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1456 EXPECT_NE(ability_, nullptr);
1457 common_metadata_header_t *data = ability_->get();
1458 camera_metadata_item_t entry;
1459 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry);
1460 EXPECT_EQ(ret, CAM_META_SUCCESS);
1461 CAMERA_LOGD("OHOS_JPEG_QUALITY value is %{public}d", entry.data.i32[0]);
1462 }
1463 }
1464
1465 /**
1466 * @tc.name: USB Camera
1467 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS
1468 * @tc.level: Level0
1469 * @tc.size: MediumTest
1470 * @tc.type: Function
1471 */
TEST_F(UtestUSBCameraTest,camera_usb_0046)1472 TEST_F(UtestUSBCameraTest, camera_usb_0046)
1473 {
1474 // Get the device manager
1475 std::vector<std::string> usbCameraIds;
1476 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1477 // 1:number of connected cameras
1478 g_usbCameraExit = usbCameraIds.size() > 1;
1479 for (int i = 0; i < usbCameraIds.size(); i++) {
1480 if (!g_usbCameraExit) {
1481 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1482 }
1483 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1484 EXPECT_NE(ability_, nullptr);
1485 common_metadata_header_t *data = ability_->get();
1486 camera_metadata_item_t entry;
1487 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
1488 EXPECT_EQ(ret, CAM_META_SUCCESS);
1489 CAMERA_LOGD("OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is %{public}d", entry.data.u8[0]);
1490 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888);
1491 }
1492 }
1493
1494 /**
1495 * @tc.name: USB Camera
1496 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
1497 * @tc.level: Level0
1498 * @tc.size: MediumTest
1499 * @tc.type: Function
1500 */
TEST_F(UtestUSBCameraTest,camera_usb_0047)1501 TEST_F(UtestUSBCameraTest, camera_usb_0047)
1502 {
1503 // Get the device manager
1504 std::vector<std::string> usbCameraIds;
1505 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1506 // 1:number of connected cameras
1507 g_usbCameraExit = usbCameraIds.size() > 1;
1508 for (int i = 0; i < usbCameraIds.size(); i++) {
1509 if (!g_usbCameraExit) {
1510 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1511 }
1512 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1513 EXPECT_NE(ability_, nullptr);
1514 common_metadata_header_t *data = ability_->get();
1515 EXPECT_NE(data, nullptr);
1516 camera_metadata_item_t entry;
1517 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
1518 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
1519 CAMERA_LOGD("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start.");
1520 const size_t STEP = 10; // print step
1521 CAMERA_LOGD("count: %{public}s", entry.count);
1522 for (size_t a = 0; a < entry.count; a++) {
1523 CAMERA_LOGD("%{public}d", entry.data.i32[a]);
1524 }
1525 CAMERA_LOGE("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end.");
1526 }
1527 }
1528 }
1529
1530 /**
1531 * @tc.name: USB Camera
1532 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_FOCAL_LENGTH
1533 * @tc.level: Level0
1534 * @tc.size: MediumTest
1535 * @tc.type: Function
1536 */
TEST_F(UtestUSBCameraTest,camera_usb_0048)1537 TEST_F(UtestUSBCameraTest, camera_usb_0048)
1538 {
1539 // Get the device manager
1540 std::vector<std::string> usbCameraIds;
1541 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1542 // 1:number of connected cameras
1543 g_usbCameraExit = usbCameraIds.size() > 1;
1544 for (int i = 0; i < usbCameraIds.size(); i++) {
1545 if (!g_usbCameraExit) {
1546 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1547 }
1548 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1549 EXPECT_NE(ability_, nullptr);
1550 common_metadata_header_t *data = ability_->get();
1551 camera_metadata_item_t entry;
1552 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
1553 if (ret == CAM_META_SUCCESS) {
1554 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH: count is %{public}s", entry.count);
1555 CAMERA_LOGD("log focal length value: %{pubilc}d", entry.data.f[0]);
1556 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1557 CAMERA_LOGD("log OHOS_ABILITY_FOCAL_LENGTH is not support");
1558 }
1559 }
1560 }
1561
1562 /**
1563 * @tc.name: USB Camera
1564 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_SENSOR_ORIENTATION
1565 * @tc.level: Level0
1566 * @tc.size: MediumTest
1567 * @tc.type: Function
1568 */
TEST_F(UtestUSBCameraTest,camera_usb_0049)1569 TEST_F(UtestUSBCameraTest, camera_usb_0049)
1570 {
1571 // Get the device manager
1572 std::vector<std::string> usbCameraIds;
1573 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1574 // 1:number of connected cameras
1575 g_usbCameraExit = usbCameraIds.size() > 1;
1576 for (int i = 0; i < usbCameraIds.size(); i++) {
1577 if (!g_usbCameraExit) {
1578 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1579 }
1580 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1581 EXPECT_NE(ability_, nullptr);
1582 common_metadata_header_t *data = ability_->get();
1583 camera_metadata_item_t entry;
1584 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
1585 EXPECT_EQ(ret, CAM_META_SUCCESS);
1586 CAMERA_LOGD("OHOS_SENSOR_ORIENTATION value is %{pubilc}d", entry.data.i32[0]);
1587 EXPECT_TRUE(entry.data.i32[0] == 0);
1588 }
1589 }
1590
1591 /**
1592 * @tc.name: USB Camera
1593 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_TYPE_UNSPECIFIED
1594 * @tc.level: Level0
1595 * @tc.size: MediumTest
1596 * @tc.type: Function
1597 */
TEST_F(UtestUSBCameraTest,camera_usb_0050)1598 TEST_F(UtestUSBCameraTest, camera_usb_0050)
1599 {
1600 // Get the device manager
1601 std::vector<std::string> usbCameraIds;
1602 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1603 // 1:number of connected cameras
1604 g_usbCameraExit = usbCameraIds.size() > 1;
1605 for (int i = 0; i < usbCameraIds.size(); i++) {
1606 if (!g_usbCameraExit) {
1607 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1608 }
1609 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1610 EXPECT_NE(ability_, nullptr);
1611 common_metadata_header_t *data = ability_->get();
1612 camera_metadata_item_t entry;
1613 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
1614 EXPECT_EQ(ret, CAM_META_SUCCESS);
1615 CAMERA_LOGD("OHOS_ABILITY_CAMERA_TYPE value is %{pubilc}d", entry.data.u8[0]);
1616 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED);
1617 }
1618 }
1619
1620 /**
1621 * @tc.name: USB Camera
1622 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN
1623 * @tc.level: Level0
1624 * @tc.size: MediumTest
1625 * @tc.type: Function
1626 */
TEST_F(UtestUSBCameraTest,camera_usb_0051)1627 TEST_F(UtestUSBCameraTest, camera_usb_0051)
1628 {
1629 // Get the device manager
1630 std::vector<std::string> usbCameraIds;
1631 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1632 // 1:number of connected cameras
1633 g_usbCameraExit = usbCameraIds.size() > 1;
1634 for (int i = 0; i < usbCameraIds.size(); i++) {
1635 if (!g_usbCameraExit) {
1636 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1637 }
1638 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1639 EXPECT_NE(ability_, nullptr);
1640 common_metadata_header_t *data = ability_->get();
1641 camera_metadata_item_t entry;
1642 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
1643 EXPECT_EQ(ret, CAM_META_SUCCESS);
1644 CAMERA_LOGD("OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is %{pubilc}d", entry.data.u8[0]);
1645 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN);
1646 }
1647 }
1648
1649 /**
1650 * @tc.name: USB Camera
1651 * @tc.desc: Plug in multiple USB cameras,get value of OHOS_ABILITY_CAMERA_POSITION
1652 * @tc.level: Level0
1653 * @tc.size: MediumTest
1654 * @tc.type: Function
1655 */
TEST_F(UtestUSBCameraTest,camera_usb_0052)1656 TEST_F(UtestUSBCameraTest, camera_usb_0052)
1657 {
1658 // Get the device manager
1659 std::vector<std::string> usbCameraIds;
1660 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1661 // 1:number of connected cameras
1662 g_usbCameraExit = usbCameraIds.size() > 1;
1663 for (int i = 0; i < usbCameraIds.size(); i++) {
1664 if (!g_usbCameraExit) {
1665 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1666 }
1667 ability_ = cameraBase_->GetCameraAbilityById(usbCameraIds[i]);
1668 EXPECT_NE(ability_, nullptr);
1669 common_metadata_header_t *data = ability_->get();
1670 camera_metadata_item_t entry;
1671 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
1672 CAMERA_LOGD("OHOS_ABILITY_CAMERA_POSITION value is %{pubilc}d", entry.data.u8[0]);
1673 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_FRONT);
1674 }
1675 }
1676
1677 /**
1678 * @tc.name: USB Camera
1679 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
1680 * @tc.level: Level0
1681 * @tc.size: MediumTest
1682 * @tc.type: Function
1683 */
TEST_F(UtestUSBCameraTest,camera_usb_0053)1684 TEST_F(UtestUSBCameraTest, camera_usb_0053)
1685 {
1686 cameraBase_->OpenUsbCamera();
1687 if (!g_usbCameraExit) {
1688 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1689 }
1690 cameraBase_->AchieveStreamOperator();
1691 if (cameraBase_->streamCustomerPreview_ == nullptr) {
1692 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1693 }
1694 std::vector<StreamInfo> streamInfos;
1695 StreamInfo streamInfo = {};
1696 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
1697 streamInfo.width_ = 1280; // 1280:picture width
1698 streamInfo.height_ = 720; // 720:picture height
1699 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1700 streamInfo.dataspace_ = 8; // 8:picture dataspace
1701 streamInfo.intent_ = PREVIEW;
1702 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1703 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
1704 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1705 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1706 streamInfos.push_back(streamInfo);
1707 if (cameraBase_->streamCustomerCapture_ == nullptr) {
1708 cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
1709 }
1710 StreamInfo streamInfoCapture = {};
1711 streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
1712 streamInfoCapture.width_ = 1280; // 1280:picture width
1713 streamInfoCapture.height_ = 720; // 720:picture height
1714 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
1715 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
1716 streamInfoCapture.intent_ = STILL_CAPTURE;
1717 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
1718 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
1719 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
1720 cameraBase_->streamCustomerCapture_->CreateProducer());
1721 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
1722 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1723 streamInfos.push_back(streamInfoCapture);
1724 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1725 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1726 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1727 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1728 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1729 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1730 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1731 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1732 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1733 }
1734
StoreFile(const unsigned char * bufStart,const uint32_t size,const char * suffix)1735 void StoreFile(const unsigned char *bufStart, const uint32_t size, const char* suffix)
1736 {
1737 static int count = 0;
1738 constexpr uint32_t pathLen = 128;
1739 char path[pathLen] = {0};
1740 char prefix[] = "/data/";
1741 struct timeval start = {};
1742 gettimeofday(&start, nullptr);
1743 std::cout << "suffix = " << suffix << std::endl;
1744 if (sprintf_s(path, sizeof(path), "%sfile_%d_%lld_%s", prefix, count++, start.tv_usec, suffix) < 0) {
1745 CAMERA_LOGE("%{public}s:StoreFile sprintf failed", __func__);
1746 return;
1747 }
1748 int fd = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
1749 if (fd < 0) {
1750 CAMERA_LOGE("demo test:StoreFile open %s %{public}s failed", path, strerror(errno));
1751 return;
1752 }
1753 int ret = write(fd, bufStart, size);
1754 if (ret == -1) {
1755 CAMERA_LOGE("demo test:StoreFile write video file error %{public}s.....\n", strerror(errno));
1756 }
1757 CAMERA_LOGD("demo test:StoreFile size == %{public}d\n", size);
1758 std::cout << "Strore File , Path = " << path << ", size = " << size << std::endl;
1759 close(fd);
1760 }
1761
1762 /**
1763 * @tc.name: USB Camera
1764 * @tc.desc: single video stream, output nv21, expected success.
1765 * @tc.level: Level0
1766 * @tc.size: MediumTest
1767 * @tc.type: Function
1768 */
TEST_F(UtestUSBCameraTest,camera_usb_0054)1769 TEST_F(UtestUSBCameraTest, camera_usb_0054)
1770 {
1771 cameraBase_->OpenUsbCamera();
1772 cameraBase_->AchieveStreamOperator();
1773 auto streamCustomerVideo = std::make_shared<StreamCustomer>();
1774
1775 uint32_t captureIdVideo = 1;
1776 uint32_t streamIdVideo = 1;
1777 std::vector<StreamInfo> streamInfos;
1778 StreamInfo streamInfo = {};
1779 streamInfo.streamId_ = streamIdVideo;
1780 streamInfo.width_ = 1280; // 1280:picture width
1781 streamInfo.height_ = 720; // 720:picture height
1782 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP;
1783 streamInfo.encodeType_ = ENCODE_TYPE_NULL;
1784 streamInfo.dataspace_ = 8; // 8:picture dataspace
1785 streamInfo.intent_ = VIDEO;
1786 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1787 streamInfo.bufferQueue_ = new BufferProducerSequenceable(streamCustomerVideo->CreateProducer());
1788 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1789 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1790 streamInfos.push_back(streamInfo);
1791
1792 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1793 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1794 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1795 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1796
1797 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1798 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
1799 StoreFile(addr, size, "_single_video.yuv");
1800 });
1801
1802 CaptureInfo captureInfoVideo = {
1803 .streamIds_ = {streamIdVideo},
1804 .captureSetting_ = cameraBase_->ability_,
1805 .enableShutterCallback_ = false,
1806 };
1807 std::cout << "start capture video" << std::endl;
1808 CAMERA_LOGE("start capture video");
1809 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1810 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1811 sleep(1);
1812
1813 std::cout << "cancel capture video" << std::endl;
1814 CAMERA_LOGE("cancel capture video");
1815 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdVideo);
1816 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1817 sleep(1);
1818
1819 std::cout << "start capture video" << std::endl;
1820 CAMERA_LOGE("start capture video");
1821 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1822 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1823 sleep(1);
1824
1825 streamCustomerVideo->ReceiveFrameOff();
1826
1827 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdVideo});
1828 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1829 sleep(1);
1830 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdVideo});
1831 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1832 }
1833
1834 /**
1835 * @tc.name: USB Camera
1836 * @tc.desc: single video stream, output jpeg, expected success.
1837 * @tc.level: Level0
1838 * @tc.size: MediumTest
1839 * @tc.type: Function
1840 */
TEST_F(UtestUSBCameraTest,camera_usb_0055)1841 TEST_F(UtestUSBCameraTest, camera_usb_0055)
1842 {
1843 cameraBase_->OpenUsbCamera();
1844 cameraBase_->AchieveStreamOperator();
1845 auto streamCustomerVideo = std::make_shared<StreamCustomer>();
1846
1847 uint32_t captureIdVideo = 1;
1848 uint32_t streamIdVideo = 1;
1849 std::vector<StreamInfo> streamInfos;
1850 StreamInfo streamInfo = {};
1851 streamInfo.streamId_ = streamIdVideo;
1852 streamInfo.width_ = 1280; // 1280:picture width
1853 streamInfo.height_ = 720; // 720:picture height
1854 streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP;
1855 streamInfo.encodeType_ = ENCODE_TYPE_JPEG;
1856 streamInfo.dataspace_ = 8; // 8:picture dataspace
1857 streamInfo.intent_ = VIDEO;
1858 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1859 streamInfo.bufferQueue_ = new (std::nothrow) BufferProducerSequenceable(streamCustomerVideo->CreateProducer());
1860 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1861 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1862 streamInfos.push_back(streamInfo);
1863
1864 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1865 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1866 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1867 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1868
1869 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1870 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
1871 StoreFile(addr, size, "_single_video.jpeg");
1872 });
1873
1874 CaptureInfo captureInfoVideo = {
1875 .streamIds_ = {streamIdVideo},
1876 .captureSetting_ = cameraBase_->ability_,
1877 .enableShutterCallback_ = false,
1878 };
1879 std::cout << "start capture video" << std::endl;
1880 CAMERA_LOGE("start capture video");
1881 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1882 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1883 sleep(1);
1884
1885 std::cout << "cancel capture video" << std::endl;
1886 CAMERA_LOGE("cancel capture video");
1887 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdVideo);
1888 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1889 sleep(1);
1890
1891 std::cout << "start capture video" << std::endl;
1892 CAMERA_LOGE("start capture video");
1893 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdVideo, captureInfoVideo, true);
1894 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1895 sleep(1);
1896
1897 streamCustomerVideo->ReceiveFrameOff();
1898
1899 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdVideo});
1900 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1901 sleep(1);
1902 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdVideo});
1903 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1904 }
1905
1906 /**
1907 * @tc.name: USB Camera
1908 * @tc.desc: Commit 2 streams together, width = 1280, height = 960, expected success.
1909 * @tc.level: Level0
1910 * @tc.size: MediumTest
1911 * @tc.type: Function
1912 */
TEST_F(UtestUSBCameraTest,camera_usb_0056)1913 TEST_F(UtestUSBCameraTest, camera_usb_0056)
1914 {
1915 cameraBase_->OpenUsbCamera();
1916 if (!g_usbCameraExit) {
1917 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1918 }
1919 cameraBase_->AchieveStreamOperator();
1920 if (cameraBase_->streamCustomerPreview_ == nullptr) {
1921 cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1922 }
1923 std::vector<StreamInfo> streamInfos;
1924 StreamInfo streamInfo = {};
1925 streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
1926 streamInfo.width_ = 1280; // 1280:picture width
1927 streamInfo.height_ = 960; // 960:picture height
1928 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1929 streamInfo.dataspace_ = 8; // 8:picture dataspace
1930 streamInfo.intent_ = PREVIEW;
1931 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1932 streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
1933 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1934 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1935 streamInfos.push_back(streamInfo);
1936 if (cameraBase_->streamCustomerVideo_ == nullptr) {
1937 cameraBase_->streamCustomerVideo_ = std::make_shared<StreamCustomer>();
1938 }
1939 StreamInfo streamInfoVideo = {};
1940 streamInfoVideo.streamId_ = cameraBase_->STREAM_ID_VIDEO;
1941 streamInfoVideo.width_ = 1280; // 1280:picture width
1942 streamInfoVideo.height_ = 960; // 960:picture height
1943 streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888;
1944 streamInfoVideo.dataspace_ = 8; // 8:picture dataspace
1945 streamInfoVideo.intent_ = VIDEO;
1946 streamInfoVideo.encodeType_ = ENCODE_TYPE_H264;
1947 streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode
1948 streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerVideo_->CreateProducer());
1949 ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr);
1950 streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1951 streamInfos.push_back(streamInfoVideo);
1952 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1953 ASSERT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1954 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1955 ASSERT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1956 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1957 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
1958 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
1959 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
1960 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1961 }
1962
1963 /**
1964 * @tc.name: USB Camera
1965 * @tc.desc: single preview stream, output jpeg, expected success.
1966 * @tc.level: Level0
1967 * @tc.size: MediumTest
1968 * @tc.type: Function
1969 */
TEST_F(UtestUSBCameraTest,camera_usb_0057)1970 TEST_F(UtestUSBCameraTest, camera_usb_0057)
1971 {
1972 cameraBase_->OpenUsbCamera();
1973 cameraBase_->AchieveStreamOperator();
1974 auto streamCustomerVideo = std::make_shared<StreamCustomer>();
1975
1976 uint32_t captureIdPreview = cameraBase_->CAPTURE_ID_PREVIEW;
1977 uint32_t streamIdPreview = cameraBase_->STREAM_ID_PREVIEW;
1978 std::vector<StreamInfo> streamInfos;
1979 StreamInfo streamInfo = {};
1980 streamInfo.streamId_ = streamIdPreview;
1981 streamInfo.width_ = 1280; // 1280:picture width
1982 streamInfo.height_ = 720; // 720:picture height
1983 streamInfo.format_ = PIXEL_FMT_BLOB;
1984 streamInfo.encodeType_ = ENCODE_TYPE_NULL;
1985 streamInfo.dataspace_ = 8; // 8:picture dataspace
1986 streamInfo.intent_ = PREVIEW;
1987 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1988 auto producer = streamCustomerVideo->CreateProducer();
1989 streamInfo.bufferQueue_ = new (std::nothrow) BufferProducerSequenceable(producer);
1990 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1991 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1992 streamInfos.push_back(streamInfo);
1993
1994 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1995 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1996 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1997 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1998
1999 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
2000 streamCustomerVideo->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
2001 StoreFile(addr, size, "preview_mjpeg.jpeg");
2002 });
2003
2004 CaptureInfo captureInfoPreview = {
2005 .streamIds_ = {streamIdPreview},
2006 .captureSetting_ = cameraBase_->ability_,
2007 .enableShutterCallback_ = false,
2008 };
2009 std::cout << "start capture preview1" << std::endl;
2010 CAMERA_LOGE("start capture preview1");
2011 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdPreview, captureInfoPreview, true);
2012 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
2013 sleep(1);
2014
2015 std::cout << "cancel capture preview1" << std::endl;
2016 CAMERA_LOGE("cancel capture preview1");
2017 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture(captureIdPreview);
2018 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
2019 sleep(1);
2020
2021 std::cout << "start capture preview2" << std::endl;
2022 CAMERA_LOGE("start capture preview2");
2023 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->Capture(captureIdPreview, captureInfoPreview, true);
2024 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
2025 sleep(1);
2026
2027 streamCustomerVideo->ReceiveFrameOff();
2028
2029 std::cout << "cancel capture preview2" << std::endl;
2030 CAMERA_LOGE("cancel capture preview2");
2031 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CancelCapture({captureIdPreview});
2032 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
2033 sleep(1);
2034 cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->ReleaseStreams({streamIdPreview});
2035 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
2036 }
2037
2038 /**
2039 * @tc.name: USB Camera
2040 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
2041 * @tc.level: Level0
2042 * @tc.size: MediumTest
2043 * @tc.type: Function
2044 */
TEST_F(UtestUSBCameraTest,camera_usb_0058)2045 TEST_F(UtestUSBCameraTest, camera_usb_0058)
2046 {
2047 bool hasFormatMjpeg = false;
2048 cameraBase_->OpenUsbCamera();
2049 ability_ = cameraBase_->GetCameraAbility();
2050 EXPECT_NE(ability_, nullptr);
2051 common_metadata_header_t *data = ability_->get();
2052 EXPECT_NE(data, nullptr);
2053 camera_metadata_item_t entry;
2054 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
2055 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
2056 std::cout << "print tag <OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start." << std::endl;
2057 std::cout << "count" << (entry.count - 1) << std::endl;
2058 for (size_t i = 1; i < entry.count; i++) {
2059 std::cout << entry.data.i32[i] << " ";
2060 if (entry.data.i32[i] != -1) {
2061 continue;
2062 }
2063 std::cout << std::endl;
2064 if (entry.data.i32[i - 1] != -1 && entry.data.i32[i + 1] == OHOS_CAMERA_FORMAT_MJPEG) {
2065 hasFormatMjpeg = true;
2066 }
2067 }
2068 std::cout << "print tag <OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end." << std::endl;
2069 }
2070 std::cout << "OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS has hasFormatMjpeg :" << hasFormatMjpeg
2071 << std::endl;
2072 }
2073