1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "anonymous_string.h"
17 #include "dcamera_channel_source_impl.h"
18 #include "dcamera_hitrace_adapter.h"
19 #include "dcamera_frame_info.h"
20 #include "dcamera_source_data_process.h"
21 #include "dcamera_source_event.h"
22 #include "dcamera_source_input.h"
23 #include "dcamera_source_input_channel_listener.h"
24 #include "dcamera_softbus_latency.h"
25 #include "distributed_camera_constants.h"
26 #include "distributed_camera_errno.h"
27 #include "distributed_hardware_log.h"
28 
29 namespace OHOS {
30 namespace DistributedHardware {
DCameraSourceInput(std::string devId,std::string dhId,std::shared_ptr<DCameraSourceDev> & camDev)31 DCameraSourceInput::DCameraSourceInput(std::string devId, std::string dhId, std::shared_ptr<DCameraSourceDev>& camDev)
32     : devId_(devId), dhId_(dhId), camDev_(camDev), isInit(false)
33 {
34     DHLOGI("DCameraSourceInput Constructor devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
35         GetAnonyString(dhId_).c_str());
36 }
37 
~DCameraSourceInput()38 DCameraSourceInput::~DCameraSourceInput()
39 {
40     DHLOGI("DCameraSourceInput Destructor devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
41         GetAnonyString(dhId_).c_str());
42     if (isInit) {
43         UnInit();
44     }
45 }
46 
ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>> & streamInfos)47 int32_t DCameraSourceInput::ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
48 {
49     uint64_t infoSize = static_cast<uint64_t>(streamInfos.size());
50     DHLOGI("DCameraSourceInput ConfigStreams devId %{public}s dhId %{public}s, size: %{public}" PRIu64,
51         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), infoSize);
52     int32_t ret = ReleaseAllStreams();
53     if (ret != DCAMERA_OK) {
54         DHLOGE("DCameraSourceInput ConfigStreams ReleaseAllStreams failed %{public}d devId: %{public}s, dhId: "
55             "%{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
56         return ret;
57     }
58 
59     if (streamInfos.empty()) {
60         return DCAMERA_OK;
61     }
62 
63     std::vector<std::shared_ptr<DCStreamInfo>> snapStreams;
64     std::vector<std::shared_ptr<DCStreamInfo>> continueStreams;
65     for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
66         std::shared_ptr<DCStreamInfo> streamInfo = *iter;
67         DHLOGI("DCameraSourceInput ConfigStreams devId: %{public}s, dhId: %{public}s, streamId: %{public}d, width: "
68             "%{public}d, height: %{public}d, format: %{public}d, dataspace: %{public}d, encodeType:%{public}d "
69             "streamType: %{public}d", GetAnonyString(devId_).c_str(),
70             GetAnonyString(dhId_).c_str(), streamInfo->streamId_, streamInfo->width_, streamInfo->height_,
71             streamInfo->format_, streamInfo->dataspace_, streamInfo->encodeType_, streamInfo->type_);
72         if (streamInfo->type_ == CONTINUOUS_FRAME) {
73             continueStreams.push_back(streamInfo);
74         }
75         if (streamInfo->type_ == SNAPSHOT_FRAME) {
76             snapStreams.push_back(streamInfo);
77         }
78     }
79 
80     do {
81         ret = dataProcess_[CONTINUOUS_FRAME]->ConfigStreams(continueStreams);
82         if (ret != DCAMERA_OK) {
83             DHLOGE("DCameraSourceInput ConfigStreams continue failed %{public}d devId %{public}s dhId %{public}s", ret,
84                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
85             break;
86         }
87         ret = dataProcess_[SNAPSHOT_FRAME]->ConfigStreams(snapStreams);
88         if (ret != DCAMERA_OK) {
89             DHLOGE("DCameraSourceInput ConfigStreams snapshot failed %{public}d devId %{public}s dhId %{public}s", ret,
90                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
91             break;
92         }
93     } while (0);
94 
95     if (ret != DCAMERA_OK) {
96         ReleaseAllStreams();
97     }
98     return ret;
99 }
100 
ReleaseStreams(std::vector<int> & streamIds,bool & isAllRelease)101 int32_t DCameraSourceInput::ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
102 {
103     DHLOGI("DCameraSourceInput ReleaseStreams devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
104         GetAnonyString(dhId_).c_str());
105     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->ReleaseStreams(streamIds);
106     if (ret != DCAMERA_OK) {
107         DHLOGE("DCameraSourceInput ReleaseStreams continue stream ReleaseStreams ret: %{public}d, devId: %{public}s,"
108             " dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
109         return ret;
110     }
111     ret = dataProcess_[SNAPSHOT_FRAME]->ReleaseStreams(streamIds);
112     if (ret != DCAMERA_OK) {
113         DHLOGE("DCameraSourceInput ReleaseStreams snapshot stream ReleaseStreams ret: %{public}d, devId: %{public}s, "
114             "dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
115         return ret;
116     }
117 
118     std::vector<int32_t> continueStreamIds;
119     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
120     std::vector<int32_t> snapStreamIds;
121     dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
122     if (continueStreamIds.empty() && snapStreamIds.empty()) {
123         isAllRelease = true;
124     }
125     return DCAMERA_OK;
126 }
127 
StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>> & captureInfos)128 int32_t DCameraSourceInput::StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos)
129 {
130     DHLOGI("DCameraSourceInput StartCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
131         GetAnonyString(dhId_).c_str());
132     for (auto iter = captureInfos.begin(); iter != captureInfos.end(); iter++) {
133         int32_t ret = DCAMERA_OK;
134         for (auto iterSet = (*iter)->streamIds_.begin(); iterSet != (*iter)->streamIds_.end(); iterSet++) {
135             DHLOGI("DCameraSourceInput StartCapture devId %{public}s dhId %{public}s StartCapture id: %{public}d",
136                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
137         }
138         uint64_t idSize = static_cast<uint64_t>((*iter)->streamIds_.size());
139         DHLOGI("DCameraSourceInput StartCapture Inner devId %{public}s dhId %{public}s streamType: %{public}d "
140             "idSize: %{public}" PRIu64" isCap: %{public}d", GetAnonyString(devId_).c_str(),
141             GetAnonyString(dhId_).c_str(), (*iter)->type_, idSize, (*iter)->isCapture_ ? 1 : 0);
142         ret = dataProcess_[(*iter)->type_]->StartCapture(*iter);
143         if (ret != DCAMERA_OK) {
144             DHLOGE("DCameraSourceInput StartCapture ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
145                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
146             return ret;
147         }
148     }
149     return DCAMERA_OK;
150 }
151 
StopCapture(std::vector<int> & streamIds,bool & isAllStop)152 int32_t DCameraSourceInput::StopCapture(std::vector<int>& streamIds, bool& isAllStop)
153 {
154     DHLOGI("DCameraSourceInput StopCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
155         GetAnonyString(dhId_).c_str());
156     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(streamIds);
157     if (ret != DCAMERA_OK) {
158         DHLOGE("DCameraSourceInput StopCapture continue ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
159             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
160         return ret;
161     }
162 
163     int32_t size = dataProcess_[CONTINUOUS_FRAME]->GetProducerSize();
164     if (size == 0) {
165         isAllStop = true;
166         std::vector<int> snapStreamIds;
167         dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
168         ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture(snapStreamIds);
169         if (ret != DCAMERA_OK) {
170             DHLOGE("DCameraSourceInput StopCapture snapshot ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
171                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
172             return ret;
173         }
174     }
175     return DCAMERA_OK;
176 }
177 
OpenChannel(std::vector<DCameraIndex> & indexs)178 int32_t DCameraSourceInput::OpenChannel(std::vector<DCameraIndex>& indexs)
179 {
180     DHLOGI("DCameraSourceInput OpenChannel devId %{public}s dhId %{public}s continue state: %{public}d, snapshot "
181         "state: %{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
182         channelState_[CONTINUOUS_FRAME], channelState_[SNAPSHOT_FRAME]);
183     if (channelState_[CONTINUOUS_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
184         int32_t ret = EstablishContinuousFrameSession(indexs);
185         if (ret != DCAMERA_OK) {
186             DHLOGE("esdablish continuous frame failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
187                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
188             return ret;
189         }
190     }
191     if (channelState_[SNAPSHOT_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
192         int32_t ret = EstablishSnapshotFrameSession(indexs);
193         if (ret != DCAMERA_OK) {
194             DHLOGE("esdablish snapshot frame failed ret: %{public}d,"
195                 "devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(),
196                 GetAnonyString(dhId_).c_str());
197             return ret;
198         }
199     }
200     return DCAMERA_OK;
201 }
202 
CloseChannel()203 int32_t DCameraSourceInput::CloseChannel()
204 {
205     DHLOGI("DCameraSourceInput CloseChannel devId %{public}s dhId %{public}s continue state: %{public}d, "
206         "snapshot state: %{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
207         channelState_[CONTINUOUS_FRAME], channelState_[SNAPSHOT_FRAME]);
208     if (channelState_[CONTINUOUS_FRAME] != DCAMERA_CHANNEL_STATE_DISCONNECTED) {
209         int32_t ret = DCAMERA_OK;
210         ret = channels_[CONTINUOUS_FRAME]->CloseSession();
211         if (ret != DCAMERA_OK) {
212             DHLOGE("DCameraSourceInput CloseChannel continue stream failed ret: %{public}d, devId: %{public}s, dhId: "
213                 "%{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
214         }
215         channelState_[CONTINUOUS_FRAME] = DCAMERA_CHANNEL_STATE_DISCONNECTED;
216 
217         ret = channels_[CONTINUOUS_FRAME]->ReleaseSession();
218         if (ret != DCAMERA_OK) {
219             DHLOGI("DCameraSourceInput release continue session failed: %{public}d devId %{public}s dhId %{public}s",
220                 ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
221         }
222     }
223 
224     if (channelState_[SNAPSHOT_FRAME] != DCAMERA_CHANNEL_STATE_DISCONNECTED) {
225         int32_t ret = DCAMERA_OK;
226         ret = channels_[SNAPSHOT_FRAME]->CloseSession();
227         if (ret != DCAMERA_OK) {
228             DHLOGE("DCameraSourceInput CloseChannel snapshot stream failed ret: %{public}d, devId: %{public}s, dhId: "
229                 "%{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
230         }
231         channelState_[SNAPSHOT_FRAME] = DCAMERA_CHANNEL_STATE_DISCONNECTED;
232 
233         ret = channels_[SNAPSHOT_FRAME]->ReleaseSession();
234         if (ret != DCAMERA_OK) {
235             DHLOGI("DCameraSourceInput release snapshot session failed: %{public}d devId %{public}s dhId %{public}s",
236                 ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
237         }
238     }
239     return DCAMERA_OK;
240 }
241 
Init()242 int32_t DCameraSourceInput::Init()
243 {
244     DHLOGI("DCameraSourceInput Init devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
245         GetAnonyString(dhId_).c_str());
246     auto input = std::shared_ptr<DCameraSourceInput>(shared_from_this());
247     std::shared_ptr<ICameraSourceDataProcess> conDataProcess = std::make_shared<DCameraSourceDataProcess>(devId_, dhId_,
248         CONTINUOUS_FRAME);
249     std::shared_ptr<ICameraChannel> continueCh = std::make_shared<DCameraChannelSourceImpl>();
250     std::shared_ptr<ICameraChannelListener> conListener =
251         std::make_shared<DCameraSourceInputChannelListener>(input, CONTINUOUS_FRAME);
252     channels_.emplace(CONTINUOUS_FRAME, continueCh);
253     listeners_.emplace(CONTINUOUS_FRAME, conListener);
254     dataProcess_.emplace(CONTINUOUS_FRAME, conDataProcess);
255     channelState_.emplace(CONTINUOUS_FRAME, DCAMERA_CHANNEL_STATE_DISCONNECTED);
256 
257     std::shared_ptr<ICameraSourceDataProcess> snapDataProcess = std::make_shared<DCameraSourceDataProcess>(devId_,
258         dhId_, SNAPSHOT_FRAME);
259     std::shared_ptr<ICameraChannel> snapShotCh = std::make_shared<DCameraChannelSourceImpl>();
260     std::shared_ptr<ICameraChannelListener> snapListener =
261         std::make_shared<DCameraSourceInputChannelListener>(input, SNAPSHOT_FRAME);
262     channels_.emplace(SNAPSHOT_FRAME, snapShotCh);
263     listeners_.emplace(SNAPSHOT_FRAME, snapListener);
264     dataProcess_.emplace(SNAPSHOT_FRAME, snapDataProcess);
265     channelState_.emplace(SNAPSHOT_FRAME, DCAMERA_CHANNEL_STATE_DISCONNECTED);
266     isInit = true;
267     DHLOGI("DCameraSourceInput Init devId end %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
268         GetAnonyString(dhId_).c_str());
269     return DCAMERA_OK;
270 }
271 
UnInit()272 int32_t DCameraSourceInput::UnInit()
273 {
274     DHLOGI("DCameraSourceInput UnInit devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
275         GetAnonyString(dhId_).c_str());
276     channels_.clear();
277     listeners_.clear();
278     dataProcess_.clear();
279     channelState_.clear();
280     isInit = false;
281     isChannelConnected_.store(false);
282     return DCAMERA_OK;
283 }
284 
UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>> & settings)285 int32_t DCameraSourceInput::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
286 {
287     return DCAMERA_OK;
288 }
289 
OnSessionState(DCStreamType streamType,int32_t state)290 void DCameraSourceInput::OnSessionState(DCStreamType streamType, int32_t state)
291 {
292     DHLOGI("DCameraSourceInput OnSessionState devId: %{public}s, dhId: %{public}s, streamType: %{public}d, state: "
293         "%{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType, state);
294     channelState_[streamType] = (DCameraChannelState)state;
295     switch (state) {
296         case DCAMERA_CHANNEL_STATE_DISCONNECTED: {
297             FinshFrameAsyncTrace(streamType);
298             DHLOGI("DCameraSourceDev PostTask CloseSession Input OnClose devId %{public}s dhId %{public}s",
299                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
300             isChannelConnected_.store(false);
301             PostChannelDisconnectedEvent();
302             break;
303         }
304         case DCAMERA_CHANNEL_STATE_CONNECTED: {
305             FinshFrameAsyncTrace(streamType);
306             isChannelConnected_.store(true);
307             channelCond_.notify_one();
308             DHLOGI("DCameraSourceInput OnSessionState state %{public}d", state);
309             break;
310         }
311         default: {
312             DHLOGI("DCameraSourceInput OnSessionState state %{public}d", state);
313             break;
314         }
315     }
316 }
317 
FinshFrameAsyncTrace(DCStreamType streamType)318 void DCameraSourceInput::FinshFrameAsyncTrace(DCStreamType streamType)
319 {
320     if (streamType == CONTINUOUS_FRAME) {
321         DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
322     } else if (streamType == SNAPSHOT_FRAME) {
323         DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
324     }
325 }
326 
OnSessionError(DCStreamType streamType,int32_t eventType,int32_t eventReason,std::string detail)327 void DCameraSourceInput::OnSessionError(DCStreamType streamType, int32_t eventType, int32_t eventReason,
328     std::string detail)
329 {
330     DHLOGI("DCameraSourceInput OnSessionError devId: %{public}s, dhId: %{public}s, eventType: %{public}d, "
331         "eventReason: %{public}d, detail %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
332         eventType, eventReason, detail.c_str());
333     (void)streamType;
334 }
335 
OnDataReceived(DCStreamType streamType,std::vector<std::shared_ptr<DataBuffer>> & buffers)336 void DCameraSourceInput::OnDataReceived(DCStreamType streamType, std::vector<std::shared_ptr<DataBuffer>>& buffers)
337 {
338     buffers[0]->frameInfo_.offset = DCameraSoftbusLatency::GetInstance().GetTimeSyncInfo(devId_);
339     int32_t ret = dataProcess_[streamType]->FeedStream(buffers);
340     if (ret != DCAMERA_OK) {
341         DHLOGE("OnDataReceived FeedStream %{public}d stream failed ret: %{public}d, devId: %{public}s, "
342             "dhId: %{public}s", streamType, ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
343     }
344 }
345 
ReleaseAllStreams()346 int32_t DCameraSourceInput::ReleaseAllStreams()
347 {
348     DHLOGI("ReleaseAllStreams devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
349         GetAnonyString(dhId_).c_str());
350     std::vector<int> continueStreamIds;
351     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
352     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->ReleaseStreams(continueStreamIds);
353     if (ret != DCAMERA_OK) {
354         DHLOGE("continue stream ReleaseStreams ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
355             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
356         return ret;
357     }
358 
359     std::vector<int> snapStreamIds;
360     dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
361     ret = dataProcess_[SNAPSHOT_FRAME]->ReleaseStreams(snapStreamIds);
362     if (ret != DCAMERA_OK) {
363         DHLOGE("ReleaseAllStreams snapshot stream ReleaseStreams ret: %{public}d, devId: %{public}s, dhId: %{public}s",
364             ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
365         return ret;
366     }
367     return DCAMERA_OK;
368 }
369 
StopAllCapture()370 int32_t DCameraSourceInput::StopAllCapture()
371 {
372     DHLOGI("StopAllCapture devId %{public}s dhId %{public}s", GetAnonyString(devId_).c_str(),
373         GetAnonyString(dhId_).c_str());
374     std::vector<int> continueStreamIds;
375     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
376     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(continueStreamIds);
377     if (ret != DCAMERA_OK) {
378         DHLOGE("StopAllCapture continue ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
379             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
380         return ret;
381     }
382 
383     std::vector<int> snapStreamIds;
384     dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
385     ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture(snapStreamIds);
386     if (ret != DCAMERA_OK) {
387         DHLOGE("StopAllCapture snapshot ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
388             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
389         return ret;
390     }
391     return DCAMERA_OK;
392 }
393 
PostChannelDisconnectedEvent()394 void DCameraSourceInput::PostChannelDisconnectedEvent()
395 {
396     std::shared_ptr<DCameraSourceDev> camDev = camDev_.lock();
397     if (camDev == nullptr) {
398         DHLOGE("DCameraSourceInput PostChannelDisconnectedEvent camDev is nullptr");
399         return;
400     }
401     camDev->OnChannelDisconnectedEvent();
402 }
403 
EstablishContinuousFrameSession(std::vector<DCameraIndex> & indexs)404 int32_t DCameraSourceInput::EstablishContinuousFrameSession(std::vector<DCameraIndex>& indexs)
405 {
406     DcameraStartAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
407     int32_t ret = channels_[CONTINUOUS_FRAME]->CreateSession(indexs, CONTINUE_SESSION_FLAG, DCAMERA_SESSION_MODE_VIDEO,
408         listeners_[CONTINUOUS_FRAME]);
409     if (ret != DCAMERA_OK) {
410         DHLOGE("Create Session failed ret: %{public}d,"
411             "devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
412         PostChannelDisconnectedEvent();
413         DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
414         return ret;
415     }
416     isChannelConnected_.store(false);
417     DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
418     return DCAMERA_OK;
419 }
420 
EstablishSnapshotFrameSession(std::vector<DCameraIndex> & indexs)421 int32_t DCameraSourceInput::EstablishSnapshotFrameSession(std::vector<DCameraIndex>& indexs)
422 {
423     DcameraStartAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
424     int32_t ret = channels_[SNAPSHOT_FRAME]->CreateSession(indexs, SNAP_SHOT_SESSION_FLAG, DCAMERA_SESSION_MODE_JPEG,
425         listeners_[SNAPSHOT_FRAME]);
426     if (ret != DCAMERA_OK) {
427         DHLOGE("create session failed ret: %{public}d,"
428             "devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
429         PostChannelDisconnectedEvent();
430         DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
431         return ret;
432     }
433     isChannelConnected_.store(false);
434     return DCAMERA_OK;
435 }
436 } // namespace DistributedHardware
437 } // namespace OHOS
438