1 /*
2 * Copyright (c) 2021-2022 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_source_controller_channel_listener.h"
27 #include "dcamera_source_service_ipc.h"
28 #include "dcamera_utils_tools.h"
29
30 #include "distributed_camera_constants.h"
31 #include "distributed_camera_errno.h"
32 #include "distributed_hardware_log.h"
33 #include "idistributed_camera_sink.h"
34
35 namespace OHOS {
36 namespace DistributedHardware {
DCameraSourceController(std::string devId,std::string dhId,std::shared_ptr<DCameraSourceStateMachine> & stateMachine,std::shared_ptr<EventBus> & eventBus)37 DCameraSourceController::DCameraSourceController(std::string devId, std::string dhId,
38 std::shared_ptr<DCameraSourceStateMachine>& stateMachine, std::shared_ptr<EventBus>& eventBus)
39 : devId_(devId), dhId_(dhId), stateMachine_(stateMachine), eventBus_(eventBus),
40 channelState_(DCAMERA_CHANNEL_STATE_DISCONNECTED)
41 {
42 DHLOGI("DCameraSourceController create devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
43 GetAnonyString(dhId_).c_str());
44 isInit = false;
45 }
46
~DCameraSourceController()47 DCameraSourceController::~DCameraSourceController()
48 {
49 DHLOGI("DCameraSourceController delete devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
50 GetAnonyString(dhId_).c_str());
51 if (isInit) {
52 UnInit();
53 }
54 camHdiProvider_ = nullptr;
55 }
56
StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos)57 int32_t DCameraSourceController::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos)
58 {
59 if (indexs_.size() > DCAMERA_MAX_NUM) {
60 DHLOGE("DCameraSourceController StartCapture not support operate %d camera", indexs_.size());
61 return DCAMERA_BAD_OPERATE;
62 }
63
64 std::string dhId = indexs_.begin()->dhId_;
65 std::string devId = indexs_.begin()->devId_;
66 DHLOGI("DCameraSourceController StartCapture devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
67 GetAnonyString(dhId).c_str());
68 DCameraCaptureInfoCmd cmd;
69 cmd.type_ = DCAMERA_PROTOCOL_TYPE_OPERATION;
70 cmd.dhId_ = dhId;
71 cmd.command_ = DCAMERA_PROTOCOL_CMD_CAPTURE;
72 cmd.value_.assign(captureInfos.begin(), captureInfos.end());
73 std::string jsonStr;
74 int32_t ret = cmd.Marshal(jsonStr);
75 if (ret != DCAMERA_OK) {
76 DHLOGE("DCameraSourceController StartCapture Marshal failed %d, devId: %s, dhId: %s", ret,
77 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
78 return ret;
79 }
80 DHLOGI("DCameraSourceController StartCapture devId: %s, dhId: %s captureCommand: %s", GetAnonyString(devId).c_str(),
81 GetAnonyString(dhId).c_str(), cmd.command_.c_str());
82 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
83 ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())),
84 jsonStr.length());
85 if (ret != EOK) {
86 DHLOGE("DCameraSourceController StartCapture memcpy_s failed %d, devId: %s, dhId: %s", ret,
87 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
88 return ret;
89 }
90 ret = channel_->SendData(buffer);
91 if (ret != DCAMERA_OK) {
92 DHLOGE("DCameraSourceController StartCapture SendData failed %d, devId: %s, dhId: %s", ret,
93 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
94 return ret;
95 }
96 DHLOGI("DCameraSourceController StartCapture devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
97 GetAnonyString(dhId).c_str());
98 return DCAMERA_OK;
99 }
100
StopCapture()101 int32_t DCameraSourceController::StopCapture()
102 {
103 if (indexs_.size() > DCAMERA_MAX_NUM) {
104 DHLOGE("DCameraSourceController StopCapture not support operate %d camera", indexs_.size());
105 return DCAMERA_BAD_OPERATE;
106 }
107
108 std::string dhId = indexs_.begin()->dhId_;
109 std::string devId = indexs_.begin()->devId_;
110 DHLOGI("DCameraSourceController StopCapture devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
111 GetAnonyString(dhId).c_str());
112 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
113 if (camSinkSrv == nullptr) {
114 DHLOGE("DCameraSourceController StopCapture 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("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController ChannelNeg 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("DCameraSourceController ChannelNeg Marshal failed ret: %d, devId: %s, dhId: %s", ret,
153 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
154 return ret;
155 }
156 DHLOGD("DCameraSourceController ChannelNeg 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("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController UpdateSettings 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("DCameraSourceController UpdateSettings 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("DCameraSourceController UpdateSettings SendData failed %d, devId: %s, dhId: %s", ret,
231 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
232 return ret;
233 }
234 DHLOGI("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController 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("DCameraSourceController GetCameraInfo 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("DCameraSourceController GetCameraInfo 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("DCameraSourceController GetCameraInfo 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("DCameraSourceController 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("DCameraSourceController 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
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 std::string jsonStr;
294 int32_t ret = cmd.Marshal(jsonStr);
295 if (ret != DCAMERA_OK) {
296 DHLOGE("DCameraSourceController Marshal OpenInfo failed %d", ret);
297 return ret;
298 }
299 DHLOGD("DCameraSourceController OpenChannel devId: %s, dhId: %s openCommand: %s", GetAnonyString(devId).c_str(),
300 GetAnonyString(dhId).c_str(), cmd.command_.c_str());
301 ret = camSinkSrv->OpenChannel(dhId, jsonStr);
302 if (ret != DCAMERA_OK) {
303 DHLOGE("DCameraSourceController SA OpenChannel failed %d", ret);
304 return ret;
305 }
306 DHLOGD("DCameraSourceController OpenChannel devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
307 GetAnonyString(dhId).c_str());
308
309 std::vector<DCameraIndex> indexs;
310 indexs.push_back(DCameraIndex(devId, dhId));
311 ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener_);
312 if (ret != DCAMERA_OK) {
313 DHLOGE("DCameraSourceController CreateSession failed %d", ret);
314 return ret;
315 }
316 ret = channel_->OpenSession();
317 if (ret != DCAMERA_OK) {
318 DHLOGE("DCameraSourceController OpenChannel OpenChannel failed %d", ret);
319 return ret;
320 }
321
322 return DCAMERA_OK;
323 }
324
CloseChannel()325 int32_t DCameraSourceController::CloseChannel()
326 {
327 if (indexs_.size() > DCAMERA_MAX_NUM) {
328 DHLOGE("DCameraSourceController CloseChannel not support operate %d camera", indexs_.size());
329 return DCAMERA_BAD_OPERATE;
330 }
331
332 std::string dhId = indexs_.begin()->dhId_;
333 std::string devId = indexs_.begin()->devId_;
334 DHLOGI("DCameraSourceController CloseChannel devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
335 GetAnonyString(dhId).c_str());
336 int32_t ret = channel_->CloseSession();
337 if (ret != DCAMERA_OK) {
338 DHLOGE("DCameraSourceController CloseChannel CloseSession failed %d", ret);
339 }
340 DHLOGI("DCameraSourceController CloseChannel devId: %s, dhId: %s success", GetAnonyString(devId).c_str(),
341 GetAnonyString(dhId).c_str());
342 channelState_ = DCAMERA_CHANNEL_STATE_DISCONNECTED;
343 ret = channel_->ReleaseSession();
344 if (ret != DCAMERA_OK) {
345 DHLOGE("DCameraSourceController CloseChannel ReleaseSession failed %d", ret);
346 }
347 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
348 if (camSinkSrv != nullptr) {
349 ret = camSinkSrv->CloseChannel(dhId);
350 if (ret != DCAMERA_OK) {
351 DHLOGE("DCameraSourceController SA CloseChannel failed %d", ret);
352 }
353 DCameraSourceServiceIpc::GetInstance().DeleteSinkRemoteCamSrv(devId);
354 }
355 return ret;
356 }
357
Init(std::vector<DCameraIndex> & indexs)358 int32_t DCameraSourceController::Init(std::vector<DCameraIndex>& indexs)
359 {
360 DHLOGI("DCameraSourceController Init");
361 if (indexs.size() > DCAMERA_MAX_NUM) {
362 DHLOGE("DCameraSourceController init error");
363 return DCAMERA_INIT_ERR;
364 }
365 camHdiProvider_ = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
366 if (camHdiProvider_ == nullptr) {
367 DHLOGE("camHdiProvider_ is null.");
368 }
369 indexs_.assign(indexs.begin(), indexs.end());
370 std::string dhId = indexs_.begin()->dhId_;
371 std::string devId = indexs_.begin()->devId_;
372 auto controller = std::shared_ptr<DCameraSourceController>(shared_from_this());
373 listener_ = std::make_shared<DCameraSourceControllerChannelListener>(controller);
374 channel_ = std::make_shared<DCameraChannelSourceImpl>();
375 DHLOGI("DCameraSourceController Init GetProvider end devId: %s, dhId: %s", GetAnonyString(devId).c_str(),
376 GetAnonyString(dhId).c_str());
377 isInit = true;
378 return DCAMERA_OK;
379 }
380
UnInit()381 int32_t DCameraSourceController::UnInit()
382 {
383 DHLOGI("DCameraSourceController UnInit");
384 indexs_.clear();
385 isInit = false;
386 return DCAMERA_OK;
387 }
388
OnSessionState(int32_t state)389 void DCameraSourceController::OnSessionState(int32_t state)
390 {
391 DHLOGI("DCameraSourceController OnSessionState state %d", state);
392 channelState_ = state;
393 switch (state) {
394 case DCAMERA_CHANNEL_STATE_CONNECTED: {
395 DcameraFinishAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID);
396 stateMachine_->UpdateState(DCAMERA_STATE_OPENED);
397 std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
398 camEvent->eventType_ = DCAMERA_MESSAGE;
399 camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_CONNECTED;
400 DCameraSourceEvent event(*this, DCAMERA_EVENT_NOFIFY, camEvent);
401 eventBus_->PostEvent<DCameraSourceEvent>(event);
402 break;
403 }
404 case DCAMERA_CHANNEL_STATE_DISCONNECTED: {
405 DcameraFinishAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID);
406 DHLOGI("DCameraSourceDev PostTask Controller CloseSession OnClose devId %s dhId %s",
407 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
408 DCameraIndex camIndex(devId_, dhId_);
409 DCameraSourceEvent event(*this, DCAMERA_EVENT_CLOSE, camIndex);
410 eventBus_->PostEvent<DCameraSourceEvent>(event);
411 std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
412 camEvent->eventType_ = DCAMERA_MESSAGE;
413 camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
414 DCameraSourceEvent eventNotify(*this, DCAMERA_EVENT_NOFIFY, camEvent);
415 eventBus_->PostEvent<DCameraSourceEvent>(eventNotify);
416 break;
417 }
418 default: {
419 break;
420 }
421 }
422 }
423
OnSessionError(int32_t eventType,int32_t eventReason,std::string detail)424 void DCameraSourceController::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
425 {
426 DHLOGI("DCameraSourceController OnSessionError devId: %s, dhId: %s, eventType: %d, eventReason: %d, detail %s",
427 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), eventType, eventReason, detail.c_str());
428 return;
429 }
430
OnDataReceived(std::vector<std::shared_ptr<DataBuffer>> & buffers)431 void DCameraSourceController::OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers)
432 {
433 if (buffers.empty()) {
434 DHLOGI("DCameraSourceController OnDataReceived empty, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(),
435 GetAnonyString(dhId_).c_str());
436 return;
437 }
438 std::shared_ptr<DataBuffer> buffer = *(buffers.begin());
439 std::string jsonStr(reinterpret_cast<char *>(buffer->Data()));
440 JSONCPP_STRING errs;
441 Json::CharReaderBuilder readerBuilder;
442 Json::Value rootValue;
443
444 std::unique_ptr<Json::CharReader> const jsonReader(readerBuilder.newCharReader());
445 if (!jsonReader->parse(jsonStr.c_str(), jsonStr.c_str() + jsonStr.length(), &rootValue, &errs) ||
446 !rootValue.isObject()) {
447 return;
448 }
449
450 if (!rootValue.isMember("Command") || !rootValue["Command"].isString()) {
451 return;
452 }
453 std::string command = rootValue["Command"].asString();
454 if (command == DCAMERA_PROTOCOL_CMD_METADATA_RESULT) {
455 HandleMetaDataResult(jsonStr);
456 }
457 return;
458 }
459
HandleMetaDataResult(std::string & jsonStr)460 void DCameraSourceController::HandleMetaDataResult(std::string& jsonStr)
461 {
462 if (camHdiProvider_ == nullptr) {
463 DHLOGI("DCameraSourceController HandleMetaDataResult camHdiProvider is null, devId: %s, dhId: %s",
464 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
465 return;
466 }
467 DCameraMetadataSettingCmd cmd;
468 int32_t ret = cmd.Unmarshal(jsonStr);
469 if (ret != DCAMERA_OK) {
470 DHLOGI("DCameraSourceController HandleMetaDataResult failed, ret: %d, devId: %s, dhId: %s", ret,
471 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
472 return;
473 }
474 DHBase dhBase;
475 dhBase.deviceId_ = devId_;
476 dhBase.dhId_ = dhId_;
477 for (auto iter = cmd.value_.begin(); iter != cmd.value_.end(); iter++) {
478 DCameraSettings setting;
479 setting.type_ = (*iter)->type_;
480 setting.value_ = (*iter)->value_;
481 int32_t retHdi = camHdiProvider_->OnSettingsResult(dhBase, setting);
482 DHLOGI("OnSettingsResult hal, ret: %d, devId: %s dhId: %s", retHdi, GetAnonyString(devId_).c_str(),
483 GetAnonyString(dhId_).c_str());
484 }
485 }
486 } // namespace DistributedHardware
487 } // namespace OHOS
488