1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef CLIENT_TRANS_UDP_STREAM_ADAPTOR_LISTENER_H_
17 #define CLIENT_TRANS_UDP_STREAM_ADAPTOR_LISTENER_H_
18 
19 #include "i_stream.h"
20 #include "i_stream_manager.h"
21 #include "softbus_def.h"
22 #include "trans_log.h"
23 
24 using Communication::SoftBus::IStreamManagerListener;
25 using Communication::SoftBus::IStream;
26 
27 namespace OHOS {
28 class StreamAdaptorListener : public IStreamManagerListener {
29 public:
30     StreamAdaptorListener() = default;
StreamAdaptorListener(std::shared_ptr<StreamAdaptor> adaptor)31     explicit StreamAdaptorListener(std::shared_ptr<StreamAdaptor> adaptor) : adaptor_(adaptor) {}
32     virtual ~StreamAdaptorListener() override = default;
ConvertStreamFrameInfo(StreamFrameInfo * outFrameInfo,const Communication::SoftBus::StreamFrameInfo * inFrameInfo)33     void ConvertStreamFrameInfo(StreamFrameInfo *outFrameInfo,
34         const Communication::SoftBus::StreamFrameInfo *inFrameInfo)
35     {
36         outFrameInfo->frameType = inFrameInfo->frameType;
37         outFrameInfo->timeStamp = (int64_t)inFrameInfo->timeStamp;
38         outFrameInfo->seqNum = (int)inFrameInfo->seqNum;
39         outFrameInfo->seqSubNum = (int)inFrameInfo->seqSubNum;
40         outFrameInfo->level = (int)inFrameInfo->level;
41         outFrameInfo->bitMap = (int)inFrameInfo->bitMap;
42         outFrameInfo->tvCount = 0;
43         outFrameInfo->tvList = nullptr;
44     }
OnStreamReceived(std::unique_ptr<IStream> stream)45     void OnStreamReceived(std::unique_ptr<IStream> stream) override
46     {
47         if (adaptor_ == nullptr || adaptor_->GetListenerCallback() == nullptr ||
48             adaptor_->GetListenerCallback()->OnStreamReceived == nullptr) {
49             return;
50         }
51         StreamFrameInfo tmpf = {0};
52         auto uniptr = stream->GetBuffer();
53         char *retbuf = uniptr.get();
54         int32_t buflen = stream->GetBufferLen();
55         auto extUniptr = stream->GetExtBuffer();
56         char *extRetBuf = extUniptr.get();
57         int32_t extRetBuflen = stream->GetExtBufferLen();
58         StreamData retStreamData = {0};
59         int32_t streamType = adaptor_->GetStreamType();
60         std::unique_ptr<char[]> plainData = nullptr;
61         if (streamType == StreamType::COMMON_VIDEO_STREAM || streamType == StreamType::COMMON_AUDIO_STREAM) {
62             retStreamData.buf = retbuf;
63             retStreamData.bufLen = buflen;
64             ConvertStreamFrameInfo(&tmpf, stream->GetStreamFrameInfo());
65         } else if (streamType == StreamType::RAW_STREAM) {
66             int32_t ret = ConvertRawStreamData(retbuf, buflen, plainData, retStreamData);
67             if (ret != SOFTBUS_OK) {
68                 TRANS_LOGE(TRANS_STREAM, "failed to convert raw stream data, ret=%{public}d", ret);
69                 return;
70             }
71         } else {
72             TRANS_LOGE(TRANS_STREAM, "Do not support, streamType=%{public}d", streamType);
73             return;
74         }
75         StreamData extStreamData = {
76             extRetBuf,
77             extRetBuflen,
78         };
79         adaptor_->GetListenerCallback()->OnStreamReceived(adaptor_->GetChannelId(),
80             &retStreamData, &extStreamData, &tmpf);
81     }
82 
OnStreamStatus(int status)83     void OnStreamStatus(int status) override
84     {
85         TRANS_LOGD(TRANS_STREAM, "status=%{public}d", status);
86 
87         if (adaptor_->GetListenerCallback() != nullptr && adaptor_->GetListenerCallback()->OnStatusChange != nullptr) {
88             TRANS_LOGI(TRANS_STREAM, "OnStatusChange status=%{public}d", status);
89             adaptor_->GetListenerCallback()->OnStatusChange(adaptor_->GetChannelId(), status);
90         }
91     }
92 
OnQosEvent(int32_t eventId,int32_t tvCount,const QosTv * tvList)93     void OnQosEvent(int32_t eventId, int32_t tvCount, const QosTv *tvList) override
94     {
95         if (adaptor_->GetListenerCallback() != nullptr && adaptor_->GetListenerCallback()->OnQosEvent != nullptr) {
96             TRANS_LOGD(TRANS_QOS, "channelId=%{public}" PRId64, adaptor_->GetChannelId());
97             adaptor_->GetListenerCallback()->OnQosEvent(adaptor_->GetChannelId(), eventId, tvCount, tvList);
98         } else {
99             TRANS_LOGE(TRANS_QOS,
100                 "Get ListenerCallback by StreamAdaptor is failed, channelId=%{public}" PRId64,
101                 adaptor_->GetChannelId());
102         }
103     }
104 
OnFrameStats(const StreamSendStats * data)105     void OnFrameStats(const StreamSendStats *data) override
106     {
107         if (adaptor_->GetListenerCallback() != nullptr && adaptor_->GetListenerCallback()->OnFrameStats != nullptr) {
108             TRANS_LOGI(TRANS_STREAM, "channelId=%{public}" PRId64, adaptor_->GetChannelId());
109             adaptor_->GetListenerCallback()->OnFrameStats(adaptor_->GetChannelId(), data);
110         } else {
111             TRANS_LOGE(TRANS_STREAM,
112                 "Get ListenerCallback by StreamAdaptor is failed, channelId=%{public}" PRId64,
113                 adaptor_->GetChannelId());
114         }
115     }
116 
OnRippleStats(const TrafficStats * data)117     void OnRippleStats(const TrafficStats *data) override
118     {
119         if (adaptor_->GetListenerCallback() != nullptr && adaptor_->GetListenerCallback()->OnRippleStats != nullptr) {
120             TRANS_LOGI(TRANS_STREAM, "channelId=%{public}" PRId64, adaptor_->GetChannelId());
121             adaptor_->GetListenerCallback()->OnRippleStats(adaptor_->GetChannelId(), data);
122         } else {
123             TRANS_LOGE(TRANS_STREAM,
124                 "Get ListenerCallback by StreamAdaptor is failed, channelId=%{public}" PRId64,
125                 adaptor_->GetChannelId());
126         }
127     }
128 
129 private:
ConvertRawStreamData(char * buf,int32_t bufLen,std::unique_ptr<char[]> & plainData,StreamData & retStreamData)130     int32_t ConvertRawStreamData(char *buf, int32_t bufLen, std::unique_ptr<char[]> &plainData,
131         StreamData &retStreamData)
132     {
133         if (!adaptor_->IsEncryptedRawStream()) {
134             retStreamData.buf = buf;
135             retStreamData.bufLen = bufLen;
136             return SOFTBUS_OK;
137         }
138 
139         ssize_t encryptOverhead = adaptor_->GetEncryptOverhead();
140         int32_t plainDataLength = bufLen - encryptOverhead;
141         if (plainDataLength < 0) {
142             TRANS_LOGE(TRANS_STREAM,
143                 "bufLen < GetEncryptOverhead. bufLen=%{public}d, GetEncryptOverhead=%{public}zd",
144                 bufLen, encryptOverhead);
145             return SOFTBUS_TRANS_DECRYPT_ERR;
146         }
147         plainData = std::make_unique<char[]>(plainDataLength);
148         ssize_t decLen = adaptor_->Decrypt(buf, bufLen, plainData.get(), plainDataLength,
149             adaptor_->GetSessionKey());
150         if (decLen != plainDataLength) {
151             TRANS_LOGE(TRANS_STREAM,
152                 "Decrypt failed, dataLen=%{public}d, decLen=%{public}zd", plainDataLength, decLen);
153             return SOFTBUS_TRANS_DECRYPT_ERR;
154         }
155         retStreamData.buf = plainData.get();
156         retStreamData.bufLen = plainDataLength;
157         return SOFTBUS_OK;
158     }
159 
160     std::shared_ptr<StreamAdaptor> adaptor_ = nullptr;
161 };
162 } // namespace OHOS
163 
164 #endif // !defined(CLIENT_TRANS_UDP_STREAM_ADAPTOR_LISTENER_H_)
165