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