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_mult.h"
16 
SetUpTestCase(void)17 void UtestUSBCameraTestMult::SetUpTestCase(void)
18 {}
TearDownTestCase(void)19 void UtestUSBCameraTestMult::TearDownTestCase(void)
20 {}
SetUp(void)21 void UtestUSBCameraTestMult::SetUp(void)
22 {
23     if (cameraBase_ == nullptr)
24     cameraBase_ = std::make_shared<TestCameraBase>();
25     cameraBase_->UsbInit();
26 }
TearDown(void)27 void UtestUSBCameraTestMult::TearDown(void)
28 {
29     cameraBase_->Close();
30 }
31 
SelectOpenCamera(std::string cameraId)32 CamRetCode UtestUSBCameraTestMult::SelectOpenCamera(std::string cameraId)
33 {
34     cameraBase_->cameraHost->GetCameraAbility(cameraId, vecAbility_);
35     MetadataUtils::ConvertVecToMetadata(vecAbility_, ability_);
36     const OHOS::sptr<DemoCameraDeviceCallback> callback = new DemoCameraDeviceCallback();
37     cameraBase_->rc = (CamRetCode)cameraBase_->cameraHost->OpenCamera(cameraId, callback, cameraDevice_);
38     if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR || cameraDevice_ == nullptr) {
39         std::cout << "OpenCamera2 failed, rc = " << cameraBase_->rc << std::endl;
40         return cameraBase_->rc;
41     }
42     std::cout << "OpenCamera2 success." << std::endl;
43     return cameraBase_->rc;
44 }
45 
AchieveStreamOperator()46 void UtestUSBCameraTestMult::AchieveStreamOperator()
47 {
48     OHOS::sptr<DemoStreamOperatorCallback> streamOperatorCallback = new DemoStreamOperatorCallback();
49     cameraBase_->rc = (CamRetCode)cameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_);
50     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
51     if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
52         std::cout << "AchieveStreamOperator2 success." << std::endl;
53     } else {
54         std::cout << "AchieveStreamOperator2 fail, rc = " << cameraBase_->rc << std::endl;
55     }
56 }
57 
DefaultInfosPreview()58 void UtestUSBCameraTestMult::DefaultInfosPreview()
59 {
60     if (streamCustomerPreview_ == nullptr) {
61         streamCustomerPreview_ = std::make_shared<StreamCustomer>();
62     }
63     streamInfoPre_.streamId_ = STREAM_ID_PREVIEW_DOUBLE;
64     streamInfoPre_.width_ = PREVIEW_WIDTH; // 640:picture width
65     streamInfoPre_.height_ = PREVIEW_HEIGHT; // 480:picture height
66     streamInfoPre_.format_ = PIXEL_FMT_RGBA_8888;
67     streamInfoPre_.dataspace_ = 8; // 8:picture dataspace
68     streamInfoPre_.intent_ = PREVIEW;
69     streamInfoPre_.tunneledMode_ = 5; // 5:tunnel mode
70     streamInfoPre_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerPreview_->CreateProducer());
71     ASSERT_NE(streamInfoPre_.bufferQueue_, nullptr);
72     streamInfoPre_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
73     std::cout << "preview success1." << std::endl;
74     std::vector<StreamInfo>().swap(streamInfos_);
75     streamInfos_.push_back(streamInfoPre_);
76 }
77 
DefaultInfosVideo()78 void UtestUSBCameraTestMult::DefaultInfosVideo()
79 {
80     if (streamCustomerVideo_ == nullptr) {
81         streamCustomerVideo_ = std::make_shared<StreamCustomer>();
82     }
83     streamInfoVideo_.streamId_ = STREAM_ID_VIDEO_DOUBLE;
84     streamInfoVideo_.width_ = VIDEO_WIDTH; // 1280:picture width
85     streamInfoVideo_.height_ = VIDEO_HEIGHT; // 960:picture height
86     streamInfoVideo_.format_ = videoFormat_;
87     streamInfoVideo_.dataspace_ = 8; // 8:picture dataspace
88     streamInfoVideo_.intent_ = VIDEO;
89     streamInfoVideo_.encodeType_ = ENCODE_TYPE_H264;
90     streamInfoVideo_.tunneledMode_ = 5; // 5:tunnel mode
91     streamInfoVideo_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerVideo_->CreateProducer());
92     ASSERT_NE(streamInfoVideo_.bufferQueue_, nullptr);
93     streamInfoVideo_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
94     std::cout << "video success1." << std::endl;
95     std::vector<StreamInfo>().swap(streamInfos_);
96     streamInfos_.push_back(streamInfoVideo_);
97 }
98 
DefaultInfosCapture()99 void UtestUSBCameraTestMult::DefaultInfosCapture()
100 {
101     if (streamCustomerCapture_ == nullptr) {
102         streamCustomerCapture_ = std::make_shared<StreamCustomer>();
103     }
104     streamInfoCapture_.streamId_ = STREAM_ID_CAPTURE_DOUBLE;
105     streamInfoCapture_.width_ = CAPTURE_WIDTH; // 1280:picture width
106     streamInfoCapture_.height_ = CAPTURE_HEIGHT; // 960:picture height
107     streamInfoCapture_.format_ = PIXEL_FMT_RGBA_8888;
108     streamInfoCapture_.dataspace_ = 8; // 8:picture dataspace
109     streamInfoCapture_.intent_ = STILL_CAPTURE;
110     streamInfoCapture_.encodeType_ = ENCODE_TYPE_JPEG;
111     streamInfoCapture_.tunneledMode_ = 5; // 5:tunnel mode
112     streamInfoCapture_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerCapture_->CreateProducer());
113     ASSERT_NE(streamInfoCapture_.bufferQueue_, nullptr);
114     streamInfoCapture_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
115     std::cout << "capture success1." << std::endl;
116     std::vector<StreamInfo>().swap(streamInfos_);
117     streamInfos_.push_back(streamInfoCapture_);
118 }
119 
StartStream(std::vector<StreamIntent> intents)120 void UtestUSBCameraTestMult::StartStream(std::vector<StreamIntent> intents)
121 {
122     for (auto& intent : intents) {
123         if (intent == PREVIEW) {
124             DefaultInfosPreview();
125         } else if (intent == VIDEO) {
126             DefaultInfosVideo();
127         } else if (intent == STILL_CAPTURE) {
128             DefaultInfosCapture();
129         }
130         cameraBase_->rc = (CamRetCode)streamOperator_->CreateStreams(streamInfos_);
131         EXPECT_EQ(false, cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR);
132         if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
133             std::cout << "CreateStreams2 success." << std::endl;
134         } else {
135             std::cout << "CreateStreams2 fail, rc = " << cameraBase_->rc << std::endl;
136         }
137 
138         cameraBase_->rc = (CamRetCode)streamOperator_->CommitStreams(NORMAL, vecAbility_);
139         EXPECT_EQ(false, cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR);
140         if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
141             std::cout << "CommitStreams2 success." << std::endl;
142         } else {
143             std::cout << "CommitStreams2 fail, rc = " << cameraBase_->rc << std::endl;
144         }
145     }
146 }
147 
StoreImage(const unsigned char * bufStart,const uint32_t size)148 void UtestUSBCameraTestMult::StoreImage(const unsigned char *bufStart, const uint32_t size)
149 {
150     constexpr uint32_t pathLen = 64;
151     char path[pathLen] = {0};
152 #ifdef CAMERA_BUILT_ON_OHOS_LITE
153     char prefix[] = "/userdata/photo/";
154 #else
155     char prefix[] = "/data/";
156 #endif
157 
158     int imgFD = 0;
159     int ret = 0;
160 
161     struct timeval start = {};
162     gettimeofday(&start, nullptr);
163     if (sprintf_s(path, sizeof(path), "%spicture222_%ld.jpeg", prefix, start.tv_usec) < 0) {
164         CAMERA_LOGE("sprintf_s error .....\n");
165         return;
166     }
167 
168     imgFD = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
169     if (imgFD == -1) {
170         CAMERA_LOGE("demo test:open image file error %{public}s.....\n", strerror(errno));
171         return;
172     }
173 
174     CAMERA_LOGD("demo test:StoreImage2 %{public}s size == %{public}d\n", path, size);
175 
176     ret = write(imgFD, bufStart, size);
177     if (ret == -1) {
178         CAMERA_LOGE("demo test:write image file error %{public}s.....\n", strerror(errno));
179     }
180 
181     close(imgFD);
182 }
183 
StoreVideo(const unsigned char * bufStart,const uint32_t size)184 void UtestUSBCameraTestMult::StoreVideo(const unsigned char *bufStart, const uint32_t size)
185 {
186     int ret = 0;
187 
188     ret = write(videoFd_, bufStart, size);
189     if (ret == -1) {
190         CAMERA_LOGE("demo test:write video file error %{public}s.....\n", strerror(errno));
191     }
192     CAMERA_LOGD("demo test:StoreVideo size == %{public}d\n", size);
193 }
194 
OpenVideoFile()195 void UtestUSBCameraTestMult::OpenVideoFile()
196 {
197     constexpr uint32_t pathLen = 64;
198     char path[pathLen] = {0};
199 #ifdef CAMERA_BUILT_ON_OHOS_LITE
200     char prefix[] = "/userdata/video/";
201 #else
202     char prefix[] = "/data/";
203 #endif
204     auto seconds = time(nullptr);
205     if (sprintf_s(path, sizeof(path), "%svideo222%ld.h264", prefix, seconds) < 0) {
206         CAMERA_LOGE("%{public}s: sprintf  failed", __func__);
207         return;
208     }
209     videoFd_ = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
210     if (videoFd_ < 0) {
211         CAMERA_LOGE("demo test: StartVideo open %s %{public}s failed", path, strerror(errno));
212     }
213 }
214 
CloseFd()215 void UtestUSBCameraTestMult::CloseFd()
216 {
217     close(videoFd_);
218     videoFd_ = -1;
219 }
220 
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)221 void UtestUSBCameraTestMult::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
222 {
223     // Get preview
224     captureInfo_.streamIds_ = {streamId};
225     captureInfo_.captureSetting_ = vecAbility_;
226     captureInfo_.enableShutterCallback_ = shutterCallback;
227     cameraBase_->rc = (CamRetCode)streamOperator_->Capture(captureId, captureInfo_, isStreaming);
228     EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
229     if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
230         std::cout << "check Capture: Capture2 success, captureId = " << captureId << std::endl;
231     } else {
232         std::cout << "check Capture: Capture2 fail, rc = " << cameraBase_->rc
233                   << ", captureId = " << captureId<< std::endl;
234     }
235     if (captureId == CAPTURE_ID_PREVIEW_DOUBLE) {
236         streamCustomerPreview_->ReceiveFrameOn(nullptr);
237     } else if (captureId == CAPTURE_ID_CAPTURE_DOUBLE) {
238         streamCustomerCapture_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
239             StoreImage(addr, size);
240         });
241     } else if (captureId == CAPTURE_ID_VIDEO_DOUBLE) {
242         OpenVideoFile();
243         streamCustomerVideo_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
244             StoreVideo(addr, size);
245         });
246     }
247     sleep(2); // 2:sleep two second
248 }
249 
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)250 void UtestUSBCameraTestMult::StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds)
251 {
252     constexpr uint32_t timeForWaitCancelCapture = 2;
253     sleep(timeForWaitCancelCapture);
254     if (captureIds.size() > 0) {
255         for (auto &captureId : captureIds) {
256             if (captureId == CAPTURE_ID_PREVIEW_DOUBLE) {
257                 streamCustomerPreview_->ReceiveFrameOff();
258             } else if (captureId == CAPTURE_ID_CAPTURE_DOUBLE) {
259                 streamCustomerCapture_->ReceiveFrameOff();
260             } else if (captureId == CAPTURE_ID_VIDEO_DOUBLE) {
261                 streamCustomerVideo_->ReceiveFrameOff();
262                 sleep(1);
263                 CloseFd();
264             }
265         }
266         for (const auto &captureId : captureIds) {
267             std::cout << "check Capture: CancelCapture success, captureId = " << captureId << std::endl;
268             cameraBase_->rc = (CamRetCode)streamOperator_->CancelCapture(captureId);
269             sleep(timeForWaitCancelCapture);
270             EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
271             if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
272                 std::cout << "check Capture: CancelCapture success, captureId = " << captureId << std::endl;
273             } else {
274                 std::cout << "check Capture: CancelCapture fail, rc = "
275                           << cameraBase_->rc <<", captureId = " << captureId << std::endl;
276             }
277         }
278     }
279     sleep(1); // 1:sleep two second
280     if (streamIds.size() > 0) {
281         // release stream
282         cameraBase_->rc = (CamRetCode)streamOperator_->ReleaseStreams(streamIds);
283         EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
284         if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
285             std::cout << "check Capture: ReleaseStreams success." << std::endl;
286         } else {
287             std::cout << "check Capture: ReleaseStreams fail, rc = "
288                       << cameraBase_->rc << ", streamIds = " << streamIds.front() << std::endl;
289         }
290     }
291 }
292 
293 const std::map<uint32_t, uint32_t> g_mapOhosFmtToPixFmt = {
294     { OHOS_CAMERA_FORMAT_RGBA_8888, PIXEL_FMT_RGBA_8888 },
295     { OHOS_CAMERA_FORMAT_YCRCB_420_SP, PIXEL_FMT_YCRCB_420_SP },
296 };
297 
ConvertPixfmtHal2V4l2(uint32_t ohosfmt)298 uint32_t UtestUSBCameraTestMult::ConvertPixfmtHal2V4l2(uint32_t ohosfmt)
299 {
300     auto it = g_mapOhosFmtToPixFmt.find(ohosfmt);
301     if (it == g_mapOhosFmtToPixFmt.end()) {
302         CAMERA_LOGI("The ohosfmt is not find in g_mapOhosFmtToPixFmt");
303         return PIXEL_FMT_RGBA_8888; // default value
304     }
305     return it->second;
306 }
307 
308 /**
309   * @tc.name: USB Camera
310   * @tc.desc: USB Camera, getCameraID success.
311   * @tc.level: Level0
312   * @tc.size: MediumTest
313   * @tc.type: Function
314   */
TEST_F(UtestUSBCameraTestMult,camera_usb_mult_0001)315 TEST_F(UtestUSBCameraTestMult, camera_usb_mult_0001)
316 {
317     std::vector<std::string> usbCameraIds;
318     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
319     // 1:number of connected cameras
320     usbCameraExit_ = usbCameraIds.size() > 1;
321     if (!usbCameraExit_) {
322         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
323     }
324     cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
325     ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
326     cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]);  // 1:second camera id
327     ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
328     cameraBase_->AchieveStreamOperator();
329     AchieveStreamOperator();
330 
331     cameraBase_->intents = {PREVIEW};
332     cameraBase_->StartStream(cameraBase_->intents);
333     StartStream(cameraBase_->intents);
334     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
335     StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
336     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
337     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
338     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
339     cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE};
340     cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE};
341     StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
342 }
343 
344 /**
345   * @tc.name: USB Camera
346   * @tc.desc: USB Camera, getCameraID success.
347   * @tc.level: Level0
348   * @tc.size: MediumTest
349   * @tc.type: Function
350   */
TEST_F(UtestUSBCameraTestMult,camera_usb_mult_0002)351 TEST_F(UtestUSBCameraTestMult, camera_usb_mult_0002)
352 {
353     std::vector<std::string> usbCameraIds;
354     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
355     // 1:number of connected cameras
356     usbCameraExit_ = usbCameraIds.size() > 1;
357     if (!usbCameraExit_) {
358         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
359     }
360     cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
361     ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
362     cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]);  // 1:second camera id
363     ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
364     cameraBase_->AchieveStreamOperator();
365     AchieveStreamOperator();
366 
367     cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
368     cameraBase_->StartStream(cameraBase_->intents);
369     StartStream(cameraBase_->intents);
370     cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
371     cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
372     StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
373     StartCapture(STREAM_ID_CAPTURE_DOUBLE, CAPTURE_ID_CAPTURE_DOUBLE, false, true);
374     cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
375     cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
376     cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
377     cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE, CAPTURE_ID_CAPTURE_DOUBLE};
378     cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE, STREAM_ID_CAPTURE_DOUBLE};
379     StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
380 }
381 
382 /**
383   * @tc.name: USB Camera
384   * @tc.desc: USB Camera, getCameraID success.
385   * @tc.level: Level0
386   * @tc.size: MediumTest
387   * @tc.type: Function
388   */
TEST_F(UtestUSBCameraTestMult,camera_usb_mult_0003)389 TEST_F(UtestUSBCameraTestMult, camera_usb_mult_0003)
390 {
391     std::vector<std::string> usbCameraIds;
392     cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
393     // 1:number of connected cameras
394     usbCameraExit_ = usbCameraIds.size() > 1;
395     if (!usbCameraExit_) {
396         GTEST_SKIP() << "No usb camera plugged in" << std::endl;
397     }
398     cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
399     ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
400     cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]);  // 1:second camera id
401     ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
402     cameraBase_->AchieveStreamOperator();
403     AchieveStreamOperator();
404 
405     ability_ = cameraBase_->GetCameraAbility();
406     EXPECT_NE(ability_, nullptr);
407     common_metadata_header_t *data = ability_->get();
408     EXPECT_NE(data, nullptr);
409     camera_metadata_item_t entry;
410     int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
411 
412     uint32_t format = 0;
413     if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
414         format = entry.data.i32[entry.count - 6]; // 6:The sixth digit from the bottom is the format of video
415     }
416     videoFormat_ = ConvertPixfmtHal2V4l2(format);
417 
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