1 /*
2 * Copyright (c) 2021-2023 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 "connection_ble_mock.h"
17
18 #include <cstdio>
19 #include <cstring>
20
21 #include <gtest/gtest.h>
22 #include <securec.h>
23
24 #include "common_list.h"
25 #include "conn_log.h"
26 #include "softbus_conn_interface.h"
27 #include "softbus_conn_manager.h"
28 #include "softbus_adapter_ble_gatt_server.h"
29 #include "softbus_def.h"
30 #include "softbus_errcode.h"
31 #include "softbus_feature_config.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_adapter_bt_common.h"
34 #include "softbus_conn_ble_server.h"
35 #include "softbus_conn_ble_client.h"
36 #include "softbus_conn_ble_manager.h"
37 #include "softbus_conn_ble_connection.h"
38 #include "softbus_utils.h"
39
40 using namespace testing::ext;
41 using namespace testing;
42 using namespace std;
43
44 namespace OHOS {
45
46 SoftBusGattsCallback *g_callback = nullptr;
47
48 extern "C" {
SoftBusRegisterGattsCallbacks(SoftBusGattsCallback * callback,SoftBusBtUuid serviceUuid)49 int SoftBusRegisterGattsCallbacks(SoftBusGattsCallback *callback, SoftBusBtUuid serviceUuid)
50 {
51 (void)serviceUuid;
52 g_callback = callback;
53 return SOFTBUS_OK;
54 }
55 }
56
57 class ServiceConnectionTest : public testing::Test {
58 public:
59 static void SetUpTestCase();
TearDownTestCase()60 static void TearDownTestCase() {}
SetUp()61 void SetUp() override {}
TearDown()62 void TearDown() override {}
63 };
64
SetUpTestCase()65 void ServiceConnectionTest::SetUpTestCase()
66 {
67 LooperInit();
68 SoftbusConfigInit();
69 ConnServerInit();
70 }
71
72 /*
73 * @tc.name: ServiceConnection001
74 * @tc.desc: Test ConnGattServerStartService.
75 * @tc.in: Test module, Test number, Test Levels.
76 * @tc.out: Zero
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80 HWTEST_F(ServiceConnectionTest, ServiceConnection001, TestSize.Level1)
81 {
82 int32_t ret;
83 NiceMock<ConnectionBleInterfaceMock> bleMock;
84 EXPECT_CALL(bleMock, SoftBusGattsAddService(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
85 ret = ConnGattServerStartService();
86 EXPECT_EQ(SOFTBUS_CONN_BLE_UNDERLAY_SERVER_ADD_SERVICE_ERR, ret);
87 }
88
89 /*
90 * @tc.name: ServiceConnection002
91 * @tc.desc: Test ConnGattServerStopService.
92 * @tc.in: Test module, Test number, Test Levels.
93 * @tc.out: Zero
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(ServiceConnectionTest, ServiceConnection002, TestSize.Level1)
98 {
99 int32_t ret;
100 NiceMock<ConnectionBleInterfaceMock> bleMock;
101 EXPECT_CALL(bleMock, SoftBusGattsStopService).WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_STOP_ERR));
102 ret = ConnGattServerStopService();
103 EXPECT_EQ(SOFTBUS_OK, ret);
104 }
105
106 /*
107 * @tc.name: ServiceConnection003
108 * @tc.desc: Test ConnGattServerDisconnect.
109 * @tc.in: Test module, Test number, Test Levels.
110 * @tc.out: Zero
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(ServiceConnectionTest, ServiceConnection003, TestSize.Level1)
115 {
116 int32_t ret;
117 ConnBleConnection connection;
118 NiceMock<ConnectionBleInterfaceMock> bleMock;
119
120 ret = ConnGattServerDisconnect(NULL);
121 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
122
123 connection.underlayerHandle = INVALID_UNDERLAY_HANDLE;
124 connection.connectionId = 1;
125 SoftBusMutexInit(&connection.lock, nullptr);
126 ret = ConnGattServerDisconnect(&connection);
127 EXPECT_EQ(SOFTBUS_OK, ret);
128
129 connection.underlayerHandle = 1;
130 connection.connectionId = 1;
131 SoftBusMutexInit(&connection.lock, nullptr);
132 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
133 ret = ConnGattServerDisconnect(&connection);
134 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
135
136 SoftBusMutexInit(&connection.lock, nullptr);
137 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
138 EXPECT_CALL(bleMock, SoftBusGattsDisconnect).WillRepeatedly(Return(SOFTBUS_MEM_ERR));
139 ret = ConnGattServerDisconnect(&connection);
140 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
141
142 SoftBusMutexInit(&connection.lock, nullptr);
143 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
144 EXPECT_CALL(bleMock, SoftBusGattsDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
145 ret = ConnGattServerDisconnect(&connection);
146 EXPECT_EQ(SOFTBUS_OK, ret);
147 }
148
149 /*
150 * @tc.name: ServiceConnection004
151 * @tc.desc: Test ConnGattServerConnect.
152 * @tc.in: Test module, Test number, Test Levels.
153 * @tc.out: Zero
154 * @tc.type: FUNC
155 * @tc.require:
156 */
157 HWTEST_F(ServiceConnectionTest, ServiceConnection004, TestSize.Level1)
158 {
159 int32_t ret;
160 SoftBusGattWriteRequest writeCbPara;
161 ConnBleConnection connection;
162 (void)memset_s(&connection, sizeof(ConnBleConnection), 0, sizeof(ConnBleConnection));
163 writeCbPara.needRsp = true;
164 g_callback->RequestWriteCallback(writeCbPara);
165 ret = ConnGattServerConnect(&connection);
166 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
167
168 writeCbPara.needRsp = false;
169 writeCbPara.attrHandle = -1;
170 g_callback->RequestWriteCallback(writeCbPara);
171 ret = SoftBusMutexInit(&connection.lock, nullptr);
172 EXPECT_EQ(SOFTBUS_OK, ret);
173
174 writeCbPara.needRsp = false;
175 writeCbPara.attrHandle = 1;
176 writeCbPara.connId = 1;
177 g_callback->RequestWriteCallback(writeCbPara);
178 connection.underlayerHandle = INVALID_UNDERLAY_HANDLE;
179 ret = ConnGattServerConnect(&connection);
180 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
181 }
182
183 /*
184 * @tc.name: ClientConnection001
185 * @tc.desc: Test ConnGattClientConnect.
186 * @tc.in: Test module, Test number, Test Levels.
187 * @tc.out: Zero
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(ServiceConnectionTest, ClientConnection001, TestSize.Level1)
192 {
193 int32_t ret;
194 ConnBleConnection connection;
195 NiceMock<ConnectionBleInterfaceMock> bleMock;
196
197 ret = ConnGattClientConnect(NULL);
198 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
199
200 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
201 ret = ConnGattClientConnect(&connection);
202 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
203
204 connection.fastestConnectEnable = true;
205 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
206 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
207 ret = ConnGattClientConnect(&connection);
208 EXPECT_EQ(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR, ret);
209
210 SoftBusMutexInit(&connection.lock, nullptr);
211 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_OK));
212 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_OK));
213 ret = ConnGattClientConnect(&connection);
214 EXPECT_EQ(SOFTBUS_OK, ret);
215 }
216
217 /*
218 * @tc.name: ClientConnection002
219 * @tc.desc: Test SwitchNotifacatedHandler.
220 * @tc.in: Test module, Test number, Test Levels.
221 * @tc.out: Zero
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(ServiceConnectionTest, ClientConnection002, TestSize.Level1)
226 {
227 int32_t ret;
228 ConnBleConnection connection;
229 bool grace = true;
230 bool refreshGatt = true;
231 NiceMock<ConnectionBleInterfaceMock> bleMock;
232
233 ret = ConnGattClientDisconnect(NULL, grace, refreshGatt);
234 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
235
236 connection.underlayerHandle = INVALID_UNDERLAY_HANDLE;
237 connection.connectionId = 1;
238 SoftBusMutexInit(&connection.lock, nullptr);
239 ret = ConnGattClientDisconnect(&connection, grace, refreshGatt);
240 EXPECT_EQ(SOFTBUS_OK, ret);
241
242 connection.underlayerHandle = 1;
243 connection.connectionId = 1;
244 SoftBusMutexInit(&connection.lock, nullptr);
245 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
246 ret = ConnGattClientDisconnect(&connection, grace, refreshGatt);
247 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
248
249 connection.underlayerHandle = 1;
250 connection.connectionId = 1;
251 SoftBusMutexInit(&connection.lock, nullptr);
252 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
253 ret = ConnGattClientDisconnect(&connection, grace, refreshGatt);
254 EXPECT_EQ(SOFTBUS_OK, ret);
255 }
256
257 /*
258 * @tc.name: ClientConnection003
259 * @tc.desc: Test ConnGattClientUpdatePriority.
260 * @tc.in: Test module, Test number, Test Levels.
261 * @tc.out: Zero
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(ServiceConnectionTest, ClientConnection003, TestSize.Level1)
266 {
267 int32_t ret;
268 ConnBleConnection connection;
269 ConnectBlePriority priority;
270 NiceMock<ConnectionBleInterfaceMock> bleMock;
271
272 priority = CONN_BLE_PRIORITY_BALANCED;
273 ret = ConnGattClientUpdatePriority(NULL, priority);
274 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
275
276 connection.underlayerHandle = 1;
277 connection.connectionId = 1;
278 connection.state = BLE_CONNECTION_STATE_CONNECTING;
279 SoftBusMutexInit(&connection.lock, nullptr);
280 ret = ConnGattClientUpdatePriority(&connection, priority);
281 EXPECT_EQ(SOFTBUS_CONN_BLE_INTERNAL_ERR, ret);
282
283 connection.state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
284 EXPECT_CALL(bleMock, ConvertBtMacToBinary).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
285 SoftBusMutexInit(&connection.lock, nullptr);
286 ret = ConnGattClientUpdatePriority(&connection, priority);
287 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
288 }
289
290 /*
291 * @tc.name: ConnGattClientDisconnect001
292 * @tc.desc: Test ConnGattClientDisconnect.
293 * @tc.in: Test module, Test number, Test Levels.
294 * @tc.out: Zero
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(ServiceConnectionTest, ConnGattClientDisconnect001, TestSize.Level1)
299 {
300 ConnBleConnection bleConnection = {{0}};
301 int32_t ret = ConnGattClientDisconnect(&bleConnection, false, false);
302 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
303
304 const char *bleMac = "11:22:33:44:55:66";
305
306 ConnBleConnection *connection =
307 ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
308 ASSERT_NE(nullptr, connection);
309
310 connection->featureBitSet = (false ? (1 << BLE_FEATURE_SUPPORT_SUPPORT_NETWORKID_BASICINFO_EXCAHNGE) : 0);
311 connection->psm = 10;
312
313 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
314 ret = ConnBleSaveConnection(connection);
315 ASSERT_EQ(SOFTBUS_OK, ret);
316 ret = ConnGattClientDisconnect(connection, false, false);
317 EXPECT_EQ(SOFTBUS_OK, ret);
318 SoftBusSleepMs(500);
319 }
320
321 /*
322 * @tc.name: ConnGattClientDisconnect002
323 * @tc.desc: Test ConnGattClientDisconnect.
324 * @tc.in: Test module, Test number, Test Levels.
325 * @tc.out: Zero
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 HWTEST_F(ServiceConnectionTest, ConnGattClientDisconnect002, TestSize.Level1)
330 {
331 ConnBleConnection bleConnection = {{0}};
332 int32_t ret = ConnGattClientDisconnect(&bleConnection, false, false);
333 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
334
335 const char *bleMac = "11:22:33:44:55:66";
336
337 ConnBleConnection *connection =
338 ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
339 ASSERT_NE(nullptr, connection);
340
341 connection->featureBitSet = (false ? (1 << BLE_FEATURE_SUPPORT_SUPPORT_NETWORKID_BASICINFO_EXCAHNGE) : 0);
342 connection->psm = 10;
343
344 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
345 connection->underlayerHandle = 1;
346 ret = ConnBleSaveConnection(connection);
347 ASSERT_EQ(SOFTBUS_OK, ret);
348
349 NiceMock<ConnectionBleInterfaceMock> bleMock;
350 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
351 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
352 ret = ConnGattClientDisconnect(connection, false, false);
353 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
354
355 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
356 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
357 ret = ConnGattClientDisconnect(connection, false, false);
358 EXPECT_EQ(SOFTBUS_OK, ret);
359
360 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
361 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
362 ret = ConnGattClientDisconnect(connection, true, false);
363 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
364
365 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
366 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
367 ret = ConnGattClientDisconnect(connection, true, false);
368 EXPECT_EQ(SOFTBUS_OK, ret);
369
370 EXPECT_CALL(bleMock, BleGattcDisconnect).WillRepeatedly(Return(SOFTBUS_GATTC_INTERFACE_FAILED));
371 EXPECT_CALL(bleMock, BleGattcUnRegister).WillRepeatedly(Return(SOFTBUS_OK));
372 ret = ConnGattClientDisconnect(connection, true, false);
373 EXPECT_EQ(SOFTBUS_GATTC_INTERFACE_FAILED, ret);
374 }
375
376 /*
377 * @tc.name: ConnGattClientSend
378 * @tc.desc: Test ConnGattClientSend.
379 * @tc.in: Test module, Test number, Test Levels.
380 * @tc.out: Zero
381 * @tc.type: FUNC
382 * @tc.require:
383 */
384 HWTEST_F(ServiceConnectionTest, ConnGattClientSend, TestSize.Level1)
385 {
386 ConnBleConnection bleConnection = {{0}};
387
388 int32_t ret = SoftBusMutexInit(&bleConnection.lock, NULL);
389 ASSERT_EQ(SOFTBUS_OK, ret);
390 bleConnection.connectionId = 10;
391 bleConnection.underlayerHandle = 0;
392 uint8_t data[] = "testdata";
393 uint32_t dataLen = sizeof(data);
394 ret = ConnGattClientSend(&bleConnection, data, dataLen, MODULE_BLE_NET);
395 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
396
397 ret = ConnGattClientSend(&bleConnection, data, dataLen, MODULE_BLE_CONN);
398 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
399 }
400
401 /*
402 * @tc.name: ServiceStopCallback 001
403 * @tc.desc: Test ServiceStopCallback.
404 * @tc.in: Test module, Test number, Test Levels.
405 * @tc.out: Zero
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(ServiceConnectionTest, ServiceStopCallback001, TestSize.Level1)
410 {
411 g_callback->ServiceStopCallback(SOFTBUS_INVALID_PARAM, 1);
412 SoftBusSleepMs(500);
413 g_callback->ServiceStopCallback(SOFTBUS_OK, 2);
414 SoftBusSleepMs(500);
415
416 SoftBusBtUuid uuid = {
417 .uuidLen = strlen(SOFTBUS_SERVICE_UUID),
418 };
419 uuid.uuid = (char *)SoftBusCalloc(uuid.uuidLen+1);
420 int32_t ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
421 EXPECT_EQ(EOK, ret);
422 g_callback->ServiceAddCallback(SOFTBUS_OK, &uuid, 10);
423 SoftBusSleepMs(500);
424
425 ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
426 EXPECT_EQ(EOK, ret);
427 g_callback->ServiceAddCallback(SOFTBUS_OK, &uuid, 10);
428 SoftBusSleepMs(500);
429
430 ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_SERVICE_UUID);
431 EXPECT_EQ(EOK, ret);
432 g_callback->ServiceAddCallback(SOFTBUS_INVALID_PARAM, &uuid, 10);
433 SoftBusSleepMs(500);
434
435 ret = strcpy_s(uuid.uuid, uuid.uuidLen + 1, SOFTBUS_SERVICE_UUID);
436 EXPECT_EQ(EOK, ret);
437 g_callback->ServiceAddCallback(SOFTBUS_OK, &uuid, 10);
438
439 g_callback->ServiceAddCallback(SOFTBUS_OK, &uuid, 1);
440
441 g_callback->ServiceStopCallback(SOFTBUS_OK, 3);
442
443 g_callback->ServiceDeleteCallback(SOFTBUS_INVALID_PARAM, 1);
444 g_callback->ServiceDeleteCallback(SOFTBUS_OK, 1);
445 const char *bleAddr = "12:22:33:44:55:66";
446
447 SoftBusBtAddr addr = {
448 .addr = {0x12, 0x22, 0x33, 0x44, 0x55, 0x66},
449 };
450 ConnBleConnection *connection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_SERVER, 1, false);
451 EXPECT_NE(nullptr, connection);
452 g_callback->ConnectServerCallback(connection->underlayerHandle, &addr);
453 SoftBusSleepMs(500);
454 }
455
456 /*
457 * @tc.name: ServiceStopCallback 001
458 * @tc.desc: Test ServiceStopCallback.
459 * @tc.in: Test module, Test number, Test Levels.
460 * @tc.out: Zero
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(ServiceConnectionTest, ServiceDeleteCallback, TestSize.Level1)
465 {
466 SoftBusBtAddr addr = {
467 .addr = {0x13, 0x23, 0x33, 0x43, 0x53, 0x63},
468 };
469 g_callback->DisconnectServerCallback(20, &addr);
470
471 const char *bleAddr = "13:23:33:43:53:63";
472 ConnBleConnection *connection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_SERVER, 11, false);
473 EXPECT_NE(nullptr, connection);
474 int32_t ret = ConnBleSaveConnection(connection);
475 ASSERT_EQ(SOFTBUS_OK, ret);
476 g_callback->DisconnectServerCallback(connection->underlayerHandle, &addr);
477 SoftBusGattReadRequest readCbPara = {
478 .connId = 1,
479 .transId = 1,
480 };
481 g_callback->RequestReadCallback(readCbPara);
482 g_callback->ResponseConfirmationCallback(SOFTBUS_OK, 1);
483 g_callback->NotifySentCallback(1, SOFTBUS_OK);
484 g_callback->MtuChangeCallback(4, 5);
485
486 const char *bleMac = "15:25:35:45:55:65";
487 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_SERVER, 20, false);
488 EXPECT_NE(nullptr, bleConnection);
489 ret = ConnBleSaveConnection(bleConnection);
490 ASSERT_EQ(SOFTBUS_OK, ret);
491 g_callback->MtuChangeCallback(bleConnection->underlayerHandle, 5);
492 SoftBusSleepMs(500);
493 }
494 }
495