1 /*
2 * Copyright (c) 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_mult.h"
16 using namespace testing::ext;
17 bool g_usbCameraExit = false;
SetUpTestCase(void)18 void UtestUSBCameraTestMult::SetUpTestCase(void)
19 {}
TearDownTestCase(void)20 void UtestUSBCameraTestMult::TearDownTestCase(void)
21 {}
SetUp(void)22 void UtestUSBCameraTestMult::SetUp(void)
23 {
24 if (cameraBase_ == nullptr)
25 cameraBase_ = std::make_shared<TestDisplay>();
26 cameraBase_->UsbInit();
27 }
TearDown(void)28 void UtestUSBCameraTestMult::TearDown(void)
29 {
30 cameraBase_->Close();
31 }
32
SelectOpenCamera(std::string cameraId)33 CamRetCode UtestUSBCameraTestMult::SelectOpenCamera(std::string cameraId)
34 {
35 cameraBase_->cameraHost->GetCameraAbility(cameraId, vecAbility_);
36 MetadataUtils::ConvertVecToMetadata(vecAbility_, ability_);
37 const OHOS::sptr<DemoCameraDeviceCallback> callback = new DemoCameraDeviceCallback();
38 cameraBase_->rc = (CamRetCode)cameraBase_->cameraHost->OpenCamera(cameraId, callback, cameraDevice_);
39 if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR || cameraDevice_ == nullptr) {
40 std::cout << "OpenCamera2 failed, rc = " << cameraBase_->rc << std::endl;
41 return cameraBase_->rc;
42 }
43 std::cout << "OpenCamera2 success." << std::endl;
44 return cameraBase_->rc;
45 }
46
AchieveStreamOperator()47 void UtestUSBCameraTestMult::AchieveStreamOperator()
48 {
49 OHOS::sptr<DemoStreamOperatorCallback> streamOperatorCallback = new DemoStreamOperatorCallback();
50 cameraBase_->rc = (CamRetCode)cameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_);
51 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
52 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
53 std::cout << "AchieveStreamOperator2 success." << std::endl;
54 } else {
55 std::cout << "AchieveStreamOperator2 fail, rc = " << cameraBase_->rc << std::endl;
56 }
57 }
58
DefaultInfosPreview()59 void UtestUSBCameraTestMult::DefaultInfosPreview()
60 {
61 if (streamCustomerPreview_ == nullptr) {
62 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
63 }
64 streamInfoPre_.streamId_ = STREAM_ID_PREVIEW_DOUBLE;
65 streamInfoPre_.width_ = PREVIEW_WIDTH; // 640:picture width
66 streamInfoPre_.height_ = PREVIEW_HEIGHT; // 480:picture height
67 streamInfoPre_.format_ = PIXEL_FMT_RGBA_8888;
68 streamInfoPre_.dataspace_ = 8; // 8:picture dataspace
69 streamInfoPre_.intent_ = PREVIEW;
70 streamInfoPre_.tunneledMode_ = 5; // 5:tunnel mode
71 streamInfoPre_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerPreview_->CreateProducer());
72 ASSERT_NE(streamInfoPre_.bufferQueue_, nullptr);
73 streamInfoPre_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
74 std::cout << "preview success1." << std::endl;
75 std::vector<StreamInfo>().swap(streamInfos_);
76 streamInfos_.push_back(streamInfoPre_);
77 }
78
DefaultInfosVideo()79 void UtestUSBCameraTestMult::DefaultInfosVideo()
80 {
81 if (streamCustomerVideo_ == nullptr) {
82 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
83 }
84 streamInfoVideo_.streamId_ = STREAM_ID_VIDEO_DOUBLE;
85 streamInfoVideo_.width_ = VIDEO_WIDTH; // 1280:picture width
86 streamInfoVideo_.height_ = VIDEO_HEIGHT; // 960:picture height
87 streamInfoVideo_.format_ = videoFormat_;
88 streamInfoVideo_.dataspace_ = 8; // 8:picture dataspace
89 streamInfoVideo_.intent_ = VIDEO;
90 streamInfoVideo_.encodeType_ = ENCODE_TYPE_H264;
91 streamInfoVideo_.tunneledMode_ = 5; // 5:tunnel mode
92 streamInfoVideo_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerVideo_->CreateProducer());
93 ASSERT_NE(streamInfoVideo_.bufferQueue_, nullptr);
94 streamInfoVideo_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
95 std::cout << "video success1." << std::endl;
96 std::vector<StreamInfo>().swap(streamInfos_);
97 streamInfos_.push_back(streamInfoVideo_);
98 }
99
DefaultInfosCapture()100 void UtestUSBCameraTestMult::DefaultInfosCapture()
101 {
102 if (streamCustomerCapture_ == nullptr) {
103 streamCustomerCapture_ = std::make_shared<StreamCustomer>();
104 }
105 streamInfoCapture_.streamId_ = STREAM_ID_CAPTURE_DOUBLE;
106 streamInfoCapture_.width_ = CAPTURE_WIDTH; // 1280:picture width
107 streamInfoCapture_.height_ = CAPTURE_HEIGHT; // 960:picture height
108 streamInfoCapture_.format_ = PIXEL_FMT_RGBA_8888;
109 streamInfoCapture_.dataspace_ = 8; // 8:picture dataspace
110 streamInfoCapture_.intent_ = STILL_CAPTURE;
111 streamInfoCapture_.encodeType_ = ENCODE_TYPE_JPEG;
112 streamInfoCapture_.tunneledMode_ = 5; // 5:tunnel mode
113 streamInfoCapture_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerCapture_->CreateProducer());
114 ASSERT_NE(streamInfoCapture_.bufferQueue_, nullptr);
115 streamInfoCapture_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
116 std::cout << "capture success1." << std::endl;
117 std::vector<StreamInfo>().swap(streamInfos_);
118 streamInfos_.push_back(streamInfoCapture_);
119 }
120
StartStream(std::vector<StreamIntent> intents)121 void UtestUSBCameraTestMult::StartStream(std::vector<StreamIntent> intents)
122 {
123 for (auto& intent : intents) {
124 if (intent == PREVIEW) {
125 DefaultInfosPreview();
126 } else if (intent == VIDEO) {
127 DefaultInfosVideo();
128 } else if (intent == STILL_CAPTURE) {
129 DefaultInfosCapture();
130 }
131 cameraBase_->rc = (CamRetCode)streamOperator_->CreateStreams(streamInfos_);
132 EXPECT_EQ(false, cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR);
133 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
134 std::cout << "CreateStreams2 success." << std::endl;
135 } else {
136 std::cout << "CreateStreams2 fail, rc = " << cameraBase_->rc << std::endl;
137 }
138
139 cameraBase_->rc = (CamRetCode)streamOperator_->CommitStreams(NORMAL, vecAbility_);
140 EXPECT_EQ(false, cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR);
141 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
142 std::cout << "CommitStreams2 success." << std::endl;
143 } else {
144 std::cout << "CommitStreams2 fail, rc = " << cameraBase_->rc << std::endl;
145 }
146 }
147 }
148
StoreImage(const unsigned char * bufStart,const uint32_t size)149 void UtestUSBCameraTestMult::StoreImage(const unsigned char *bufStart, const uint32_t size)
150 {
151 constexpr uint32_t pathLen = 64;
152 char path[pathLen] = {0};
153 #ifdef CAMERA_BUILT_ON_OHOS_LITE
154 char prefix[] = "/userdata/photo/";
155 #else
156 char prefix[] = "/data/";
157 #endif
158
159 int imgFD = 0;
160 int ret = 0;
161
162 struct timeval start = {};
163 gettimeofday(&start, nullptr);
164 if (sprintf_s(path, sizeof(path), "%spicture222_%ld.jpeg", prefix, start.tv_usec) < 0) {
165 CAMERA_LOGE("sprintf_s error .....\n");
166 return;
167 }
168
169 imgFD = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
170 if (imgFD == -1) {
171 CAMERA_LOGE("demo test:open image file error %{public}s.....\n", strerror(errno));
172 return;
173 }
174
175 CAMERA_LOGD("demo test:StoreImage2 %{public}s size == %{public}d\n", path, size);
176
177 ret = write(imgFD, bufStart, size);
178 if (ret == -1) {
179 CAMERA_LOGE("demo test:write image file error %{public}s.....\n", strerror(errno));
180 }
181
182 close(imgFD);
183 }
184
StoreVideo(const unsigned char * bufStart,const uint32_t size)185 void UtestUSBCameraTestMult::StoreVideo(const unsigned char *bufStart, const uint32_t size)
186 {
187 int ret = 0;
188
189 ret = write(videoFd_, bufStart, size);
190 if (ret == -1) {
191 CAMERA_LOGE("demo test:write video file error %{public}s.....\n", strerror(errno));
192 }
193 CAMERA_LOGD("demo test:StoreVideo size == %{public}d\n", size);
194 }
195
OpenVideoFile()196 void UtestUSBCameraTestMult::OpenVideoFile()
197 {
198 constexpr uint32_t pathLen = 64;
199 char path[pathLen] = {0};
200 #ifdef CAMERA_BUILT_ON_OHOS_LITE
201 char prefix[] = "/userdata/video/";
202 #else
203 char prefix[] = "/data/";
204 #endif
205 auto seconds = time(nullptr);
206 if (sprintf_s(path, sizeof(path), "%svideo222%ld.h264", prefix, seconds) < 0) {
207 CAMERA_LOGE("%{public}s: sprintf failed", __func__);
208 return;
209 }
210 videoFd_ = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
211 if (videoFd_ < 0) {
212 CAMERA_LOGE("demo test: StartVideo open %s %{public}s failed", path, strerror(errno));
213 }
214 }
215
CloseFd()216 void UtestUSBCameraTestMult::CloseFd()
217 {
218 close(videoFd_);
219 videoFd_ = -1;
220 }
221
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)222 void UtestUSBCameraTestMult::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
223 {
224 // Get preview
225 captureInfo_.streamIds_ = {streamId};
226 captureInfo_.captureSetting_ = vecAbility_;
227 captureInfo_.enableShutterCallback_ = shutterCallback;
228 cameraBase_->rc = (CamRetCode)streamOperator_->Capture(captureId, captureInfo_, isStreaming);
229 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
230 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
231 std::cout << "check Capture: Capture2 success, captureId = " << captureId << std::endl;
232 } else {
233 std::cout << "check Capture: Capture2 fail, rc = " << cameraBase_->rc
234 << ", captureId = " << captureId<< std::endl;
235 }
236 if (captureId == CAPTURE_ID_PREVIEW_DOUBLE) {
237 streamCustomerPreview_->ReceiveFrameOn(nullptr);
238 } else if (captureId == CAPTURE_ID_CAPTURE_DOUBLE) {
239 streamCustomerCapture_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
240 StoreImage(addr, size);
241 });
242 } else if (captureId == CAPTURE_ID_VIDEO_DOUBLE) {
243 OpenVideoFile();
244 streamCustomerVideo_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
245 StoreVideo(addr, size);
246 });
247 }
248 sleep(2); // 2:sleep two second
249 }
250
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)251 void UtestUSBCameraTestMult::StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds)
252 {
253 constexpr uint32_t TIME_FOR_WAIT_CANCEL_CAPTURE = 2;
254 sleep(TIME_FOR_WAIT_CANCEL_CAPTURE);
255 if (sizeof(captureIds) > 0) {
256 for (auto &captureId : captureIds) {
257 if (captureId == CAPTURE_ID_PREVIEW_DOUBLE) {
258 streamCustomerPreview_->ReceiveFrameOff();
259 } else if (captureId == CAPTURE_ID_CAPTURE_DOUBLE) {
260 streamCustomerCapture_->ReceiveFrameOff();
261 } else if (captureId == CAPTURE_ID_VIDEO_DOUBLE) {
262 streamCustomerVideo_->ReceiveFrameOff();
263 sleep(1);
264 CloseFd();
265 }
266 }
267 for (const auto &captureId : captureIds) {
268 std::cout << "check Capture: CancelCapture success, captureId = " << captureId << std::endl;
269 cameraBase_->rc = (CamRetCode)streamOperator_->CancelCapture(captureId);
270 sleep(TIME_FOR_WAIT_CANCEL_CAPTURE);
271 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
272 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
273 std::cout << "check Capture: CancelCapture success, captureId = " << captureId << std::endl;
274 } else {
275 std::cout << "check Capture: CancelCapture fail, rc = "
276 << cameraBase_->rc <<", captureId = " << captureId << std::endl;
277 }
278 }
279 }
280 sleep(1); // 1:sleep two second
281 if (sizeof(streamIds) > 0) {
282 // release stream
283 cameraBase_->rc = (CamRetCode)streamOperator_->ReleaseStreams(streamIds);
284 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
285 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
286 std::cout << "check Capture: ReleaseStreams success." << std::endl;
287 } else {
288 std::cout << "check Capture: ReleaseStreams fail, rc = "
289 << cameraBase_->rc << ", streamIds = " << streamIds.front() << std::endl;
290 }
291 }
292 }
293
294 const std::map<uint32_t, uint32_t> g_mapOhosFmtToPixFmt = {
295 { OHOS_CAMERA_FORMAT_RGBA_8888, PIXEL_FMT_RGBA_8888 },
296 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, PIXEL_FMT_YCRCB_420_SP },
297 };
298
ConvertPixfmtHal2V4l2(uint32_t ohosfmt)299 uint32_t UtestUSBCameraTestMult::ConvertPixfmtHal2V4l2(uint32_t ohosfmt)
300 {
301 auto it = g_mapOhosFmtToPixFmt.find(ohosfmt);
302 if (it == g_mapOhosFmtToPixFmt.end()) {
303 CAMERA_LOGI("The ohosfmt is not find in g_mapOhosFmtToPixFmt");
304 return PIXEL_FMT_RGBA_8888; // default value
305 }
306 return it->second;
307 }
308
309 /**
310 * @tc.name: USB Camera
311 * @tc.desc: USB Camera, getCameraID success.
312 * @tc.level: Level0
313 * @tc.size: MediumTest
314 * @tc.type: Function
315 */
316 HWTEST_F(UtestUSBCameraTestMult, SUB_Driver_Camera_MultipleUsb_0600, TestSize.Level1)
317 {
318 std::vector<std::string> usbCameraIds;
319 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
320 std::cout << "usbCameraIds.size = " << usbCameraIds.size() << std::endl;
321 usbCameraExit_ = usbCameraIds.size() > 1;
322 if (!usbCameraExit_) {
323 std::cout << "Less than two USB cameras plugged in" << std::endl;
324 } else if (usbCameraExit_) {
325 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
326 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
327 cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]); // 1:second camera id
328 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
329 cameraBase_->AchieveStreamOperator();
330 AchieveStreamOperator();
331
332 ability_ = cameraBase_->GetCameraAbility();
333 EXPECT_NE(ability_, nullptr);
334 common_metadata_header_t *data = ability_->get();
335 EXPECT_NE(data, nullptr);
336 camera_metadata_item_t entry;
337 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
338
339 uint32_t format = 0;
340 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
341 format = entry.data.i32[entry.count - 6]; // 6:The sixth digit from the bottom is the format of video
342 }
343 videoFormat_ = ConvertPixfmtHal2V4l2(format);
344
345 for (int i = 0; i < usbCameraIds.size(); i++) {
346 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
347 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
348 // Get the stream manager
349 cameraBase_->AchieveStreamOperator();
350 // start stream
351 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
352 cameraBase_->StartStream(cameraBase_->intents);
353 // Get preview
354 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
355 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
356 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
357 // release stream
358 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
359 cameraBase_->CAPTURE_ID_VIDEO};
360 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
361 cameraBase_->STREAM_ID_VIDEO};
362 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
363 }
364 }
365 }
366
367 /**
368 * @tc.name: USB Camera
369 * @tc.desc: Commit 2 streams together, Preview and still_capture streams, isStreaming is true.
370 * @tc.level: Level0
371 * @tc.size: MediumTest
372 * @tc.type: Function
373 */
374 HWTEST_F(UtestUSBCameraTestMult, SUB_Driver_Camera_MultipleUsb_0100, TestSize.Level1)
375 {
376 std::vector<std::string> usbCameraIds;
377 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
378 std::cout << "usbCameraIds.size = " << usbCameraIds.size() << std::endl;
379 usbCameraExit_ = usbCameraIds.size() > 1;
380 if (!usbCameraExit_) {
381 std::cout << "Less than two USB cameras plugged in" << std::endl;
382 } else if (usbCameraExit_) {
383 for (int i = 0; i < usbCameraIds.size(); i++) {
384 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
385 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
386 // Get the stream manager
387 cameraBase_->AchieveStreamOperator();
388 // start stream
389 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
390 cameraBase_->StartStream(cameraBase_->intents);
391 // Get preview
392 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
393 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
394 // release stream
395 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
396 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
397 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
398 }
399 }
400 }
401
402 /**
403 * @tc.name: USB Camera
404 * @tc.desc: Open the capture stream for both cameras at the same time.
405 * @tc.level: Level0
406 * @tc.size: MediumTest
407 * @tc.type: Function
408 */
409 HWTEST_F(UtestUSBCameraTestMult, SUB_Driver_Camera_MultipleUsb_0200, TestSize.Level1)
410 {
411 std::vector<std::string> usbCameraIds;
412 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
413 std::cout << "usbCameraIds.size = " << usbCameraIds.size() << std::endl;
414 usbCameraExit_ = usbCameraIds.size() > 1;
415 if (!usbCameraExit_) {
416 std::cout << "Less than two USB cameras plugged in" << std::endl;
417 } else if (usbCameraExit_) {
418 for (int i = 0; i < usbCameraIds.size(); i++) {
419 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[i]);
420 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
421 // Get the stream manager
422 cameraBase_->AchieveStreamOperator();
423 // start stream
424 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
425 cameraBase_->StartStream(cameraBase_->intents);
426 // Get preview
427 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
428 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
429 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
430 // release stream
431 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
432 cameraBase_->CAPTURE_ID_VIDEO};
433 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
434 cameraBase_->STREAM_ID_VIDEO};
435 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
436 }
437 }
438 }
439
440 /**
441 * @tc.name: USB Camera
442 * @tc.desc: One camera starts capturing and the other camera starts recording.
443 * @tc.level: Level0
444 * @tc.size: MediumTest
445 * @tc.type: Function
446 */
447 HWTEST_F(UtestUSBCameraTestMult, SUB_Driver_Camera_MultipleUsb_0300, TestSize.Level1)
448 {
449 std::vector<std::string> usbCameraIds;
450 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
451 std::cout << "usbCameraIds.size = " << usbCameraIds.size() << std::endl;
452 usbCameraExit_ = usbCameraIds.size() > 1;
453 if (!usbCameraExit_) {
454 std::cout << "Less than two USB cameras plugged in" << std::endl;
455 } else if (usbCameraExit_) {
456 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]);
457 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
458 // Get the stream manager
459 cameraBase_->AchieveStreamOperator();
460 // start stream
461 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
462 cameraBase_->StartStream(cameraBase_->intents);
463 // Get preview
464 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
465 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
466 // release stream
467 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
468 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
469 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
470
471 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[1]);
472 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
473 // Get the stream manager
474 cameraBase_->AchieveStreamOperator();
475 // start stream
476 cameraBase_->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
477 cameraBase_->StartStream(cameraBase_->intents);
478 // Get preview
479 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
480 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
481 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
482 // release stream
483 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE,
484 cameraBase_->CAPTURE_ID_VIDEO};
485 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE,
486 cameraBase_->STREAM_ID_VIDEO};
487 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
488 }
489 }
490
491 /**
492 * @tc.name: USB Camera
493 * @tc.desc: USB Camera, getCameraID success.
494 * @tc.level: Level0
495 * @tc.size: MediumTest
496 * @tc.type: Function
497 */
498 HWTEST_F(UtestUSBCameraTestMult, SUB_Driver_Camera_MultipleUsb_0400, TestSize.Level1)
499 {
500 std::vector<std::string> usbCameraIds;
501 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
502 std::cout << "usbCameraIds.size = " << usbCameraIds.size() << std::endl;
503 usbCameraExit_ = usbCameraIds.size() > 1;
504 if (!usbCameraExit_) {
505 std::cout << "Less than two USB cameras plugged in" << std::endl;
506 } else if (usbCameraExit_) {
507 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
508 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
509 cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]); // 1:second camera id
510 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
511 cameraBase_->AchieveStreamOperator();
512 AchieveStreamOperator();
513
514 cameraBase_->intents = {PREVIEW};
515 cameraBase_->StartStream(cameraBase_->intents);
516 StartStream(cameraBase_->intents);
517 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
518 StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
519 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
520 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
521 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
522 cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE};
523 cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE};
524 StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
525 }
526 }
527
528 /**
529 * @tc.name: USB Camera
530 * @tc.desc: USB Camera, getCameraID success.
531 * @tc.level: Level0
532 * @tc.size: MediumTest
533 * @tc.type: Function
534 */
535 HWTEST_F(UtestUSBCameraTestMult, SUB_Driver_Camera_MultipleUsb_0500, TestSize.Level1)
536 {
537 std::vector<std::string> usbCameraIds;
538 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
539 std::cout << "usbCameraIds.size = " << usbCameraIds.size() << std::endl;
540 usbCameraExit_ = usbCameraIds.size() > 1;
541 if (!usbCameraExit_) {
542 std::cout << "Less than two USB cameras plugged in" << std::endl;
543 } else if (usbCameraExit_) {
544 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
545 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
546 cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]); // 1:second camera id
547 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
548 cameraBase_->AchieveStreamOperator();
549 AchieveStreamOperator();
550
551 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
552 cameraBase_->StartStream(cameraBase_->intents);
553 StartStream(cameraBase_->intents);
554 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
555 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
556 StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
557 StartCapture(STREAM_ID_CAPTURE_DOUBLE, CAPTURE_ID_CAPTURE_DOUBLE, false, true);
558 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
559 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
560 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
561 cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE, CAPTURE_ID_CAPTURE_DOUBLE};
562 cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE, STREAM_ID_CAPTURE_DOUBLE};
563 StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
564 }
565 }