1 /*
2 * Copyright (c) 2021-2025 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 "softbus_access_token_adapter.h"
19 #include "softbus_server_ipc_interface_code.h"
20 #include "trans_channel_manager.h"
21 #include "trans_log.h"
22 #include "trans_session_account_adapter.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 if (pkgName == NULL) {
36 TRANS_LOGE(TRANS_SDK, "invalid param.");
37 return SOFTBUS_INVALID_PARAM;
38 }
39 sptr<IRemoteObject> remote = Remote();
40 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
41 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
42 MessageParcel data;
43 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
44 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
45 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(state),
46 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write permStateChangeType failed");
47 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteCString(pkgName),
48 SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED, TRANS_CTRL, "write pkgName failed");
49 MessageParcel reply;
50 MessageOption option = { MessageOption::TF_ASYNC };
51 int32_t ret = remote->SendRequest(CLIENT_ON_PERMISSION_CHANGE, data, reply, option);
52 if (ret != SOFTBUS_OK) {
53 TRANS_LOGE(TRANS_CTRL,
54 "DataSyncPermissionChange send request failed, ret=%{public}d", ret);
55 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
56 }
57 return SOFTBUS_OK;
58 }
59
MessageParcelWriteEx(MessageParcel & data,const ChannelInfo * channel)60 static int32_t MessageParcelWriteEx(MessageParcel &data, const ChannelInfo *channel)
61 {
62 WRITE_PARCEL_WITH_RET(data, Int32, channel->routeType, SOFTBUS_IPC_ERR);
63 WRITE_PARCEL_WITH_RET(data, Int32, channel->encrypt, SOFTBUS_IPC_ERR);
64 WRITE_PARCEL_WITH_RET(data, Int32, channel->algorithm, SOFTBUS_IPC_ERR);
65 WRITE_PARCEL_WITH_RET(data, Int32, channel->crc, SOFTBUS_IPC_ERR);
66 WRITE_PARCEL_WITH_RET(data, Uint32, channel->dataConfig, SOFTBUS_IPC_ERR);
67 WRITE_PARCEL_WITH_RET(data, Int32, channel->linkType, SOFTBUS_IPC_ERR);
68 WRITE_PARCEL_WITH_RET(data, Int32, channel->osType, SOFTBUS_IPC_ERR);
69 WRITE_PARCEL_WITH_RET(data, Bool, channel->isSupportTlv, SOFTBUS_IPC_ERR);
70 WRITE_PARCEL_WITH_RET(data, CString, channel->peerDeviceId, SOFTBUS_IPC_ERR);
71 WRITE_PARCEL_WITH_RET(data, Bool, channel->isD2D, SOFTBUS_IPC_ERR);
72 if (channel->isD2D) {
73 WRITE_PARCEL_WITH_RET(data, Int32, channel->pagingId, SOFTBUS_IPC_ERR);
74 WRITE_PARCEL_WITH_RET(data, Uint32, channel->businessFlag, SOFTBUS_IPC_ERR);
75 WRITE_PARCEL_WITH_RET(data, Uint32, channel->deviceTypeId, SOFTBUS_IPC_ERR);
76 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(channel->pagingNonce, PAGING_NONCE_LEN),
77 SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, TRANS_CTRL, "write pagingNonce failed");
78 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(channel->pagingSessionkey, SHORT_SESSION_KEY_LENGTH),
79 SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, TRANS_CTRL, "write pagingSessionkey failed");
80 WRITE_PARCEL_WITH_RET(data, Uint32, channel->dataLen, SOFTBUS_IPC_ERR);
81 if (channel->dataLen > 0) {
82 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(channel->extraData, channel->dataLen),
83 SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, TRANS_CTRL, "write extraData failed");
84 }
85 if (channel->isServer) {
86 WRITE_PARCEL_WITH_RET(data, CString, channel->pagingAccountId, SOFTBUS_IPC_ERR);
87 }
88 } else {
89 WRITE_PARCEL_WITH_RET(data, Int32, channel->tokenType, SOFTBUS_IPC_ERR);
90 if (channel->tokenType > ACCESS_TOKEN_TYPE_HAP && channel->channelType != CHANNEL_TYPE_AUTH &&
91 channel->isServer) {
92 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerUserId, SOFTBUS_IPC_ERR);
93 WRITE_PARCEL_WITH_RET(data, Uint64, channel->peerTokenId, SOFTBUS_IPC_ERR);
94 WRITE_PARCEL_WITH_RET(data, CString, channel->peerExtraAccessInfo, SOFTBUS_IPC_ERR);
95 }
96 if (!data.WriteRawData(channel->sessionKey, channel->keyLen)) {
97 TRANS_LOGE(TRANS_CTRL, "write sessionKey and keyLen failed.");
98 return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
99 }
100 WRITE_PARCEL_WITH_RET(data, CString, channel->groupId, SOFTBUS_IPC_ERR);
101 }
102 return SOFTBUS_OK;
103 }
104
MessageParcelWrite(MessageParcel & data,const char * sessionName,const ChannelInfo * channel)105 int32_t TransClientProxy::MessageParcelWrite(MessageParcel &data, const char *sessionName, const ChannelInfo *channel)
106 {
107 if (sessionName == NULL || channel == NULL) {
108 return SOFTBUS_INVALID_PARAM;
109 }
110 if (!data.WriteInterfaceToken(GetDescriptor())) {
111 TRANS_LOGE(TRANS_CTRL, "write InterfaceToken failed.");
112 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
113 }
114 WRITE_PARCEL_WITH_RET(data, CString, sessionName, SOFTBUS_IPC_ERR);
115 WRITE_PARCEL_WITH_RET(data, Int32, channel->sessionId, SOFTBUS_IPC_ERR);
116 WRITE_PARCEL_WITH_RET(data, Int32, channel->channelId, SOFTBUS_IPC_ERR);
117 WRITE_PARCEL_WITH_RET(data, Int32, channel->channelType, SOFTBUS_IPC_ERR);
118 WRITE_PARCEL_WITH_RET(data, Uint64, channel->laneId, SOFTBUS_IPC_ERR);
119 WRITE_PARCEL_WITH_RET(data, Int32, channel->connectType, SOFTBUS_IPC_ERR);
120
121 if (channel->channelType == CHANNEL_TYPE_TCP_DIRECT) {
122 WRITE_PARCEL_WITH_RET(data, FileDescriptor, channel->fd, SOFTBUS_IPC_ERR);
123 WRITE_PARCEL_WITH_RET(data, CString, channel->myIp, SOFTBUS_IPC_ERR);
124 WRITE_PARCEL_WITH_RET(data, Uint32, channel->fdProtocol, SOFTBUS_IPC_ERR);
125 WRITE_PARCEL_WITH_RET(data, CString, channel->peerIp, SOFTBUS_IPC_ERR);
126 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
127 WRITE_PARCEL_WITH_RET(data, CString, channel->pkgName, SOFTBUS_IPC_ERR);
128 }
129 WRITE_PARCEL_WITH_RET(data, Bool, channel->isServer, SOFTBUS_IPC_ERR);
130 WRITE_PARCEL_WITH_RET(data, Bool, channel->isEnabled, SOFTBUS_IPC_ERR);
131 WRITE_PARCEL_WITH_RET(data, Bool, channel->isEncrypt, SOFTBUS_IPC_ERR);
132 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerUid, SOFTBUS_IPC_ERR);
133 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerPid, SOFTBUS_IPC_ERR);
134 WRITE_PARCEL_WITH_RET(data, Uint32, channel->keyLen, SOFTBUS_IPC_ERR);
135 WRITE_PARCEL_WITH_RET(data, CString, channel->peerSessionName, SOFTBUS_IPC_ERR);
136 WRITE_PARCEL_WITH_RET(data, Int32, channel->businessType, SOFTBUS_IPC_ERR);
137 if (channel->channelType == CHANNEL_TYPE_UDP) {
138 WRITE_PARCEL_WITH_RET(data, CString, channel->myIp, SOFTBUS_IPC_ERR);
139 WRITE_PARCEL_WITH_RET(data, Int32, channel->streamType, SOFTBUS_IPC_ERR);
140 WRITE_PARCEL_WITH_RET(data, Bool, channel->isUdpFile, SOFTBUS_IPC_ERR);
141
142 if (!channel->isServer) {
143 WRITE_PARCEL_WITH_RET(data, Int32, channel->peerPort, SOFTBUS_IPC_ERR);
144 WRITE_PARCEL_WITH_RET(data, CString, channel->peerIp, SOFTBUS_IPC_ERR);
145 }
146 }
147 return MessageParcelWriteEx(data, channel);
148 }
149
OnClientTransLimitChange(int32_t channelId,uint8_t tos)150 int32_t TransClientProxy::OnClientTransLimitChange(int32_t channelId, uint8_t tos)
151 {
152 sptr<IRemoteObject> remote = Remote();
153 if (remote == nullptr) {
154 TRANS_LOGE(TRANS_CTRL, "remote is nullptr");
155 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
156 }
157 MessageParcel data;
158 if (!data.WriteInterfaceToken(GetDescriptor())) {
159 TRANS_LOGE(TRANS_CTRL, "write InterfaceToken failed!");
160 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
161 }
162 if (!data.WriteInt32(channelId)) {
163 TRANS_LOGE(TRANS_CTRL, "write channel id failed");
164 return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
165 }
166 if (!data.WriteUint8(tos)) {
167 TRANS_LOGE(TRANS_CTRL, "write tos failed");
168 return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
169 }
170
171 MessageParcel reply;
172 MessageOption option = { MessageOption::TF_ASYNC };
173 int32_t ret = remote->SendRequest(CLIENT_ON_TRANS_LIMIT_CHANGE, data, reply, option);
174 if (ret != SOFTBUS_OK) {
175 TRANS_LOGE(TRANS_CTRL, "OnClientTransLimitChange send request failed, ret=%{public}d", ret);
176 return ret;
177 }
178 return SOFTBUS_OK;
179 }
180
OnChannelOpened(const char * sessionName,const ChannelInfo * channel)181 int32_t TransClientProxy::OnChannelOpened(const char *sessionName, const ChannelInfo *channel)
182 {
183 sptr<IRemoteObject> remote = Remote();
184 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
185 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
186 MessageParcel data;
187 int32_t ret = MessageParcelWrite(data, sessionName, channel);
188 if (ret != SOFTBUS_OK) {
189 TRANS_LOGE(TRANS_CTRL, "message parcel write failed.");
190 return ret;
191 }
192
193 MessageParcel reply;
194 MessageOption option = { MessageOption::TF_ASYNC };
195 ret = remote->SendRequest(CLIENT_ON_CHANNEL_OPENED, data, reply, option);
196 int32_t channelId = channel->channelId;
197 int32_t channelType = channel->channelType;
198 if (ret != SOFTBUS_OK) {
199 TRANS_LOGE(TRANS_CTRL, "OnChannelOpened send request failed, ret=%{public}d", ret);
200 return ret;
201 }
202 if (channel->isServer) {
203 TransCheckChannelOpenToLooperDelay(channelId, channelType, FAST_INTERVAL_MILLISECOND);
204 }
205 return SOFTBUS_OK;
206 }
207
OnChannelBind(int32_t channelId,int32_t channelType)208 int32_t TransClientProxy::OnChannelBind(int32_t channelId, int32_t channelType)
209 {
210 sptr<IRemoteObject> remote = Remote();
211 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
212 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
213
214 MessageParcel data;
215 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
216 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
217 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
218 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
219 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
220 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
221 MessageParcel reply;
222 MessageOption option = { MessageOption::TF_ASYNC };
223 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_BIND, data, reply, option);
224 if (ret != SOFTBUS_OK) {
225 TRANS_LOGE(
226 TRANS_CTRL, "OnChannelBind send request failed, ret=%{public}d, channelId=%{public}d", ret, channelId);
227 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
228 }
229
230 return SOFTBUS_OK;
231 }
232
OnChannelOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)233 int32_t TransClientProxy::OnChannelOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
234 {
235 sptr<IRemoteObject> remote = Remote();
236 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
237 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
238
239 MessageParcel data;
240 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
241 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
242 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
243 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
244 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
245 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
246 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(errCode),
247 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write error code failed");
248
249 MessageParcel reply;
250 MessageOption option = { MessageOption::TF_ASYNC };
251 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_OPENFAILED, data, reply, option);
252 if (ret != SOFTBUS_OK) {
253 TRANS_LOGE(TRANS_CTRL, "OnChannelOpenFailed send request failed, ret=%{public}d", ret);
254 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
255 }
256
257 return SOFTBUS_OK;
258 }
259
OnChannelLinkDown(const char * networkId,int32_t routeType)260 int32_t TransClientProxy::OnChannelLinkDown(const char *networkId, int32_t routeType)
261 {
262 sptr<IRemoteObject> remote = Remote();
263 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
264 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
265 TRANS_CHECK_AND_RETURN_RET_LOGE(networkId != nullptr,
266 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "invalid parameters");
267
268 MessageParcel data;
269 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
270 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
271 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteCString(networkId),
272 SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED, TRANS_CTRL, "write networkId failed");
273 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(routeType),
274 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write routeType failed");
275
276 MessageParcel reply;
277 MessageOption option(MessageOption::TF_ASYNC);
278 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_LINKDOWN, data, reply, option);
279 if (ret != SOFTBUS_OK) {
280 TRANS_LOGE(TRANS_CTRL, "OnChannelLinkDwon send request failed, ret=%{public}d", ret);
281 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
282 }
283 return SOFTBUS_OK;
284 }
285
OnChannelClosed(int32_t channelId,int32_t channelType,int32_t messageType)286 int32_t TransClientProxy::OnChannelClosed(int32_t channelId, int32_t channelType, int32_t messageType)
287 {
288 sptr<IRemoteObject> remote = Remote();
289 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
290 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
291
292 MessageParcel data;
293 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
294 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
295 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
296 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
297 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
298 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
299 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(messageType),
300 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write message type failed");
301
302 MessageParcel reply;
303 MessageOption option(MessageOption::TF_ASYNC);
304 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_CLOSED, data, reply, option);
305 if (ret != SOFTBUS_OK) {
306 TRANS_LOGE(TRANS_CTRL, "OnChannelClosed send request failed, ret=%{public}d", ret);
307 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
308 }
309 return SOFTBUS_OK;
310 }
311
OnChannelMsgReceived(int32_t channelId,int32_t channelType,const void * dataInfo,uint32_t len,int32_t type)312 int32_t TransClientProxy::OnChannelMsgReceived(int32_t channelId, int32_t channelType, const void *dataInfo,
313 uint32_t len, int32_t type)
314 {
315 sptr<IRemoteObject> remote = Remote();
316 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
317 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
318
319 MessageParcel data;
320 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
321 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
322 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
323 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
324 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
325 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
326 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteUint32(len),
327 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write data len failed");
328 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(dataInfo, len),
329 SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, TRANS_CTRL, "write (dataInfo, len) failed");
330 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(type),
331 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write type failed");
332
333 MessageParcel reply;
334 MessageOption option(MessageOption::TF_ASYNC);
335 TRANS_LOGD(TRANS_CTRL, "SendRequest start");
336 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_MSGRECEIVED, data, reply, option);
337 if (ret != SOFTBUS_OK) {
338 TRANS_LOGE(TRANS_CTRL, "OnChannelMsgReceived send request failed, ret=%{public}d",
339 ret);
340 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
341 }
342 return SOFTBUS_OK;
343 }
344
OnChannelQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)345 int32_t TransClientProxy::OnChannelQosEvent(int32_t channelId, int32_t channelType, int32_t eventId, int32_t tvCount,
346 const QosTv *tvList)
347 {
348 sptr<IRemoteObject> remote = Remote();
349 TRANS_CHECK_AND_RETURN_RET_LOGE(remote != nullptr,
350 SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
351
352 MessageParcel data;
353 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()),
354 SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED, TRANS_CTRL, "write InterfaceToken failed!");
355 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
356 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
357 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelType),
358 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
359 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(eventId),
360 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write eventId failed");
361 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(tvCount),
362 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write tv count failed");
363 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteRawData(tvList, sizeof(QosTv) * tvCount),
364 SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED, TRANS_CTRL, "write tv list failed");
365 MessageParcel reply;
366 MessageOption option;
367 int32_t ret = remote->SendRequest(CLIENT_ON_CHANNEL_QOSEVENT, data, reply, option);
368 if (ret != SOFTBUS_OK) {
369 TRANS_LOGE(TRANS_CTRL, "OnChannelQosEvent send request failed, ret=%{public}d", ret);
370 return ret;
371 }
372 int32_t serverRet;
373 if (!reply.ReadInt32(serverRet)) {
374 TRANS_LOGE(TRANS_CTRL, "OnChannelQosEvent read serverRet failed");
375 return SOFTBUS_TRANS_PROXY_READINT_FAILED;
376 }
377 return SOFTBUS_OK;
378 }
379
SetChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)380 int32_t TransClientProxy::SetChannelInfo(
381 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
382 {
383 if (sessionName == nullptr) {
384 TRANS_LOGE(TRANS_CTRL, "Invalid param");
385 return SOFTBUS_INVALID_PARAM;
386 }
387 sptr<IRemoteObject> remote = Remote();
388 if (remote == nullptr) {
389 TRANS_LOGE(TRANS_CTRL, "Remote is nullptr");
390 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
391 }
392
393 MessageParcel data;
394 if (!data.WriteInterfaceToken(GetDescriptor())) {
395 TRANS_LOGE(TRANS_CTRL, "Write InterfaceToken failed!");
396 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
397 }
398 WRITE_PARCEL_WITH_RET(data, CString, sessionName, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
399 WRITE_PARCEL_WITH_RET(data, Int32, sessionId, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
400 WRITE_PARCEL_WITH_RET(data, Int32, channelId, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
401 WRITE_PARCEL_WITH_RET(data, Int32, channelType, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
402 MessageParcel reply;
403 MessageOption option;
404 int32_t ret = remote->SendRequest(CLIENT_SET_CHANNEL_INFO, data, reply, option);
405 if (ret != SOFTBUS_OK) {
406 TRANS_LOGE(TRANS_CTRL, "Send request failed, ret=%{public}d", ret);
407 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
408 }
409 int32_t serverRet;
410 if (!reply.ReadInt32(serverRet)) {
411 TRANS_LOGE(TRANS_CTRL, "read serverRet failed");
412 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
413 }
414 return serverRet;
415 }
416
OnClientChannelOnQos(int32_t channelId,int32_t channelType,QoSEvent event,const QosTV * qos,uint32_t count)417 int32_t TransClientProxy::OnClientChannelOnQos(
418 int32_t channelId, int32_t channelType, QoSEvent event, const QosTV *qos, uint32_t count)
419 {
420 if (qos == nullptr) {
421 TRANS_LOGE(TRANS_CTRL, "qos is nullptr");
422 return SOFTBUS_INVALID_PARAM;
423 }
424 sptr<IRemoteObject> remote = Remote();
425 TRANS_CHECK_AND_RETURN_RET_LOGE(
426 remote != nullptr, SOFTBUS_TRANS_PROXY_REMOTE_NULL, TRANS_CTRL, "remote is nullptr");
427
428 MessageParcel data;
429 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInterfaceToken(GetDescriptor()), SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED,
430 TRANS_CTRL, "write interface token failed!");
431 TRANS_CHECK_AND_RETURN_RET_LOGE(
432 data.WriteInt32(channelId), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel id failed");
433 TRANS_CHECK_AND_RETURN_RET_LOGE(
434 data.WriteInt32(channelType), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write channel type failed");
435 TRANS_CHECK_AND_RETURN_RET_LOGE(
436 data.WriteInt32(event), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write qos event failed");
437 TRANS_CHECK_AND_RETURN_RET_LOGE(
438 data.WriteUint32(count), SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "write qos tv count failed");
439 TRANS_CHECK_AND_RETURN_RET_LOGE(
440 data.WriteBuffer(qos, sizeof(QosTV) * count), SOFTBUS_IPC_ERR, TRANS_CTRL, "write qos failed");
441 MessageParcel reply;
442 MessageOption option = { MessageOption::TF_ASYNC };
443 int32_t ret = remote->SendRequest(CLIENT_CHANNEL_ON_QOS, data, reply, option);
444 if (ret != SOFTBUS_OK) {
445 TRANS_LOGE(TRANS_CTRL, "OnClientChannelOnQos send request failed, ret=%{public}d", ret);
446 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
447 }
448 return SOFTBUS_OK;
449 }
450
OnCheckCollabRelation(const CollabInfo * sourceInfo,bool isSinkSide,const CollabInfo * sinkInfo,int32_t channelId,int32_t channelType)451 int32_t TransClientProxy::OnCheckCollabRelation(const CollabInfo *sourceInfo, bool isSinkSide,
452 const CollabInfo *sinkInfo, int32_t channelId, int32_t channelType)
453 {
454 if (sourceInfo == nullptr || sinkInfo == nullptr) {
455 TRANS_LOGE(TRANS_CTRL, "invalid param.");
456 return SOFTBUS_INVALID_PARAM;
457 }
458 sptr<IRemoteObject> remote = Remote();
459 if (remote == nullptr) {
460 TRANS_LOGE(TRANS_CTRL, "Remote is nullptr");
461 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
462 }
463
464 MessageParcel data;
465 if (!data.WriteInterfaceToken(GetDescriptor())) {
466 TRANS_LOGE(TRANS_CTRL, "Write InterfaceToken failed!");
467 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
468 }
469 WRITE_PARCEL_WITH_RET(data, Bool, isSinkSide, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
470 WRITE_PARCEL_WITH_RET(data, CString, sourceInfo->accountId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
471 WRITE_PARCEL_WITH_RET(data, Uint64, sourceInfo->tokenId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
472 WRITE_PARCEL_WITH_RET(data, Int32, sourceInfo->userId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
473 WRITE_PARCEL_WITH_RET(data, Int32, sourceInfo->pid, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
474 WRITE_PARCEL_WITH_RET(data, CString, sourceInfo->deviceId, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
475 WRITE_PARCEL_WITH_RET(data, CString, sinkInfo->accountId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
476 WRITE_PARCEL_WITH_RET(data, Uint64, sinkInfo->tokenId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
477 WRITE_PARCEL_WITH_RET(data, Int32, sinkInfo->userId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
478 WRITE_PARCEL_WITH_RET(data, Int32, sinkInfo->pid, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
479 WRITE_PARCEL_WITH_RET(data, CString, sinkInfo->deviceId, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
480 if (isSinkSide) {
481 WRITE_PARCEL_WITH_RET(data, Int32, channelId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
482 WRITE_PARCEL_WITH_RET(data, Int32, channelType, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
483 MessageParcel reply;
484 MessageOption option(MessageOption::TF_ASYNC);
485 int32_t ret = remote->SendRequest(CLIENT_CHECK_COLLAB_RELATION, data, reply, option);
486 if (ret != SOFTBUS_OK) {
487 TRANS_LOGE(TRANS_CTRL, "Send request failed, ret=%{public}d", ret);
488 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
489 }
490 TransCheckChannelOpenToLooperDelay(channelId, channelType, FAST_INTERVAL_MILLISECOND);
491 return ret;
492 }
493 MessageParcel reply;
494 MessageOption option(MessageOption::TF_SYNC);
495 int32_t ret = remote->SendRequest(CLIENT_CHECK_COLLAB_RELATION, data, reply, option);
496 if (ret != SOFTBUS_OK) {
497 TRANS_LOGE(TRANS_CTRL, "Send request failed, ret=%{public}d", ret);
498 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
499 }
500 return ret;
501 }
502
OnBrProxyOpened(int32_t channelId,const char * brMac,const char * uuid,int32_t reason)503 int32_t TransClientProxy::OnBrProxyOpened(int32_t channelId, const char *brMac, const char *uuid, int32_t reason)
504 {
505 if (brMac == nullptr || uuid == nullptr) {
506 TRANS_LOGE(TRANS_CTRL, "[br_proxy] invalid param.");
507 return SOFTBUS_INVALID_PARAM;
508 }
509 sptr<IRemoteObject> remote = Remote();
510 if (remote == nullptr) {
511 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Remote is nullptr");
512 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
513 }
514
515 MessageParcel data;
516 if (!data.WriteInterfaceToken(GetDescriptor())) {
517 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Write InterfaceToken failed!");
518 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
519 }
520
521 WRITE_PARCEL_WITH_RET(data, Int32, channelId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
522 WRITE_PARCEL_WITH_RET(data, CString, brMac, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
523 WRITE_PARCEL_WITH_RET(data, CString, uuid, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
524 WRITE_PARCEL_WITH_RET(data, Int32, reason, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
525
526 MessageParcel reply;
527 MessageOption option(MessageOption::TF_SYNC);
528 int32_t ret = remote->SendRequest(CLIENT_ON_BR_PROXY_OPENED, data, reply, option);
529 if (ret != SOFTBUS_OK) {
530 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Send request failed, ret=%{public}d", ret);
531 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
532 }
533 return ret;
534 }
535
OnBrProxyDataRecv(int32_t channelId,const uint8_t * data,uint32_t len)536 int32_t TransClientProxy::OnBrProxyDataRecv(int32_t channelId, const uint8_t *data, uint32_t len)
537 {
538 if (data == nullptr) {
539 TRANS_LOGE(TRANS_CTRL, "[br_proxy] invalid param.");
540 return SOFTBUS_INVALID_PARAM;
541 }
542 sptr<IRemoteObject> remote = Remote();
543 if (remote == nullptr) {
544 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Remote is nullptr");
545 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
546 }
547
548 MessageParcel pData;
549 if (!pData.WriteInterfaceToken(GetDescriptor())) {
550 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Write InterfaceToken failed!");
551 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
552 }
553
554 TRANS_CHECK_AND_RETURN_RET_LOGE(pData.WriteInt32(channelId),
555 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "[br_proxy] write channelId failed");
556 TRANS_CHECK_AND_RETURN_RET_LOGE(pData.WriteUint32(len),
557 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "[br_proxy] write data len failed");
558 TRANS_CHECK_AND_RETURN_RET_LOGE(pData.WriteRawData(data, len),
559 SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, TRANS_CTRL, "[br_proxy] write (data, len) failed");
560
561 MessageParcel reply;
562 MessageOption option(MessageOption::TF_SYNC);
563 int32_t ret = remote->SendRequest(CLIENT_ON_BR_PROXY_DATA_RECV, pData, reply, option);
564 if (ret != SOFTBUS_OK) {
565 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Send request failed, ret=%{public}d", ret);
566 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
567 }
568 return ret;
569 }
570
OnBrProxyStateChanged(int32_t channelId,int32_t channelState)571 int32_t TransClientProxy::OnBrProxyStateChanged(int32_t channelId, int32_t channelState)
572 {
573 sptr<IRemoteObject> remote = Remote();
574 if (remote == nullptr) {
575 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Remote is nullptr");
576 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
577 }
578
579 MessageParcel data;
580 if (!data.WriteInterfaceToken(GetDescriptor())) {
581 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Write InterfaceToken failed!");
582 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
583 }
584
585 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelId),
586 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "[br_proxy] write channelId failed");
587 TRANS_CHECK_AND_RETURN_RET_LOGE(data.WriteInt32(channelState),
588 SOFTBUS_TRANS_PROXY_WRITEINT_FAILED, TRANS_CTRL, "[br_proxy] write channelState failed");
589
590 MessageParcel reply;
591 MessageOption option(MessageOption::TF_SYNC);
592 int32_t ret = remote->SendRequest(CLIENT_ON_BR_PROXY_STATE_CHANGED, data, reply, option);
593 if (ret != SOFTBUS_OK) {
594 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Send request failed, ret=%{public}d", ret);
595 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
596 }
597 return ret;
598 }
599
OnBrProxyQueryPermission(const char * bundleName,bool * isEmpowered)600 int32_t TransClientProxy::OnBrProxyQueryPermission(const char *bundleName, bool *isEmpowered)
601 {
602 sptr<IRemoteObject> remote = Remote();
603 if (remote == nullptr) {
604 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Remote is nullptr");
605 return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
606 }
607
608 MessageParcel data;
609 if (!data.WriteInterfaceToken(GetDescriptor())) {
610 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Write InterfaceToken failed!");
611 return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
612 }
613
614 WRITE_PARCEL_WITH_RET(data, CString, bundleName, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
615
616 MessageParcel reply;
617 MessageOption option(MessageOption::TF_SYNC);
618 int32_t ret = remote->SendRequest(CLIENT_ON_BR_PROXY_QUERY_PERMISSION, data, reply, option);
619 if (ret != SOFTBUS_OK) {
620 TRANS_LOGE(TRANS_CTRL, "[br_proxy] Send request failed, ret=%{public}d", ret);
621 return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
622 }
623
624 if (!reply.ReadBool(*isEmpowered)) {
625 TRANS_LOGE(TRANS_CTRL, "read serverRet failed");
626 return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
627 }
628 return ret;
629 }
630
OnJoinLNNResult(void * addr,uint32_t addrTypeLen,const char * networkId,int32_t retCode)631 int32_t TransClientProxy::OnJoinLNNResult(void *addr, uint32_t addrTypeLen, const char *networkId, int32_t retCode)
632 {
633 (void)addr;
634 (void)addrTypeLen;
635 (void)networkId;
636 (void)retCode;
637 return SOFTBUS_OK;
638 }
639
OnJoinMetaNodeResult(void * addr,uint32_t addrTypeLen,void * metaInfo,uint32_t infoLen,int32_t retCode)640 int32_t TransClientProxy::OnJoinMetaNodeResult(void *addr, uint32_t addrTypeLen, void *metaInfo,
641 uint32_t infoLen, int32_t retCode)
642 {
643 (void)addr;
644 (void)addrTypeLen;
645 (void)metaInfo;
646 (void)infoLen;
647 (void)retCode;
648 return SOFTBUS_OK;
649 }
650
OnLeaveLNNResult(const char * networkId,int32_t retCode)651 int32_t TransClientProxy::OnLeaveLNNResult(const char *networkId, int32_t retCode)
652 {
653 (void)networkId;
654 (void)retCode;
655 return SOFTBUS_OK;
656 }
657
OnLeaveMetaNodeResult(const char * networkId,int32_t retCode)658 int32_t TransClientProxy::OnLeaveMetaNodeResult(const char *networkId, int32_t retCode)
659 {
660 (void)networkId;
661 (void)retCode;
662 return SOFTBUS_OK;
663 }
664
OnNodeOnlineStateChanged(const char * pkgName,bool isOnline,void * info,uint32_t infoTypeLen)665 int32_t TransClientProxy::OnNodeOnlineStateChanged(const char *pkgName, bool isOnline,
666 void *info, uint32_t infoTypeLen)
667 {
668 (void)pkgName;
669 (void)isOnline;
670 (void)info;
671 (void)infoTypeLen;
672 return SOFTBUS_OK;
673 }
674
OnNodeBasicInfoChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)675 int32_t TransClientProxy::OnNodeBasicInfoChanged(const char *pkgName, void *info,
676 uint32_t infoTypeLen, int32_t type)
677 {
678 (void)pkgName;
679 (void)info;
680 (void)infoTypeLen;
681 (void)type;
682 return SOFTBUS_OK;
683 }
684
OnNodeStatusChanged(const char * pkgName,void * info,uint32_t infoTypeLen,int32_t type)685 int32_t TransClientProxy::OnNodeStatusChanged(const char *pkgName, void *info,
686 uint32_t infoTypeLen, int32_t type)
687 {
688 (void)pkgName;
689 (void)info;
690 (void)infoTypeLen;
691 (void)type;
692 return SOFTBUS_OK;
693 }
694
OnTimeSyncResult(const void * info,uint32_t infoTypeLen,int32_t retCode)695 int32_t TransClientProxy::OnTimeSyncResult(const void *info, uint32_t infoTypeLen, int32_t retCode)
696 {
697 (void)info;
698 (void)infoTypeLen;
699 (void)retCode;
700 return SOFTBUS_OK;
701 }
702
OnPublishLNNResult(int32_t publishId,int32_t reason)703 void TransClientProxy::OnPublishLNNResult(int32_t publishId, int32_t reason)
704 {
705 (void)publishId;
706 (void)reason;
707 }
708
OnRefreshLNNResult(int32_t refreshId,int32_t reason)709 void TransClientProxy::OnRefreshLNNResult(int32_t refreshId, int32_t reason)
710 {
711 (void)refreshId;
712 (void)reason;
713 }
714
OnRefreshDeviceFound(const void * device,uint32_t deviceLen)715 void TransClientProxy::OnRefreshDeviceFound(const void *device, uint32_t deviceLen)
716 {
717 (void)device;
718 (void)deviceLen;
719 }
720
OnDataLevelChanged(const char * networkId,const DataLevelInfo * dataLevelInfo)721 void TransClientProxy::OnDataLevelChanged(const char *networkId, const DataLevelInfo *dataLevelInfo)
722 {
723 (void)networkId;
724 (void)dataLevelInfo;
725 }
726
OnMsdpRangeResult(const RangeResultInnerInfo * rangeInfo)727 void TransClientProxy::OnMsdpRangeResult(const RangeResultInnerInfo *rangeInfo)
728 {
729 (void)rangeInfo;
730 }
731 } // namespace OHOS