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