1 /*
2 * Copyright (c) 2021-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 using namespace OHOS;
17 using namespace std;
18 using namespace testing::ext;
19 using namespace OHOS::Camera;
20 bool usbCameraExit_ = false;
21
SetUpTestCase(void)22 void USBCameraTest::SetUpTestCase(void)
23 {}
TearDownTestCase(void)24 void USBCameraTest::TearDownTestCase(void)
25 {}
SetUp(void)26 void USBCameraTest::SetUp(void)
27 {
28 if (display_ == nullptr)
29 display_ = std::make_shared<TestDisplay>();
30 display_->UsbInit();
31 }
TearDown(void)32 void USBCameraTest::TearDown(void)
33 {
34 display_->Close();
35 }
36
37 /**
38 * @tc.name: USB Camera
39 * @tc.desc: Add USB Camera, getCameraID success.
40 * @tc.level: Level0
41 * @tc.size: MediumTest
42 * @tc.type: Function
43 */
44 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0010, TestSize.Level1)
45 {
46 uint32_t rc = 0;
47 std::cout << "==========[test log] Add USB Camera, getCameraID success."<< std::endl;
48 std::vector<std::string> cameraIds;
49 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
50 display_->cameraHost->GetCameraIds(cameraIds);
51 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
52 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl;
53 for (const auto &cameraId : cameraIds) {
54 std::cout << "==========[test log] cameraId = " << cameraId << std::endl;
55 }
56 std::cout << "==========[test log] 2. please add the usb camera, wait for 5s..."<< std::endl;
57 sleep(5); // judging add or delete the usb camera, wait for 5s.
58 std::cout << "==========[test log] r u ready? wait for 5s..."<< std::endl;
59 sleep(5); // judging r u ready, wait for 5s.
60 std::cout << "==========[test log] 3. check the cameraID again... wait for 5s..."<< std::endl;
61 sleep(5); // checking the cameraID again, wait for 5s.
62 if (cameraIds.size() == 1) {
63 cameraIds.clear();
64 }
65 rc = display_->cameraHost->GetCameraIds(cameraIds);
66 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
67 for (const auto &cameraId : cameraIds) {
68 std::cout << "cameraId = " << cameraId << std::endl;
69 }
70 if (cameraIds.size() > 1) {
71 usbCameraExit_ = true;
72 }
73 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
74 }
75
76 /**
77 * @tc.name: USB Camera
78 * @tc.desc: Delect USB Camera, getCameraID success.
79 * @tc.level: Level0
80 * @tc.size: MediumTest
81 * @tc.type: Function
82 */
83 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0020, TestSize.Level1)
84 {
85 uint32_t rc = 0;
86 std::cout << "==========[test log] Delect USB Camera, getCameraID success."<< std::endl;
87 std::vector<std::string> cameraIds;
88 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
89 display_->cameraHost->GetCameraIds(cameraIds);
90 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
91 std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl;
92 for (const auto &cameraId : cameraIds) {
93 std::cout << "==========[test log] cameraId = " << cameraId << std::endl;
94 }
95 std::cout << "==========[test log] 2. please delect the usb camera, wait for 5s... "<< std::endl;
96 sleep(5); // judging add or delete the usb camera, wait for 5s.
97 std::cout << "==========[test log] r u ready? wait for 5s..."<< std::endl;
98 sleep(5); // judging r u ready, wait for 5s.
99 std::cout << "==========[test log] 3. check the cameraID again... wait for 5s..."<< std::endl;
100 sleep(5); // checking the cameraID again, wait for 5s.
101 if (cameraIds.size() == 1) {
102 cameraIds.clear();
103 }
104 rc = display_->cameraHost->GetCameraIds(cameraIds);
105 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
106 for (const auto &cameraId : cameraIds) {
107 std::cout << "cameraId = " << cameraId << std::endl;
108 }
109 if (cameraIds.size() > 1) {
110 usbCameraExit_ = true;
111 }
112 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
113 }
114
115 /**
116 * @tc.name: USB Camera
117 * @tc.desc: Loop Add/Delect USB Camera, getCameraID success.
118 * @tc.level: Level0
119 * @tc.size: MediumTest
120 * @tc.type: Function
121 */
122 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0030, TestSize.Level1)
123 {
124 uint32_t rc = 0;
125 std::cout << "==========[test log] Insert USB Camera, getCameraID success."<< std::endl;
126 std::vector<std::string> cameraIds;
127 std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
128 display_->cameraHost->GetCameraIds(cameraIds);
129 std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
130 for (int i=0 ;i<=10 ;i++) {
131 std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 5s..."<< std::endl;
132 sleep(5); // judging add or delete the usb camera, wait for 5s.
133 std::cout << "==========[test log] r u ready? wait for 5s..."<< std::endl;
134 sleep(5); // judging r u ready, wait for 5s.
135 std::cout << "==========[test log] 3. check the cameraID again... wait for 5s..."<< std::endl;
136 sleep(5); // checking the cameraID again, wait for 5s.
137 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
138 cameraIds.clear();
139 display_->cameraHost->GetCameraIds(cameraIds);
140 std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
141 }
142 std::cout << "==========[test log] 2. please add the usb camera, wait for 5s..."<< std::endl;
143 sleep(5); // judging add or delete the usb camera, wait for 5s.
144 std::cout << "==========[test log] r u ready? wait for 5s..."<< std::endl;
145 sleep(5); // judging r u ready, wait for 5s.
146 std::cout << "==========[test log] 3. check the cameraID again... wait for 5s..."<< std::endl;
147 sleep(5); // checking the cameraID again, wait for 5s.
148 if (cameraIds.size() == 1) {
149 cameraIds.clear();
150 }
151 rc = display_->cameraHost->GetCameraIds(cameraIds);
152 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
153 for (const auto &cameraId : cameraIds) {
154 std::cout << "cameraId = " << cameraId << std::endl;
155 }
156 if (cameraIds.size() > 1) {
157 usbCameraExit_ = true;
158 }
159 }
160
161
162 /**
163 * @tc.name: USB Camera
164 * @tc.desc: get value of OHOS_ABILITY_ZOOM_RATIO_RANGE
165 * @tc.level: Level0
166 * @tc.size: MediumTest
167 * @tc.type: Function
168 */
169 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0040, TestSize.Level1)
170 {
171 if (!usbCameraExit_) {
172 std::cout << "No usb camera plugged in" << std::endl;
173 } else if (usbCameraExit_) {
174 ability_ = display_->GetCameraAbility();
175 EXPECT_NE(ability_, nullptr);
176 common_metadata_header_t *data = ability_->get();
177 camera_metadata_item_t entry;
178 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry);
179 if (ret == CAM_META_SUCCESS) {
180 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE: count is " << (int)entry.count << std::endl;
181 std::cout << "Zoom ratio range: [" << entry.data.f[0];
182 std::cout << "," << entry.data.f[1] << "]" << std::endl;
183 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
184 std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE is not support" << std::endl;
185 }
186 }
187 }
188
189 /**
190 * @tc.name: USB Camera
191 * @tc.desc: get value of OHOS_ABILITY_CAMERA_CONNECTION_TYPE
192 * @tc.level: Level0
193 * @tc.size: MediumTest
194 * @tc.type: Function
195 */
196 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0050, TestSize.Level1)
197 {
198 if (!usbCameraExit_) {
199 std::cout << "No usb camera plugged in" << std::endl;
200 } else if (usbCameraExit_) {
201 ability_ = display_->GetCameraAbility();
202 EXPECT_NE(ability_, nullptr);
203 common_metadata_header_t *data = ability_->get();
204 camera_metadata_item_t entry;
205 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
206 EXPECT_EQ(ret, CAM_META_SUCCESS);
207 std::cout << "OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is "
208 << static_cast<int>(entry.data.u8[0]) << std::endl;
209 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN);
210 }
211 }
212
213 /**
214 * @tc.name: USB Camera
215 * @tc.desc: get value of OHOS_ABILITY_CAMERA_POSITION
216 * @tc.level: Level0
217 * @tc.size: MediumTest
218 * @tc.type: Function
219 */
220 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0060, TestSize.Level1)
221 {
222 if (!usbCameraExit_) {
223 std::cout << "No usb camera plugged in" << std::endl;
224 } else if (usbCameraExit_) {
225 ability_ = display_->GetCameraAbility();
226 EXPECT_NE(ability_, nullptr);
227 common_metadata_header_t *data = ability_->get();
228 camera_metadata_item_t entry;
229 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
230 EXPECT_EQ(ret, CAM_META_SUCCESS);
231 std::cout << "OHOS_ABILITY_CAMERA_POSITION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
232 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_OTHER);
233 }
234 }
235
236 /**
237 * @tc.name: USB Camera
238 * @tc.desc: get value of OHOS_ABILITY_FLASH_AVAILABLE
239 * @tc.level: Level0
240 * @tc.size: MediumTest
241 * @tc.type: Function
242 */
243 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0070, TestSize.Level1)
244 {
245 if (!usbCameraExit_) {
246 std::cout << "No usb camera plugged in" << std::endl;
247 } else if (usbCameraExit_) {
248 ability_ = display_->GetCameraAbility();
249 EXPECT_NE(ability_, nullptr);
250 common_metadata_header_t *data = ability_->get();
251 camera_metadata_item_t entry;
252 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry);
253 EXPECT_EQ(ret, CAM_META_SUCCESS);
254 std::cout << "OHOS_ABILITY_FLASH_AVAILABLE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
255 }
256 }
257
258 /**
259 * @tc.name: USB Camera
260 * @tc.desc: get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES
261 * @tc.level: Level0
262 * @tc.size: MediumTest
263 * @tc.type: Function
264 */
265 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0080, TestSize.Level1)
266 {
267 if (!usbCameraExit_) {
268 std::cout << "No usb camera plugged in" << std::endl;
269 } else if (usbCameraExit_) {
270 ability_ = display_->GetCameraAbility();
271 EXPECT_NE(ability_, nullptr);
272 common_metadata_header_t *data = ability_->get();
273 camera_metadata_item_t entry;
274 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry);
275 if (ret == CAM_META_SUCCESS) {
276 for (int i = 0; i < entry.count; i++) {
277 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is "
278 << static_cast<int>(entry.data.u8[i]) << std::endl;
279 }
280 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
281 std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support" << std::endl;
282 }
283 }
284 }
285
286 /**
287 * @tc.name: USB Camera
288 * @tc.desc: get value of OHOS_ABILITY_FLASH_MODES
289 * @tc.level: Level0
290 * @tc.size: MediumTest
291 * @tc.type: Function
292 */
293 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0090, TestSize.Level1)
294 {
295 if (!usbCameraExit_) {
296 std::cout << "No usb camera plugged in" << std::endl;
297 } else if (usbCameraExit_) {
298 ability_ = display_->GetCameraAbility();
299 common_metadata_header_t *data = ability_->get();
300 camera_metadata_item_t entry;
301 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
302 if (ret == CAM_META_SUCCESS) {
303 std::cout << "supported flash mode list:";
304 for (int i = 0; i < entry.count; i++) {
305 std::cout << " " << static_cast<int>(entry.data.u8[i]);
306 }
307 std::cout << std::endl;
308 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
309 std::cout << "OHOS_ABILITY_FLASH_MODES is not support" << std::endl;
310 }
311 }
312 }
313
314 /**
315 * @tc.name: USB Camera
316 * @tc.desc: get value of OHOS_ABILITY_FOCUS_MODES
317 * @tc.level: Level0
318 * @tc.size: MediumTest
319 * @tc.type: Function
320 */
321 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0100, TestSize.Level1)
322 {
323 if (!usbCameraExit_) {
324 std::cout << "No usb camera plugged in" << std::endl;
325 } else if (usbCameraExit_) {
326 ability_ = display_->GetCameraAbility();
327 EXPECT_NE(ability_, nullptr);
328 common_metadata_header_t *data = ability_->get();
329 camera_metadata_item_t entry;
330 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
331 if (ret == CAM_META_SUCCESS) {
332 std::cout << "supported focus mode list:";
333 for (int i = 0; i < entry.count; i++) {
334 std::cout << " " << static_cast<int>(entry.data.u8[i]);
335 }
336 std::cout << std::endl;
337 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
338 std::cout << "OHOS_ABILITY_FOCUS_MODES is not support" << std::endl;
339 }
340 }
341 }
342
343 /**
344 * @tc.name: USB Camera
345 * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_MODES
346 * @tc.level: Level0
347 * @tc.size: MediumTest
348 * @tc.type: Function
349 */
350 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0110, TestSize.Level1)
351 {
352 if (!usbCameraExit_) {
353 std::cout << "No usb camera plugged in" << std::endl;
354 } else if (usbCameraExit_) {
355 ability_ = display_->GetCameraAbility();
356 EXPECT_NE(ability_, nullptr);
357 common_metadata_header_t *data = ability_->get();
358 camera_metadata_item_t entry;
359 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
360 if (ret == CAM_META_SUCCESS) {
361 std::cout << "supported exposure mode list:";
362 for (int i = 0; i < entry.count; i++) {
363 std::cout << " " << static_cast<int>(entry.data.u8[i]);
364 }
365 std::cout << std::endl;
366 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
367 std::cout << "OHOS_ABILITY_EXPOSURE_MODES is not support" << std::endl;
368 }
369 }
370 }
371
372 /**
373 * @tc.name: USB Camera
374 * @tc.desc: get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED
375 * @tc.level: Level0
376 * @tc.size: MediumTest
377 * @tc.type: Function
378 */
379 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0120, TestSize.Level1)
380 {
381 if (!usbCameraExit_) {
382 std::cout << "No usb camera plugged in" << std::endl;
383 } else if (usbCameraExit_) {
384 ability_ = display_->GetCameraAbility();
385 EXPECT_NE(ability_, nullptr);
386 common_metadata_header_t *data = ability_->get();
387 camera_metadata_item_t entry;
388 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
389 EXPECT_EQ(ret, CAM_META_SUCCESS);
390 std::cout << "capture mirror supported is :";
391 for (int i = 0; i < entry.count; i++) {
392 std::cout << " " << static_cast<int>(entry.data.u8[i]);
393 }
394 std::cout << std::endl;
395 }
396 }
397
398 /**
399 * @tc.name: USB Camera
400 * @tc.desc: get value of OHOS_ABILITY_MUTE_MODES
401 * @tc.level: Level0
402 * @tc.size: MediumTest
403 * @tc.type: Function
404 */
405 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0130, TestSize.Level1)
406 {
407 if (!usbCameraExit_) {
408 std::cout << "No usb camera plugged in" << std::endl;
409 } else if (usbCameraExit_) {
410 ability_ = display_->GetCameraAbility();
411 EXPECT_NE(ability_, nullptr);
412 common_metadata_header_t *data = ability_->get();
413 camera_metadata_item_t entry;
414 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry);
415 if (ret == CAM_META_SUCCESS) {
416 std::cout << "supported mute mode is:";
417 for (int i = 0; i < entry.count; i++) {
418 std::cout << " " << static_cast<int>(entry.data.u8[i]);
419 }
420 std::cout << std::endl;
421 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
422 std::cout << "OHOS_ABILITY_MUTE_MODES is not support" << std::endl;
423 }
424 }
425 }
426
427 /**
428 * @tc.name: USB Camera
429 * @tc.desc: get value of OHOS_ABILITY_FPS_RANGES
430 * @tc.level: Level0
431 * @tc.size: MediumTest
432 * @tc.type: Function
433 */
434 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0140, TestSize.Level1)
435 {
436 if (!usbCameraExit_) {
437 std::cout << "No usb camera plugged in" << std::endl;
438 } else if (usbCameraExit_) {
439 ability_ = display_->GetCameraAbility();
440 EXPECT_NE(ability_, nullptr);
441 common_metadata_header_t *data = ability_->get();
442 camera_metadata_item_t entry;
443 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
444 EXPECT_EQ(ret, CAM_META_SUCCESS);
445 std::cout << "supported fps ranges list: [";
446 std::cout << static_cast<int>(entry.data.i32[0]) << "," << static_cast<int>(entry.data.i32[1]) << "]";
447 std::cout << std::endl;
448 }
449 }
450
451 /**
452 * @tc.name: USB Camera
453 * @tc.desc: get value of OHOS_ABILITY_CAMERA_TYPE
454 * @tc.level: Level0
455 * @tc.size: MediumTest
456 * @tc.type: Function
457 */
458 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0150, TestSize.Level1)
459 {
460 if (!usbCameraExit_) {
461 std::cout << "No usb camera plugged in" << std::endl;
462 } else if (usbCameraExit_) {
463 ability_ = display_->GetCameraAbility();
464 EXPECT_NE(ability_, nullptr);
465 common_metadata_header_t *data = ability_->get();
466 camera_metadata_item_t entry;
467 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
468 EXPECT_EQ(ret, CAM_META_SUCCESS);
469 std::cout << "OHOS_ABILITY_CAMERA_TYPE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
470 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED);
471 }
472 }
473
474 /**
475 * @tc.name: USB Camera
476 * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS
477 * @tc.level: Level0
478 * @tc.size: MediumTest
479 * @tc.type: Function
480 */
481 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0160, TestSize.Level1)
482 {
483 if (!usbCameraExit_) {
484 std::cout << "No usb camera plugged in" << std::endl;
485 } else if (usbCameraExit_) {
486 ability_ = display_->GetCameraAbility();
487 EXPECT_NE(ability_, nullptr);
488 common_metadata_header_t *data = ability_->get();
489 camera_metadata_item_t entry;
490 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
491 EXPECT_EQ(ret, CAM_META_SUCCESS);
492 std::cout << "OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is "
493 << static_cast<int>(entry.data.u8[0]) << std::endl;
494 EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888);
495 }
496 }
497
498 /**
499 * @tc.name: USB Camera
500 * @tc.desc: UpdateSettings, fps=10,default width = 640, height =480.
501 * @tc.level: Level0
502 * @tc.size: MediumTest
503 * @tc.type: Function
504 */
505 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0170, TestSize.Level1)
506 {
507 if (!usbCameraExit_) {
508 std::cout << "No usb camera plugged in" << std::endl;
509 } else if (usbCameraExit_) {
510 // Get the device manager
511 display_->OpenUsbCamera();
512 // Create and get streamOperator information
513 display_->AchieveStreamOperator();
514 // Create data stream
515 display_->StartStreamUpdate(640,480);
516 // updateSettings
517 const uint32_t ITEM_CAPACITY = 100;
518 const uint32_t DATA_CAPACITY = 2000;
519 const int32_t FPS_VALUE = 10;// 10:fps
520 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
521 ITEM_CAPACITY, DATA_CAPACITY);
522 std::vector<int32_t> fpsRange;
523 fpsRange.push_back(FPS_VALUE);
524 fpsRange.push_back(FPS_VALUE);
525 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
526 const int32_t DEVICE_STREAM_ID = 0;
527 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
528 std::vector<uint8_t> setting;
529 MetadataUtils::ConvertMetadataToVec(meta, setting);
530 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
531 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
532
533 // capture
534 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
535 // release stream
536 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
537 display_->streamIds = {display_->STREAM_ID_PREVIEW};
538 display_->StopStream(display_->captureIds, display_->streamIds);
539 }
540 }
541
542 /**
543 * @tc.name: USB Camera
544 * @tc.desc: UpdateSettings, fps=30,default width = 640, height =480.
545 * @tc.level: Level0
546 * @tc.size: MediumTest
547 * @tc.type: Function
548 */
549 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0180, TestSize.Level1)
550 {
551 if (!usbCameraExit_) {
552 std::cout << "No usb camera plugged in" << std::endl;
553 } else if (usbCameraExit_) {
554 // Get the device manager
555 display_->OpenUsbCamera();
556 // Create and get streamOperator information
557 display_->AchieveStreamOperator();
558 // Create data stream
559 display_->StartStreamUpdate(640,480);
560 // updateSettings
561 const uint32_t ITEM_CAPACITY = 100;
562 const uint32_t DATA_CAPACITY = 2000;
563 const int32_t FPS_VALUE = 30;// 30:fps
564 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
565 ITEM_CAPACITY, DATA_CAPACITY);
566 std::vector<int32_t> fpsRange;
567 fpsRange.push_back(FPS_VALUE);
568 fpsRange.push_back(FPS_VALUE);
569 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
570 const int32_t DEVICE_STREAM_ID = 0;
571 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
572 std::vector<uint8_t> setting;
573 MetadataUtils::ConvertMetadataToVec(meta, setting);
574 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
575 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
576
577 // capture
578 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
579 // release stream
580 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
581 display_->streamIds = {display_->STREAM_ID_PREVIEW};
582 display_->StopStream(display_->captureIds, display_->streamIds);
583 }
584 }
585 /**
586 * @tc.name: USB Camera
587 * @tc.desc: Preview stream, width = 800, height =600, fps=10.
588 * @tc.level: Level0
589 * @tc.size: MediumTest
590 * @tc.type: Function
591 */
592 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0190, TestSize.Level1)
593 {
594 if (!usbCameraExit_) {
595 std::cout << "No usb camera plugged in" << std::endl;
596 } else if (usbCameraExit_) {
597 display_->OpenUsbCamera();
598 // Create and get streamOperator information
599 display_->AchieveStreamOperator();
600 // Create data stream
601 display_->StartStreamUpdate(800,600);
602 // updateSettings
603 const uint32_t ITEM_CAPACITY = 100;
604 const uint32_t DATA_CAPACITY = 2000;
605 const int32_t FPS_VALUE = 10;// 10:fps
606 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
607 std::vector<int32_t> fpsRange;
608 fpsRange.push_back(FPS_VALUE);
609 fpsRange.push_back(FPS_VALUE);
610 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
611 const int32_t DEVICE_STREAM_ID = 0;
612 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
613 std::vector<uint8_t> setting;
614 MetadataUtils::ConvertMetadataToVec(meta, setting);
615 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
616 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
617
618 // capture
619 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
620 // release stream
621 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
622 display_->streamIds = {display_->STREAM_ID_PREVIEW};
623 display_->StopStream(display_->captureIds, display_->streamIds);
624 }
625 }
626
627 /**
628 * @tc.name: USB Camera
629 * @tc.desc: Preview stream, width = 352, height =288, fps=30.
630 * @tc.level: Level0
631 * @tc.size: MediumTest
632 * @tc.type: Function
633 */
634 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0200, TestSize.Level1)
635 {
636 if (!usbCameraExit_) {
637 std::cout << "No usb camera plugged in" << std::endl;
638 } else if (usbCameraExit_) {
639 // Get the device manager
640 display_->OpenUsbCamera();
641 // Create and get streamOperator information
642 display_->AchieveStreamOperator();
643 // Create data stream
644 display_->StartStreamUpdate(352,288);
645 // updateSettings
646 const uint32_t ITEM_CAPACITY = 100;
647 const uint32_t DATA_CAPACITY = 2000;
648 const int32_t FPS_VALUE = 30;// 30:fps
649 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
650 ITEM_CAPACITY, DATA_CAPACITY);
651 std::vector<int32_t> fpsRange;
652 fpsRange.push_back(FPS_VALUE);
653 fpsRange.push_back(FPS_VALUE);
654 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
655 const int32_t DEVICE_STREAM_ID = 0;
656 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
657 std::vector<uint8_t> setting;
658 MetadataUtils::ConvertMetadataToVec(meta, setting);
659 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
660 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
661
662 // capture
663 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
664 // release stream
665 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
666 display_->streamIds = {display_->STREAM_ID_PREVIEW};
667 display_->StopStream(display_->captureIds, display_->streamIds);
668 }
669 }
670
671 /**
672 * @tc.name: USB Camera
673 * @tc.desc: Preview stream, width = 320, height =240, fps=30.
674 * @tc.level: Level0
675 * @tc.size: MediumTest
676 * @tc.type: Function
677 */
678 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0210, TestSize.Level1)
679 {
680 if (!usbCameraExit_) {
681 std::cout << "No usb camera plugged in" << std::endl;
682 } else if (usbCameraExit_) {
683 // Get the device manager
684 display_->OpenUsbCamera();
685 // Create and get streamOperator information
686 display_->AchieveStreamOperator();
687 // Create data stream
688 display_->StartStreamUpdate(320,240);
689 // updateSettings
690 const uint32_t ITEM_CAPACITY = 100;
691 const uint32_t DATA_CAPACITY = 2000;
692 const int32_t FPS_VALUE = 30;// 30:fps
693 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
694 ITEM_CAPACITY, DATA_CAPACITY);
695 std::vector<int32_t> fpsRange;
696 fpsRange.push_back(FPS_VALUE);
697 fpsRange.push_back(FPS_VALUE);
698 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
699 const int32_t DEVICE_STREAM_ID = 0;
700 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
701 std::vector<uint8_t> setting;
702 MetadataUtils::ConvertMetadataToVec(meta, setting);
703 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
704 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
705
706 // capture
707 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
708 // release stream
709 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
710 display_->streamIds = {display_->STREAM_ID_PREVIEW};
711 display_->StopStream(display_->captureIds, display_->streamIds);
712 }
713 }
714 /**
715 * @tc.name: USB Camera
716 * @tc.desc: Preview stream, width = 176, height =144, fps=30.
717 * @tc.level: Level0
718 * @tc.size: MediumTest
719 * @tc.type: Function
720 */
721 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0220, TestSize.Level1)
722 {
723 if (!usbCameraExit_) {
724 std::cout << "No usb camera plugged in" << std::endl;
725 } else if (usbCameraExit_) {
726 // Get the device manager
727 display_->OpenUsbCamera();
728 // Create and get streamOperator information
729 display_->AchieveStreamOperator();
730 // Create data stream
731 display_->StartStreamUpdate(176,144);
732 // updateSettings
733 const uint32_t ITEM_CAPACITY = 100;
734 const uint32_t DATA_CAPACITY = 2000;
735 const int32_t FPS_VALUE = 30;// 30:fps
736 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
737 ITEM_CAPACITY, DATA_CAPACITY);
738 std::vector<int32_t> fpsRange;
739 fpsRange.push_back(FPS_VALUE);
740 fpsRange.push_back(FPS_VALUE);
741 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
742 const int32_t DEVICE_STREAM_ID = 0;
743 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
744 std::vector<uint8_t> setting;
745 MetadataUtils::ConvertMetadataToVec(meta, setting);
746 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
747 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
748
749 // capture
750 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
751 // release stream
752 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
753 display_->streamIds = {display_->STREAM_ID_PREVIEW};
754 display_->StopStream(display_->captureIds, display_->streamIds);
755 }
756 }
757 /**
758 * @tc.name: USB Camera
759 * @tc.desc: Preview stream, width = 160, height =120, fps=30.
760 * @tc.level: Level0
761 * @tc.size: MediumTest
762 * @tc.type: Function
763 */
764 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0230, TestSize.Level1)
765 {
766 if (!usbCameraExit_) {
767 std::cout << "No usb camera plugged in" << std::endl;
768 } else if (usbCameraExit_) {
769 // Get the device manager
770 display_->OpenUsbCamera();
771 // Create and get streamOperator information
772 display_->AchieveStreamOperator();
773 // Create data stream
774 display_->StartStreamUpdate(160,120);
775 // updateSettings
776 const uint32_t ITEM_CAPACITY = 100;
777 const uint32_t DATA_CAPACITY = 2000;
778 const int32_t FPS_VALUE = 30;// 30:fps
779 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
780 ITEM_CAPACITY, DATA_CAPACITY);
781 std::vector<int32_t> fpsRange;
782 fpsRange.push_back(FPS_VALUE);
783 fpsRange.push_back(FPS_VALUE);
784 meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
785 const int32_t DEVICE_STREAM_ID = 0;
786 meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
787 std::vector<uint8_t> setting;
788 MetadataUtils::ConvertMetadataToVec(meta, setting);
789 display_->rc = (CamRetCode)display_->cameraDevice->UpdateSettings(setting);
790 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
791
792 // capture
793 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
794 // release stream
795 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
796 display_->streamIds = {display_->STREAM_ID_PREVIEW};
797 display_->StopStream(display_->captureIds, display_->streamIds);
798 }
799 }
800
801 /**
802 * @tc.name: USB Camera
803 * @tc.desc: get value of OHOS_JPEG_ORIENTATION
804 * @tc.level: Level0
805 * @tc.size: MediumTest
806 * @tc.type: Function
807 */
808 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0250, TestSize.Level1)
809 {
810 if (!usbCameraExit_) {
811 std::cout << "No usb camera plugged in" << std::endl;
812 } else if (usbCameraExit_) {
813 ability_ = display_->GetCameraAbility();
814 EXPECT_NE(ability_, nullptr);
815 common_metadata_header_t *data = ability_->get();
816 camera_metadata_item_t entry;
817 int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry);
818 EXPECT_EQ(ret, CAM_META_SUCCESS);
819 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.i32[0]) << std::endl;
820 }
821 }
822
823 /**
824 * @tc.name: USB Camera
825 * @tc.desc: get value of OHOS_JPEG_QUALITY
826 * @tc.level: Level0
827 * @tc.size: MediumTest
828 * @tc.type: Function
829 */
830 HWTEST_F(USBCameraTest, SUB_DriverSystem_UsbCameraHdi_0260, TestSize.Level1)
831 {
832 if (!usbCameraExit_) {
833 std::cout << "No usb camera plugged in" << std::endl;
834 } else if (usbCameraExit_) {
835 ability_ = display_->GetCameraAbility();
836 EXPECT_NE(ability_, nullptr);
837 common_metadata_header_t *data = ability_->get();
838 camera_metadata_item_t entry;
839 int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry);
840 EXPECT_EQ(ret, CAM_META_SUCCESS);
841 std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
842 }
843 }