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 "trans_client_proxy_standard.h"
17
18 #include "message_parcel.h"
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_server_ipc_interface_code.h"
22 #include "trans_log.h"
23
24 #define WRITE_PARCEL_WITH_RET(parcel, type, data, retval) \
25 do { \
26 if (!(parcel).Write##type(data)) { \
27 TRANS_LOGE(TRANS_SVC, "write data failed."); \
28 return (retval); \
29 } \
30 } while (false)
31
32 namespace OHOS {
OnClientPermissonChange(const char * pkgName,int32_t state)33 int32_t TransClientProxy::OnClientPermissonChange(const char *pkgName, int32_t state)
34 {
35 sptr<IRemoteObject> remote = Remote();
36 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
37 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
38 MessageParcel data;
39 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
40 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
41 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(state),
42 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write permStateChangeType failed");
43 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteCString(pkgName),
44 SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED, TRANS_CTRL, "write pkgName failed");
45 MessageParcel reply;
46 MessageOption option = { MessageOption::TF_ASYNC };
47 int32_t ret = remote->SendRequest(CLIENT_ON_PERMISSION_CHANGE, data, reply, option);
48 if (ret != SOFTBUS_OK) {
49 TRANS_LOGE(TRANS_CTRL,
50 "DataSyncPermissionChange send request failed, ret=%{public}d", ret);
51 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
52 }
53 return SOFTBUS_OK;
54 }
55
MessageParcelWrite(MessageParcel & data,const char * sessionName,const ChannelInfo * channel)56 int32_t TransClientProxy::MessageParcelWrite(MessageParcel &data, const char *sessionName, const ChannelInfo *channel)
57 {
58 if (!data.WriteInterfaceToken(GetDescriptor())) {
59 TRANS_LOGE(TRANS_CTRL, "write InterfaceToken failed.");
60 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
61 }
62 WRITE_PARCEL_WITH_RET(data, CString, sessionName, SOFTBUS_IPC_ERR);
63 WRITE_PARCEL_WITH_RET(data, Int32, channel->channelId, SOFTBUS_IPC_ERR);
64 WRITE_PARCEL_WITH_RET(data, Int32, channel->channelType, SOFTBUS_IPC_ERR);
65 WRITE_PARCEL_WITH_RET(data, Uint64, channel->laneId, SOFTBUS_IPC_ERR);
66 WRITE_PARCEL_WITH_RET(data, Int32, channel->connectType, SOFTBUS_IPC_ERR);
67
68 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
69 WRITE_PARCEL_WITH_RET(data, FileDescriptor, channel->fd, SOFTBUS_IPC_ERR);
70 WRITE_PARCEL_WITH_RET(data, CString, channel->myIp, SOFTBUS_IPC_ERR);
71 }
72 WRITE_PARCEL_WITH_RET(data, Bool, channel->isServer, SOFTBUS_IPC_ERR);
73 WRITE_PARCEL_WITH_RET(data, Bool, channel->isEnabled, SOFTBUS_IPC_ERR);
74 WRITE_PARCEL_WITH_RET(data, Bool, channel->isEncrypt, SOFTBUS_IPC_ERR);
75 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerUid, SOFTBUS_IPC_ERR);
76 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerPid, SOFTBUS_IPC_ERR);
77 WRITE_PARCEL_WITH_RET(data, CString, channel->groupId, SOFTBUS_IPC_ERR);
78 WRITE_PARCEL_WITH_RET(data, Uint32, channel->keyLen, SOFTBUS_IPC_ERR);
79 if (!data.WriteRawData(channel->sessionKey, channel->keyLen)) {
80 TRANS_LOGE(TRANS_CTRL, "write sessionKey and keyLen failed.");
81 return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
82 }
83 WRITE_PARCEL_WITH_RET(data, CString, channel->peerSessionName, SOFTBUS_IPC_ERR);
84 WRITE_PARCEL_WITH_RET(data, CString, channel->peerDeviceId, SOFTBUS_IPC_ERR);
85 WRITE_PARCEL_WITH_RET(data, Int32, channel->businessType, SOFTBUS_IPC_ERR);
86 if (channel->channelType == CHANNEL_TYPE_UDP) {
87 WRITE_PARCEL_WITH_RET(data, CString, channel->myIp, SOFTBUS_IPC_ERR);
88 WRITE_PARCEL_WITH_RET(data, Int32, channel->streamType, SOFTBUS_IPC_ERR);
89 WRITE_PARCEL_WITH_RET(data, Bool, channel->isUdpFile, SOFTBUS_IPC_ERR);
90
91 if (!channel->isServer) {
92 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
93 WRITE_PARCEL_WITH_RET(data, CString, channel->peerIp, SOFTBUS_IPC_ERR);
94 }
95 }
96 WRITE_PARCEL_WITH_RET(data, Int32, channel->routeType, SOFTBUS_IPC_ERR);
97 WRITE_PARCEL_WITH_RET(data, Int32, channel->encrypt, SOFTBUS_IPC_ERR);
98 WRITE_PARCEL_WITH_RET(data, Int32, channel->algorithm, SOFTBUS_IPC_ERR);
99 WRITE_PARCEL_WITH_RET(data, Int32, channel->crc, SOFTBUS_IPC_ERR);
100 WRITE_PARCEL_WITH_RET(data, Uint32, channel->dataConfig, SOFTBUS_IPC_ERR);
101 WRITE_PARCEL_WITH_RET(data, Int32, channel->linkType, SOFTBUS_IPC_ERR);
102 WRITE_PARCEL_WITH_RET(data, Int32, channel->osType, SOFTBUS_IPC_ERR);
103 return SOFTBUS_OK;
104 }
105
OnClientTransLimitChange(int32_t channelId,uint8_t tos)106 int32_t TransClientProxy::OnClientTransLimitChange(int32_t channelId, uint8_t tos)
107 {
108 sptr<IRemoteObject> remote = Remote();
109 if (remote == nullptr) {
110 TRANS_LOGE(TRANS_CTRL, "remote is nullptr");
111 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
112 }
113 MessageParcel data;
114 if (!data.WriteInterfaceToken(GetDescriptor())) {
115 TRANS_LOGE(TRANS_CTRL, "write InterfaceToken failed!");
116 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
117 }
118 if (!data.WriteInt32(channelId)) {
119 TRANS_LOGE(TRANS_CTRL, "write channel id failed");
120 return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
121 }
122 if (!data.WriteUint8(tos)) {
123 TRANS_LOGE(TRANS_CTRL, "write tos failed");
124 return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
125 }
126
127 MessageParcel reply;
128 MessageOption option;
129 int32_t ret = remote->SendRequest(CLIENT_ON_TRANS_LIMIT_CHANGE, data, reply, option);
130 if (ret != SOFTBUS_OK) {
131 TRANS_LOGE(TRANS_CTRL, "OnClientTransLimitChange send request failed, ret=%{public}d", ret);
132 return ret;
133 }
134 int32_t serverRet;
135 if (!reply.ReadInt32(serverRet)) {
136 TRANS_LOGE(TRANS_CTRL, "OnChannelOpened read serverRet failed");
137 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
138 }
139 return serverRet;
140 }
141
OnChannelOpened(const char * sessionName,const ChannelInfo * channel)142 int32_t TransClientProxy::OnChannelOpened(const char *sessionName, const ChannelInfo *channel)
143 {
144 sptr<IRemoteObject> remote = Remote();
145 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
146 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
147 MessageParcel data;
148 int32_t ret = MessageParcelWrite(data, sessionName, channel);
149 if (ret != SOFTBUS_OK) {
150 TRANS_LOGE(TRANS_CTRL, "message parcel write failed.");
151 return ret;
152 }
153
154 MessageParcel reply;
155 MessageOption option;
156 ret = remote->SendRequest(CLIENT_ON_CHANNEL_OPENED, data, reply, option);
157 if (ret != SOFTBUS_OK) {
158 TRANS_LOGE(TRANS_CTRL, "OnChannelOpened send request failed, ret=%{public}d", ret);
159 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
160 }
161 int32_t serverRet;
162 if (!reply.ReadInt32(serverRet)) {
163 TRANS_LOGE(TRANS_CTRL, "OnChannelOpened read serverRet failed");
164 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
165 }
166 return serverRet;
167 }
168
OnChannelBind(int32_t channelId,int32_t channelType)169 int32_t TransClientProxy::OnChannelBind(int32_t channelId, int32_t channelType)
170 {
171 sptr<IRemoteObject> remote = Remote();
172 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
173 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
174
175 MessageParcel data;
176 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
177 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
178 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
179 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
180 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
181 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
182
183 MessageParcel reply;
184 MessageOption option = { MessageOption::TF_ASYNC };
185 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_BIND, data, reply, option);
186 if (ret != SOFTBUS_OK) {
187 TRANS_LOGE(
188 TRANS_CTRL, "OnChannelBind send request failed, ret=%{public}d, channelId=%{public}d", ret, channelId);
189 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
190 }
191
192 return SOFTBUS_OK;
193 }
194
OnChannelOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)195 int32_t TransClientProxy::OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
196 {
197 sptr<IRemoteObject> remote = Remote();
198 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
199 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
200
201 MessageParcel data;
202 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
203 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
204 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
205 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
206 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
207 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
208 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(errCode),
209 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write error code failed");
210
211 MessageParcel reply;
212 MessageOption option = { MessageOption::TF_ASYNC };
213 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_OPENFAILED, data, reply, option);
214 if (ret != SOFTBUS_OK) {
215 TRANS_LOGE(TRANS_CTRL, "OnChannelOpenFailed send request failed, ret=%{public}d", ret);
216 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
217 }
218
219 return SOFTBUS_OK;
220 }
221
OnChannelLinkDown(const char * networkId,int32_t routeType)222 int32_t TransClientProxy::OnChannelLinkDown(const char *networkId, int32_t routeType)
223 {
224 sptr<IRemoteObject> remote = Remote();
225 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
226 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
227 TRANS_CHECK_AND_RETURN_RET_LOGE(networkId != nullptr,
228 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "invalid parameters");
229
230 MessageParcel data;
231 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
232 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
233 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteCString(networkId),
234 SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED, TRANS_CTRL, "write networkId failed");
235 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(routeType),
236 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write routeType failed");
237
238 MessageParcel reply;
239 MessageOption option(MessageOption::TF_ASYNC);
240 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_LINKDOWN, data, reply, option);
241 if (ret != SOFTBUS_OK) {
242 TRANS_LOGE(TRANS_CTRL, "OnChannelLinkDwon send request failed, ret=%{public}d", ret);
243 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
244 }
245 return SOFTBUS_OK;
246 }
247
OnChannelClosed(int32_t channelId,int32_t channelType,int32_t messageType)248 int32_t TransClientProxy::OnChannelClosed(int32_t channelId, int32_t channelType, int32_t messageType)
249 {
250 sptr<IRemoteObject> remote = Remote();
251 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
252 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
253
254 MessageParcel data;
255 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
256 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
257 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
258 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
259 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
260 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
261 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(messageType),
262 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write message type failed");
263
264 MessageParcel reply;
265 MessageOption option(MessageOption::TF_ASYNC);
266 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_CLOSED, data, reply, option);
267 if (ret != SOFTBUS_OK) {
268 TRANS_LOGE(TRANS_CTRL, "OnChannelClosed send request failed, ret=%{public}d", ret);
269 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
270 }
271 return SOFTBUS_OK;
272 }
273
OnChannelMsgReceived(int32_t channelId,int32_t channelType,const void * dataInfo,uint32_t len,int32_t type)274 int32_t TransClientProxy::OnChannelMsgReceived(int32_t channelId, int32_t channelType, const void *dataInfo,
275 uint32_t len, int32_t type)
276 {
277 sptr<IRemoteObject> remote = Remote();
278 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
279 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
280
281 MessageParcel data;
282 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
283 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
284 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
285 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
286 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
287 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
288 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteUint32(len),
289 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write data len failed");
290 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(dataInfo, len),
291 SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, TRANS_CTRL, "write (dataInfo, len) failed");
292 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(type),
293 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write type failed");
294
295 MessageParcel reply;
296 MessageOption option(MessageOption::TF_ASYNC);
297 TRANS_LOGD(TRANS_CTRL, "SendRequest start");
298 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_MSGRECEIVED, data, reply, option);
299 if (ret != SOFTBUS_OK) {
300 TRANS_LOGE(TRANS_CTRL, "OnChannelMsgReceived send request failed, ret=%{public}d",
301 ret);
302 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
303 }
304 return SOFTBUS_OK;
305 }
306
OnChannelQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)307 int32_t TransClientProxy::OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId, int32_t tvCount,
308 const QosTv *tvList)
309 {
310 sptr<IRemoteObject> remote = Remote();
311 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
312 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
313
314 MessageParcel data;
315 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
316 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
317 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
318 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
319 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
320 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
321 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(eventId),
322 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write eventId failed");
323 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(tvCount),
324 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write tv count failed");
325 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(tvList, sizeof(QosTv) * tvCount),
326 SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, TRANS_CTRL, "write tv list failed");
327 MessageParcel reply;
328 MessageOption option;
329 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_QOSEVENT, data, reply, option);
330 if (ret != SOFTBUS_OK) {
331 TRANS_LOGE(TRANS_CTRL, "OnChannelQosEvent send request failed, ret=%{public}d", ret);
332 return ret;
333 }
334 int32_t serverRet;
335 if (!reply.ReadInt32(serverRet)) {
336 TRANS_LOGE(TRANS_CTRL, "OnChannelQosEvent read serverRet failed");
337 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
338 }
339 return SOFTBUS_OK;
340 }
341
SetChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)342 int32_t TransClientProxy::SetChannelInfo(
343 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
344 {
345 if (sessionName == nullptr) {
346 TRANS_LOGE(TRANS_CTRL, "Invalid param");
347 return SOFTBUS_INVALID_PARAM;
348 }
349 sptr<IRemoteObject> remote = Remote();
350 if (remote == nullptr) {
351 TRANS_LOGE(TRANS_CTRL, "Remote is nullptr");
352 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
353 }
354
355 MessageParcel data;
356 if (!data.WriteInterfaceToken(GetDescriptor())) {
357 TRANS_LOGE(TRANS_CTRL, "Write InterfaceToken failed!");
358 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
359 }
360 WRITE_PARCEL_WITH_RET(data, CString, sessionName, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
361 WRITE_PARCEL_WITH_RET(data, Int32, sessionId, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
362 WRITE_PARCEL_WITH_RET(data, Int32, channelId, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
363 WRITE_PARCEL_WITH_RET(data, Int32, channelType, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
364 MessageParcel reply;
365 MessageOption option;
366 int32_t ret = remote->SendRequest(CLIENT_SET_CHANNEL_INFO, data, reply, option);
367 if (ret != SOFTBUS_OK) {
368 TRANS_LOGE(TRANS_CTRL, "Send request failed, ret=%{public}d", ret);
369 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
370 }
371 int32_t serverRet;
372 if (!reply.ReadInt32(serverRet)) {
373 TRANS_LOGE(TRANS_CTRL, "read serverRet failed");
374 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
375 }
376 return serverRet;
377 }
378
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int retCode)379 int32_t TransClientProxy::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
380 {
381 (void)addr;
382 (void)addrTypeLen;
383 (void)networkId;
384 (void)retCode;
385 return SOFTBUS_OK;
386 }
387
OnJoinMetaNodeResult(void * addr,uint32_t addrTypeLen,void * metaInfo,uint32_t infoLen,int retCode)388 int32_t TransClientProxy::OnJoinMetaNodeResult(void *addr, uint32_t addrTypeLen, void *metaInfo,
389 uint32_t infoLen, int retCode)
390 {
391 (void)addr;
392 (void)addrTypeLen;
393 (void)metaInfo;
394 (void)infoLen;
395 (void)retCode;
396 return SOFTBUS_OK;
397 }
398
OnLeaveLNNResult(const char * networkId,int retCode)399 int32_t TransClientProxy::OnLeaveLNNResult(const char *networkId, int retCode)
400 {
401 (void)networkId;
402 (void)retCode;
403 return SOFTBUS_OK;
404 }
405
OnLeaveMetaNodeResult(const char * networkId,int retCode)406 int32_t TransClientProxy::OnLeaveMetaNodeResult(const char *networkId, int retCode)
407 {
408 (void)networkId;
409 (void)retCode;
410 return SOFTBUS_OK;
411 }
412
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)413 int32_t TransClientProxy::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
414 void *info, uint32_t infoTypeLen)
415 {
416 (void)pkgName;
417 (void)isOnline;
418 (void)info;
419 (void)infoTypeLen;
420 return SOFTBUS_OK;
421 }
422
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)423 int32_t TransClientProxy::OnNodeBasicInfoChanged(const char *pkgName, void *info,
424 uint32_t infoTypeLen, int32_t type)
425 {
426 (void)pkgName;
427 (void)info;
428 (void)infoTypeLen;
429 (void)type;
430 return SOFTBUS_OK;
431 }
432
OnNodeStatusChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)433 int32_t TransClientProxy::OnNodeStatusChanged(const char *pkgName, void *info,
434 uint32_t infoTypeLen, int32_t type)
435 {
436 (void)pkgName;
437 (void)info;
438 (void)infoTypeLen;
439 (void)type;
440 return SOFTBUS_OK;
441 }
442
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)443 int32_t TransClientProxy::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
444 {
445 (void)info;
446 (void)infoTypeLen;
447 (void)retCode;
448 return SOFTBUS_OK;
449 }
450
OnPublishLNNResult(int32_t publishId,int32_t reason)451 void TransClientProxy::OnPublishLNNResult(int32_t publishId, int32_t reason)
452 {
453 (void)publishId;
454 (void)reason;
455 }
456
OnRefreshLNNResult(int32_t refreshId,int32_t reason)457 void TransClientProxy::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
458 {
459 (void)refreshId;
460 (void)reason;
461 }
462
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)463 void TransClientProxy::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
464 {
465 (void)device;
466 (void)deviceLen;
467 }
468
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)469 void TransClientProxy::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
470 {
471 (void)networkId;
472 (void)dataLevelInfo;
473 }
474 } // namespace OHOS