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 "softbus_client_stub.h"
17
18 #include <string>
19
20 #include "client_bus_center_manager.h"
21 #include "client_trans_channel_callback.h"
22 #include "client_trans_session_manager.h"
23 #include "client_trans_socket_manager.h"
24 #include "comm_log.h"
25 #include "ipc_skeleton.h"
26 #include "ipc_types.h"
27 #include "message_parcel.h"
28 #include "securec.h"
29 #include "session_set_timer.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_def.h"
32 #include "softbus_errcode.h"
33 #include "softbus_server_ipc_interface_code.h"
34 #include "client_trans_udp_manager.h"
35
36 namespace OHOS {
37 static constexpr uint32_t DFX_TIMERS_S = 15;
38
SoftBusClientStub()39 SoftBusClientStub::SoftBusClientStub()
40 {
41 memberFuncMap_[CLIENT_ON_CHANNEL_OPENED] = &SoftBusClientStub::OnChannelOpenedInner;
42 memberFuncMap_[CLIENT_ON_CHANNEL_OPENFAILED] = &SoftBusClientStub::OnChannelOpenFailedInner;
43 memberFuncMap_[CLIENT_ON_CHANNEL_LINKDOWN] = &SoftBusClientStub::OnChannelLinkDownInner;
44 memberFuncMap_[CLIENT_ON_CHANNEL_CLOSED] = &SoftBusClientStub::OnChannelClosedInner;
45 memberFuncMap_[CLIENT_ON_CHANNEL_MSGRECEIVED] = &SoftBusClientStub::OnChannelMsgReceivedInner;
46 memberFuncMap_[CLIENT_ON_CHANNEL_QOSEVENT] = &SoftBusClientStub::OnChannelQosEventInner;
47 memberFuncMap_[CLIENT_ON_JOIN_RESULT] = &SoftBusClientStub::OnJoinLNNResultInner;
48 memberFuncMap_[CLIENT_ON_LEAVE_RESULT] = &SoftBusClientStub::OnLeaveLNNResultInner;
49 memberFuncMap_[CLIENT_ON_NODE_ONLINE_STATE_CHANGED] = &SoftBusClientStub::OnNodeOnlineStateChangedInner;
50 memberFuncMap_[CLIENT_ON_NODE_BASIC_INFO_CHANGED] = &SoftBusClientStub::OnNodeBasicInfoChangedInner;
51 memberFuncMap_[CLIENT_ON_NODE_STATUS_CHANGED] = &SoftBusClientStub::OnNodeStatusChangedInner;
52 memberFuncMap_[CLIENT_ON_LOCAL_NETWORK_ID_CHANGED] = &SoftBusClientStub::OnLocalNetworkIdChangedInner;
53 memberFuncMap_[CLIENT_ON_NODE_DEVICE_NOT_TRUST] = &SoftBusClientStub::OnNodeDeviceNotTrustedInner;
54 memberFuncMap_[CLIENT_ON_HICHAIN_PROOF_EXCEPTION] = &SoftBusClientStub::OnHichainProofExceptionInner;
55 memberFuncMap_[CLIENT_ON_TIME_SYNC_RESULT] = &SoftBusClientStub::OnTimeSyncResultInner;
56 memberFuncMap_[CLIENT_ON_PUBLISH_LNN_RESULT] = &SoftBusClientStub::OnPublishLNNResultInner;
57 memberFuncMap_[CLIENT_ON_REFRESH_LNN_RESULT] = &SoftBusClientStub::OnRefreshLNNResultInner;
58 memberFuncMap_[CLIENT_ON_REFRESH_DEVICE_FOUND] = &SoftBusClientStub::OnRefreshDeviceFoundInner;
59 memberFuncMap_[CLIENT_ON_PERMISSION_CHANGE] = &SoftBusClientStub::OnClientPermissonChangeInner;
60 memberFuncMap_[CLIENT_SET_CHANNEL_INFO] = &SoftBusClientStub::SetChannelInfoInner;
61 memberFuncMap_[CLIENT_ON_DATA_LEVEL_CHANGED] = &SoftBusClientStub::OnDataLevelChangedInner;
62 memberFuncMap_[CLIENT_ON_TRANS_LIMIT_CHANGE] = &SoftBusClientStub::OnClientTransLimitChangeInner;
63 memberFuncMap_[CLIENT_ON_CHANNEL_BIND] = &SoftBusClientStub::OnChannelBindInner;
64 memberFuncMap_[CLIENT_CHANNEL_ON_QOS] = &SoftBusClientStub::OnChannelOnQosInner;
65 }
66
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)67 int32_t SoftBusClientStub::OnRemoteRequest(uint32_t code,
68 MessageParcel &data, MessageParcel &reply, MessageOption &option)
69 {
70 COMM_LOGD(COMM_SDK, "SoftBusClientStub::OnReceived, code=%{public}u", code);
71 if (data.ReadInterfaceToken() != GetDescriptor()) {
72 COMM_LOGE(COMM_SDK, "SoftBusClientStub: ReadInterfaceToken faild!");
73 return SOFTBUS_TRANS_PROXY_READTOKEN_FAILED;
74 }
75 auto itFunc = memberFuncMap_.find(code);
76 if (itFunc != memberFuncMap_.end()) {
77 auto memberFunc = itFunc->second;
78 if (memberFunc != nullptr) {
79 return (this->*memberFunc)(data, reply);
80 }
81 }
82 COMM_LOGI(COMM_SDK, "SoftBusClientStub: default case, need check.");
83 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
84 }
85
OnClientPermissonChangeInner(MessageParcel & data,MessageParcel & reply)86 int32_t SoftBusClientStub::OnClientPermissonChangeInner(MessageParcel &data, MessageParcel &reply)
87 {
88 int32_t state;
89 COMM_CHECK_AND_RETURN_RET_LOGE(
90 data.ReadInt32(state), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read state failed");
91
92 const char *pkgName = data.ReadCString();
93 COMM_CHECK_AND_RETURN_RET_LOGE(
94 pkgName != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read pkgName failed");
95
96 PermissionStateChange(pkgName, state);
97 return SOFTBUS_OK;
98 }
99
OnClientTransLimitChangeInner(MessageParcel & data,MessageParcel & reply)100 int32_t SoftBusClientStub::OnClientTransLimitChangeInner(MessageParcel &data, MessageParcel &reply)
101 {
102 int32_t channelId;
103 COMM_CHECK_AND_RETURN_RET_LOGE(
104 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read channelId failed");
105
106 uint8_t tos;
107 COMM_CHECK_AND_RETURN_RET_LOGE(
108 data.ReadUint8(tos), SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tos failed");
109
110 int32_t ret = OnClientTransLimitChange(channelId, tos);
111 COMM_CHECK_AND_RETURN_RET_LOGE(
112 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, COMM_SDK, "write reply failed");
113
114 return SOFTBUS_OK;
115 }
116
OnClientTransLimitChange(int32_t channelId,uint8_t tos)117 int32_t SoftBusClientStub::OnClientTransLimitChange(int32_t channelId, uint8_t tos)
118 {
119 return TransLimitChange(channelId, tos);
120 }
121
OnChannelOpened(const char * sessionName,const ChannelInfo * info)122 int32_t SoftBusClientStub::OnChannelOpened(const char *sessionName, const ChannelInfo *info)
123 {
124 int32_t id = SetTimer("OnChannelOpened", DFX_TIMERS_S);
125 int32_t ret = TransOnChannelOpened(sessionName, info);
126 CancelTimer(id);
127 return ret;
128 }
129
OnChannelOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)130 int32_t SoftBusClientStub::OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
131 {
132 return TransOnChannelOpenFailed(channelId, channelType, errCode);
133 }
134
OnChannelLinkDown(const char * networkId,int32_t routeType)135 int32_t SoftBusClientStub::OnChannelLinkDown(const char *networkId, int32_t routeType)
136 {
137 return TransOnChannelLinkDown(networkId, routeType);
138 }
139
OnChannelClosed(int32_t channelId,int32_t channelType,int32_t messageType)140 int32_t SoftBusClientStub::OnChannelClosed(int32_t channelId, int32_t channelType, int32_t messageType)
141 {
142 return TransOnChannelClosed(channelId, channelType, messageType, SHUTDOWN_REASON_PEER);
143 }
144
OnChannelMsgReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,int32_t type)145 int32_t SoftBusClientStub::OnChannelMsgReceived(int32_t channelId, int32_t channelType, const void *data,
146 uint32_t len, int32_t type)
147 {
148 return TransOnChannelMsgReceived(channelId, channelType, data, len, static_cast<SessionPktType>(type));
149 }
150
OnChannelQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)151 int32_t SoftBusClientStub::OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
152 int32_t tvCount, const QosTv *tvList)
153 {
154 return TransOnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
155 }
156
SetChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)157 int32_t SoftBusClientStub::SetChannelInfo(
158 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
159 {
160 return TransSetChannelInfo(sessionName, sessionId, channelId, channelType);
161 }
162
MessageParcelRead(MessageParcel & data,ChannelInfo * channel)163 static int32_t MessageParcelRead(MessageParcel &data, ChannelInfo *channel)
164 {
165 READ_PARCEL_WITH_RET(data, Int32, channel->channelId, SOFTBUS_IPC_ERR);
166 READ_PARCEL_WITH_RET(data, Int32, channel->channelType, SOFTBUS_IPC_ERR);
167 READ_PARCEL_WITH_RET(data, Uint64, channel->laneId, SOFTBUS_IPC_ERR);
168 READ_PARCEL_WITH_RET(data, Int32, channel->connectType, SOFTBUS_IPC_ERR);
169 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
170 channel->fd = data.ReadFileDescriptor();
171 channel->myIp = (char *)data.ReadCString();
172 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
173 }
174 READ_PARCEL_WITH_RET(data, Bool, channel->isServer, SOFTBUS_IPC_ERR);
175 READ_PARCEL_WITH_RET(data, Bool, channel->isEnabled, SOFTBUS_IPC_ERR);
176 READ_PARCEL_WITH_RET(data, Bool, channel->isEncrypt, SOFTBUS_IPC_ERR);
177 READ_PARCEL_WITH_RET(data, Int32, channel->peerUid, SOFTBUS_IPC_ERR);
178 READ_PARCEL_WITH_RET(data, Int32, channel->peerPid, SOFTBUS_IPC_ERR);
179 channel->groupId = (char *)data.ReadCString();
180 COMM_CHECK_AND_RETURN_RET_LOGE(channel->groupId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read groupId failed");
181 READ_PARCEL_WITH_RET(data, Uint32, channel->keyLen, SOFTBUS_IPC_ERR);
182 channel->sessionKey = (char *)data.ReadRawData(channel->keyLen);
183 COMM_CHECK_AND_RETURN_RET_LOGE(channel->sessionKey != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read rawData failed");
184 channel->peerSessionName = (char *)data.ReadCString();
185 COMM_CHECK_AND_RETURN_RET_LOGE(
186 channel->peerSessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerSessionName failed");
187 channel->peerDeviceId = (char *)data.ReadCString();
188 COMM_CHECK_AND_RETURN_RET_LOGE(
189 channel->peerDeviceId != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read peerDeviceId failed");
190 READ_PARCEL_WITH_RET(data, Int32, channel->businessType, SOFTBUS_IPC_ERR);
191 if (channel->channelType == CHANNEL_TYPE_UDP) {
192 channel->myIp = (char *)data.ReadCString();
193 COMM_CHECK_AND_RETURN_RET_LOGE(channel->myIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read myIp failed");
194 READ_PARCEL_WITH_RET(data, Int32, channel->streamType, SOFTBUS_IPC_ERR);
195 READ_PARCEL_WITH_RET(data, Bool, channel->isUdpFile, SOFTBUS_IPC_ERR);
196 if (!channel->isServer) {
197 READ_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
198 channel->peerIp = (char *)data.ReadCString();
199 COMM_CHECK_AND_RETURN_RET_LOGE(
200 channel->peerIp != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read channel.peerIp failed");
201 }
202 }
203 READ_PARCEL_WITH_RET(data, Int32, channel->routeType, SOFTBUS_IPC_ERR);
204 READ_PARCEL_WITH_RET(data, Int32, channel->encrypt, SOFTBUS_IPC_ERR);
205 READ_PARCEL_WITH_RET(data, Int32, channel->algorithm, SOFTBUS_IPC_ERR);
206 READ_PARCEL_WITH_RET(data, Int32, channel->crc, SOFTBUS_IPC_ERR);
207 READ_PARCEL_WITH_RET(data, Uint32, channel->dataConfig, SOFTBUS_IPC_ERR);
208 READ_PARCEL_WITH_RET(data, Int32, channel->linkType, SOFTBUS_IPC_ERR);
209 READ_PARCEL_WITH_RET(data, Int32, channel->osType, SOFTBUS_IPC_ERR);
210 return SOFTBUS_OK;
211 }
212
OnChannelOpenedInner(MessageParcel & data,MessageParcel & reply)213 int32_t SoftBusClientStub::OnChannelOpenedInner(MessageParcel &data, MessageParcel &reply)
214 {
215 const char *sessionName = data.ReadCString();
216 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
217
218 ChannelInfo channel = { 0 };
219 int32_t ret = MessageParcelRead(data, &channel);
220 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "read channel info failed");
221
222 ret = OnChannelOpened(sessionName, &channel);
223 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
224 return SOFTBUS_OK;
225 }
226
OnChannelOpenFailedInner(MessageParcel & data,MessageParcel & reply)227 int32_t SoftBusClientStub::OnChannelOpenFailedInner(MessageParcel &data, MessageParcel &reply)
228 {
229 int32_t channelId;
230 COMM_CHECK_AND_RETURN_RET_LOGE(
231 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
232
233 int32_t channelType;
234 COMM_CHECK_AND_RETURN_RET_LOGE(
235 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
236
237 int32_t errCode;
238 COMM_CHECK_AND_RETURN_RET_LOGE(
239 data.ReadInt32(errCode), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read errCode failed");
240
241 int32_t ret = OnChannelOpenFailed(channelId, channelType, errCode);
242 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK, "OnChannelOpenFailed fail! ret=%{public}d", ret);
243
244 return SOFTBUS_OK;
245 }
246
OnChannelLinkDownInner(MessageParcel & data,MessageParcel & reply)247 int32_t SoftBusClientStub::OnChannelLinkDownInner(MessageParcel &data, MessageParcel &reply)
248 {
249 const char *networkId = data.ReadCString();
250 COMM_CHECK_AND_RETURN_RET_LOGE(
251 networkId != nullptr, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, COMM_SDK, "read networkId failed!");
252
253 COMM_LOGD(COMM_SDK, "SDK OnChannelMsgReceived");
254 int32_t routeType;
255 COMM_CHECK_AND_RETURN_RET_LOGE(
256 data.ReadInt32(routeType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read routeType failed");
257
258 int32_t retReply = OnChannelLinkDown(networkId, routeType);
259 if (retReply != SOFTBUS_OK) {
260 COMM_LOGE(COMM_SDK, "OnChannelLinkDown proc error!");
261 }
262 return SOFTBUS_OK;
263 }
264
OnChannelClosedInner(MessageParcel & data,MessageParcel & reply)265 int32_t SoftBusClientStub::OnChannelClosedInner(MessageParcel &data, MessageParcel &reply)
266 {
267 int32_t channelId;
268 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
269
270 int32_t channelType;
271 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
272
273 int32_t messageType;
274 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(messageType), SOFTBUS_IPC_ERR, COMM_SDK, "read messageType failed");
275
276 int32_t ret = OnChannelClosed(channelId, channelType, messageType);
277 COMM_CHECK_AND_RETURN_RET_LOGE(reply.WriteInt32(ret), SOFTBUS_IPC_ERR, COMM_SDK, "write reply failed");
278
279 return SOFTBUS_OK;
280 }
281
OnChannelMsgReceivedInner(MessageParcel & data,MessageParcel & reply)282 int32_t SoftBusClientStub::OnChannelMsgReceivedInner(MessageParcel &data, MessageParcel &reply)
283 {
284 int32_t channelId;
285 COMM_CHECK_AND_RETURN_RET_LOGE(
286 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
287
288 int32_t channelType;
289 COMM_CHECK_AND_RETURN_RET_LOGE(
290 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
291
292 uint32_t len;
293 COMM_CHECK_AND_RETURN_RET_LOGE(
294 data.ReadUint32(len), SOFTBUS_TRANS_PROXY_READUINT_FAILED, COMM_SDK, "read data len failed");
295
296 char *dataInfo = (char *)data.ReadRawData(len);
297 COMM_CHECK_AND_RETURN_RET_LOGE(
298 dataInfo != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read dataInfo failed!");
299
300 int32_t type;
301 COMM_CHECK_AND_RETURN_RET_LOGE(
302 data.ReadInt32(type), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read type failed");
303
304 int ret = OnChannelMsgReceived(channelId, channelType, dataInfo, len, type);
305 COMM_CHECK_AND_RETURN_RET_LOGE(
306 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
307
308 return SOFTBUS_OK;
309 }
310
OnChannelQosEventInner(MessageParcel & data,MessageParcel & reply)311 int32_t SoftBusClientStub::OnChannelQosEventInner(MessageParcel &data, MessageParcel &reply)
312 {
313 COMM_LOGI(COMM_EVENT, "OnChannelQosEventInner");
314 int32_t channelId;
315 COMM_CHECK_AND_RETURN_RET_LOGE(
316 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
317
318 int32_t channelType;
319 COMM_CHECK_AND_RETURN_RET_LOGE(
320 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
321
322 int32_t eventId;
323 COMM_CHECK_AND_RETURN_RET_LOGE(
324 data.ReadInt32(eventId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read eventId failed");
325
326 int32_t tvCount;
327 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(tvCount) && tvCount > 0, SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK,
328 "read tv failed! count=%{public}d", tvCount);
329
330 QosTv *tvList = (QosTv *)data.ReadRawData(sizeof(QosTv) * tvCount);
331 COMM_CHECK_AND_RETURN_RET_LOGE(
332 tvList != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read tv list failed!");
333
334 int ret = OnChannelQosEvent(channelId, channelType, eventId, tvCount, tvList);
335 COMM_CHECK_AND_RETURN_RET_LOGE(
336 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
337
338 return SOFTBUS_OK;
339 }
340
OnChannelOnQosInner(MessageParcel & data,MessageParcel & reply)341 int32_t SoftBusClientStub::OnChannelOnQosInner(MessageParcel &data, MessageParcel &reply)
342 {
343 COMM_LOGI(COMM_EVENT, "OnChannelOnQosInner");
344 int32_t channelId;
345 COMM_CHECK_AND_RETURN_RET_LOGE(
346 data.ReadInt32(channelId), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelId failed");
347
348 int32_t channelType;
349 COMM_CHECK_AND_RETURN_RET_LOGE(
350 data.ReadInt32(channelType), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read channelType failed");
351
352 int32_t event;
353 COMM_CHECK_AND_RETURN_RET_LOGE(
354 data.ReadInt32(event), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read event failed");
355
356 uint32_t count;
357 COMM_CHECK_AND_RETURN_RET_LOGE(
358 data.ReadUint32(count), SOFTBUS_TRANS_PROXY_READINT_FAILED, COMM_SDK, "read count failed");
359 COMM_CHECK_AND_RETURN_RET_LOGE(count < QOS_TYPE_BUTT, SOFTBUS_INVALID_PARAM, COMM_SDK, "invalid count");
360
361 QosTV *qos = (QosTV *)data.ReadBuffer(sizeof(QosTV) * count);
362 COMM_CHECK_AND_RETURN_RET_LOGE(
363 qos != nullptr, SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, COMM_SDK, "read qos failed!");
364
365 int32_t ret = OnClientChannelOnQos(channelId, channelType, (QoSEvent)event, qos, count);
366 if (ret != SOFTBUS_OK) {
367 COMM_LOGE(COMM_SDK, "OnClientChannelOnQos failed, ret=%{public}d", ret);
368 }
369 return SOFTBUS_OK;
370 }
371
SetChannelInfoInner(MessageParcel & data,MessageParcel & reply)372 int32_t SoftBusClientStub::SetChannelInfoInner(MessageParcel &data, MessageParcel &reply)
373 {
374 const char *sessionName = data.ReadCString();
375 COMM_CHECK_AND_RETURN_RET_LOGE(sessionName != nullptr, SOFTBUS_IPC_ERR, COMM_SDK, "read sessionName failed");
376
377 int32_t sessionId;
378 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(sessionId), SOFTBUS_IPC_ERR, COMM_SDK, "read sessionId failed");
379
380 int32_t channelId;
381 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
382
383 int32_t channelType;
384 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
385
386 int ret = SetChannelInfo(sessionName, sessionId, channelId, channelType);
387 COMM_CHECK_AND_RETURN_RET_LOGE(
388 reply.WriteInt32(ret), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, COMM_SDK, "write reply failed");
389
390 return SOFTBUS_OK;
391 }
392
OnJoinLNNResultInner(MessageParcel & data,MessageParcel & reply)393 int32_t SoftBusClientStub::OnJoinLNNResultInner(MessageParcel &data, MessageParcel &reply)
394 {
395 uint32_t addrTypeLen;
396 if (!data.ReadUint32(addrTypeLen) || addrTypeLen != sizeof(ConnectionAddr)) {
397 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr type failed! length=%{public}d", addrTypeLen);
398 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
399 }
400 void *addr = (void *)data.ReadRawData(addrTypeLen);
401 if (addr == nullptr) {
402 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read addr failed!");
403 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
404 }
405 int32_t retCode;
406 if (!data.ReadInt32(retCode)) {
407 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read retCode failed!");
408 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
409 }
410 const char *networkId = nullptr;
411 if (retCode == 0) {
412 networkId = data.ReadCString();
413 if (networkId == nullptr) {
414 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner read networkId failed!");
415 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
416 }
417 }
418 int32_t retReply = OnJoinLNNResult(addr, addrTypeLen, networkId, retCode);
419 if (retReply != SOFTBUS_OK) {
420 COMM_LOGE(COMM_SDK, "OnJoinLNNResultInner notify join result failed!");
421 }
422 return SOFTBUS_OK;
423 }
424
OnLeaveLNNResultInner(MessageParcel & data,MessageParcel & reply)425 int32_t SoftBusClientStub::OnLeaveLNNResultInner(MessageParcel &data, MessageParcel &reply)
426 {
427 const char *networkId = data.ReadCString();
428 if (networkId == nullptr) {
429 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read networkId failed!");
430 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
431 }
432 int32_t retCode;
433 if (!data.ReadInt32(retCode)) {
434 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner read retCode failed!");
435 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
436 }
437 int32_t retReply = OnLeaveLNNResult(networkId, retCode);
438 if (retReply != SOFTBUS_OK) {
439 COMM_LOGE(COMM_SDK, "OnLeaveLNNResultInner notify leave result failed!");
440 }
441 return SOFTBUS_OK;
442 }
443
OnNodeOnlineStateChangedInner(MessageParcel & data,MessageParcel & reply)444 int32_t SoftBusClientStub::OnNodeOnlineStateChangedInner(MessageParcel &data, MessageParcel &reply)
445 {
446 const char *pkgName = data.ReadCString();
447 if (pkgName == nullptr || strlen(pkgName) == 0) {
448 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
449 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
450 }
451 bool isOnline = false;
452 if (!data.ReadBool(isOnline)) {
453 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read online state failed!");
454 return SOFTBUS_TRANS_PROXY_READBOOL_FAILED;
455 }
456 uint32_t infoTypeLen;
457 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
458 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read info type failed! length=%{public}d", infoTypeLen);
459 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
460 }
461 void *info = (void *)data.ReadRawData(infoTypeLen);
462 if (info == nullptr) {
463 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner read basic info failed!");
464 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
465 }
466 int32_t retReply = OnNodeOnlineStateChanged(pkgName, isOnline, info, infoTypeLen);
467 COMM_LOGI(COMM_SDK, "notify complete, pkgName=%{public}s, isOnline=%{public}d", pkgName, isOnline);
468 if (!reply.WriteInt32(retReply)) {
469 COMM_LOGE(COMM_SDK, "OnNodeOnlineStateChangedInner write reply failed!");
470 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
471 }
472 return SOFTBUS_OK;
473 }
474
OnNodeBasicInfoChangedInner(MessageParcel & data,MessageParcel & reply)475 int32_t SoftBusClientStub::OnNodeBasicInfoChangedInner(MessageParcel &data, MessageParcel &reply)
476 {
477 const char *pkgName = data.ReadCString();
478 if (pkgName == nullptr || strlen(pkgName) == 0) {
479 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
480 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
481 }
482 int32_t type;
483 if (!data.ReadInt32(type)) {
484 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read type failed!");
485 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
486 }
487 COMM_LOGD(COMM_SDK, "OnNodeBasicInfoChangedInner type. type=%{public}d", type);
488 uint32_t infoTypeLen;
489 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeBasicInfo)) {
490 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
491 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
492 }
493 void *info = (void *)data.ReadRawData(infoTypeLen);
494 if (info == nullptr) {
495 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner read basic info failed!");
496 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
497 }
498 int32_t retReply = OnNodeBasicInfoChanged(pkgName, info, infoTypeLen, type);
499 if (!reply.WriteInt32(retReply)) {
500 COMM_LOGE(COMM_SDK, "OnNodeBasicInfoChangedInner write reply failed!");
501 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
502 }
503 return SOFTBUS_OK;
504 }
505
OnNodeStatusChangedInner(MessageParcel & data,MessageParcel & reply)506 int32_t SoftBusClientStub::OnNodeStatusChangedInner(MessageParcel &data, MessageParcel &reply)
507 {
508 const char *pkgName = data.ReadCString();
509 if (pkgName == nullptr || strlen(pkgName) == 0) {
510 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
511 return SOFTBUS_INVALID_PARAM;
512 }
513 int32_t type;
514 if (!data.ReadInt32(type)) {
515 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read type failed!");
516 return SOFTBUS_NETWORK_READINT32_FAILED;
517 }
518 COMM_LOGD(COMM_SDK, "OnNodeStatusChangedInner type=%{public}d", type);
519 uint32_t infoTypeLen;
520 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(NodeStatus)) {
521 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read failed! infoTypeLen=%{public}d", infoTypeLen);
522 return SOFTBUS_NETWORK_READINT32_FAILED;
523 }
524 void *info = (void *)data.ReadRawData(infoTypeLen);
525 if (info == nullptr) {
526 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner read node status failed!");
527 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
528 }
529 int32_t retReply = OnNodeStatusChanged(pkgName, info, infoTypeLen, type);
530 if (!reply.WriteInt32(retReply)) {
531 COMM_LOGE(COMM_SDK, "OnNodeStatusChangedInner write reply failed!");
532 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
533 }
534 return SOFTBUS_OK;
535 }
536
OnLocalNetworkIdChangedInner(MessageParcel & data,MessageParcel & reply)537 int32_t SoftBusClientStub::OnLocalNetworkIdChangedInner(MessageParcel &data, MessageParcel &reply)
538 {
539 const char *pkgName = data.ReadCString();
540 if (pkgName == nullptr || strlen(pkgName) == 0) {
541 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
542 return SOFTBUS_INVALID_PARAM;
543 }
544 int32_t retReply = OnLocalNetworkIdChanged(pkgName);
545 if (!reply.WriteInt32(retReply)) {
546 COMM_LOGE(COMM_SDK, "OnLocalNetworkIdChangedInner write reply failed!");
547 return SOFTBUS_IPC_ERR;
548 }
549 return SOFTBUS_OK;
550 }
551
OnNodeDeviceNotTrustedInner(MessageParcel & data,MessageParcel & reply)552 int32_t SoftBusClientStub::OnNodeDeviceNotTrustedInner(MessageParcel &data, MessageParcel &reply)
553 {
554 const char *pkgName = data.ReadCString();
555 if (pkgName == nullptr || strlen(pkgName) == 0) {
556 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
557 return SOFTBUS_INVALID_PARAM;
558 }
559 const char *msg = data.ReadCString();
560 if (msg == nullptr) {
561 COMM_LOGE(COMM_SDK, "OnNodeDeviceNotTrustedInner read msg failed!");
562 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
563 }
564 int32_t retReply = OnNodeDeviceNotTrusted(pkgName, msg);
565 if (!reply.WriteInt32(retReply)) {
566 COMM_LOGE(COMM_SDK, "OnNodeDeviceNotTrustedInner write reply failed!");
567 return SOFTBUS_IPC_ERR;
568 }
569 return SOFTBUS_OK;
570 }
571
OnHichainProofExceptionInner(MessageParcel & data,MessageParcel & reply)572 int32_t SoftBusClientStub::OnHichainProofExceptionInner(MessageParcel &data, MessageParcel &reply)
573 {
574 const char *pkgName = data.ReadCString();
575 if (pkgName == nullptr || strlen(pkgName) == 0) {
576 COMM_LOGE(COMM_SDK, "Invalid package name, or length is zero");
577 return SOFTBUS_INVALID_PARAM;
578 }
579 uint32_t proofLen = 0;
580 if (!data.ReadUint32(proofLen)) {
581 COMM_LOGE(COMM_SDK, "read failed! proofLen=%{public}u", proofLen);
582 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
583 }
584 char *proofInfo = nullptr;
585 if (proofLen != 0) {
586 proofInfo = (char *)data.ReadRawData(proofLen);
587 if (proofInfo == nullptr) {
588 COMM_LOGE(COMM_SDK, "read proofInfo failed!");
589 return SOFTBUS_NETWORK_READRAWDATA_FAILED;
590 }
591 }
592 uint16_t deviceTypeId = 0;
593 if (!data.ReadUint16(deviceTypeId)) {
594 COMM_LOGE(COMM_SDK, "read failed! deviceTypeId=%{public}hu", deviceTypeId);
595 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
596 }
597 int32_t errCode = 0;
598 if (!data.ReadInt32(errCode)) {
599 COMM_LOGE(COMM_SDK, "read failed! errCode=%{public}d", errCode);
600 return SOFTBUS_NETWORK_PROXY_READINT_FAILED;
601 }
602 int32_t retReply = OnHichainProofException(pkgName, proofInfo, proofLen, deviceTypeId, errCode);
603 if (!reply.WriteInt32(retReply)) {
604 COMM_LOGE(COMM_SDK, "OnHichainProofException write reply failed!");
605 return SOFTBUS_NETWORK_WRITEINT32_FAILED;
606 }
607 return SOFTBUS_OK;
608 }
609
OnTimeSyncResultInner(MessageParcel & data,MessageParcel & reply)610 int32_t SoftBusClientStub::OnTimeSyncResultInner(MessageParcel &data, MessageParcel &reply)
611 {
612 uint32_t infoTypeLen;
613 if (!data.ReadUint32(infoTypeLen) || infoTypeLen != sizeof(TimeSyncResultInfo)) {
614 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed! length=%{public}d", infoTypeLen);
615 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
616 }
617 void *info = (void *)data.ReadRawData(infoTypeLen);
618 if (info == nullptr) {
619 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read info failed!");
620 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
621 }
622 int32_t retCode;
623 if (!data.ReadInt32(retCode)) {
624 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner read retCode failed!");
625 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
626 }
627
628 int32_t retReply = OnTimeSyncResult(info, infoTypeLen, retCode);
629 if (!reply.WriteInt32(retReply)) {
630 COMM_LOGE(COMM_SDK, "OnTimeSyncResultInner write reply failed!");
631 return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
632 }
633 return SOFTBUS_OK;
634 }
635
OnPublishLNNResultInner(MessageParcel & data,MessageParcel & reply)636 int32_t SoftBusClientStub::OnPublishLNNResultInner(MessageParcel &data, MessageParcel &reply)
637 {
638 int32_t publishId;
639 if (!data.ReadInt32(publishId)) {
640 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read publishId failed!");
641 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
642 }
643 int32_t reason;
644 if (!data.ReadInt32(reason)) {
645 COMM_LOGE(COMM_SDK, "OnPublishLNNResultInner read reason failed!");
646 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
647 }
648
649 OnPublishLNNResult(publishId, reason);
650 return SOFTBUS_OK;
651 }
652
OnRefreshLNNResultInner(MessageParcel & data,MessageParcel & reply)653 int32_t SoftBusClientStub::OnRefreshLNNResultInner(MessageParcel &data, MessageParcel &reply)
654 {
655 int32_t refreshId;
656 if (!data.ReadInt32(refreshId)) {
657 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read publishId failed!");
658 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
659 }
660 int32_t reason;
661 if (!data.ReadInt32(reason)) {
662 COMM_LOGE(COMM_SDK, "OnRefreshLNNResultInner read reason failed!");
663 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
664 }
665
666 OnRefreshLNNResult(refreshId, reason);
667 return SOFTBUS_OK;
668 }
669
OnRefreshDeviceFoundInner(MessageParcel & data,MessageParcel & reply)670 int32_t SoftBusClientStub::OnRefreshDeviceFoundInner(MessageParcel &data, MessageParcel &reply)
671 {
672 uint32_t deviceLen;
673 if (!data.ReadUint32(deviceLen) || deviceLen != sizeof(DeviceInfo)) {
674 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed! length=%{public}d", deviceLen);
675 return SOFTBUS_TRANS_PROXY_READUINT_FAILED;
676 }
677 void *device = (void *)data.ReadRawData(deviceLen);
678 if (device == nullptr) {
679 COMM_LOGE(COMM_SDK, "OnRefreshDeviceFoundInner read info failed!");
680 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
681 }
682 OnRefreshDeviceFound(device, deviceLen);
683 return SOFTBUS_OK;
684 }
685
OnDataLevelChangedInner(MessageParcel & data,MessageParcel & reply)686 int32_t SoftBusClientStub::OnDataLevelChangedInner(MessageParcel &data, MessageParcel &reply)
687 {
688 const char *networkId = data.ReadCString();
689 if (networkId == nullptr || strlen(networkId) == 0) {
690 COMM_LOGE(COMM_SDK, "Invalid network, or length is zero");
691 return SOFTBUS_TRANS_PROXY_READCSTRING_FAILED;
692 }
693
694 DataLevelInfo *info = (DataLevelInfo *)data.ReadRawData(sizeof(DataLevelInfo));
695 if (info == nullptr) {
696 COMM_LOGE(COMM_SDK, "OnDataLevelChangedInner read data level chagne info failed");
697 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
698 }
699 OnDataLevelChanged(networkId, info);
700 return SOFTBUS_OK;
701 }
702
OnChannelBind(int32_t channelId,int32_t channelType)703 int32_t SoftBusClientStub::OnChannelBind(int32_t channelId, int32_t channelType)
704 {
705 return TransOnChannelBind(channelId, channelType);
706 }
707
OnChannelBindInner(MessageParcel & data,MessageParcel & reply)708 int32_t SoftBusClientStub::OnChannelBindInner(MessageParcel &data, MessageParcel &reply)
709 {
710 int32_t channelId;
711 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelId), SOFTBUS_IPC_ERR, COMM_SDK, "read channelId failed");
712
713 int32_t channelType;
714 COMM_CHECK_AND_RETURN_RET_LOGE(data.ReadInt32(channelType), SOFTBUS_IPC_ERR, COMM_SDK, "read channelType failed");
715
716 int32_t ret = OnChannelBind(channelId, channelType);
717 COMM_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, COMM_SDK,
718 "OnChannelBind failed! ret=%{public}d, channelId=%{public}d, channelType=%{public}d",
719 ret, channelId, channelType);
720
721 return SOFTBUS_OK;
722 }
723
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int retCode)724 int32_t SoftBusClientStub::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
725 {
726 (void)addrTypeLen;
727 return LnnOnJoinResult(addr, networkId, retCode);
728 }
729
OnLeaveLNNResult(const char * networkId,int retCode)730 int32_t SoftBusClientStub::OnLeaveLNNResult(const char *networkId, int retCode)
731 {
732 return LnnOnLeaveResult(networkId, retCode);
733 }
734
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)735 int32_t SoftBusClientStub::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
736 void *info, uint32_t infoTypeLen)
737 {
738 (void)infoTypeLen;
739 return LnnOnNodeOnlineStateChanged(pkgName, isOnline, info);
740 }
741
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)742 int32_t SoftBusClientStub::OnNodeBasicInfoChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
743 {
744 (void)infoTypeLen;
745 return LnnOnNodeBasicInfoChanged(pkgName, info, type);
746 }
747
OnNodeStatusChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)748 int32_t SoftBusClientStub::OnNodeStatusChanged(const char *pkgName, void *info, uint32_t infoTypeLen, int32_t type)
749 {
750 (void)infoTypeLen;
751 return LnnOnNodeStatusChanged(pkgName, info, type);
752 }
753
OnLocalNetworkIdChanged(const char * pkgName)754 int32_t SoftBusClientStub::OnLocalNetworkIdChanged(const char *pkgName)
755 {
756 return LnnOnLocalNetworkIdChanged(pkgName);
757 }
758
OnNodeDeviceNotTrusted(const char * pkgName,const char * msg)759 int32_t SoftBusClientStub::OnNodeDeviceNotTrusted(const char *pkgName, const char *msg)
760 {
761 return LnnOnNodeDeviceNotTrusted(pkgName, msg);
762 }
763
OnHichainProofException(const char * pkgName,const char * proofInfo,uint32_t proofLen,uint16_t deviceTypeId,int32_t errCode)764 int32_t SoftBusClientStub::OnHichainProofException(
765 const char *pkgName, const char *proofInfo, uint32_t proofLen, uint16_t deviceTypeId, int32_t errCode)
766 {
767 return LnnOnHichainProofException(pkgName, proofInfo, proofLen, deviceTypeId, errCode);
768 }
769
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)770 int32_t SoftBusClientStub::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
771 {
772 (void)infoTypeLen;
773 return LnnOnTimeSyncResult(info, retCode);
774 }
775
OnPublishLNNResult(int32_t publishId,int32_t reason)776 void SoftBusClientStub::OnPublishLNNResult(int32_t publishId, int32_t reason)
777 {
778 LnnOnPublishLNNResult(publishId, reason);
779 }
780
OnRefreshLNNResult(int32_t refreshId,int32_t reason)781 void SoftBusClientStub::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
782 {
783 LnnOnRefreshLNNResult(refreshId, reason);
784 }
785
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)786 void SoftBusClientStub::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
787 {
788 (void)deviceLen;
789 LnnOnRefreshDeviceFound(device);
790 }
791
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)792 void SoftBusClientStub::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
793 {
794 LnnOnDataLevelChanged(networkId, dataLevelInfo);
795 }
796
OnClientChannelOnQos(int32_t channelId,int32_t channelType,QoSEvent event,const QosTV * qos,uint32_t count)797 int32_t SoftBusClientStub::OnClientChannelOnQos(
798 int32_t channelId, int32_t channelType, QoSEvent event, const QosTV *qos, uint32_t count)
799 {
800 if (event < QOS_SATISFIED || event > QOS_NOT_SATISFIED) {
801 COMM_LOGE(COMM_SDK, "OnChannelOnQos invalid event=%{public}d", event);
802 return SOFTBUS_INVALID_PARAM;
803 }
804 if (qos == nullptr || count == 0) {
805 COMM_LOGE(COMM_SDK, "OnChannelOnQos invalid qos or count");
806 return SOFTBUS_INVALID_PARAM;
807 }
808 return TransOnChannelOnQos(channelId, channelType, event, qos, count);
809 }
810 } // namespace OHOS
811