1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "usb_camera_test.h"
16 
17 bool g_usbCameraExit = false;
18 
SetUpTestCase(void)19 void UtestUSBCameraTest::SetUpTestCase(void)
20 {}
TearDownTestCase(void)21 void UtestUSBCameraTest::TearDownTestCase(void)
22 {}
SetUp(void)23 void UtestUSBCameraTest::SetUp(void)
24 {
25     if (cameraBase_ == nullptr)
26     cameraBase_ = std::make_shared<TestCameraBase>();
27     cameraBase_->UsbInit();
28 }
TearDown(void)29 void UtestUSBCameraTest::TearDown(void)
30 {
31     cameraBase_->Close();
32 }
33 
34 /**
35   * @tc.name: USB Camera
36   * @tc.desc: USB Camera, getCameraID success.
37   * @tc.level: Level0
38   * @tc.size: MediumTest
39   * @tc.type: Function
40   */
TEST_F(UtestUSBCameraTest,camera_usb_0001)41 TEST_F(UtestUSBCameraTest, camera_usb_0001)
42 {
43     uint32_t rc = 0;
44     std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl;
45     std::vector<std::string> cameraIds;
46     std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
47     cameraBase_->cameraHost->GetCameraIds(cameraIds);
48     std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
49     std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl;
50     for (const auto &cameraId : cameraIds) {
51         std::cout << "==========[test log] cameraId = " << cameraId << std::endl;
52     }
53     std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 10s..."<< std::endl;
54     sleep(3); // judging add or delete the usb camera, wait for 3s.
55     std::cout << "==========[test log] r u ready? wait for 10s..."<< std::endl;
56     sleep(3); // judging r u ready, wait for 3s.
57     std::cout << "==========[test log] 3. check the cameraID again... wait for 10s..."<< std::endl;
58     sleep(3); // checking the cameraID again, wait for 3s.
59     std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
60     if (cameraIds.size() == 1) {
61         cameraIds.clear();
62     }
63     rc = cameraBase_->cameraHost->GetCameraIds(cameraIds);
64     EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
65     for (const auto &cameraId : cameraIds) {
66         std::cout << "cameraId = " << cameraId << std::endl;
67     }
68     if (cameraIds.size() > 1) {
69         g_usbCameraExit = true;
70     }
71 }
72 
73 /**
74   * @tc.name: USB Camera
75   * @tc.desc: get value of OHOS_ABILITY_ZOOM_RATIO_RANGE
76   * @tc.level: Level0
77   * @tc.size: MediumTest
78   * @tc.type: Function
79   */
TEST_F(UtestUSBCameraTest,camera_usb_0002)80 TEST_F(UtestUSBCameraTest, camera_usb_0002)
81 {
82     if (!g_usbCameraExit) {
83         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
84     }
85     ability_ = cameraBase_->GetCameraAbility();
86     EXPECT_NE(ability_, nullptr);
87     common_metadata_header_t *data = ability_->get();
88     camera_metadata_item_t entry;
89     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_ZOOM_RATIO_RANGE, &entry);
90     if (ret == CAM_META_SUCCESS) {
91         std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE: count is " << (int)entry.count << std::endl;
92         std::cout << "Zoom ratio range: [" << entry.data.f[0];
93         std::cout << "," << entry.data.f[1] << "]" << std::endl;
94     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
95         std::cout << "OHOS_ABILITY_ZOOM_RATIO_RANGE is not support" << std::endl;
96     }
97 }
98 
99 /**
100   * @tc.name: USB Camera
101   * @tc.desc: get value of OHOS_ABILITY_CAMERA_CONNECTION_TYPE
102   * @tc.level: Level0
103   * @tc.size: MediumTest
104   * @tc.type: Function
105   */
TEST_F(UtestUSBCameraTest,camera_usb_0003)106 TEST_F(UtestUSBCameraTest, camera_usb_0003)
107 {
108     if (!g_usbCameraExit) {
109         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
110     }
111     ability_ = cameraBase_->GetCameraAbility();
112     EXPECT_NE(ability_, nullptr);
113     common_metadata_header_t *data = ability_->get();
114     camera_metadata_item_t entry;
115     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &entry);
116     EXPECT_EQ(ret, CAM_META_SUCCESS);
117     std::cout << "OHOS_ABILITY_CAMERA_CONNECTION_TYPE value is "
118         << static_cast<int>(entry.data.u8[0]) << std::endl;
119     EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN);
120 }
121 
122 /**
123   * @tc.name: USB Camera
124   * @tc.desc: get value of OHOS_ABILITY_CAMERA_POSITION
125   * @tc.level: Level0
126   * @tc.size: MediumTest
127   * @tc.type: Function
128   */
TEST_F(UtestUSBCameraTest,camera_usb_0004)129 TEST_F(UtestUSBCameraTest, camera_usb_0004)
130 {
131     if (!g_usbCameraExit) {
132         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
133     }
134     ability_ = cameraBase_->GetCameraAbility();
135     EXPECT_NE(ability_, nullptr);
136     common_metadata_header_t *data = ability_->get();
137     camera_metadata_item_t entry;
138     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_POSITION, &entry);
139     EXPECT_EQ(ret, CAM_META_SUCCESS);
140     std::cout << "OHOS_ABILITY_CAMERA_POSITION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
141     EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_POSITION_OTHER);
142 }
143 
144 /**
145   * @tc.name: USB Camera
146   * @tc.desc: get value of OHOS_ABILITY_FLASH_AVAILABLE
147   * @tc.level: Level0
148   * @tc.size: MediumTest
149   * @tc.type: Function
150   */
TEST_F(UtestUSBCameraTest,camera_usb_0005)151 TEST_F(UtestUSBCameraTest, camera_usb_0005)
152 {
153     if (!g_usbCameraExit) {
154         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
155     }
156     ability_ = cameraBase_->GetCameraAbility();
157     EXPECT_NE(ability_, nullptr);
158     common_metadata_header_t *data = ability_->get();
159     camera_metadata_item_t entry;
160     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_AVAILABLE, &entry);
161     EXPECT_EQ(ret, CAM_META_SUCCESS);
162     std::cout << "OHOS_ABILITY_FLASH_AVAILABLE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
163 }
164 
165 /**
166   * @tc.name: USB Camera
167   * @tc.desc: get value of OHOS_ABILITY_VIDEO_STABILIZATION_MODES
168   * @tc.level: Level0
169   * @tc.size: MediumTest
170   * @tc.type: Function
171   */
TEST_F(UtestUSBCameraTest,camera_usb_0006)172 TEST_F(UtestUSBCameraTest, camera_usb_0006)
173 {
174     if (!g_usbCameraExit) {
175         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
176     }
177     ability_ = cameraBase_->GetCameraAbility();
178     EXPECT_NE(ability_, nullptr);
179     common_metadata_header_t *data = ability_->get();
180     camera_metadata_item_t entry;
181     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &entry);
182     if (ret == CAM_META_SUCCESS) {
183         for (int i = 0; i < entry.count; i++) {
184             std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES value is "
185                     << static_cast<int>(entry.data.u8[i]) << std::endl;
186         }
187     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
188         std::cout << "OHOS_ABILITY_VIDEO_STABILIZATION_MODES is not support" << std::endl;
189     }
190 }
191 
192 /**
193   * @tc.name: USB Camera
194   * @tc.desc: get value of OHOS_ABILITY_FLASH_MODES
195   * @tc.level: Level0
196   * @tc.size: MediumTest
197   * @tc.type: Function
198   */
TEST_F(UtestUSBCameraTest,camera_usb_007)199 TEST_F(UtestUSBCameraTest, camera_usb_007)
200 {
201     if (!g_usbCameraExit) {
202         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
203     }
204     ability_ = cameraBase_->GetCameraAbility();
205     common_metadata_header_t *data = ability_->get();
206     camera_metadata_item_t entry;
207     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FLASH_MODES, &entry);
208     if (ret == CAM_META_SUCCESS) {
209         std::cout << "supported flash mode list:";
210         for (int i = 0; i < entry.count; i++) {
211             std::cout << " " << static_cast<int>(entry.data.u8[i]);
212         }
213         std::cout << std::endl;
214     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
215         std::cout << "OHOS_ABILITY_FLASH_MODES is not support" << std::endl;
216     }
217 }
218 
219 /**
220   * @tc.name: USB Camera
221   * @tc.desc: get value of OHOS_ABILITY_FOCUS_MODES
222   * @tc.level: Level0
223   * @tc.size: MediumTest
224   * @tc.type: Function
225   */
TEST_F(UtestUSBCameraTest,camera_usb_008)226 TEST_F(UtestUSBCameraTest, camera_usb_008)
227 {
228     if (!g_usbCameraExit) {
229         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
230     }
231     ability_ = cameraBase_->GetCameraAbility();
232     EXPECT_NE(ability_, nullptr);
233     common_metadata_header_t *data = ability_->get();
234     camera_metadata_item_t entry;
235     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_MODES, &entry);
236     if (ret == CAM_META_SUCCESS) {
237         std::cout << "supported focus mode list:";
238         for (int i = 0; i < entry.count; i++) {
239             std::cout << " " << static_cast<int>(entry.data.u8[i]);
240         }
241         std::cout << std::endl;
242     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
243         std::cout << "OHOS_ABILITY_FOCUS_MODES is not support" << std::endl;
244     }
245 }
246 
247 /**
248   * @tc.name: USB Camera
249   * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_MODES
250   * @tc.level: Level0
251   * @tc.size: MediumTest
252   * @tc.type: Function
253   */
TEST_F(UtestUSBCameraTest,camera_usb_009)254 TEST_F(UtestUSBCameraTest, camera_usb_009)
255 {
256     if (!g_usbCameraExit) {
257         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
258     }
259     ability_ = cameraBase_->GetCameraAbility();
260     EXPECT_NE(ability_, nullptr);
261     common_metadata_header_t *data = ability_->get();
262     camera_metadata_item_t entry;
263     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_MODES, &entry);
264     if (ret == CAM_META_SUCCESS) {
265         std::cout << "supported exposure mode list:";
266         for (int i = 0; i < entry.count; i++) {
267             std::cout << " " << static_cast<int>(entry.data.u8[i]);
268         }
269         std::cout << std::endl;
270     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
271         std::cout << "OHOS_ABILITY_EXPOSURE_MODES is not support" << std::endl;
272     }
273 }
274 
275 /**
276   * @tc.name: USB Camera
277   * @tc.desc: get value of OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED
278   * @tc.level: Level0
279   * @tc.size: MediumTest
280   * @tc.type: Function
281   */
TEST_F(UtestUSBCameraTest,camera_usb_0010)282 TEST_F(UtestUSBCameraTest, camera_usb_0010)
283 {
284     if (!g_usbCameraExit) {
285         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
286     }
287     ability_ = cameraBase_->GetCameraAbility();
288     EXPECT_NE(ability_, nullptr);
289     common_metadata_header_t *data = ability_->get();
290     camera_metadata_item_t entry;
291     int ret = FindCameraMetadataItem(data, OHOS_CONTROL_CAPTURE_MIRROR_SUPPORTED, &entry);
292     EXPECT_EQ(ret, CAM_META_SUCCESS);
293     std::cout << "capture mirror supported is :";
294     for (int i = 0; i < entry.count; i++) {
295         std::cout << " " << static_cast<int>(entry.data.u8[i]);
296     }
297     std::cout << std::endl;
298 }
299 
300 /**
301   * @tc.name: USB Camera
302   * @tc.desc: get value of OHOS_ABILITY_MUTE_MODES
303   * @tc.level: Level0
304   * @tc.size: MediumTest
305   * @tc.type: Function
306   */
TEST_F(UtestUSBCameraTest,camera_usb_0011)307 TEST_F(UtestUSBCameraTest, camera_usb_0011)
308 {
309     if (!g_usbCameraExit) {
310         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
311     }
312     ability_ = cameraBase_->GetCameraAbility();
313     EXPECT_NE(ability_, nullptr);
314     common_metadata_header_t *data = ability_->get();
315     camera_metadata_item_t entry;
316     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MUTE_MODES, &entry);
317     if (ret == CAM_META_SUCCESS) {
318         std::cout << "supported mute mode is:";
319         for (int i = 0; i < entry.count; i++) {
320             std::cout << " " << static_cast<int>(entry.data.u8[i]);
321         }
322         std::cout << std::endl;
323     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
324         std::cout << "OHOS_ABILITY_MUTE_MODES is not support" << std::endl;
325     }
326 }
327 
328 /**
329   * @tc.name: USB Camera
330   * @tc.desc: get value of OHOS_ABILITY_FPS_RANGES
331   * @tc.level: Level0
332   * @tc.size: MediumTest
333   * @tc.type: Function
334   */
TEST_F(UtestUSBCameraTest,camera_usb_0012)335 TEST_F(UtestUSBCameraTest, camera_usb_0012)
336 {
337     if (!g_usbCameraExit) {
338         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
339     }
340     ability_ = cameraBase_->GetCameraAbility();
341     EXPECT_NE(ability_, nullptr);
342     common_metadata_header_t *data = ability_->get();
343     camera_metadata_item_t entry;
344     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FPS_RANGES, &entry);
345     EXPECT_EQ(ret, CAM_META_SUCCESS);
346     std::cout << "supported fps ranges list: [";
347     std::cout << static_cast<int>(entry.data.i32[0]) << "," << static_cast<int>(entry.data.i32[1]) << "]";
348     std::cout << std::endl;
349 }
350 
351 /**
352   * @tc.name: USB Camera
353   * @tc.desc: get value of OHOS_ABILITY_CAMERA_TYPE
354   * @tc.level: Level0
355   * @tc.size: MediumTest
356   * @tc.type: Function
357   */
TEST_F(UtestUSBCameraTest,camera_usb_0013)358 TEST_F(UtestUSBCameraTest, camera_usb_0013)
359 {
360     if (!g_usbCameraExit) {
361         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
362     }
363     ability_ = cameraBase_->GetCameraAbility();
364     EXPECT_NE(ability_, nullptr);
365     common_metadata_header_t *data = ability_->get();
366     camera_metadata_item_t entry;
367     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_TYPE, &entry);
368     EXPECT_EQ(ret, CAM_META_SUCCESS);
369     std::cout << "OHOS_ABILITY_CAMERA_TYPE value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
370     EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_TYPE_UNSPECIFIED);
371 }
372 
373 /**
374   * @tc.name: USB Camera
375   * @tc.desc: get value of OHOS_JPEG_ORIENTATION
376   * @tc.level: Level0
377   * @tc.size: MediumTest
378   * @tc.type: Function
379   */
TEST_F(UtestUSBCameraTest,camera_usb_0014)380 TEST_F(UtestUSBCameraTest, camera_usb_0014)
381 {
382     if (!g_usbCameraExit) {
383         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
384     }
385     ability_ = cameraBase_->GetCameraAbility();
386     EXPECT_NE(ability_, nullptr);
387     common_metadata_header_t *data = ability_->get();
388     camera_metadata_item_t entry;
389     int ret = FindCameraMetadataItem(data, OHOS_JPEG_ORIENTATION, &entry);
390     EXPECT_EQ(ret, CAM_META_SUCCESS);
391     std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.i32[0]) << std::endl;
392 }
393 
394 /**
395   * @tc.name: USB Camera
396   * @tc.desc: get value of OHOS_JPEG_QUALITY
397   * @tc.level: Level0
398   * @tc.size: MediumTest
399   * @tc.type: Function
400   */
TEST_F(UtestUSBCameraTest,camera_usb_0015)401 TEST_F(UtestUSBCameraTest, camera_usb_0015)
402 {
403     if (!g_usbCameraExit) {
404         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
405     }
406     ability_ = cameraBase_->GetCameraAbility();
407     EXPECT_NE(ability_, nullptr);
408     common_metadata_header_t *data = ability_->get();
409     camera_metadata_item_t entry;
410     int ret = FindCameraMetadataItem(data, OHOS_JPEG_QUALITY, &entry);
411     EXPECT_EQ(ret, CAM_META_SUCCESS);
412     std::cout << "OHOS_JPEG_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
413 }
414 
415 /**
416   * @tc.name: USB Camera
417   * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS
418   * @tc.level: Level0
419   * @tc.size: MediumTest
420   * @tc.type: Function
421   */
TEST_F(UtestUSBCameraTest,camera_usb_0016)422 TEST_F(UtestUSBCameraTest, camera_usb_0016)
423 {
424     if (!g_usbCameraExit) {
425         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
426     }
427     ability_ = cameraBase_->GetCameraAbility();
428     EXPECT_NE(ability_, nullptr);
429     common_metadata_header_t *data = ability_->get();
430     camera_metadata_item_t entry;
431     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &entry);
432     EXPECT_EQ(ret, CAM_META_SUCCESS);
433     std::cout << "OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS value is "
434         << static_cast<int>(entry.data.u8[0]) << std::endl;
435     EXPECT_TRUE(entry.data.u8[0] == OHOS_CAMERA_FORMAT_RGBA_8888);
436 }
437 
438 /**
439   * @tc.name: USB Camera
440   * @tc.desc: get value of OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
441   * @tc.level: Level0
442   * @tc.size: MediumTest
443   * @tc.type: Function
444   */
TEST_F(UtestUSBCameraTest,camera_usb_0017)445 TEST_F(UtestUSBCameraTest, camera_usb_0017)
446 {
447     if (!g_usbCameraExit) {
448         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
449     }
450     ability_ = cameraBase_->GetCameraAbility();
451     EXPECT_NE(ability_, nullptr);
452     common_metadata_header_t *data = ability_->get();
453     EXPECT_NE(data, nullptr);
454     camera_metadata_item_t entry;
455     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
456     if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
457         std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start." << std::endl;
458         const size_t STEP = 10; // print step
459         std::cout << "count" << entry.count << std::endl;
460         for (size_t i = 0; i < entry.count; i++) {
461             std::cout << entry.data.i32[i] << " ";
462             if ((i != 0) && (i % STEP == 0 || i == entry.count - 1)) {
463                 std::cout << std::endl;
464             }
465         }
466         std::cout << "print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end." << std::endl;
467     }
468 }
469 
470 /**
471   * @tc.name: USB Camera
472   * @tc.desc: Preview stream, expected success.
473   * @tc.level: Level0
474   * @tc.size: MediumTest
475   * @tc.type: Function
476   */
TEST_F(UtestUSBCameraTest,camera_usb_0018)477 TEST_F(UtestUSBCameraTest, camera_usb_0018)
478 {
479     if (!g_usbCameraExit) {
480         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
481     }
482     // Get the device manager
483     cameraBase_->OpenUsbCamera();
484     // Get the stream manager
485     cameraBase_->AchieveStreamOperator();
486     // start stream
487     cameraBase_->intents = {PREVIEW};
488     cameraBase_->StartStream(cameraBase_->intents);
489     // Get preview
490     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
491     // release stream
492     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
493     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
494     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
495 }
496 
497 /**
498   * @tc.name: USB Camera
499   * @tc.desc: Preview stream, width = 1280, height = 720, expected success.
500   * @tc.level: Level0
501   * @tc.size: MediumTest
502   * @tc.type: Function
503   */
TEST_F(UtestUSBCameraTest,camera_usb_0019)504 TEST_F(UtestUSBCameraTest, camera_usb_0019)
505 {
506     if (!g_usbCameraExit) {
507         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
508     }
509     // Get the device manager
510     cameraBase_->OpenUsbCamera();
511     // Create and get streamOperator information
512     cameraBase_->AchieveStreamOperator();
513     // Create data stream
514     if (cameraBase_->streamCustomerPreview_ == nullptr) {
515         cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
516     }
517     OHOS::sptr<OHOS::IBufferProducer> producer = cameraBase_->streamCustomerPreview_->CreateProducer();
518     producer->SetQueueSize(8); // 8:set bufferQueue size
519 
520     std::vector<StreamInfo> streamInfos;
521     StreamInfo streamInfo = {};
522     streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
523     streamInfo.width_ = 1280; // 1280:picture width
524     streamInfo.height_ = 720; // 720:picture height
525     streamInfo.format_ = PIXEL_FMT_RGBA_8888;
526     streamInfo.dataspace_ = 8; // 8:picture dataspace
527     streamInfo.intent_ = PREVIEW;
528     streamInfo.tunneledMode_ = 5; // 5:tunnel mode
529     streamInfo.bufferQueue_ = new BufferProducerSequenceable(producer);
530     ASSERT_NE(streamInfo.bufferQueue_, nullptr);
531     std::vector<StreamInfo>().swap(streamInfos);
532     streamInfos.push_back(streamInfo);
533     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
534     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
535     // Submit stream information
536     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
537     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
538     // capture
539     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
540     // release stream
541     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
542     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
543     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
544 }
545 
546 /**
547   * @tc.name: USB Camera
548   * @tc.desc: UpdateSettings, fps.
549   * @tc.level: Level0
550   * @tc.size: MediumTest
551   * @tc.type: Function
552   */
TEST_F(UtestUSBCameraTest,camera_usb_0020)553 TEST_F(UtestUSBCameraTest, camera_usb_0020)
554 {
555     if (!g_usbCameraExit) {
556         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
557     }
558     // Get the device manager
559     cameraBase_->OpenUsbCamera();
560     // get the stream manager
561     cameraBase_->AchieveStreamOperator();
562 
563     // start stream
564     cameraBase_->intents = {PREVIEW};
565     cameraBase_->StartStream(cameraBase_->intents);
566 
567     // updateSettings
568     const uint32_t itemCapacity = 100;
569     const uint32_t dataCapacity = 2000;
570     const int32_t fpsValue = 10;
571     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
572         itemCapacity, dataCapacity);
573     std::vector<int32_t> fpsRange;
574     fpsRange.push_back(fpsValue);
575     fpsRange.push_back(fpsValue);
576     meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
577     const int32_t DEVICE_STREAM_ID = 0;
578     meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
579     std::vector<uint8_t> setting;
580     MetadataUtils::ConvertMetadataToVec(meta, setting);
581     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
582     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
583 
584     // get preview
585     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
586 
587     // release stream
588     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
589     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
590     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
591 }
592 
593 /**
594   * @tc.name: USB Camera
595   * @tc.desc: USB Camera, OnCameraStatus and OnCameraEvent.
596   * @tc.level: Level0
597   * @tc.size: MediumTest
598   * @tc.type: Function
599   */
TEST_F(UtestUSBCameraTest,camera_usb_0021)600 TEST_F(UtestUSBCameraTest, camera_usb_0021)
601 {
602     uint32_t rc = 0;
603     std::cout << "==========[test log] USB Camera, getCameraID success."<< std::endl;
604     std::vector<std::string> cameraIds;
605     std::cout << "==========[test log] 1. get current system cameraID."<< std::endl;
606     cameraBase_->cameraHost->GetCameraIds(cameraIds);
607     std::cout << "==========[test log] First cameraId.size = " << cameraIds.size() << std::endl;
608     std::cout << "==========[test log] OnCameraStatus interface has been mobilized" << std::endl;
609     for (const auto &cameraId : cameraIds) {
610         std::cout << "==========[test log] cameraId = " << cameraId << std::endl;
611     }
612     const int count = 4;
613     for (int i = 0; i < count; i++) {
614         std::cout << "==========[test log] 2. please add or delete the usb camera, wait for 3s..."<< std::endl;
615         sleep(3); // judging add or delete the usb camera, wait for 3s.
616     }
617     std::cout << "==========[test log] 3. check the cameraID again... wait for 3s..."<< std::endl;
618     sleep(3); // checking the cameraID again, wait for 3s.
619     std::cout << "==========[test log] Second cameraId.size = " << cameraIds.size() << std::endl;
620     if (cameraIds.size() == 1) {
621         cameraIds.clear();
622     }
623     rc = cameraBase_->cameraHost->GetCameraIds(cameraIds);
624     EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
625     for (const auto &cameraId : cameraIds) {
626         std::cout << "cameraId = " << cameraId << std::endl;
627     }
628 }
629 
630 /**
631   * @tc.name: USB Camera
632   * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
633   * @tc.level: Level0
634   * @tc.size: MediumTest
635   * @tc.type: Function
636   */
TEST_F(UtestUSBCameraTest,camera_usb_0022)637 TEST_F(UtestUSBCameraTest, camera_usb_0022)
638 {
639     // Get the device manager
640     cameraBase_->OpenUsbCamera();
641     if (!g_usbCameraExit) {
642         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
643     }
644     // Get the stream manager
645     cameraBase_->AchieveStreamOperator();
646     // start stream
647     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
648     cameraBase_->StartStream(cameraBase_->intents);
649     // Get preview
650     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
651     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
652     // release stream
653     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
654     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
655     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
656 }
657 
658 /**
659   * @tc.name: USB Camera
660   * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
661   * @tc.level: Level0
662   * @tc.size: MediumTest
663   * @tc.type: Function
664   */
TEST_F(UtestUSBCameraTest,camera_usb_0023)665 TEST_F(UtestUSBCameraTest, camera_usb_0023)
666 {
667     cameraBase_->OpenUsbCamera();
668     if (!g_usbCameraExit) {
669         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
670     }
671     cameraBase_->AchieveStreamOperator();
672     if (cameraBase_->streamCustomerPreview_ == nullptr) {
673         cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
674     }
675     std::vector<StreamInfo> streamInfos;
676     StreamInfo streamInfo = {};
677     streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
678     streamInfo.width_ = 1280; // 1280:picture width
679     streamInfo.height_ = 720; // 720:picture height
680     streamInfo.format_ = PIXEL_FMT_RGBA_8888;
681     streamInfo.dataspace_ = 8; // 8:picture dataspace
682     streamInfo.intent_ = PREVIEW;
683     streamInfo.tunneledMode_ = 5; // 5:tunnel mode
684     streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
685     ASSERT_NE(streamInfo.bufferQueue_, nullptr);
686     streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
687     streamInfos.push_back(streamInfo);
688     if (cameraBase_->streamCustomerCapture_ == nullptr) {
689         cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
690     }
691     StreamInfo streamInfoCapture = {};
692     streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
693     streamInfoCapture.width_ = 1280; // 1280:picture width
694     streamInfoCapture.height_ = 960; // 960:picture height
695     streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
696     streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
697     streamInfoCapture.intent_ = STILL_CAPTURE;
698     streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
699     streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
700     streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
701         cameraBase_->streamCustomerCapture_->CreateProducer());
702     ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
703     streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
704     streamInfos.push_back(streamInfoCapture);
705     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
706     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
707     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
708     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
709     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
710     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
711     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
712     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
713     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
714 }
715 
716 /**
717   * @tc.name: preview and capture
718   * @tc.desc: Commit 2 streams together, Change the value OHOS_JPEG_ORIENTATION, isStreaming is true.
719   * @tc.level: Level0
720   * @tc.size: MediumTest
721   * @tc.type: Function
722   */
TEST_F(UtestUSBCameraTest,camera_usb_0024)723 TEST_F(UtestUSBCameraTest, camera_usb_0024)
724 {
725     // Get the device manager
726     cameraBase_->OpenUsbCamera();
727     if (!g_usbCameraExit) {
728         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
729     }
730     // Get the stream manager
731     cameraBase_->AchieveStreamOperator();
732     std::vector<int32_t> jpegOrientationVector;
733     jpegOrientationVector.push_back(OHOS_CAMERA_JPEG_ROTATION_270);
734     cameraBase_->ability->updateEntry(OHOS_JPEG_ORIENTATION, jpegOrientationVector.data(),
735         jpegOrientationVector.size());
736     cameraBase_->ability_.clear();
737     MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_);
738     // start stream
739     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
740     cameraBase_->StartStream(cameraBase_->intents);
741 
742     // Get preview
743     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
744     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
745     // release stream
746     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
747     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
748     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
749 }
750 
751 /**
752   * @tc.name: preview and capture
753   * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
754   * @tc.level: Level0
755   * @tc.size: MediumTest
756   * @tc.type: Function
757   */
TEST_F(UtestUSBCameraTest,camera_usb_0025)758 TEST_F(UtestUSBCameraTest, camera_usb_0025)
759 {
760     // Get the device manager
761     cameraBase_->OpenUsbCamera();
762     if (!g_usbCameraExit) {
763         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
764     }
765     // Get the stream manager
766     cameraBase_->AchieveStreamOperator();
767     std::vector<int32_t> jpegQualityVector;
768     jpegQualityVector.push_back(OHOS_CAMERA_JPEG_LEVEL_LOW);
769     cameraBase_->ability->updateEntry(OHOS_JPEG_QUALITY, jpegQualityVector.data(), jpegQualityVector.size());
770     cameraBase_->ability_.clear();
771     MetadataUtils::ConvertMetadataToVec(cameraBase_->ability, cameraBase_->ability_);
772     // start stream
773     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
774     cameraBase_->StartStream(cameraBase_->intents);
775 
776     // Get preview
777     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
778     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
779     // release stream
780     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
781     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
782     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
783 }
784 
785 /**
786   * @tc.name: Video
787   * @tc.desc: Preview + video, commit together, success.
788   * @tc.level: Level0
789   * @tc.size: MediumTest
790   * @tc.type: Function
791   */
TEST_F(UtestUSBCameraTest,camera_usb_0026)792 TEST_F(UtestUSBCameraTest, camera_usb_0026)
793 {
794     // Get the device manager
795     cameraBase_->OpenUsbCamera();
796     if (!g_usbCameraExit) {
797         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
798     }
799     // Create and get streamOperator information
800     cameraBase_->AchieveStreamOperator();
801     // start stream
802     cameraBase_->intents = {PREVIEW, VIDEO};
803     cameraBase_->StartStream(cameraBase_->intents);
804     // Get preview
805     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
806     cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
807 
808     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
809     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
810     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
811 }
812 
813 /**
814   * @tc.name: USB Camera
815   * @tc.desc: Preview stream, width = 1280, height = 720, expected success.
816   * @tc.level: Level0
817   * @tc.size: MediumTest
818   * @tc.type: Function
819   */
TEST_F(UtestUSBCameraTest,camera_usb_0027)820 TEST_F(UtestUSBCameraTest, camera_usb_0027)
821 {
822     cameraBase_->OpenUsbCamera();
823     if (!g_usbCameraExit) {
824         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
825     }
826     cameraBase_->AchieveStreamOperator();
827     if (cameraBase_->streamCustomerPreview_ == nullptr) {
828         cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
829     }
830     std::vector<StreamInfo> streamInfos;
831     StreamInfo streamInfo = {};
832     streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
833     streamInfo.width_ = 1280; // 1280:picture width
834     streamInfo.height_ = 720; // 720:picture height
835     streamInfo.format_ = PIXEL_FMT_RGBA_8888;
836     streamInfo.dataspace_ = 8; // 8:picture dataspace
837     streamInfo.intent_ = PREVIEW;
838     streamInfo.tunneledMode_ = 5; // 5:tunnel mode
839     streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
840     ASSERT_NE(streamInfo.bufferQueue_, nullptr);
841     streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
842     streamInfos.push_back(streamInfo);
843     if (cameraBase_->streamCustomerVideo_ == nullptr) {
844         cameraBase_->streamCustomerVideo_ = std::make_shared<StreamCustomer>();
845     }
846     StreamInfo streamInfoVideo = {};
847     streamInfoVideo.streamId_ = cameraBase_->STREAM_ID_VIDEO;
848     streamInfoVideo.width_ = 1280; // 1280:picture width
849     streamInfoVideo.height_ = 960; // 960:picture height
850     streamInfoVideo.format_ = PIXEL_FMT_RGBA_8888;
851     streamInfoVideo.dataspace_ = 8; // 8:picture dataspace
852     streamInfoVideo.intent_ = VIDEO;
853     streamInfoVideo.encodeType_ = ENCODE_TYPE_H264;
854     streamInfoVideo.tunneledMode_ = 5; // 5:tunnel mode
855     streamInfoVideo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerVideo_->CreateProducer());
856     ASSERT_NE(streamInfoVideo.bufferQueue_, nullptr);
857     streamInfoVideo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
858     streamInfos.push_back(streamInfoVideo);
859     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
860     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
861     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
862     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
863     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
864     cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
865     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
866     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
867     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
868 }
869 
870 /**
871   * @tc.name: USB Camera
872   * @tc.desc: UpdateSettings, fps.
873   * @tc.level: Level0
874   * @tc.size: MediumTest
875   * @tc.type: Function
876   */
TEST_F(UtestUSBCameraTest,camera_usb_0028)877 TEST_F(UtestUSBCameraTest, camera_usb_0028)
878 {
879     // Get the device manager
880     cameraBase_->OpenUsbCamera();
881     if (!g_usbCameraExit) {
882         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
883     }
884     // get the stream manager
885     cameraBase_->AchieveStreamOperator();
886 
887     // start stream
888     cameraBase_->intents = {PREVIEW, VIDEO};
889     cameraBase_->StartStream(cameraBase_->intents);
890 
891     // updateSettings
892     const uint32_t itemCapacity = 100;
893     const uint32_t dataCapacity = 2000;
894     const int32_t fpsValue = 10;
895     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
896         itemCapacity, dataCapacity);
897     std::vector<int32_t> fpsRange;
898     fpsRange.push_back(fpsValue);
899     fpsRange.push_back(fpsValue);
900     meta->addEntry(OHOS_CONTROL_FPS_RANGES, fpsRange.data(), fpsRange.size());
901     const int32_t DEVICE_STREAM_ID = 0;
902     meta->addEntry(OHOS_CAMERA_STREAM_ID, &DEVICE_STREAM_ID, 1);
903     std::vector<uint8_t> setting;
904     MetadataUtils::ConvertMetadataToVec(meta, setting);
905     cameraBase_->rc = (CamRetCode)cameraBase_->cameraDevice->UpdateSettings(setting);
906     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
907 
908     // get preview
909     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
910     cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
911 
912     // release stream
913     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
914     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
915     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
916 }
917 
918 /**
919   * @tc.name: USB Camera
920   * @tc.desc: Commit 3 streams together, Preview,Video and still_capture streams, isStreaming is true.
921   * @tc.level: Level0
922   * @tc.size: MediumTest
923   * @tc.type: Function
924   */
TEST_F(UtestUSBCameraTest,camera_usb_0029)925 TEST_F(UtestUSBCameraTest, camera_usb_0029)
926 {
927     // Get the device manager
928     cameraBase_->OpenUsbCamera();
929     if (!g_usbCameraExit) {
930         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
931     }
932     // Get the stream manager
933     cameraBase_->AchieveStreamOperator();
934     // start stream
935     cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
936     cameraBase_->StartStream(cameraBase_->intents);
937     // Get preview
938     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
939     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
940     cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
941     // release stream
942     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
943         cameraBase_->CAPTURE_ID_VIDEO};
944     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
945         cameraBase_->STREAM_ID_VIDEO};
946     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
947 }
948 
949 /**
950   * @tc.name: USB Camera
951   * @tc.desc: get value of OHOS_SENSOR_ORIENTATION
952   * @tc.level: Level0
953   * @tc.size: MediumTest
954   * @tc.type: Function
955   */
TEST_F(UtestUSBCameraTest,camera_usb_0030)956 TEST_F(UtestUSBCameraTest, camera_usb_0030)
957 {
958     if (!g_usbCameraExit) {
959         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
960     }
961     ability_ = cameraBase_->GetCameraAbility();
962     EXPECT_NE(ability_, nullptr);
963     common_metadata_header_t *data = ability_->get();
964     camera_metadata_item_t entry;
965     int ret = FindCameraMetadataItem(data, OHOS_SENSOR_ORIENTATION, &entry);
966     EXPECT_EQ(ret, CAM_META_SUCCESS);
967     std::cout << "OHOS_SENSOR_ORIENTATION value is " << static_cast<int>(entry.data.u8[0]) << std::endl;
968     EXPECT_TRUE(entry.data.u8[0] == 0);
969 }
970 
971 /**
972   * @tc.name: USB Camera
973   * @tc.desc: get value of OHOS_ABILITY_FOCAL_LENGTH
974   * @tc.level: Level0
975   * @tc.size: MediumTest
976   * @tc.type: Function
977   */
TEST_F(UtestUSBCameraTest,camera_usb_0031)978 TEST_F(UtestUSBCameraTest, camera_usb_0031)
979 {
980     if (!g_usbCameraExit) {
981         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
982     }
983     ability_ = cameraBase_->GetCameraAbility();
984     EXPECT_NE(ability_, nullptr);
985     common_metadata_header_t *data = ability_->get();
986     camera_metadata_item_t entry;
987     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_FOCAL_LENGTH, &entry);
988     if (ret == CAM_META_SUCCESS) {
989         std::cout << "log OHOS_ABILITY_FOCAL_LENGTH: count is " << (int)entry.count << std::endl;
990         std::cout << "log focal length value: " << entry.data.f[0] << std::endl;
991     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
992         std::cout << "log OHOS_ABILITY_FOCAL_LENGTH is not support" << std::endl;
993     }
994 }
995 
996 /**
997   * @tc.name: USB Camera
998   * @tc.desc: USB Camera, Select the camera according to the cameraId
999   * @tc.level: Level0
1000   * @tc.size: MediumTest
1001   * @tc.type: Function
1002   */
TEST_F(UtestUSBCameraTest,camera_usb_0032)1003 TEST_F(UtestUSBCameraTest, camera_usb_0032)
1004 {
1005     // Get the device manager
1006     std::vector<std::string> usbCameraIds;
1007     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1008     if (usbCameraIds.size() > 2) { // 2:usb camera quantity
1009         g_usbCameraExit = true;
1010     } else {
1011         g_usbCameraExit = false;
1012     }
1013     for (int i = 0; i < usbCameraIds.size(); i++) {
1014         if (!g_usbCameraExit) {
1015             GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1016         }
1017         cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
1018         ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
1019         // Get the stream manager
1020         cameraBase_->AchieveStreamOperator();
1021         // start stream
1022         cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
1023         cameraBase_->StartStream(cameraBase_->intents);
1024         // Get preview
1025         cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1026         cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1027         // release stream
1028         cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1029         cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1030         cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1031     }
1032 }
1033 
1034 /**
1035   * @tc.name: USB Camera
1036   * @tc.desc: Commit 2 streams together, width = 1280, height = 720, expected success.
1037   * @tc.level: Level0
1038   * @tc.size: MediumTest
1039   * @tc.type: Function
1040   */
TEST_F(UtestUSBCameraTest,camera_usb_0033)1041 TEST_F(UtestUSBCameraTest, camera_usb_0033)
1042 {
1043     std::vector<std::string> usbCameraIds;
1044     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1045     if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1046         g_usbCameraExit = true;
1047     } else {
1048         g_usbCameraExit = false;
1049     }
1050     cameraBase_->OpenUsbCamera();
1051     if (!g_usbCameraExit) {
1052         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1053     }
1054     cameraBase_->AchieveStreamOperator();
1055     if (cameraBase_->streamCustomerPreview_ == nullptr) {
1056         cameraBase_->streamCustomerPreview_ = std::make_shared<StreamCustomer>();
1057     }
1058     std::vector<StreamInfo> streamInfos;
1059     StreamInfo streamInfo = {};
1060     streamInfo.streamId_ = cameraBase_->STREAM_ID_PREVIEW;
1061     streamInfo.width_ = 1280; // 1280:picture width
1062     streamInfo.height_ = 960; // 720:picture height
1063     streamInfo.format_ = PIXEL_FMT_RGBA_8888;
1064     streamInfo.dataspace_ = 8; // 8:picture dataspace
1065     streamInfo.intent_ = PREVIEW;
1066     streamInfo.tunneledMode_ = 5; // 5:tunnel mode
1067     streamInfo.bufferQueue_ = new BufferProducerSequenceable(cameraBase_->streamCustomerPreview_->CreateProducer());
1068     ASSERT_NE(streamInfo.bufferQueue_, nullptr);
1069     streamInfo.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1070     streamInfos.push_back(streamInfo);
1071     if (cameraBase_->streamCustomerCapture_ == nullptr) {
1072         cameraBase_->streamCustomerCapture_ = std::make_shared<StreamCustomer>();
1073     }
1074     StreamInfo streamInfoCapture = {};
1075     streamInfoCapture.streamId_ = cameraBase_->STREAM_ID_CAPTURE;
1076     streamInfoCapture.width_ = 640; // 1280:picture width
1077     streamInfoCapture.height_ = 480; // 960:picture height
1078     streamInfoCapture.format_ = PIXEL_FMT_RGBA_8888;
1079     streamInfoCapture.dataspace_ = 8; // 8:picture dataspace
1080     streamInfoCapture.intent_ = STILL_CAPTURE;
1081     streamInfoCapture.encodeType_ = ENCODE_TYPE_JPEG;
1082     streamInfoCapture.tunneledMode_ = 5; // 5:tunnel mode
1083     streamInfoCapture.bufferQueue_ = new BufferProducerSequenceable(
1084         cameraBase_->streamCustomerCapture_->CreateProducer());
1085     ASSERT_NE(streamInfoCapture.bufferQueue_, nullptr);
1086     streamInfoCapture.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
1087     streamInfos.push_back(streamInfoCapture);
1088     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CreateStreams(streamInfos);
1089     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1090     cameraBase_->rc = (CamRetCode)cameraBase_->streamOperator->CommitStreams(NORMAL, cameraBase_->ability_);
1091     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
1092     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
1093     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
1094     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
1095     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
1096     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
1097 }
1098 
1099 /**
1100   * @tc.name: USB Camera
1101   * @tc.desc: get value of OHOS_ABILITY_EXPOSURE_TIME
1102   * @tc.level: Level0
1103   * @tc.size: MediumTest
1104   * @tc.type: Function
1105   */
TEST_F(UtestUSBCameraTest,camera_usb_0034)1106 TEST_F(UtestUSBCameraTest, camera_usb_0034)
1107 {
1108     std::vector<std::string> usbCameraIds;
1109     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1110     if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1111         g_usbCameraExit = true;
1112     } else {
1113         g_usbCameraExit = false;
1114     }
1115     if (!g_usbCameraExit) {
1116         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1117     }
1118     ability_ = cameraBase_->GetCameraAbility();
1119     EXPECT_NE(ability_, nullptr);
1120     common_metadata_header_t *data = ability_->get();
1121     camera_metadata_item_t entry;
1122     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_EXPOSURE_TIME, &entry);
1123     if (ret == CAM_META_SUCCESS) {
1124         std::cout << "log OHOS_ABILITY_EXPOSURE_TIME: count is " << (int)entry.count << std::endl;
1125         std::cout << "log exposure time value: [" << entry.data.i32[0] << ", " << entry.data.i32[1] << "]" <<std::endl;
1126         std::cout << std::endl;
1127     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1128         std::cout << "OHOS_ABILITY_EXPOSURE_TIME is not support" << std::endl;
1129     }
1130 }
1131 
1132 /**
1133   * @tc.name: USB Camera
1134   * @tc.desc: get value of OHOS_ABILITY_AE_LOCK
1135   * @tc.level: Level0
1136   * @tc.size: MediumTest
1137   * @tc.type: Function
1138   */
TEST_F(UtestUSBCameraTest,camera_usb_0035)1139 TEST_F(UtestUSBCameraTest, camera_usb_0035)
1140 {
1141     std::vector<std::string> usbCameraIds;
1142     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1143     if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1144         g_usbCameraExit = true;
1145     } else {
1146         g_usbCameraExit = false;
1147     }
1148     if (!g_usbCameraExit) {
1149         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1150     }
1151     ability_ = cameraBase_->GetCameraAbility();
1152     EXPECT_NE(ability_, nullptr);
1153     common_metadata_header_t *data = ability_->get();
1154     camera_metadata_item_t entry;
1155     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AE_LOCK, &entry);
1156     if (ret == CAM_META_SUCCESS) {
1157         std::cout << "supported ae lock list:";
1158         for (int i = 0; i < entry.count; i++) {
1159             std::cout << " " << static_cast<int>(entry.data.u8[i]);
1160         }
1161         std::cout << std::endl;
1162     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1163         std::cout << "OHOS_ABILITY_AE_LOCK is not support" << std::endl;
1164     }
1165 }
1166 
1167 /**
1168   * @tc.name: USB Camera
1169   * @tc.desc: get value of OHOS_ABILITY_AWB_MODES
1170   * @tc.level: Level0
1171   * @tc.size: MediumTest
1172   * @tc.type: Function
1173   */
TEST_F(UtestUSBCameraTest,camera_usb_0036)1174 TEST_F(UtestUSBCameraTest, camera_usb_0036)
1175 {
1176     std::vector<std::string> usbCameraIds;
1177     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1178     if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1179         g_usbCameraExit = true;
1180     } else {
1181         g_usbCameraExit = false;
1182     }
1183     if (!g_usbCameraExit) {
1184         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1185     }
1186     ability_ = cameraBase_->GetCameraAbility();
1187     EXPECT_NE(ability_, nullptr);
1188     common_metadata_header_t *data = ability_->get();
1189     camera_metadata_item_t entry;
1190     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AWB_MODES, &entry);
1191     if (ret == CAM_META_SUCCESS) {
1192         std::cout << "supported awb mode list:";
1193         for (int i = 0; i < entry.count; i++) {
1194             std::cout << " " << static_cast<int>(entry.data.u8[i]);
1195         }
1196         std::cout << std::endl;
1197     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1198         std::cout << "OHOS_ABILITY_AWB_MODES is not support" << std::endl;
1199     }
1200 }
1201 
1202 /**
1203   * @tc.name: USB Camera
1204   * @tc.desc: get value of OHOS_ABILITY_AWB_LOCK
1205   * @tc.level: Level0
1206   * @tc.size: MediumTest
1207   * @tc.type: Function
1208   */
TEST_F(UtestUSBCameraTest,camera_usb_0037)1209 TEST_F(UtestUSBCameraTest, camera_usb_0037)
1210 {
1211     std::vector<std::string> usbCameraIds;
1212     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1213     if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1214         g_usbCameraExit = true;
1215     } else {
1216         g_usbCameraExit = false;
1217     }
1218     if (!g_usbCameraExit) {
1219         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1220     }
1221     ability_ = cameraBase_->GetCameraAbility();
1222     EXPECT_NE(ability_, nullptr);
1223     common_metadata_header_t *data = ability_->get();
1224     camera_metadata_item_t entry;
1225     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AWB_LOCK, &entry);
1226     if (ret == CAM_META_SUCCESS) {
1227         std::cout << "supported awb list list:";
1228         for (int i = 0; i < entry.count; i++) {
1229             std::cout << " " << static_cast<int>(entry.data.u8[i]);
1230         }
1231         std::cout << std::endl;
1232     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1233         std::cout << "OHOS_ABILITY_AWB_LOCK is not support" << std::endl;
1234     }
1235 }
1236 
1237 /**
1238   * @tc.name: USB Camera
1239   * @tc.desc: get value of OHOS_ABILITY_METER_MODES
1240   * @tc.level: Level0
1241   * @tc.size: MediumTest
1242   * @tc.type: Function
1243   */
TEST_F(UtestUSBCameraTest,camera_usb_0038)1244 TEST_F(UtestUSBCameraTest, camera_usb_0038)
1245 {
1246     std::vector<std::string> usbCameraIds;
1247     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
1248     if (usbCameraIds.size() > 1) { // 2:usb camera quantity
1249         g_usbCameraExit = true;
1250     } else {
1251         g_usbCameraExit = false;
1252     }
1253     if (!g_usbCameraExit) {
1254         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
1255     }
1256     ability_ = cameraBase_->GetCameraAbility();
1257     EXPECT_NE(ability_, nullptr);
1258     common_metadata_header_t *data = ability_->get();
1259     camera_metadata_item_t entry;
1260     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_METER_MODES, &entry);
1261     if (ret == CAM_META_SUCCESS) {
1262         std::cout << "supported meter list list:";
1263         for (int i = 0; i < entry.count; i++) {
1264             std::cout << " " << static_cast<int>(entry.data.u8[i]);
1265         }
1266         std::cout << std::endl;
1267     } else if (ret == CAM_META_ITEM_NOT_FOUND) {
1268         std::cout << "OHOS_ABILITY_METER_MODES is not support" << std::endl;
1269     }
1270 }
1271