1 /*
2 * Copyright (c) 2021-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
16 #include "dcamera_source_controller.h"
17
18 #include <securec.h>
19 #include "json/json.h"
20
21 #include "dcamera_capture_info_cmd.h"
22 #include "dcamera_channel_source_impl.h"
23 #include "dcamera_hitrace_adapter.h"
24 #include "dcamera_metadata_setting_cmd.h"
25 #include "dcamera_protocol.h"
26 #include "dcamera_softbus_latency.h"
27 #include "dcamera_source_controller_channel_listener.h"
28 #include "dcamera_source_service_ipc.h"
29 #include "dcamera_utils_tools.h"
30
31 #include "distributed_camera_constants.h"
32 #include "distributed_camera_errno.h"
33 #include "distributed_hardware_log.h"
34 #include "idistributed_camera_sink.h"
35 #include "dcamera_low_latency.h"
36
37 namespace OHOS {
38 namespace DistributedHardware {
DCameraSourceController(std::string devId,std::string dhId,std::shared_ptr<DCameraSourceStateMachine> & stateMachine,std::shared_ptr<DCameraSourceDev> & camDev)39 DCameraSourceController::DCameraSourceController(std::string devId, std::string dhId,
40 std::shared_ptr<DCameraSourceStateMachine>& stateMachine, std::shared_ptr<DCameraSourceDev>& camDev)
41 : devId_(devId), dhId_(dhId), stateMachine_(stateMachine), camDev_(camDev),
42 channelState_(DCAMERA_CHANNEL_STATE_DISCONNECTED)
43 {
44 DHLOGI("DCameraSourceController create devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
45 GetAnonyString(dhId_).c_str());
46 isInit = false;
47 }
48
~DCameraSourceController()49 DCameraSourceController::~DCameraSourceController()
50 {
51 DHLOGI("DCameraSourceController delete devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
52 GetAnonyString(dhId_).c_str());
53 if (isInit) {
54 UnInit();
55 }
56 camHdiProvider_ = nullptr;
57 }
58
StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos)59 int32_t DCameraSourceController::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
60 {
61 if (indexs_.size() > DCAMERA_MAX_NUM) {
62 DHLOGE("StartCapture not support operate %d camera", indexs_.size());
63 return DCAMERA_BAD_OPERATE;
64 }
65
66 std::string dhId = indexs_.begin()->dhId_;
67 std::string devId = indexs_.begin()->devId_;
68 DHLOGI("StartCapture devId: %s, dhId: %s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
69 DCameraCaptureInfoCmd cmd;
70 cmd.type_ = DCAMERA_PROTOCOL_TYPE_OPERATION;
71 cmd.dhId_ = dhId;
72 cmd.command_ = DCAMERA_PROTOCOL_CMD_CAPTURE;
73 cmd.value_.assign(captureInfos.begin(), captureInfos.end());
74 std::string jsonStr;
75 int32_t ret = cmd.Marshal(jsonStr);
76 if (ret != DCAMERA_OK) {
77 DHLOGE("Marshal failed %d, devId: %s, dhId: %s", ret,
78 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
79 return ret;
80 }
81 DHLOGI("devId: %s, dhId: %s captureCommand: %s", GetAnonyString(devId).c_str(),
82 GetAnonyString(dhId).c_str(), cmd.command_.c_str());
83 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
84 ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())),
85 jsonStr.length());
86 if (ret != EOK) {
87 DHLOGE("memcpy_s failed %d, devId: %s, dhId: %s", ret,
88 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
89 return ret;
90 }
91 ret = channel_->SendData(buffer);
92 if (ret != DCAMERA_OK) {
93 DHLOGE("SendData failed %d, devId: %s, dhId: %s", ret,
94 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
95 return ret;
96 }
97 DHLOGI("StartCapture devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
98 GetAnonyString(dhId).c_str());
99 return DCAMERA_OK;
100 }
101
StopCapture()102 int32_t DCameraSourceController::StopCapture()
103 {
104 if (indexs_.size() > DCAMERA_MAX_NUM) {
105 DHLOGE("StopCapture not support operate %d camera", indexs_.size());
106 return DCAMERA_BAD_OPERATE;
107 }
108
109 std::string dhId = indexs_.begin()->dhId_;
110 std::string devId = indexs_.begin()->devId_;
111 DHLOGI("StopCapture devId: %s, dhId: %s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
112 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
113 if (camSinkSrv == nullptr) {
114 DHLOGE("can not get service, devId: %s", GetAnonyString(devId).c_str());
115 return DCAMERA_BAD_OPERATE;
116 }
117 int32_t ret = camSinkSrv->StopCapture(dhId);
118 if (ret != DCAMERA_OK) {
119 DHLOGE("StopCapture failed: %d, devId: %s, dhId: %s", ret,
120 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
121 return DCAMERA_BAD_OPERATE;
122 }
123 DHLOGI("StopCapture devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
124 GetAnonyString(dhId).c_str());
125 return DCAMERA_OK;
126 }
127
ChannelNeg(std::shared_ptr<DCameraChannelInfo> & info)128 int32_t DCameraSourceController::ChannelNeg(std::shared_ptr<DCameraChannelInfo>& info)
129 {
130 if (indexs_.size() > DCAMERA_MAX_NUM) {
131 DHLOGE("ChannelNeg not support operate %d camera", indexs_.size());
132 return DCAMERA_BAD_OPERATE;
133 }
134
135 std::string dhId = indexs_.begin()->dhId_;
136 std::string devId = indexs_.begin()->devId_;
137 DHLOGI("ChannelNeg devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
138 GetAnonyString(dhId).c_str());
139 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
140 if (camSinkSrv == nullptr) {
141 DHLOGE("can not get service, devId: %s", GetAnonyString(devId).c_str());
142 return DCAMERA_BAD_OPERATE;
143 }
144 DCameraChannelInfoCmd cmd;
145 cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
146 cmd.dhId_ = dhId;
147 cmd.command_ = DCAMERA_PROTOCOL_CMD_CHAN_NEG;
148 cmd.value_ = info;
149 std::string jsonStr;
150 int32_t ret = cmd.Marshal(jsonStr);
151 if (ret != DCAMERA_OK) {
152 DHLOGE("Marshal failed ret: %d, devId: %s, dhId: %s", ret,
153 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
154 return ret;
155 }
156 DHLOGD("devId: %s, dhId: %s channelNegCommand: %s",
157 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), cmd.command_.c_str());
158 ret = camSinkSrv->ChannelNeg(dhId, jsonStr);
159 if (ret != DCAMERA_OK) {
160 DHLOGE("ChannelNeg rpc failed ret: %d, devId: %s, dhId: %s", ret,
161 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
162 return ret;
163 }
164 DHLOGD("DCameraSourceController ChannelNeg devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
165 GetAnonyString(dhId).c_str());
166 return DCAMERA_OK;
167 }
168
DCameraNotify(std::shared_ptr<DCameraEvent> & events)169 int32_t DCameraSourceController::DCameraNotify(std::shared_ptr<DCameraEvent>& events)
170 {
171 if (events->eventResult_ == DCAMERA_EVENT_CAMERA_ERROR) {
172 DcameraFinishAsyncTrace(DCAMERA_CONTINUE_FIRST_FRAME, DCAMERA_CONTINUE_FIRST_FRAME_TASKID);
173 DcameraFinishAsyncTrace(DCAMERA_SNAPSHOT_FIRST_FRAME, DCAMERA_SNAPSHOT_FIRST_FRAME_TASKID);
174 }
175 if (camHdiProvider_ == nullptr) {
176 DHLOGI("DCameraNotify camHdiProvider is nullptr devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
177 GetAnonyString(dhId_).c_str());
178 return DCAMERA_BAD_OPERATE;
179 }
180 DHBase dhBase;
181 dhBase.deviceId_ = devId_;
182 dhBase.dhId_ = dhId_;
183 DCameraHDFEvent hdiEvent;
184 hdiEvent.type_ = events->eventType_;
185 hdiEvent.result_ = events->eventResult_;
186 hdiEvent.content_ = events->eventContent_;
187 int32_t retHdi = camHdiProvider_->Notify(dhBase, hdiEvent);
188 DHLOGI("Nofify hal, ret: %d, devId: %s dhId: %s, type: %d, result: %d, content: %s", retHdi,
189 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), events->eventType_, events->eventResult_,
190 events->eventContent_.c_str());
191 if (retHdi != SUCCESS) {
192 return DCAMERA_BAD_OPERATE;
193 }
194 return DCAMERA_OK;
195 }
196
UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>> & settings)197 int32_t DCameraSourceController::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
198 {
199 if (indexs_.size() > DCAMERA_MAX_NUM) {
200 DHLOGE("UpdateSettings not support operate %d camera", indexs_.size());
201 return DCAMERA_BAD_OPERATE;
202 }
203
204 std::string dhId = indexs_.begin()->dhId_;
205 std::string devId = indexs_.begin()->devId_;
206 DHLOGI("UpdateSettings devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
207 GetAnonyString(dhId).c_str());
208 DCameraMetadataSettingCmd cmd;
209 cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
210 cmd.dhId_ = dhId;
211 cmd.command_ = DCAMERA_PROTOCOL_CMD_UPDATE_METADATA;
212 cmd.value_.assign(settings.begin(), settings.end());
213 std::string jsonStr;
214 int32_t ret = cmd.Marshal(jsonStr);
215 if (ret != DCAMERA_OK) {
216 DHLOGE("Marshal failed %d, devId: %s, dhId: %s", ret,
217 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
218 return ret;
219 }
220 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
221 ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())),
222 jsonStr.length());
223 if (ret != EOK) {
224 DHLOGE("memcpy_s failed %d, devId: %s, dhId: %s", ret,
225 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
226 return ret;
227 }
228 ret = channel_->SendData(buffer);
229 if (ret != DCAMERA_OK) {
230 DHLOGE("SendData failed %d, devId: %s, dhId: %s", ret,
231 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
232 return ret;
233 }
234 DHLOGI("UpdateSettings devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
235 GetAnonyString(dhId).c_str());
236 return DCAMERA_OK;
237 }
238
GetCameraInfo(std::shared_ptr<DCameraInfo> & camInfo)239 int32_t DCameraSourceController::GetCameraInfo(std::shared_ptr<DCameraInfo>& camInfo)
240 {
241 if (indexs_.size() > DCAMERA_MAX_NUM) {
242 DHLOGE("GetCameraInfo not support operate %d camera", indexs_.size());
243 return DCAMERA_BAD_OPERATE;
244 }
245
246 std::string dhId = indexs_.begin()->dhId_;
247 std::string devId = indexs_.begin()->devId_;
248 DHLOGI("GetCameraInfo devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
249 GetAnonyString(dhId).c_str());
250 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
251 if (camSinkSrv == nullptr) {
252 DHLOGE("can not get service, devId: %s", GetAnonyString(devId).c_str());
253 return DCAMERA_BAD_OPERATE;
254 }
255 std::string camInfoJson;
256 int32_t ret = camSinkSrv->GetCameraInfo(dhId, camInfoJson);
257 if (ret != DCAMERA_OK) {
258 DHLOGE("GetCameraInfo failed: %d, devId: %s, dhId: %s", ret,
259 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
260 return ret;
261 }
262 DCameraInfoCmd cmd;
263 ret = cmd.Unmarshal(camInfoJson);
264 if (ret != DCAMERA_OK) {
265 DHLOGE("DCameraInfoCmd Unmarshal failed: %d", ret);
266 return ret;
267 }
268 camInfo = cmd.value_;
269 return DCAMERA_OK;
270 }
271
OpenChannel(std::shared_ptr<DCameraOpenInfo> & openInfo)272 int32_t DCameraSourceController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& openInfo)
273 {
274 if (indexs_.size() > DCAMERA_MAX_NUM) {
275 DHLOGE("OpenChannel not support operate %d camera", indexs_.size());
276 return DCAMERA_BAD_OPERATE;
277 }
278 std::string dhId = indexs_.begin()->dhId_;
279 std::string devId = indexs_.begin()->devId_;
280 DHLOGI("OpenChannel devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
281 GetAnonyString(dhId).c_str());
282 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
283 if (camSinkSrv == nullptr) {
284 DHLOGE("DCameraSourceController can not get service, devId: %s", GetAnonyString(devId).c_str());
285 return DCAMERA_BAD_OPERATE;
286 }
287 std::string jsonStr;
288 DCameraOpenInfoCmd cmd;
289 cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
290 cmd.dhId_ = dhId;
291 cmd.command_ = DCAMERA_PROTOCOL_CMD_OPEN_CHANNEL;
292 cmd.value_ = openInfo;
293 int32_t ret = cmd.Marshal(jsonStr);
294 if (ret != DCAMERA_OK) {
295 DHLOGE("DCameraSourceController Marshal OpenInfo failed %d", ret);
296 return ret;
297 }
298 ret = camSinkSrv->OpenChannel(dhId, jsonStr);
299 if (ret != DCAMERA_OK) {
300 DHLOGE("DCameraSourceController SA OpenChannel failed %d", ret);
301 return ret;
302 }
303 DHLOGD("DCameraSourceController OpenChannel devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
304 GetAnonyString(dhId).c_str());
305
306 std::vector<DCameraIndex> indexs;
307 indexs.push_back(DCameraIndex(devId, dhId));
308 ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener_);
309 if (ret != DCAMERA_OK) {
310 DHLOGE("DCameraSourceController CreateSession failed %d", ret);
311 return ret;
312 }
313 ret = channel_->OpenSession();
314 if (ret != DCAMERA_OK) {
315 DHLOGE("DCameraSourceController OpenSession failed.");
316 PostChannelDisconnectedEvent();
317 return ret;
318 }
319 return WaitforSessionResult(devId);
320 }
321
CloseChannel()322 int32_t DCameraSourceController::CloseChannel()
323 {
324 if (indexs_.size() > DCAMERA_MAX_NUM) {
325 DHLOGE("CloseChannel not support operate %d camera", indexs_.size());
326 return DCAMERA_BAD_OPERATE;
327 }
328 DCameraLowLatency::GetInstance().DisableLowLatency();
329 DCameraSoftbusLatency::GetInstance().StopSoftbusTimeSync(devId_);
330 std::string dhId = indexs_.begin()->dhId_;
331 std::string devId = indexs_.begin()->devId_;
332 DHLOGI("CloseChannel devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
333 GetAnonyString(dhId).c_str());
334 int32_t ret = channel_->CloseSession();
335 if (ret != DCAMERA_OK) {
336 DHLOGE("CloseSession failed %d", ret);
337 }
338 DHLOGI("CloseChannel devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
339 GetAnonyString(dhId).c_str());
340 channelState_ = DCAMERA_CHANNEL_STATE_DISCONNECTED;
341 ret = channel_->ReleaseSession();
342 if (ret != DCAMERA_OK) {
343 DHLOGE("ReleaseSession failed %d", ret);
344 }
345 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
346 if (camSinkSrv != nullptr) {
347 ret = camSinkSrv->CloseChannel(dhId);
348 if (ret != DCAMERA_OK) {
349 DHLOGE("DCameraSourceController SA CloseChannel failed %d", ret);
350 }
351 DCameraSourceServiceIpc::GetInstance().DeleteSinkRemoteCamSrv(devId);
352 }
353 return ret;
354 }
355
Init(std::vector<DCameraIndex> & indexs)356 int32_t DCameraSourceController::Init(std::vector<DCameraIndex>& indexs)
357 {
358 DHLOGI("DCameraSourceController Init");
359 if (indexs.size() > DCAMERA_MAX_NUM) {
360 DHLOGE("DCameraSourceController init error");
361 return DCAMERA_INIT_ERR;
362 }
363 camHdiProvider_ = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
364 if (camHdiProvider_ == nullptr) {
365 DHLOGE("camHdiProvider_ is null.");
366 }
367 indexs_.assign(indexs.begin(), indexs.end());
368 std::string dhId = indexs_.begin()->dhId_;
369 std::string devId = indexs_.begin()->devId_;
370 auto controller = std::shared_ptr<DCameraSourceController>(shared_from_this());
371 listener_ = std::make_shared<DCameraSourceControllerChannelListener>(controller);
372 channel_ = std::make_shared<DCameraChannelSourceImpl>();
373 DHLOGI("DCameraSourceController Init GetProvider end devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
374 GetAnonyString(dhId).c_str());
375 isInit = true;
376 return DCAMERA_OK;
377 }
378
UnInit()379 int32_t DCameraSourceController::UnInit()
380 {
381 DHLOGI("DCameraSourceController UnInit");
382 indexs_.clear();
383 isInit = false;
384 isChannelConnected_.store(false);
385 return DCAMERA_OK;
386 }
387
OnSessionState(int32_t state)388 void DCameraSourceController::OnSessionState(int32_t state)
389 {
390 DHLOGI("DCameraSourceController OnSessionState state %d", state);
391 channelState_ = state;
392 switch (state) {
393 case DCAMERA_CHANNEL_STATE_CONNECTED: {
394 DcameraFinishAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID);
395 isChannelConnected_.store(true);
396 channelCond_.notify_all();
397 stateMachine_->UpdateState(DCAMERA_STATE_OPENED);
398 std::shared_ptr<DCameraSourceDev> camDev = camDev_.lock();
399 if (camDev == nullptr) {
400 DHLOGE("DCameraSourceController OnSessionState camDev is nullptr");
401 break;
402 }
403 camDev->OnChannelConnectedEvent();
404 break;
405 }
406 case DCAMERA_CHANNEL_STATE_DISCONNECTED: {
407 DcameraFinishAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID);
408 DHLOGI("DCameraSourceDev PostTask Controller CloseSession OnClose devId %s dhId %s",
409 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
410 isChannelConnected_.store(false);
411 PostChannelDisconnectedEvent();
412 break;
413 }
414 default: {
415 break;
416 }
417 }
418 }
419
OnSessionError(int32_t eventType,int32_t eventReason,std::string detail)420 void DCameraSourceController::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
421 {
422 DHLOGI("DCameraSourceController OnSessionError devId: %s, dhId: %s, eventType: %d, eventReason: %d, detail %s",
423 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), eventType, eventReason, detail.c_str());
424 return;
425 }
426
OnDataReceived(std::vector<std::shared_ptr<DataBuffer>> & buffers)427 void DCameraSourceController::OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers)
428 {
429 if (buffers.empty()) {
430 DHLOGI("DCameraSourceController OnDataReceived empty, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(),
431 GetAnonyString(dhId_).c_str());
432 return;
433 }
434 std::shared_ptr<DataBuffer> buffer = *(buffers.begin());
435 std::string jsonStr(reinterpret_cast<char *>(buffer->Data()));
436 JSONCPP_STRING errs;
437 Json::CharReaderBuilder readerBuilder;
438 Json::Value rootValue;
439
440 std::unique_ptr<Json::CharReader> const jsonReader(readerBuilder.newCharReader());
441 if (!jsonReader->parse(jsonStr.c_str(), jsonStr.c_str() + jsonStr.length(), &rootValue, &errs) ||
442 !rootValue.isObject()) {
443 return;
444 }
445
446 if (!rootValue.isMember("Command") || !rootValue["Command"].isString()) {
447 return;
448 }
449 std::string command = rootValue["Command"].asString();
450 if (command == DCAMERA_PROTOCOL_CMD_METADATA_RESULT) {
451 HandleMetaDataResult(jsonStr);
452 }
453 return;
454 }
455
HandleMetaDataResult(std::string & jsonStr)456 void DCameraSourceController::HandleMetaDataResult(std::string& jsonStr)
457 {
458 if (camHdiProvider_ == nullptr) {
459 DHLOGI("DCameraSourceController HandleMetaDataResult camHdiProvider is null, devId: %s, dhId: %s",
460 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
461 return;
462 }
463 DCameraMetadataSettingCmd cmd;
464 int32_t ret = cmd.Unmarshal(jsonStr);
465 if (ret != DCAMERA_OK) {
466 DHLOGI("DCameraSourceController HandleMetaDataResult failed, ret: %d, devId: %s, dhId: %s", ret,
467 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
468 return;
469 }
470 DHBase dhBase;
471 dhBase.deviceId_ = devId_;
472 dhBase.dhId_ = dhId_;
473 for (auto iter = cmd.value_.begin(); iter != cmd.value_.end(); iter++) {
474 DCameraSettings setting;
475 setting.type_ = (*iter)->type_;
476 setting.value_ = (*iter)->value_;
477 int32_t retHdi = camHdiProvider_->OnSettingsResult(dhBase, setting);
478 DHLOGI("OnSettingsResult hal, ret: %d, devId: %s dhId: %s", retHdi, GetAnonyString(devId_).c_str(),
479 GetAnonyString(dhId_).c_str());
480 }
481 }
482
WaitforSessionResult(const std::string & devId)483 int32_t DCameraSourceController::WaitforSessionResult(const std::string& devId)
484 {
485 isChannelConnected_.store(false);
486 std::unique_lock<std::mutex> lck(channelMtx_);
487 DHLOGD("wait for channel session callback notify.");
488 bool isChannelConnected = channelCond_.wait_for(lck, std::chrono::seconds(CHANNEL_REL_SECONDS),
489 [this]() { return isChannelConnected_.load(); });
490 if (!isChannelConnected) {
491 DHLOGE("wait for channel session callback timeout(%ds).",
492 CHANNEL_REL_SECONDS);
493 PostChannelDisconnectedEvent();
494 return DCAMERA_BAD_VALUE;
495 }
496 DCameraLowLatency::GetInstance().EnableLowLatency();
497 DCameraSoftbusLatency::GetInstance().StartSoftbusTimeSync(devId);
498 return DCAMERA_OK;
499 }
500
PostChannelDisconnectedEvent()501 void DCameraSourceController::PostChannelDisconnectedEvent()
502 {
503 std::shared_ptr<DCameraSourceDev> camDev = camDev_.lock();
504 if (camDev == nullptr) {
505 DHLOGE("DCameraSourceController PostChannelDisconnectedEvent camDev is nullptr");
506 return;
507 }
508 camDev->OnChannelDisconnectedEvent();
509 }
510 } // namespace DistributedHardware
511 } // namespace OHOS
512