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 "dcamera_source_controller.h"
17
18 #include <securec.h>
19 #include <cstdlib>
20 #include "iservice_registry.h"
21 #include "iservmgr_hdi.h"
22 #include "iproxy_broker.h"
23
24 #include "anonymous_string.h"
25 #include "dcamera_capture_info_cmd.h"
26 #include "dcamera_channel_source_impl.h"
27 #include "dcamera_hitrace_adapter.h"
28 #include "dcamera_metadata_setting_cmd.h"
29 #include "dcamera_protocol.h"
30 #include "dcamera_radar.h"
31 #include "dcamera_softbus_latency.h"
32 #include "dcamera_source_controller_channel_listener.h"
33 #include "dcamera_source_service_ipc.h"
34 #include "dcamera_utils_tools.h"
35
36 #include "distributed_camera_constants.h"
37 #include "distributed_camera_errno.h"
38 #include "distributed_hardware_log.h"
39 #include "idistributed_camera_sink.h"
40 #include "dcamera_low_latency.h"
41
42 namespace OHOS {
43 namespace DistributedHardware {
DCameraSourceController(std::string devId,std::string dhId,std::shared_ptr<DCameraSourceStateMachine> & stateMachine,std::shared_ptr<DCameraSourceDev> & camDev)44 DCameraSourceController::DCameraSourceController(std::string devId, std::string dhId,
45 std::shared_ptr<DCameraSourceStateMachine>& stateMachine, std::shared_ptr<DCameraSourceDev>& camDev)
46 : devId_(devId), dhId_(dhId), stateMachine_(stateMachine), camDev_(camDev),
47 channelState_(DCAMERA_CHANNEL_STATE_DISCONNECTED)
48 {
49 DHLOGI("DCameraSourceController create devId: %{public}s dhId: %{public}s", GetAnonyString(devId_).c_str(),
50 GetAnonyString(dhId_).c_str());
51 isInit = false;
52 cameraHdiRecipient_ = sptr<DCameraHdiRecipient>(new DCameraHdiRecipient());
53 }
54
~DCameraSourceController()55 DCameraSourceController::~DCameraSourceController()
56 {
57 DHLOGI("DCameraSourceController delete devId: %{public}s dhId: %{public}s", GetAnonyString(devId_).c_str(),
58 GetAnonyString(dhId_).c_str());
59 if (isInit) {
60 UnInit();
61 }
62 camHdiProvider_ = nullptr;
63 }
64
StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>> & captureInfos,int32_t sceneMode)65 int32_t DCameraSourceController::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos,
66 int32_t sceneMode)
67 {
68 if (indexs_.size() > DCAMERA_MAX_NUM) {
69 DHLOGE("StartCapture not support operate %{public}zu camera", indexs_.size());
70 return DCAMERA_BAD_OPERATE;
71 }
72
73 std::string dhId = indexs_.begin()->dhId_;
74 std::string devId = indexs_.begin()->devId_;
75 DHLOGI("StartCapture devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
76 GetAnonyString(dhId).c_str());
77 DCameraCaptureInfoCmd cmd;
78 cmd.type_ = DCAMERA_PROTOCOL_TYPE_OPERATION;
79 cmd.dhId_ = dhId;
80 cmd.command_ = DCAMERA_PROTOCOL_CMD_CAPTURE;
81 cmd.value_.assign(captureInfos.begin(), captureInfos.end());
82 cmd.sceneMode_ = sceneMode;
83 std::string jsonStr;
84 int32_t ret = cmd.Marshal(jsonStr);
85 if (ret != DCAMERA_OK) {
86 DHLOGE("Marshal failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
87 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
88 return ret;
89 }
90 DHLOGI("devId: %{public}s, dhId: %{public}s captureCommand: %{public}s", GetAnonyString(devId).c_str(),
91 GetAnonyString(dhId).c_str(), cmd.command_.c_str());
92 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
93 ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())),
94 jsonStr.length());
95 if (ret != EOK) {
96 DHLOGE("memcpy_s failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
97 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
98 return ret;
99 }
100 CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "channel_ is null.");
101 ret = channel_->SendData(buffer);
102 if (ret != DCAMERA_OK) {
103 DHLOGE("SendData failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
104 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
105 return ret;
106 }
107 DHLOGI("StartCapture devId: %{public}s, dhId: %{public}s success", GetAnonyString(devId).c_str(),
108 GetAnonyString(dhId).c_str());
109 return DCAMERA_OK;
110 }
111
StopCapture()112 int32_t DCameraSourceController::StopCapture()
113 {
114 if (indexs_.size() > DCAMERA_MAX_NUM) {
115 DHLOGE("StopCapture not support operate %{public}zu camera", indexs_.size());
116 return DCAMERA_BAD_OPERATE;
117 }
118
119 std::string dhId = indexs_.begin()->dhId_;
120 std::string devId = indexs_.begin()->devId_;
121 DHLOGI("StopCapture devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
122 GetAnonyString(dhId).c_str());
123 if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
124 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
125 CHECK_AND_RETURN_RET_LOG(camSinkSrv == nullptr, DCAMERA_BAD_VALUE, "stopCapture can not get sink service");
126 int32_t ret = camSinkSrv->StopCapture(dhId);
127 if (ret != DCAMERA_OK) {
128 DHLOGE("StopCapture failed: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
129 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
130 return DCAMERA_BAD_OPERATE;
131 }
132 } else {
133 cJSON *rootValue = cJSON_CreateObject();
134 if (rootValue == nullptr) {
135 return DCAMERA_BAD_VALUE;
136 }
137 cJSON_AddStringToObject(rootValue, "Command", DCAMERA_PROTOCOL_CMD_STOP_CAPTURE.c_str());
138 char *data = cJSON_Print(rootValue);
139 if (data == nullptr) {
140 cJSON_Delete(rootValue);
141 return DCAMERA_BAD_VALUE;
142 }
143 std::string jsonStr = std::string(data);
144 cJSON_Delete(rootValue);
145 cJSON_free(data);
146 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
147 int32_t ret = memcpy_s(buffer->Data(), buffer->Capacity(),
148 reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())), jsonStr.length());
149 CHECK_AND_RETURN_RET_LOG(ret != EOK, ret, "StopCapture memcpy_s failed ret: %{public}d", ret);
150 CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "channel_ is null.");
151 ret = channel_->SendData(buffer);
152 if (ret != DCAMERA_OK) {
153 DHLOGE("StopCapture SendData failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
154 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
155 return ret;
156 }
157 }
158 DHLOGI("StopCapture devId: %{public}s, dhId: %{public}s success", GetAnonyString(devId).c_str(),
159 GetAnonyString(dhId).c_str());
160 return DCAMERA_OK;
161 }
162
ChannelNeg(std::shared_ptr<DCameraChannelInfo> & info)163 int32_t DCameraSourceController::ChannelNeg(std::shared_ptr<DCameraChannelInfo>& info)
164 {
165 if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
166 if (indexs_.size() > DCAMERA_MAX_NUM) {
167 DHLOGE("ChannelNeg not support operate %{public}zu camera", indexs_.size());
168 return DCAMERA_BAD_OPERATE;
169 }
170
171 std::string dhId = indexs_.begin()->dhId_;
172 std::string devId = indexs_.begin()->devId_;
173 DHLOGI("ChannelNeg devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
174 GetAnonyString(dhId).c_str());
175 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
176 if (camSinkSrv == nullptr) {
177 DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
178 return DCAMERA_BAD_OPERATE;
179 }
180 DCameraChannelInfoCmd cmd;
181 cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
182 cmd.dhId_ = dhId;
183 cmd.command_ = DCAMERA_PROTOCOL_CMD_CHAN_NEG;
184 cmd.value_ = info;
185 std::string jsonStr;
186 int32_t ret = cmd.Marshal(jsonStr);
187 if (ret != DCAMERA_OK) {
188 DHLOGE("Marshal failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
189 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
190 return ret;
191 }
192 DHLOGD("devId: %{public}s, dhId: %{public}s channelNegCommand: %{public}s",
193 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), cmd.command_.c_str());
194 ret = camSinkSrv->ChannelNeg(dhId, jsonStr);
195 if (ret != DCAMERA_OK) {
196 DHLOGE("ChannelNeg rpc failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
197 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
198 return ret;
199 }
200 DHLOGD("DCameraSourceController ChannelNeg devId: %{public}s, dhId: %{public}s success",
201 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
202 }
203 return DCAMERA_OK;
204 }
205
DCameraNotify(std::shared_ptr<DCameraEvent> & events)206 int32_t DCameraSourceController::DCameraNotify(std::shared_ptr<DCameraEvent>& events)
207 {
208 if (events->eventResult_ == DCAMERA_EVENT_CAMERA_SUCCESS &&
209 events->eventContent_ == START_CAPTURE_SUCC) {
210 DcameraRadar::GetInstance().ReportDcameraOpen("StartCapture", CameraOpen::START_CAPTURE,
211 BizState::BIZ_STATE_END, DCAMERA_OK);
212 }
213
214 if (events->eventResult_ == DCAMERA_EVENT_CAMERA_ERROR) {
215 DcameraFinishAsyncTrace(DCAMERA_CONTINUE_FIRST_FRAME, DCAMERA_CONTINUE_FIRST_FRAME_TASKID);
216 DcameraFinishAsyncTrace(DCAMERA_SNAPSHOT_FIRST_FRAME, DCAMERA_SNAPSHOT_FIRST_FRAME_TASKID);
217 }
218 if (camHdiProvider_ == nullptr) {
219 DHLOGI("DCameraNotify camHdiProvider is nullptr devId: %{public}s dhId: %{public}s",
220 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
221 return DCAMERA_BAD_OPERATE;
222 }
223 DHBase dhBase;
224 dhBase.deviceId_ = devId_;
225 dhBase.dhId_ = dhId_;
226 if (events->eventType_ == DCAMERA_SINK_STOP && events->eventResult_ == DCAMERA_EVENT_SINK_STOP) {
227 events->eventType_ = DCAMERA_OPERATION;
228 events->eventResult_ = DCAMERA_EVENT_DEVICE_ERROR;
229 }
230 DCameraHDFEvent hdiEvent;
231 hdiEvent.type_ = events->eventType_;
232 hdiEvent.result_ = events->eventResult_;
233 hdiEvent.content_ = events->eventContent_;
234 int32_t retHdi = camHdiProvider_->Notify(dhBase, hdiEvent);
235 DHLOGI("Nofify hal, ret: %{public}d, devId: %{public}s dhId: %{public}s, type: %{public}d, result: %{public}d, "
236 "content: %{public}s", retHdi, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
237 events->eventType_, events->eventResult_, events->eventContent_.c_str());
238 if (retHdi != SUCCESS) {
239 return DCAMERA_BAD_OPERATE;
240 }
241 return DCAMERA_OK;
242 }
243
UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>> & settings)244 int32_t DCameraSourceController::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
245 {
246 if (indexs_.size() > DCAMERA_MAX_NUM) {
247 DHLOGE("UpdateSettings not support operate %{public}zu camera", indexs_.size());
248 return DCAMERA_BAD_OPERATE;
249 }
250
251 std::string dhId = indexs_.begin()->dhId_;
252 std::string devId = indexs_.begin()->devId_;
253 DHLOGI("UpdateSettings devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
254 GetAnonyString(dhId).c_str());
255 DCameraMetadataSettingCmd cmd;
256 cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
257 cmd.dhId_ = dhId;
258 cmd.command_ = DCAMERA_PROTOCOL_CMD_UPDATE_METADATA;
259 cmd.value_.assign(settings.begin(), settings.end());
260 std::string jsonStr;
261 int32_t ret = cmd.Marshal(jsonStr);
262 if (ret != DCAMERA_OK) {
263 DHLOGE("Marshal failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
264 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
265 return ret;
266 }
267 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
268 ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())),
269 jsonStr.length());
270 if (ret != EOK) {
271 DHLOGE("memcpy_s failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
272 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
273 return ret;
274 }
275 CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "channel_ is null.");
276 ret = channel_->SendData(buffer);
277 if (ret != DCAMERA_OK) {
278 DHLOGE("SendData failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
279 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
280 return ret;
281 }
282 DHLOGI("UpdateSettings devId: %{public}s, dhId: %{public}s success", GetAnonyString(devId).c_str(),
283 GetAnonyString(dhId).c_str());
284 return DCAMERA_OK;
285 }
286
GetCameraInfo(std::shared_ptr<DCameraInfo> & camInfo)287 int32_t DCameraSourceController::GetCameraInfo(std::shared_ptr<DCameraInfo>& camInfo)
288 {
289 if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
290 if (indexs_.size() > DCAMERA_MAX_NUM) {
291 DHLOGE("GetCameraInfo not support operate %{public}zu camera", indexs_.size());
292 return DCAMERA_BAD_OPERATE;
293 }
294
295 std::string dhId = indexs_.begin()->dhId_;
296 std::string devId = indexs_.begin()->devId_;
297 DHLOGI("GetCameraInfo devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
298 GetAnonyString(dhId).c_str());
299 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
300 if (camSinkSrv == nullptr) {
301 DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
302 return DCAMERA_BAD_OPERATE;
303 }
304 std::string camInfoJson;
305 int32_t ret = camSinkSrv->GetCameraInfo(dhId, camInfoJson);
306 if (ret != DCAMERA_OK) {
307 DHLOGE("GetCameraInfo failed: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
308 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
309 return ret;
310 }
311 DCameraInfoCmd cmd;
312 ret = cmd.Unmarshal(camInfoJson);
313 if (ret != DCAMERA_OK) {
314 DHLOGE("DCameraInfoCmd Unmarshal failed: %{public}d", ret);
315 return ret;
316 }
317 camInfo = cmd.value_;
318 }
319 return DCAMERA_OK;
320 }
321
OpenChannel(std::shared_ptr<DCameraOpenInfo> & openInfo)322 int32_t DCameraSourceController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& openInfo)
323 {
324 if (indexs_.size() > DCAMERA_MAX_NUM) {
325 DHLOGE("OpenChannel not support operate %{public}zu camera", indexs_.size());
326 return DCAMERA_BAD_OPERATE;
327 }
328 std::string dhId = indexs_.begin()->dhId_;
329 std::string devId = indexs_.begin()->devId_;
330 DHLOGI("DCameraSourceController OpenChannel Start, devId: %{public}s, dhId: %{public}s",
331 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
332 if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
333 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
334 if (camSinkSrv == nullptr) {
335 DHLOGE("DCameraSourceController can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
336 return DCAMERA_BAD_OPERATE;
337 }
338 std::string jsonStr;
339 DCameraOpenInfoCmd cmd;
340 cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
341 cmd.dhId_ = dhId;
342 cmd.command_ = DCAMERA_PROTOCOL_CMD_OPEN_CHANNEL;
343 cmd.value_ = openInfo;
344 int32_t ret = cmd.Marshal(jsonStr);
345 if (ret != DCAMERA_OK) {
346 DHLOGE("DCameraSourceController Marshal OpenInfo failed %{public}d", ret);
347 return ret;
348 }
349 ret = camSinkSrv->OpenChannel(dhId, jsonStr);
350 if (ret != DCAMERA_OK) {
351 DHLOGE("DCameraSourceController SA OpenChannel failed %{public}d", ret);
352 return ret;
353 }
354 DHLOGD("DCameraSourceController OpenChannel devId: %{public}s, dhId: %{public}s success",
355 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
356 }
357
358 std::vector<DCameraIndex> indexs;
359 indexs.push_back(DCameraIndex(devId, dhId));
360 CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "OpenChannel channel_ is null.");
361 int32_t ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener_);
362 if (ret != DCAMERA_OK) {
363 DHLOGE("DCameraSourceController Bind Socket failed, ret: %{public}d", ret);
364 PostChannelDisconnectedEvent();
365 return ret;
366 }
367 return PublishEnableLatencyMsg(devId);
368 }
369
CloseChannel()370 int32_t DCameraSourceController::CloseChannel()
371 {
372 if (indexs_.size() > DCAMERA_MAX_NUM) {
373 DHLOGE("CloseChannel not support operate %{public}zu camera", indexs_.size());
374 return DCAMERA_BAD_OPERATE;
375 }
376 DCameraLowLatency::GetInstance().DisableLowLatency();
377 DCameraSoftbusLatency::GetInstance().StopSoftbusTimeSync(devId_);
378 std::string dhId = indexs_.begin()->dhId_;
379 std::string devId = indexs_.begin()->devId_;
380 DHLOGI("DCameraSourceController CloseChannel Start, devId: %{public}s, dhId: %{public}s",
381 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
382 CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "CloseChannel channel_ is null.");
383 int32_t ret = channel_->CloseSession();
384 if (ret != DCAMERA_OK) {
385 DHLOGE("CloseSession failed %{public}d", ret);
386 }
387 DHLOGI("DCameraSourceController CloseChannel devId: %{public}s, dhId: %{public}s success",
388 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
389 channelState_ = DCAMERA_CHANNEL_STATE_DISCONNECTED;
390 ret = channel_->ReleaseSession();
391 if (ret != DCAMERA_OK) {
392 DHLOGE("ReleaseSession failed %{public}d", ret);
393 }
394 if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
395 sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
396 if (camSinkSrv != nullptr) {
397 ret = camSinkSrv->CloseChannel(dhId);
398 if (ret != DCAMERA_OK) {
399 DHLOGE("DCameraSourceController SA CloseChannel failed %{public}d", ret);
400 }
401 DCameraSourceServiceIpc::GetInstance().DeleteSinkRemoteCamSrv(devId);
402 }
403 }
404 return ret;
405 }
406
Init(std::vector<DCameraIndex> & indexs)407 int32_t DCameraSourceController::Init(std::vector<DCameraIndex>& indexs)
408 {
409 DHLOGI("DCameraSourceController Init");
410 if (indexs.size() > DCAMERA_MAX_NUM) {
411 DHLOGE("DCameraSourceController init error");
412 return DCAMERA_INIT_ERR;
413 }
414 camHdiProvider_ = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
415 if (camHdiProvider_ == nullptr) {
416 DHLOGE("camHdiProvider_ is null.");
417 return DCAMERA_INIT_ERR;
418 }
419 remote_ = OHOS::HDI::hdi_objcast<IDCameraProvider>(camHdiProvider_);
420 if (remote_ != nullptr) {
421 remote_->AddDeathRecipient(cameraHdiRecipient_);
422 }
423
424 indexs_.assign(indexs.begin(), indexs.end());
425 std::string dhId = indexs_.begin()->dhId_;
426 std::string devId = indexs_.begin()->devId_;
427 auto controller = std::shared_ptr<DCameraSourceController>(shared_from_this());
428 listener_ = std::make_shared<DCameraSourceControllerChannelListener>(controller);
429 channel_ = std::make_shared<DCameraChannelSourceImpl>();
430 DHLOGI("DCameraSourceController Init GetProvider end devId: %{public}s, dhId: %{public}s",
431 GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
432 isInit = true;
433 return DCAMERA_OK;
434 }
435
UnInit()436 int32_t DCameraSourceController::UnInit()
437 {
438 DHLOGI("DCameraSourceController UnInit");
439 indexs_.clear();
440 isInit = false;
441 isChannelConnected_.store(false);
442 if (remote_ != nullptr) {
443 remote_->RemoveDeathRecipient(cameraHdiRecipient_);
444 }
445 return DCAMERA_OK;
446 }
447
OnSessionState(int32_t state,std::string networkId)448 void DCameraSourceController::OnSessionState(int32_t state, std::string networkId)
449 {
450 DHLOGI("DCameraSourceController OnSessionState state %{public}d", state);
451 channelState_ = state;
452 switch (state) {
453 case DCAMERA_CHANNEL_STATE_CONNECTED: {
454 DcameraFinishAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID);
455 isChannelConnected_.store(true);
456 stateMachine_->UpdateState(DCAMERA_STATE_OPENED);
457 std::shared_ptr<DCameraSourceDev> camDev = camDev_.lock();
458 if (camDev == nullptr) {
459 DHLOGE("DCameraSourceController OnSessionState camDev is nullptr");
460 break;
461 }
462 camDev->OnChannelConnectedEvent();
463 break;
464 }
465 case DCAMERA_CHANNEL_STATE_DISCONNECTED: {
466 DcameraFinishAsyncTrace(DCAMERA_OPEN_CHANNEL_CONTROL, DCAMERA_OPEN_CHANNEL_TASKID);
467 DHLOGI("DCameraSourceDev PostTask Controller CloseSession OnClose devId %{public}s dhId %{public}s",
468 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
469 isChannelConnected_.store(false);
470 PostChannelDisconnectedEvent();
471 break;
472 }
473 default: {
474 break;
475 }
476 }
477 }
478
OnSessionError(int32_t eventType,int32_t eventReason,std::string detail)479 void DCameraSourceController::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
480 {
481 DHLOGI("DCameraSourceController OnSessionError devId: %{public}s, dhId: %{public}s, eventType: %{public}d, "
482 "eventReason: %{public}d, detail %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
483 eventType, eventReason, detail.c_str());
484 return;
485 }
486
OnDataReceived(std::vector<std::shared_ptr<DataBuffer>> & buffers)487 void DCameraSourceController::OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers)
488 {
489 for (auto& buffer : buffers) {
490 if (buffer->Size() <= 0 || buffer->Size() > DATABUFF_MAX_SIZE) {
491 DHLOGI("buffer is invalid");
492 return;
493 }
494 HandleReceivedData(buffer);
495 }
496 }
497
HandleReceivedData(std::shared_ptr<DataBuffer> & dataBuffer)498 void DCameraSourceController::HandleReceivedData(std::shared_ptr<DataBuffer>& dataBuffer)
499 {
500 DHLOGI("DCameraSourceController::HandleReceivedData dhId: %{public}s", GetAnonyString(dhId_).c_str());
501 uint8_t *data = dataBuffer->Data();
502 std::string jsonStr(reinterpret_cast<const char *>(data), dataBuffer->Capacity());
503 cJSON *rootValue = cJSON_Parse(jsonStr.c_str());
504 if (rootValue == nullptr) {
505 return;
506 }
507 cJSON *comvalue = cJSON_GetObjectItemCaseSensitive(rootValue, "Command");
508 if (comvalue == nullptr || !cJSON_IsString(comvalue) || (comvalue->valuestring == nullptr)) {
509 cJSON_Delete(rootValue);
510 DHLOGE("parse command failed");
511 return;
512 }
513 std::string command = std::string(comvalue->valuestring);
514 cJSON_Delete(rootValue);
515 if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_METADATA_RESULT) == 0)) {
516 HandleMetaDataResult(jsonStr);
517 } else if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_STATE_NOTIFY) == 0)) {
518 DCameraEventCmd cmd;
519 int32_t ret = cmd.Unmarshal(jsonStr);
520 if (ret != DCAMERA_OK) {
521 DHLOGE("DCameraSourceController Unmarshal failed, ret: %{public}d, devId: %{public}s, "
522 "dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
523 return;
524 }
525 DCameraNotify(cmd.value_);
526 }
527 }
528
HandleMetaDataResult(std::string & jsonStr)529 void DCameraSourceController::HandleMetaDataResult(std::string& jsonStr)
530 {
531 if (camHdiProvider_ == nullptr) {
532 DHLOGI("DCameraSourceController HandleMetaDataResult camHdiProvider is null, devId: %{public}s, "
533 "dhId: %{public}s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
534 return;
535 }
536 DCameraMetadataSettingCmd cmd;
537 int32_t ret = cmd.Unmarshal(jsonStr);
538 if (ret != DCAMERA_OK) {
539 DHLOGI("DCameraSourceController HandleMetaDataResult failed, ret: %{public}d, devId: %{public}s, "
540 "dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
541 return;
542 }
543 DHBase dhBase;
544 dhBase.deviceId_ = devId_;
545 dhBase.dhId_ = dhId_;
546 for (auto iter = cmd.value_.begin(); iter != cmd.value_.end(); iter++) {
547 DCameraSettings setting;
548 setting.type_ = (*iter)->type_;
549 setting.value_ = (*iter)->value_;
550 int32_t retHdi = camHdiProvider_->OnSettingsResult(dhBase, setting);
551 DHLOGI("OnSettingsResult hal, ret: %{public}d, devId: %{public}s dhId: %{public}s", retHdi,
552 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
553 }
554 }
555
PublishEnableLatencyMsg(const std::string & devId)556 int32_t DCameraSourceController::PublishEnableLatencyMsg(const std::string& devId)
557 {
558 DHLOGI("DCameraSourceController PublishEnableLatencyMsg Start,devId: %{public}s", GetAnonyString(devId_).c_str());
559 isChannelConnected_.store(false);
560 DCameraLowLatency::GetInstance().EnableLowLatency();
561 DCameraSoftbusLatency::GetInstance().StartSoftbusTimeSync(devId);
562 DHLOGI("DCameraSourceController PublishEnableLatencyMsg End,devId: %{public}s", GetAnonyString(devId_).c_str());
563 return DCAMERA_OK;
564 }
565
PostChannelDisconnectedEvent()566 void DCameraSourceController::PostChannelDisconnectedEvent()
567 {
568 std::shared_ptr<DCameraSourceDev> camDev = camDev_.lock();
569 if (camDev == nullptr) {
570 DHLOGE("DCameraSourceController PostChannelDisconnectedEvent camDev is nullptr");
571 return;
572 }
573 camDev->OnChannelDisconnectedEvent();
574 }
575
PauseDistributedHardware(const std::string & networkId)576 int32_t DCameraSourceController::PauseDistributedHardware(const std::string &networkId)
577 {
578 return DCAMERA_OK;
579 }
580
ResumeDistributedHardware(const std::string & networkId)581 int32_t DCameraSourceController::ResumeDistributedHardware(const std::string &networkId)
582 {
583 return DCAMERA_OK;
584 }
585
StopDistributedHardware(const std::string & networkId)586 int32_t DCameraSourceController::StopDistributedHardware(const std::string &networkId)
587 {
588 return DCAMERA_OK;
589 }
590
OnRemoteDied(const wptr<IRemoteObject> & remote)591 void DCameraSourceController::DCameraHdiRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
592 {
593 DHLOGE("Exit the current process.");
594 _Exit(0);
595 }
596 } // namespace DistributedHardware
597 } // namespace OHOS
598