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 
OnClientChannelOnQos(int32_t channelId,int32_t channelType,QoSEvent event,const QosTV * qos,uint32_t count)379 int32_t TransClientProxy::OnClientChannelOnQos(
380     int32_t channelId, int32_t channelType, QoSEvent event, const QosTV *qos, uint32_t count)
381 {
382     if (qos == nullptr) {
383         TRANS_LOGE(TRANS_CTRL, "qos is nullptr");
384         return SOFTBUS_INVALID_PARAM;
385     }
386     sptr<IRemoteObject> remote = Remote();
387     TRANS_CHECK_AND_RETURN_RET_LOGE(
388         remote != nullptr, SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
389 
390     MessageParcel data;
391     TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()), SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED,
392         TRANS_CTRL, "write interface token failed!");
393     TRANS_CHECK_AND_RETURN_RET_LOGE(
394         data.WriteInt32(channelId), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
395     TRANS_CHECK_AND_RETURN_RET_LOGE(
396         data.WriteInt32(channelType), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
397     TRANS_CHECK_AND_RETURN_RET_LOGE(
398         data.WriteInt32(event), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write qos event failed");
399     TRANS_CHECK_AND_RETURN_RET_LOGE(
400         data.WriteUint32(count), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write qos tv count failed");
401     TRANS_CHECK_AND_RETURN_RET_LOGE(
402         data.WriteBuffer(qos, sizeof(QosTV) * count), SOFTBUS_IPC_ERR, TRANS_CTRL, "write qos failed");
403     MessageParcel reply;
404     MessageOption option = { MessageOption::TF_ASYNC };
405     int32_t ret = remote->SendRequest(CLIENT_CHANNEL_ON_QOS, data, reply, option);
406     if (ret != SOFTBUS_OK) {
407         TRANS_LOGE(TRANS_CTRL, "OnClientChannelOnQos send request failed, ret=%{public}d", ret);
408         return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
409     }
410     return SOFTBUS_OK;
411 }
412 
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int retCode)413 int32_t TransClientProxy::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int retCode)
414 {
415     (void)addr;
416     (void)addrTypeLen;
417     (void)networkId;
418     (void)retCode;
419     return SOFTBUS_OK;
420 }
421 
OnJoinMetaNodeResult(void * addr,uint32_t addrTypeLen,void * metaInfo,uint32_t infoLen,int retCode)422 int32_t TransClientProxy::OnJoinMetaNodeResult(void *addr, uint32_t addrTypeLen, void *metaInfo,
423     uint32_t infoLen, int retCode)
424 {
425     (void)addr;
426     (void)addrTypeLen;
427     (void)metaInfo;
428     (void)infoLen;
429     (void)retCode;
430     return SOFTBUS_OK;
431 }
432 
OnLeaveLNNResult(const char * networkId,int retCode)433 int32_t TransClientProxy::OnLeaveLNNResult(const char *networkId, int retCode)
434 {
435     (void)networkId;
436     (void)retCode;
437     return SOFTBUS_OK;
438 }
439 
OnLeaveMetaNodeResult(const char * networkId,int retCode)440 int32_t TransClientProxy::OnLeaveMetaNodeResult(const char *networkId, int retCode)
441 {
442     (void)networkId;
443     (void)retCode;
444     return SOFTBUS_OK;
445 }
446 
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)447 int32_t TransClientProxy::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
448     void *info, uint32_t infoTypeLen)
449 {
450     (void)pkgName;
451     (void)isOnline;
452     (void)info;
453     (void)infoTypeLen;
454     return SOFTBUS_OK;
455 }
456 
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)457 int32_t TransClientProxy::OnNodeBasicInfoChanged(const char *pkgName, void *info,
458     uint32_t infoTypeLen, int32_t type)
459 {
460     (void)pkgName;
461     (void)info;
462     (void)infoTypeLen;
463     (void)type;
464     return SOFTBUS_OK;
465 }
466 
OnNodeStatusChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)467 int32_t TransClientProxy::OnNodeStatusChanged(const char *pkgName, void *info,
468     uint32_t infoTypeLen, int32_t type)
469 {
470     (void)pkgName;
471     (void)info;
472     (void)infoTypeLen;
473     (void)type;
474     return SOFTBUS_OK;
475 }
476 
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)477 int32_t TransClientProxy::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
478 {
479     (void)info;
480     (void)infoTypeLen;
481     (void)retCode;
482     return SOFTBUS_OK;
483 }
484 
OnPublishLNNResult(int32_t publishId,int32_t reason)485 void TransClientProxy::OnPublishLNNResult(int32_t publishId, int32_t reason)
486 {
487     (void)publishId;
488     (void)reason;
489 }
490 
OnRefreshLNNResult(int32_t refreshId,int32_t reason)491 void TransClientProxy::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
492 {
493     (void)refreshId;
494     (void)reason;
495 }
496 
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)497 void TransClientProxy::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
498 {
499     (void)device;
500     (void)deviceLen;
501 }
502 
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)503 void TransClientProxy::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
504 {
505     (void)networkId;
506     (void)dataLevelInfo;
507 }
508 } // namespace OHOS