1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "anonymous_string.h"
17 #include "dcamera_hisysevent_adapter.h"
18 #include "dcamera_sink_frame_info.h"
19 #include "dcamera_softbus_adapter.h"
20 #include "distributed_camera_constants.h"
21 #include "distributed_camera_errno.h"
22 #include "distributed_hardware_log.h"
23 #include <securec.h>
24 #include "softbus_bus_center.h"
25 #include "softbus_common.h"
26 #include "softbus_error_code.h"
27 #include "dcamera_utils_tools.h"
28 #include "dcamera_frame_info.h"
29 
30 namespace OHOS {
31 namespace DistributedHardware {
32 namespace {
33 static QosTV g_qosInfo[] = {
34     { .qos = QOS_TYPE_MIN_BW, .value = DCAMERA_QOS_TYPE_MIN_BW },
35     { .qos = QOS_TYPE_MAX_LATENCY, .value = DCAMERA_QOS_TYPE_MAX_LATENCY },
36     { .qos = QOS_TYPE_MIN_LATENCY, .value = DCAMERA_QOS_TYPE_MIN_LATENCY}
37 };
38 static uint32_t g_QosTV_Param_Index = static_cast<uint32_t>(sizeof(g_qosInfo) / sizeof(QosTV));
39 }
40 IMPLEMENT_SINGLE_INSTANCE(DCameraSoftbusAdapter);
41 
DCameraSourceOnBind(int32_t socket,PeerSocketInfo info)42 static void DCameraSourceOnBind(int32_t socket, PeerSocketInfo info)
43 {
44     return;
45 }
46 
DCameraSourceOnShutDown(int32_t socket,ShutdownReason reason)47 static void DCameraSourceOnShutDown(int32_t socket, ShutdownReason reason)
48 {
49     DCameraSoftbusAdapter::GetInstance().SourceOnShutDown(socket, reason);
50     return;
51 }
52 
DCameraSourceOnBytes(int32_t socket,const void * data,uint32_t dataLen)53 static void DCameraSourceOnBytes(int32_t socket, const void *data, uint32_t dataLen)
54 {
55     DCameraSoftbusAdapter::GetInstance().SourceOnBytes(socket, data, dataLen);
56     return;
57 }
58 
DCameraSourceOnMessage(int32_t socket,const void * data,uint32_t dataLen)59 static void DCameraSourceOnMessage(int32_t socket, const void *data, uint32_t dataLen)
60 {
61     DCameraSoftbusAdapter::GetInstance().SourceOnMessage(socket, data, dataLen);
62     return;
63 }
64 
DCameraSourceOnStream(int32_t socket,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)65 static void DCameraSourceOnStream(int32_t socket, const StreamData *data, const StreamData *ext,
66     const StreamFrameInfo *param)
67 {
68     DCameraSoftbusAdapter::GetInstance().SourceOnStream(socket, data, ext, param);
69     return;
70 }
71 
72 // sink
DCameraSinkOnBind(int32_t socket,PeerSocketInfo info)73 static void DCameraSinkOnBind(int32_t socket, PeerSocketInfo info)
74 {
75     DCameraSoftbusAdapter::GetInstance().SinkOnBind(socket, info);
76     return;
77 }
78 
DCameraSinkOnShutDown(int32_t socket,ShutdownReason reason)79 static void DCameraSinkOnShutDown(int32_t socket, ShutdownReason reason)
80 {
81     DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(socket, reason);
82     return;
83 }
84 
DCameraSinkOnBytes(int32_t socket,const void * data,uint32_t dataLen)85 static void DCameraSinkOnBytes(int32_t socket, const void *data, uint32_t dataLen)
86 {
87     DCameraSoftbusAdapter::GetInstance().SinkOnBytes(socket, data, dataLen);
88     return;
89 }
90 
DCameraSinkOnMessage(int32_t socket,const void * data,uint32_t dataLen)91 static void DCameraSinkOnMessage(int32_t socket, const void *data, uint32_t dataLen)
92 {
93     DCameraSoftbusAdapter::GetInstance().SinkOnMessage(socket, data, dataLen);
94     return;
95 }
96 
DCameraSinkOnStream(int32_t socket,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)97 static void DCameraSinkOnStream(int32_t socket, const StreamData *data, const StreamData *ext,
98     const StreamFrameInfo *param)
99 {
100     DCameraSoftbusAdapter::GetInstance().SinkOnStream(socket, data, ext, param);
101     return;
102 }
103 
DCameraSoftbusAdapter()104 DCameraSoftbusAdapter::DCameraSoftbusAdapter()
105 {
106     sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_CTRL] = TransDataType::DATA_TYPE_BYTES;
107     sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_VIDEO] = TransDataType::DATA_TYPE_VIDEO_STREAM;
108     sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_JPEG] = TransDataType::DATA_TYPE_BYTES;
109 
110     ISocketListener sourceListener;
111     sourceListener.OnBind = DCameraSourceOnBind;
112     sourceListener.OnShutdown = DCameraSourceOnShutDown;
113     sourceListener.OnBytes = DCameraSourceOnBytes;
114     sourceListener.OnMessage = DCameraSourceOnMessage;
115     sourceListener.OnStream = DCameraSourceOnStream;
116     sessListeners_[DCAMERA_CHANNLE_ROLE_SOURCE] = sourceListener;
117 
118     ISocketListener sinkListener;
119     sinkListener.OnBind = DCameraSinkOnBind;
120     sinkListener.OnShutdown = DCameraSinkOnShutDown;
121     sinkListener.OnBytes = DCameraSinkOnBytes;
122     sinkListener.OnMessage = DCameraSinkOnMessage;
123     sinkListener.OnStream = DCameraSinkOnStream;
124     sessListeners_[DCAMERA_CHANNLE_ROLE_SINK] = sinkListener;
125 }
126 
~DCameraSoftbusAdapter()127 DCameraSoftbusAdapter::~DCameraSoftbusAdapter()
128 {
129 }
130 
CreatSoftBusSinkSocketServer(std::string mySessionName,DCAMERA_CHANNEL_ROLE role,DCameraSessionMode sessionMode,std::string peerDevId,std::string peerSessionName)131 int32_t DCameraSoftbusAdapter::CreatSoftBusSinkSocketServer(std::string mySessionName, DCAMERA_CHANNEL_ROLE role,
132     DCameraSessionMode sessionMode, std::string peerDevId, std::string peerSessionName)
133 {
134     DHLOGI("create socket server start, mySessionName: %{public}s,peerSessionName: %{public}s",
135         GetAnonyString(mySessionName).c_str(), GetAnonyString(peerSessionName).c_str());
136     {
137         std::lock_guard<std::mutex> autoLock(mySessionNameLock_);
138         if (mySessionNameSet_.find(mySessionName) != mySessionNameSet_.end()) {
139             DHLOGI("current mySessionName had Listened");
140             return DCAMERA_OK;
141         }
142         mySessionNameSet_.insert(mySessionName);
143     }
144     SocketInfo serverSocketInfo = {
145         .name =  const_cast<char*>(mySessionName.c_str()),
146         .peerName = const_cast<char*>(peerSessionName.c_str()),
147         .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
148         .pkgName = const_cast<char*>(PKG_NAME.c_str()),
149         .dataType = sessionModeAndDataTypeMap_[sessionMode],
150     };
151     int socketId = Socket(serverSocketInfo);
152     if (socketId < 0) {
153         DHLOGE("create socket server error, socket is invalid");
154         return DCAMERA_BAD_VALUE;
155     }
156     int ret = Listen(socketId, g_qosInfo, g_QosTV_Param_Index, &sessListeners_[role]);
157     if (ret != DCAMERA_OK) {
158         DHLOGE("create socket server error");
159         Shutdown(socketId);
160         return DCAMERA_BAD_VALUE;
161     }
162     {
163         std::lock_guard<std::mutex> autoLock(mySessionNamePeerDevIdLock_);
164         std::string peerDevIdMySessionName = peerDevId + std::string("_") + mySessionName;
165         peerDevIdMySessionNameMap_[peerDevIdMySessionName] = mySessionName;
166     }
167     DHLOGI("create socket server end, mySessionName: %{public}s, peerSessionName: %{public}s",
168         GetAnonyString(mySessionName).c_str(), GetAnonyString(peerSessionName).c_str());
169     return DCAMERA_OK;
170 }
171 
CreateSoftBusSourceSocketClient(std::string myDevId,std::string peerSessionName,std::string peerDevId,DCameraSessionMode sessionMode,DCAMERA_CHANNEL_ROLE role)172 int32_t DCameraSoftbusAdapter::CreateSoftBusSourceSocketClient(std::string myDevId, std::string peerSessionName,
173     std::string peerDevId, DCameraSessionMode sessionMode, DCAMERA_CHANNEL_ROLE role)
174 {
175     DHLOGI("create socket client start, myDevId: %{public}s, peerSessionName: %{public}s",
176         GetAnonyString(myDevId).c_str(), GetAnonyString(peerSessionName).c_str());
177     std::string myDevIdPeerSessionName = myDevId + std::string("_") + peerSessionName;
178     SocketInfo clientSocketInfo = {
179         .name = const_cast<char*>(myDevIdPeerSessionName.c_str()),
180         .peerName = const_cast<char*>(peerSessionName.c_str()),
181         .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
182         .pkgName = const_cast<char*>(PKG_NAME.c_str()),
183         .dataType = sessionModeAndDataTypeMap_[sessionMode],
184     };
185     int socketId = Socket(clientSocketInfo);
186     if (socketId < 0) {
187         DHLOGE("create socket client error, socket is invalid");
188         return DCAMERA_BAD_VALUE;
189     }
190     int ret = Bind(socketId, g_qosInfo, g_QosTV_Param_Index, &sessListeners_[role]);
191     if (ret != DCAMERA_OK) {
192         DHLOGE("create socket client error");
193         Shutdown(socketId);
194         return DCAMERA_BAD_VALUE;
195     }
196     sourceSocketId_ = socketId;
197     DHLOGI("create socket client end, myDevId: %{public}s, peerSessionName: %{public}s",
198         GetAnonyString(myDevId).c_str(), GetAnonyString(peerSessionName).c_str());
199     return DCAMERA_OK;
200 }
201 
DestroySoftbusSessionServer(std::string sessionName)202 int32_t DCameraSoftbusAdapter::DestroySoftbusSessionServer(std::string sessionName)
203 {
204     std::lock_guard<std::mutex> autoLock(optLock_);
205     if (sessionTotal_.find(sessionName) == sessionTotal_.end()) {
206         DHLOGI("current sessionName already destroy, sessionName: %{public}s", GetAnonyString(sessionName).c_str());
207         return DCAMERA_OK;
208     }
209 
210     sessionTotal_[sessionName]--;
211     DHLOGI("sessionName destroy %{public}s totalnum: %{public}d", GetAnonyString(sessionName).c_str(),
212         sessionTotal_[sessionName]);
213     uint32_t total_ = sessionTotal_[sessionName];
214     if (total_ == 0) {
215         sessionTotal_.erase(sessionName);
216     }
217     return DCAMERA_OK;
218 }
219 
CloseSoftbusSession(int32_t socket)220 int32_t DCameraSoftbusAdapter::CloseSoftbusSession(int32_t socket)
221 {
222     DHLOGI("Shutdown softbus socket start: %{public}d", socket);
223     Shutdown(socket); // shutdown socket
224     {
225         std::lock_guard<std::mutex> autoLock(idMapLock_);
226         sessionIdMap_.erase(socket);
227     }
228     {
229         std::lock_guard<std::mutex> autoLock(sinkSocketLock_);
230         sinkSocketSessionMap_.erase(socket);
231     }
232     {
233         std::lock_guard<std::mutex> autoLock(sourceSocketLock_);
234         sourceSocketSessionMap_.erase(socket);
235     }
236     DHLOGI("Shutdown softbus socket: %{public}d end", socket);
237     return DCAMERA_OK;
238 }
239 
SendSofbusBytes(int32_t socket,std::shared_ptr<DataBuffer> & buffer)240 int32_t DCameraSoftbusAdapter::SendSofbusBytes(int32_t socket, std::shared_ptr<DataBuffer>& buffer)
241 {
242     CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
243     return SendBytes(socket, buffer->Data(), buffer->Size());
244 }
245 
SendSofbusStream(int32_t socket,std::shared_ptr<DataBuffer> & buffer)246 int32_t DCameraSoftbusAdapter::SendSofbusStream(int32_t socket, std::shared_ptr<DataBuffer>& buffer)
247 {
248     CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
249     StreamData streamData = { reinterpret_cast<char *>(buffer->Data()), buffer->Size() };
250     int64_t timeStamp;
251     if (!buffer->FindInt64(TIME_STAMP_US, timeStamp)) {
252         DHLOGD("SendSofbusStream find %{public}s failed.", TIME_STAMP_US.c_str());
253     }
254     int32_t frameType;
255     if (!buffer->FindInt32(FRAME_TYPE, frameType)) {
256         DHLOGD("SendSofbusStream find %{public}s failed.", FRAME_TYPE.c_str());
257     }
258     int32_t index;
259     if (!buffer->FindInt32(INDEX, index)) {
260         DHLOGD("SendSofbusStream find %{public}s failed.", INDEX.c_str());
261     }
262     int64_t startEncodeT;
263     if (!buffer->FindInt64(START_ENCODE_TIME_US, startEncodeT)) {
264         DHLOGD("SendSofbusStream find %{public}s failed.", START_ENCODE_TIME_US.c_str());
265     }
266     int64_t finishEncodeT;
267     if (!buffer->FindInt64(FINISH_ENCODE_TIME_US, finishEncodeT)) {
268         DHLOGD("SendSofbusStream find %{public}s failed.", FINISH_ENCODE_TIME_US.c_str());
269     }
270     std::string jsonStr = "";
271     DCameraSinkFrameInfo sinkFrameInfo;
272     sinkFrameInfo.pts_ = timeStamp;
273     sinkFrameInfo.type_ = frameType;
274     sinkFrameInfo.index_ = index;
275     sinkFrameInfo.startEncodeT_ = startEncodeT;
276     sinkFrameInfo.finishEncodeT_ = finishEncodeT;
277     sinkFrameInfo.sendT_ = GetNowTimeStampUs();
278     sinkFrameInfo.Marshal(jsonStr);
279     StreamData ext = { const_cast<char *>(jsonStr.c_str()), jsonStr.length() };
280     StreamFrameInfo param = { 0 };
281     int32_t ret = SendStream(socket, &streamData, &ext, &param);
282     if (ret != SOFTBUS_OK) {
283         DHLOGD("SendSofbusStream failed, ret is %{public}d", ret);
284         return DCAMERA_BAD_VALUE;
285     }
286     return DCAMERA_OK;
287 }
288 
DCameraSoftbusGetSessionById(int32_t sessionId,std::shared_ptr<DCameraSoftbusSession> & session)289 int32_t DCameraSoftbusAdapter::DCameraSoftbusGetSessionById(int32_t sessionId,
290     std::shared_ptr<DCameraSoftbusSession>& session)
291 {
292     DHLOGI("get softbus session by sessionId: %{public}d", sessionId);
293     std::lock_guard<std::mutex> autoLock(idMapLock_);
294     auto iter = sessionIdMap_.find(sessionId);
295     if (iter == sessionIdMap_.end()) {
296         DHLOGE("get softbus session by id not find session %{public}d", sessionId);
297         return DCAMERA_NOT_FOUND;
298     }
299     session = iter->second;
300     return DCAMERA_OK;
301 }
302 
DCameraSoftbusSourceGetSession(int32_t socket,std::shared_ptr<DCameraSoftbusSession> & session)303 int32_t DCameraSoftbusAdapter::DCameraSoftbusSourceGetSession(int32_t socket,
304     std::shared_ptr<DCameraSoftbusSession>& session)
305 {
306     std::lock_guard<std::mutex> autoLock(sourceSocketLock_);
307     auto iter =  sourceSocketSessionMap_.find(socket);
308     if (iter == sourceSocketSessionMap_.end()) {
309         DHLOGE("source can not find current socket %{public}d", socket);
310         return DCAMERA_NOT_FOUND;
311     }
312     session = iter->second;
313     return DCAMERA_OK;
314 }
315 
316 // source
SourceOnBind(int32_t socket,PeerSocketInfo info)317 int32_t DCameraSoftbusAdapter::SourceOnBind(int32_t socket, PeerSocketInfo info)
318 {
319     DHLOGI("source bind socket begin, socket: %{public}d", socket);
320     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
321     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
322     if (ret != DCAMERA_OK || session == nullptr) {
323         DHLOGE("source bind socket can not find socket %{public}d", socket);
324         return DCAMERA_NOT_FOUND;
325     }
326     ret = session->OnSessionOpened(socket);
327     if (ret != DCAMERA_OK) {
328         DHLOGE("source bind socket failed, ret: %{public}d socket: %{public}d", ret, socket);
329     } else {
330         std::lock_guard<std::mutex> autoLock(idMapLock_);
331         sessionIdMap_.emplace(socket, session);
332     }
333     DHLOGI("source bind socket end, socket: %{public}d end", socket);
334     return ret;
335 }
336 
SourceOnShutDown(int32_t socket,ShutdownReason reason)337 void DCameraSoftbusAdapter::SourceOnShutDown(int32_t socket, ShutdownReason reason)
338 {
339     DHLOGI("source on shutdown socket start, socket: %{public}d", socket);
340     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
341     int32_t ret = DCameraSoftbusGetSessionById(socket, session);
342     if (ret != DCAMERA_OK || session == nullptr) {
343         DHLOGE("SourceOnShutDown can not find socket %{public}d", socket);
344         return;
345     }
346     {
347         std::lock_guard<std::mutex> autoLock(idMapLock_);
348         sessionIdMap_.erase(socket);
349     }
350     session->OnSessionClose(socket);
351     DHLOGI("source on shutdown socket end socket: %{public}d end", socket);
352     return;
353 }
354 
SourceOnBytes(int32_t socket,const void * data,uint32_t dataLen)355 void DCameraSoftbusAdapter::SourceOnBytes(int32_t socket, const void *data, uint32_t dataLen)
356 {
357     if (dataLen == 0 || dataLen > DCAMERA_MAX_RECV_DATA_LEN || data == nullptr) {
358         DHLOGE("source callback send bytes error, dataLen: %{public}d, socket: %{public}d", dataLen, socket);
359         return;
360     }
361     DHLOGI("source callback send bytes start, socket: %{public}d", socket);
362     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
363     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
364     if (ret != DCAMERA_OK || session == nullptr) {
365         DHLOGE("source callback send bytes not find session %{public}d", socket);
366         return;
367     }
368 
369     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(dataLen);
370     ret = memcpy_s(buffer->Data(), buffer->Capacity(), data, dataLen);
371     if (ret != EOK) {
372         DHLOGE("source callback send bytes memcpy_s failed ret: %{public}d", ret);
373         return;
374     }
375     session->OnDataReceived(buffer);
376     DHLOGI("source callback send bytes end, socket: %{public}d", socket);
377     return;
378 }
379 
SourceOnMessage(int32_t socket,const void * data,uint32_t dataLen)380 void DCameraSoftbusAdapter::SourceOnMessage(int32_t socket, const void *data, uint32_t dataLen)
381 {
382     (void)socket;
383     (void)data;
384     (void)dataLen;
385     return;
386 }
387 
SourceOnStream(int32_t socket,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)388 void DCameraSoftbusAdapter::SourceOnStream(int32_t socket, const StreamData *data, const StreamData *ext,
389     const StreamFrameInfo *param)
390 {
391     int64_t recvT = GetNowTimeStampUs();
392     if (data == nullptr) {
393         DHLOGE("SourceOnStream Error, data is null, socket: %{public}d.", socket);
394         return;
395     }
396     int32_t dataLen = data->bufLen;
397     if (dataLen <= 0 || dataLen > static_cast<int32_t>(DCAMERA_MAX_RECV_DATA_LEN)) {
398         DHLOGE("SourceOnStream Error, dataLen: %{public}d, socket: %{public}d", dataLen, socket);
399         return;
400     }
401     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
402     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
403     if (ret != DCAMERA_OK || session == nullptr) {
404         DHLOGE("SourceOnStream not find socket %{public}d", socket);
405         return;
406     }
407 
408     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(data->bufLen);
409     buffer->SetInt64(RECV_TIME_US, recvT);
410     ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(data->buf), data->bufLen);
411     if (ret != EOK) {
412         DHLOGE("SourceOnStream memcpy_s failed ret: %{public}d", ret);
413         return;
414     }
415     ret = HandleSourceStreamExt(buffer, ext);
416     if (ret != DCAMERA_OK) {
417         DHLOGE("Handle source stream ext failed, ret is: %{public}d", ret);
418     }
419     session->OnDataReceived(buffer);
420 }
421 
HandleSourceStreamExt(std::shared_ptr<DataBuffer> & buffer,const StreamData * ext)422 int32_t DCameraSoftbusAdapter::HandleSourceStreamExt(std::shared_ptr<DataBuffer>& buffer, const StreamData *ext)
423 {
424     if (ext == nullptr) {
425         DHLOGE("Source stream ext is null.");
426         return DCAMERA_BAD_VALUE;
427     }
428     int32_t extLen = ext->bufLen;
429     if (extLen <= 0 || extLen > DCAMERA_MAX_RECV_EXT_LEN) {
430         DHLOGD("ExtLen is: %{public}d.", extLen);
431         return DCAMERA_BAD_VALUE;
432     }
433 
434     std::string jsonStr(reinterpret_cast<const char*>(ext->buf), ext->bufLen);
435     DCameraSinkFrameInfo sinkFrameInfo;
436     int32_t ret = sinkFrameInfo.Unmarshal(jsonStr);
437     if (ret != DCAMERA_OK) {
438         DHLOGE("Unmarshal sinkFrameInfo failed.");
439         return DCAMERA_BAD_VALUE;
440     }
441     int64_t recvT;
442     CHECK_AND_RETURN_RET_LOG(buffer == nullptr, DCAMERA_BAD_VALUE, "Data buffer is null");
443     if (!buffer->FindInt64(RECV_TIME_US, recvT)) {
444         DHLOGD("HandleSourceStreamExt find %{public}s failed.", RECV_TIME_US.c_str());
445     }
446     DCameraFrameInfo frameInfo;
447     frameInfo.type = sinkFrameInfo.type_;
448     frameInfo.pts = sinkFrameInfo.pts_;
449     frameInfo.index = sinkFrameInfo.index_;
450     frameInfo.ver = sinkFrameInfo.ver_;
451     frameInfo.timePonit.startEncode = sinkFrameInfo.startEncodeT_;
452     frameInfo.timePonit.finishEncode = sinkFrameInfo.finishEncodeT_;
453     frameInfo.timePonit.send = sinkFrameInfo.sendT_;
454     frameInfo.timePonit.recv = recvT;
455     buffer->frameInfo_ = frameInfo;
456     return DCAMERA_OK;
457 }
458 
GetSourceSocketId()459 int32_t DCameraSoftbusAdapter::GetSourceSocketId()
460 {
461     return sourceSocketId_;
462 }
463 
RecordSourceSocketSession(int32_t socket,std::shared_ptr<DCameraSoftbusSession> session)464 void DCameraSoftbusAdapter::RecordSourceSocketSession(int32_t socket, std::shared_ptr<DCameraSoftbusSession> session)
465 {
466     if (session == nullptr) {
467         DHLOGE("RecordSourceSocketSession error, session is null");
468         return;
469     }
470     {
471         std::lock_guard<std::mutex> autoLock(sourceSocketLock_);
472         sourceSocketSessionMap_[socket] = session;
473     }
474 }
475 
DCameraSoftbusSinkGetSession(int32_t socket,std::shared_ptr<DCameraSoftbusSession> & session)476 int32_t DCameraSoftbusAdapter::DCameraSoftbusSinkGetSession(int32_t socket,
477     std::shared_ptr<DCameraSoftbusSession>& session)
478 {
479     DHLOGI("sink find session start, socket: %{public}d", socket);
480     {
481         std::lock_guard<std::mutex> autoLock(sinkSocketLock_);
482         auto iter = sinkSocketSessionMap_.find(socket);
483         if (iter == sinkSocketSessionMap_.end()) {
484             DHLOGE("sink can not find socket %{public}d", socket);
485             return DCAMERA_NOT_FOUND;
486         }
487         session = iter->second;
488         CHECK_AND_RETURN_RET_LOG(session == nullptr, DCAMERA_BAD_VALUE, "Softbus session is null");
489         if (session->GetSessionId() < 0) {
490             DHLOGE("sink find session error, current sessionId is invalid");
491             return DCAMERA_BAD_VALUE;
492         }
493     }
494     DHLOGI("sink find session end, socket: %{public}d", socket);
495     return DCAMERA_OK;
496 }
497 
DCameraSoftBusGetSessionByPeerSocket(int32_t socket,std::shared_ptr<DCameraSoftbusSession> & session,PeerSocketInfo info)498 int32_t DCameraSoftbusAdapter::DCameraSoftBusGetSessionByPeerSocket(int32_t socket,
499     std::shared_ptr<DCameraSoftbusSession> &session, PeerSocketInfo info)
500 {
501     DHLOGI("find session by peer socket start, socket %{public}d", socket);
502     std::string mySessionName = "";
503     {
504         std::lock_guard<std::mutex> autoLock(mySessionNamePeerDevIdLock_);
505         auto sessionNameIter = peerDevIdMySessionNameMap_.find(info.name);
506         if (sessionNameIter == peerDevIdMySessionNameMap_.end()) {
507             DHLOGE("find session by peer socket error, socket %{public}d", socket);
508             return DCAMERA_NOT_FOUND;
509         }
510         mySessionName = sessionNameIter->second;
511     }
512     auto iter = sinkSessions_.find(std::string(mySessionName));
513     if (iter == sinkSessions_.end()) {
514         DHLOGE("find session by peer socket error, mySessionName %{public}s",
515             GetAnonyString(mySessionName).c_str());
516         return DCAMERA_NOT_FOUND;
517     }
518     session = iter->second;
519     {
520         std::lock_guard<std::mutex> autoLock(sinkSocketLock_);
521         sinkSocketSessionMap_[socket] = session;
522     }
523     DHLOGI("find session by peer socket end, socket %{public}d", socket);
524     return DCAMERA_OK;
525 }
526 
527 // sink
SinkOnBind(int32_t socket,PeerSocketInfo info)528 int32_t DCameraSoftbusAdapter::SinkOnBind(int32_t socket, PeerSocketInfo info)
529 {
530     DHLOGI("sink bind socket start, socket: %{public}d", socket);
531     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
532     int32_t ret = DCameraSoftBusGetSessionByPeerSocket(socket, session, info);
533     if (ret != DCAMERA_OK || session == nullptr) {
534         DHLOGE("sink bind socket error, can not find socket %{public}d", socket);
535         return DCAMERA_NOT_FOUND;
536     }
537     ret = session->OnSessionOpened(socket);
538     if (ret != DCAMERA_OK) {
539         DHLOGE("sink bind socket error, not find socket %{public}d", socket);
540     } else {
541         std::lock_guard<std::mutex> autoLock(idMapLock_);
542         sessionIdMap_.emplace(socket, session);
543     }
544     DHLOGI("sink bind socket end, socket: %{public}d", socket);
545     return ret;
546 }
547 
SinkOnShutDown(int32_t socket,ShutdownReason reason)548 void DCameraSoftbusAdapter::SinkOnShutDown(int32_t socket, ShutdownReason reason)
549 {
550     DHLOGI("sink on shutdown socket start, socket: %{public}d", socket);
551     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
552     int32_t ret = DCameraSoftbusGetSessionById(socket, session);
553     if (ret != DCAMERA_OK || session == nullptr) {
554         DHLOGE("sink on shutdown socket can not find socket %{public}d", socket);
555         return;
556     }
557     {
558         std::lock_guard<std::mutex> autoLock(idMapLock_);
559         sessionIdMap_.erase(socket);
560     }
561     session->OnSessionClose(socket);
562     DHLOGI("sink on shutdown socket end, socket: %{public}d", socket);
563     return;
564 }
565 
SinkOnBytes(int32_t socket,const void * data,uint32_t dataLen)566 void DCameraSoftbusAdapter::SinkOnBytes(int32_t socket, const void *data, uint32_t dataLen)
567 {
568     if (dataLen == 0 || dataLen > DCAMERA_MAX_RECV_DATA_LEN || data == nullptr) {
569         DHLOGE("sink on bytes error, dataLen: %{public}d, socket: %{public}d", dataLen, socket);
570         return;
571     }
572     DHLOGI("sink on bytes start, socket: %{public}d", socket);
573     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
574     int32_t ret = DCameraSoftbusSinkGetSession(socket, session);
575     if (ret != DCAMERA_OK || session == nullptr) {
576         DHLOGE("sink on bytes error, can not find session %{public}d", socket);
577         return;
578     }
579     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(dataLen);
580     ret = memcpy_s(buffer->Data(), buffer->Capacity(), data, dataLen);
581     if (ret != EOK) {
582         DHLOGE("sink on bytes memcpy_s failed ret: %{public}d", ret);
583         return;
584     }
585     session->OnDataReceived(buffer);
586     DHLOGI("sink on bytes end, socket: %{public}d", socket);
587     return;
588 }
589 
SinkOnMessage(int32_t socket,const void * data,uint32_t dataLen)590 void DCameraSoftbusAdapter::SinkOnMessage(int32_t socket, const void *data, uint32_t dataLen)
591 {
592     return;
593 }
594 
SinkOnStream(int32_t socket,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)595 void DCameraSoftbusAdapter::SinkOnStream(int32_t socket, const StreamData *data, const StreamData *ext,
596     const StreamFrameInfo *param)
597 {
598     if (data == nullptr) {
599         DHLOGE("SinkOnStream error, data is null, socket: %{public}d.", socket);
600         return;
601     }
602     int32_t dataLen = data->bufLen;
603     if (dataLen <= 0 || dataLen > static_cast<int32_t>(DCAMERA_MAX_RECV_DATA_LEN)) {
604         DHLOGE("SinkOnStream error, dataLen: %{public}d socket: %{public}d", dataLen, socket);
605         return;
606     }
607     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
608     int32_t ret = DCameraSoftbusSinkGetSession(socket, session);
609     if (ret != DCAMERA_OK || session == nullptr) {
610         DHLOGE("SinkOnStream error, can not find socket %{public}d", socket);
611         return;
612     }
613 
614     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(data->bufLen);
615     ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(data->buf), data->bufLen);
616     if (ret != EOK) {
617         DHLOGE("SinkOnStream error, memcpy_s failed ret: %{public}d", ret);
618         return;
619     }
620     session->OnDataReceived(buffer);
621     return;
622 }
623 
GetLocalNetworkId(std::string & myDevId)624 int32_t DCameraSoftbusAdapter::GetLocalNetworkId(std::string& myDevId)
625 {
626     NodeBasicInfo basicInfo = { { 0 } };
627     int32_t ret = GetLocalNodeDeviceInfo(PKG_NAME.c_str(), &basicInfo);
628     if (ret != DCAMERA_OK) {
629         DHLOGE("GetLocalNodeDeviceInfo failed ret: %{public}d", ret);
630         return ret;
631     }
632 
633     myDevId = std::string(basicInfo.networkId);
634     return DCAMERA_OK;
635 }
636 } // namespace DistributedHardware
637 } // namespace OHOS
638