1 /*
2 * Copyright (c) 2021-2024 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_Driver_Camera_UsbHotSwap_0100, 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_Driver_Camera_UsbHotSwap_0200, 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_Driver_Camera_UsbHotSwap_0300, 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_Driver_Camera_UsbAbility_0100, 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_Driver_Camera_UsbAbility_0200, 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_Driver_Camera_UsbAbility_0300, 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_Driver_Camera_UsbAbility_0400, 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_Driver_Camera_UsbAbility_0500, 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_Driver_Camera_UsbAbility_0600, 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_Driver_Camera_UsbAbility_0700, 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_Driver_Camera_UsbAbility_0800, 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_Driver_Camera_UsbAbility_0900, 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_Driver_Camera_UsbAbility_1000, 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_Driver_Camera_UsbAbility_1100, 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_Driver_Camera_UsbAbility_1200, 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_Driver_Camera_UsbAbility_1300, 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_Driver_Camera_UsbPreview_0100, 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_Driver_Camera_UsbPreview_0200, 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_Driver_Camera_UsbPreview_0300, 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_Driver_Camera_UsbPreview_0400, 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_Driver_Camera_UsbPreview_0500, 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_Driver_Camera_UsbPreview_0600, 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_Driver_Camera_UsbPreview_0700, 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_Driver_Camera_UsbAbility_1400, 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_Driver_Camera_UsbAbility_1500, 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 }
844 /**
845 * @tc.name: USB Camera
846 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
847 * @tc.level: Level0
848 * @tc.size: MediumTest
849 * @tc.type: Function
850 */
851 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbPicture_0100, TestSize.Level3)
852 {
853 if (!usbCameraExit_) {
854 std::cout << "No usb camera plugged in" << std::endl;
855 } else if (usbCameraExit_) {
856 // Get the device manager
857 display_->OpenUsbCamera();
858 // Get the stream manager
859 display_->AchieveStreamOperator();
860 // start stream
861 display_->intents = {PREVIEW, STILL_CAPTURE};
862 display_->StartStream(display_->intents);
863 // Get preview
864 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
865 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
866 // release stream
867 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
868 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
869 display_->StopStream(display_->captureIds, display_->streamIds);
870 }
871 }
872 /**
873 * @tc.name: USB Camera
874 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
875 * @tc.level: Level0
876 * @tc.size: MediumTest
877 * @tc.type: Function
878 */
879 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbPicture_0200, TestSize.Level3)
880 {
881 if (!usbCameraExit_) {
882 std::cout << "No usb camera plugged in" << std::endl;
883 } else if (usbCameraExit_) {
884 // Get the device manager
885 display_->OpenUsbCamera();
886 display_->AchieveStreamOperator();
887 if (display_->streamCustomerPreview_ == nullptr) {
888 display_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
889 }
890 std::vector<StreamInfo> streamInfos;
891 StreamInfo streamInfo = {};
892 streamInfo.streamId_ = display_->STREAM_ID_PREVIEW;
893 streamInfo.width_ = 1280; // 1280:picture width
894 streamInfo.height_ = 720; // 720:picture height
895 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
896 streamInfo.dataspace_ = 8; // 8:picture dataspace
897 streamInfo.intent_ = PREVIEW;
898 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
899 streamInfo.bufferQueue_ = new BufferProducerSequenceable(display_->streamCustomerPreview_->CreateProducer());
900 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
901 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
902 streamInfos.push_back(streamInfo);
903 if (display_->streamCustomerCapture_ == nullptr) {
904 display_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
905 }
906 StreamInfo streamInfoCapture = {};
907 streamInfoCapture.streamId_ = display_->STREAM_ID_CAPTURE;
908 streamInfoCapture.width_ = 1280; // 1280:picture width
909 streamInfoCapture.height_ = 960; // 960:picture height
910 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
911 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
912 streamInfoCapture.intent_ = STILL_CAPTURE;
913 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
914 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
915 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
916 display_->streamCustomerCapture_->CreateProducer());
917 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
918 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
919 streamInfos.push_back(streamInfoCapture);
920 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
921 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
922 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
923 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
924 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
925 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
926 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
927 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
928 display_->StopStream(display_->captureIds, display_->streamIds);
929 }
930 }
931 /**
932 * @tc.name: preview and capture
933 * @tc.desc: Commit 2 streams together, Change the value OHOS_JPEG_ORIENTATION, isStreaming is true.
934 * @tc.level: Level0
935 * @tc.size: MediumTest
936 * @tc.type: Function
937 */
938 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbPicture_0300, TestSize.Level3)
939 {
940 if (!usbCameraExit_) {
941 std::cout << "No usb camera plugged in" << std::endl;
942 } else if (usbCameraExit_) {
943 // Get the device manager
944 display_->OpenUsbCamera();
945 // Get the stream manager
946 display_->AchieveStreamOperator();
947 std::vector<int32_t> jpegOrientationVector;
948 jpegOrientationVector.push_back(OHOS_CAMERA_JPEG_ROTATION_270);
949 display_->ability->updateEntry(OHOS_JPEG_ORIENTATION, jpegOrientationVector.data(),
950 jpegOrientationVector.size());
951 display_->ability_.clear();
952 MetadataUtils::ConvertMetadataToVec(display_->ability, display_->ability_);
953 // start stream
954 display_->intents = {PREVIEW, STILL_CAPTURE};
955 display_->StartStream(display_->intents);
956
957 // Get preview
958 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
959 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
960 // release stream
961 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
962 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
963 display_->StopStream(display_->captureIds, display_->streamIds);
964 }
965 }
966 /**
967 * @tc.name: preview and capture
968 * @tc.desc: Commit 2 streams together,Change OHOS_JPEG_QUALITY isStreaming is true.
969 * @tc.level: Level0
970 * @tc.size: MediumTest
971 * @tc.type: Function
972 */
973 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbPicture_0400, TestSize.Level3)
974 {
975 if (!usbCameraExit_) {
976 std::cout << "No usb camera plugged in" << std::endl;
977 } else if (usbCameraExit_) {
978 // Get the device manager
979 display_->OpenUsbCamera();
980 // Get the stream manager
981 display_->AchieveStreamOperator();
982 std::vector<int32_t> jpegQualityVector;
983 jpegQualityVector.push_back(OHOS_CAMERA_JPEG_LEVEL_LOW);
984 display_->ability->updateEntry(OHOS_JPEG_QUALITY, jpegQualityVector.data(), jpegQualityVector.size());
985 display_->ability_.clear();
986 MetadataUtils::ConvertMetadataToVec(display_->ability, display_->ability_);
987 // start stream
988 display_->intents = {PREVIEW, STILL_CAPTURE};
989 display_->StartStream(display_->intents);
990
991 // Get preview
992 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
993 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
994 // release stream
995 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
996 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
997 display_->StopStream(display_->captureIds, display_->streamIds);
998 }
999 }
1000 /**
1001 * @tc.name: Video
1002 * @tc.desc: Preview + video, commit together, success.
1003 * @tc.level: Level0
1004 * @tc.size: MediumTest
1005 * @tc.type: Function
1006 */
1007 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbVideo_0100, TestSize.Level3)
1008 {
1009 if (!usbCameraExit_) {
1010 std::cout << "No usb camera plugged in" << std::endl;
1011 } else if (usbCameraExit_) {
1012 // Get the device manager
1013 display_->OpenUsbCamera();
1014 // Create and get streamOperator information
1015 display_->AchieveStreamOperator();
1016 // start stream
1017 display_->intents = {PREVIEW, VIDEO};
1018 display_->StartStream(display_->intents);
1019 // Get preview
1020 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
1021 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
1022
1023 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
1024 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
1025 display_->StopStream(display_->captureIds, display_->streamIds);
1026 }
1027 }
1028 /**
1029 * @tc.name: USB Camera
1030 * @tc.desc: Preview stream, width = 1280, height = 720, expected success.
1031 * @tc.level: Level0
1032 * @tc.size: MediumTest
1033 * @tc.type: Function
1034 */
1035 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbVideo_0200, TestSize.Level3)
1036 {
1037 if (!usbCameraExit_) {
1038 std::cout << "No usb camera plugged in" << std::endl;
1039 } else if (usbCameraExit_) {
1040 // Get the device manager
1041 display_->OpenUsbCamera();
1042 display_->AchieveStreamOperator();
1043 if (display_->streamCustomerPreview_ == nullptr) {
1044 display_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1045 }
1046 std::vector<StreamInfo> streamInfos;
1047 StreamInfo streamInfo = {};
1048 streamInfo.streamId_ = display_->STREAM_ID_PREVIEW;
1049 streamInfo.width_ = 1280; // 1280:picture width
1050 streamInfo.height_ = 720; // 720:picture height
1051 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1052 streamInfo.dataspace_ = 8; // 8:picture dataspace
1053 streamInfo.intent_ = PREVIEW;
1054 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1055 streamInfo.bufferQueue_ = new BufferProducerSequenceable(display_->streamCustomerPreview_->CreateProducer());
1056 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1057 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1058 streamInfos.push_back(streamInfo);
1059 if (display_->streamCustomerVideo_ == nullptr) {
1060 display_->streamCustomerVideo_ = std::make_shared<StreamCustomer>();
1061 }
1062 StreamInfo streamInfoVideo = {};
1063 streamInfoVideo.streamId_ = display_->STREAM_ID_VIDEO;
1064 streamInfoVideo.width_ = 1280; // 1280:picture width
1065 streamInfoVideo.height_ = 960; // 960:picture height
1066 streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888;
1067 streamInfoVideo.dataspace_ = 8; // 8:picture dataspace
1068 streamInfoVideo.intent_ = VIDEO;
1069 streamInfoVideo.encodeType_ = ENCODE_TYPE_H264;
1070 streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode
1071 streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(display_->streamCustomerVideo_->CreateProducer());
1072 ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr);
1073 streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1074 streamInfos.push_back(streamInfoVideo);
1075 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
1076 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
1077 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
1078 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
1079 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
1080 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
1081 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_VIDEO};
1082 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_VIDEO};
1083 display_->StopStream(display_->captureIds, display_->streamIds);
1084 }
1085 }
1086 /**
1087 * @tc.name: USB Camera
1088 * @tc.desc: Commit 3 streams together, Preview,Video and still_capture streams, isStreaming is true.
1089 * @tc.level: Level0
1090 * @tc.size: MediumTest
1091 * @tc.type: Function
1092 */
1093
1094 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbVideo_0300, TestSize.Level3)
1095 {
1096 if (!usbCameraExit_) {
1097 std::cout << "No usb camera plugged in" << std::endl;
1098 } else if (usbCameraExit_) {
1099 // Get the device manager
1100 display_->OpenUsbCamera();
1101 // Get the stream manager
1102 display_->AchieveStreamOperator();
1103 // start stream
1104 display_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
1105 display_->StartStream(display_->intents);
1106 // Get preview
1107 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
1108 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
1109 display_->StartCapture(display_->STREAM_ID_VIDEO, display_->CAPTURE_ID_VIDEO, false, true);
1110 // release stream
1111 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE,
1112 display_->CAPTURE_ID_VIDEO};
1113 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE,
1114 display_->STREAM_ID_VIDEO};
1115 display_->StopStream(display_->captureIds, display_->streamIds);
1116 }
1117 }
1118 /**
1119 * @tc.name: USB Camera
1120 * @tc.desc: get value of OHOS_SENSOR_ORIENTATION
1121 * @tc.level: Level0
1122 * @tc.size: MediumTest
1123 * @tc.type: Function
1124 */
1125 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbAbility_1600, TestSize.Level3)
1126 {
1127 if (!usbCameraExit_) {
1128 std::cout << "No usb camera plugged in" << std::endl;
1129 } else if (usbCameraExit_) {
1130 ability_ = display_->GetCameraAbility();
1131 EXPECT_NE(ability_, nullptr);
1132 common_metadata_header_t *data = ability_->get();
1133 camera_metadata_item_t entry;
1134 int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
1135 EXPECT_EQ(ret, CAM_META_SUCCESS);
1136 std::cout << "OHOS_SENSOR_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
1137 EXPECT_TRUE(entry.data.u8[0] == 0);
1138 }
1139 }
1140 /**
1141 * @tc.name: USB Camera
1142 * @tc.desc: get value of OHOS_ABILITY_FOCAL_LENGTH
1143 * @tc.level: Level0
1144 * @tc.size: MediumTest
1145 * @tc.type: Function
1146 */
1147 HWTEST_F(USBCameraTest, SUB_Driver_Camera_UsbAbility_1700, TestSize.Level3)
1148 {
1149 if (!usbCameraExit_) {
1150 std::cout << "No usb camera plugged in" << std::endl;
1151 } else if (usbCameraExit_) {
1152 ability_ = display_->GetCameraAbility();
1153 EXPECT_NE(ability_, nullptr);
1154 common_metadata_header_t *data = ability_->get();
1155 camera_metadata_item_t entry;
1156 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
1157 if (ret == CAM_META_SUCCESS) {
1158 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH: count is " << (int)entry.count << std::endl;
1159 std::cout << "log focal length value: " << entry.data.f[0] << std::endl;
1160 } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1161 std::cout << "log OHOS_ABILITY_FOCAL_LENGTH is not support" << std::endl;
1162 }
1163 }
1164 }
1165
1166 /**
1167 * @tc.name: USB Camera
1168 * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
1169 * @tc.level: Level0
1170 * @tc.size: MediumTest
1171 * @tc.type: Function
1172 */
1173 HWTEST_F(USBCameraTest, SUB_Driver_Camera_Pipeline_0100, TestSize.Level3)
1174 {
1175 if (!usbCameraExit_) {
1176 std::cout << "No usb camera plugged in" << std::endl;
1177 } else if (usbCameraExit_) {
1178 std::vector<std::string> usbCameraIds;
1179 display_->cameraHost->GetCameraIds(usbCameraIds);
1180 if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1181 usbCameraExit_ = true;
1182 } else {
1183 usbCameraExit_ = false;
1184 }
1185 display_->OpenUsbCamera();
1186 if (!usbCameraExit_) {
1187 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1188 }
1189 display_->AchieveStreamOperator();
1190 if (display_->streamCustomerPreview_ == nullptr) {
1191 display_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1192 }
1193 std::vector<StreamInfo> streamInfos;
1194 StreamInfo streamInfo = {};
1195 streamInfo.streamId_ = display_->STREAM_ID_PREVIEW;
1196 streamInfo.width_ = 1280; // 1280:picture width
1197 streamInfo.height_ = 960; // 720:picture height
1198 streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1199 streamInfo.dataspace_ = 8; // 8:picture dataspace
1200 streamInfo.intent_ = PREVIEW;
1201 streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1202 streamInfo.bufferQueue_ = new BufferProducerSequenceable(display_->streamCustomerPreview_->CreateProducer());
1203 ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1204 streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1205 streamInfos.push_back(streamInfo);
1206 if (display_->streamCustomerCapture_ == nullptr) {
1207 display_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
1208 }
1209 StreamInfo streamInfoCapture = {};
1210 streamInfoCapture.streamId_ = display_->STREAM_ID_CAPTURE;
1211 streamInfoCapture.width_ = 640; // 1280:picture width
1212 streamInfoCapture.height_ = 480; // 960:picture height
1213 streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
1214 streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
1215 streamInfoCapture.intent_ = STILL_CAPTURE;
1216 streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
1217 streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
1218 streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
1219 display_->streamCustomerCapture_->CreateProducer());
1220 ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
1221 streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1222 streamInfos.push_back(streamInfoCapture);
1223 display_->rc = (CamRetCode)display_->streamOperator->CreateStreams(streamInfos);
1224 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
1225 display_->rc = (CamRetCode)display_->streamOperator->CommitStreams(NORMAL, display_->ability_);
1226 EXPECT_EQ(true, display_->rc == HDI::Camera::V1_0::NO_ERROR);
1227 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
1228 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
1229 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
1230 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
1231 display_->StopStream(display_->captureIds, display_->streamIds);
1232 }
1233 }