1 /*
2 * Copyright (C) 2021-2022 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 "gatt_connection_manager.h"
17 #include "adapter_config.h"
18 #include "att.h"
19 #include "btm.h"
20 #include "gap_if.h"
21 #include "gap_le_if.h"
22 #include "gatt_defines.h"
23 #include "gatt_service_base.h"
24 #include "hisysevent.h"
25 #include "interface_adapter_ble.h"
26 #include "interface_adapter_manager.h"
27 #include "log.h"
28 #include "log_util.h"
29 #include "securec.h"
30
31 namespace OHOS {
32 namespace bluetooth {
33 constexpr uint8_t OBSERVER_EVENT_CONNECTED = 0x0;
34 constexpr uint8_t OBSERVER_EVENT_DISCONNECTED = 0x1;
35 constexpr uint8_t OBSERVER_EVENT_CONNECTING = 0x2;
36 constexpr uint8_t OBSERVER_EVENT_DISCONNECTING = 0x3;
37 constexpr uint8_t OBSERVER_EVENT_RECONNECTED = 0x04;
38 constexpr uint8_t OBSERVER_EVENT_DISCONNECTED_INTER = 0x05;
39
40 constexpr uint8_t MAX_RETRY_CONNECT_TIMES = 0;
41 constexpr uint8_t HCI_CONNECTION_FAILED_TO_BE_ESTABLISHED = 0x3E;
42
43 const std::string GattConnectionManager::Device::STATE_IDLE = "IDLE";
44 const std::string GattConnectionManager::Device::STATE_CONNECTING = "CONNECTING";
45 const std::string GattConnectionManager::Device::STATE_CONNECTED = "CONNECTED";
46 const std::string GattConnectionManager::Device::STATE_DISCONNECTING = "DISCONNECTING";
47 const std::string GattConnectionManager::Device::STATE_DISCONNECTED = "DISCONNECTED";
48
49 using DeviceIterator = std::list<std::unique_ptr<GattConnectionManager::Device>>::iterator;
50
51 struct GattConnectionManager::impl : public GattServiceBase {
52 utility::Dispatcher *dispatcher_ = nullptr;
53 std::array<std::pair<bool, GattConnectionObserver *>, MAX_OBSERVER_NUM> observers_
54 = {std::make_pair(false, nullptr)};
55 std::list<std::unique_ptr<GattConnectionManager::Device>> devices_ = {};
56 std::mutex registerMutex_ = {};
57 std::mutex devicelistRWMutex_ = {};
58 struct {
59 uint16_t connIntervalMin_;
60 uint16_t connIntervalMax_;
61 uint16_t connLatency_;
62 uint16_t supervisionTimeout_;
63 uint16_t mtu_;
64 uint16_t flushTimeout_;
65 uint8_t mode_;
66 uint8_t securityMode_;
67 uint16_t bleMaxConnections_;
68 uint16_t classicMaxConnections_;
69 } connectionParameter_ = {};
70
71 impl();
72
73 GattConnectionManager::Device *FindOrRegister(
74 const GattDevice &device, bool autoConnect, std::unique_lock<std::mutex> &deviceLock);
75 GattConnectionManager::Device *FindOrRegister(
76 const BtAddr &addr, uint8_t transport, std::unique_lock<std::mutex> &deviceLock);
77 bool HasSpareDeviceSpace(uint8_t transport);
78 GattConnectionManager::Device *FindDevice(
79 const BtAddr &addr, uint8_t transport, std::unique_lock<std::mutex> &deviceLock);
80 GattConnectionManager::Device *FindDevice(const GattDevice &device, std::unique_lock<std::mutex> &deviceLock);
81 GattConnectionManager::Device *FindDevice(uint16_t handle, std::unique_lock<std::mutex> &deviceLock);
82 void ClearDeviceList();
83 void RemoveDevice(const GattDevice &device);
84 void DisconnectAllDevice();
85 void NotifyObserver(const GattDevice &device, uint8_t event, uint16_t connectionHandle, int ret);
86 int DoConnect(GattConnectionManager::Device &device);
87 int DoConnectComplete(GattConnectionManager::Device &device, const utility::Message &msg);
88 static void DoDisconnect(uint16_t handle);
89 static int DoDisconnectComplete(GattConnectionManager::Device &device, const utility::Message &msg);
90 int DoRequestConnectionPriority(GattConnectionManager::Device &device, int connPriority);
91 void NotifyPriorityUpdated(
92 const GattDevice &device, uint16_t connInterval, uint16_t connLatency, uint16_t timeout, int status);
93 static void ConnectionInComming(const BtAddr &addr, uint8_t transport, uint16_t connectHandle, void *data);
94 static int CheckDeviceParameter(const GattDevice &device);
95 static int ConvertTransport(int transport);
96 static int ConvertConnectionState(const std::string &state);
97 void DoShutDown();
98 static uint16_t GetBleMaxConnectedDevices();
99 static uint16_t GetBleMinConnectionInterval(int connPriority);
100 static uint16_t GetBleMaxConnectionInterval(int connPriority);
101 static uint16_t GetBleConnectionLatency(int connPriority);
102 static uint16_t GetBleConnectionSupervisionTimeout(int connPriority);
103 static uint16_t GetClassicMaxConnectedDevices();
104 static uint16_t GetClassicConnectionMtu();
105 uint8_t GetClassicConnectionMode();
106 uint16_t GetClassicConnectionFlushTimeout();
107 uint8_t GetClassicConnectionSecurityMode();
108
109 static void LEConnectCompleted(uint16_t connectHandle, AttLeConnectCallback *data, void *context);
110 static void LEDisconnectCompleted(uint16_t connectHandle, AttLeDisconnectCallback *data, void *context);
111 static void BREDRConnectCompleted(uint16_t connectHandle, AttBredrConnectCallback *data, void *context);
112 static void BREDRDisconnectCompleted(uint16_t connectHandle, AttBredrDisconnectCallback *data, void *context);
113 static void BREDRConnectInd(uint16_t connectHandle, void *context);
114
115 static void LEConnectionParamterReq(const BtAddr *addr, uint16_t connIntervalMin, uint16_t connIntervalMax,
116 uint16_t connLatency, uint16_t timeout, void *context);
117 static void LEConnectionUpdateComplete(uint8_t status, const BtAddr *addr, uint16_t connInterval,
118 uint16_t connLatency, uint16_t timeout, void *context);
119
120 void LEConnectionParamterReqImpl(
121 BtAddr addr, uint16_t connIntervalMin, uint16_t connIntervalMax, uint16_t connLatency, uint16_t timeout);
122 void LEConnectionUpdateCompleteImpl(
123 uint8_t status, BtAddr addr, uint16_t connInterval, uint16_t connLatency, uint16_t timeout);
124
125 void LEConnectCompletedImpl(uint16_t connectHandle, AttLeConnectCallback data);
126 void LEDisconnectCompletedImpl(uint16_t connectHandle, AttLeDisconnectCallback data);
127 void BREDRConnectCompletedImpl(uint16_t connectHandle, AttBredrConnectCallback data);
128 void BREDRDisconnectCompletedImpl(uint16_t connectHandle, AttBredrDisconnectCallback data);
129 static AttConnectCallback BuildAttConnectCallback();
130
131 static void ChangeConnectionMode(bool isDirect);
132 void DirectConnectTimeout(const GattDevice &device);
133
134 BT_DISALLOW_COPY_AND_ASSIGN(impl);
135 };
136
GattConnectionManager()137 GattConnectionManager::GattConnectionManager() : pimpl(std::make_unique<impl>())
138 {}
139
~GattConnectionManager()140 GattConnectionManager::~GattConnectionManager()
141 {
142 pimpl->ClearDeviceList();
143 }
144
Connect(const GattDevice & device,bool autoConnect) const145 int GattConnectionManager::Connect(const GattDevice &device, bool autoConnect) const
146 {
147 int result = pimpl->CheckDeviceParameter(device);
148 if (GattStatus::GATT_SUCCESS == result) {
149 {
150 std::unique_lock<std::mutex> devLock;
151 auto internalDevice = pimpl->FindOrRegister(device, autoConnect, devLock);
152 if (internalDevice != nullptr) {
153 if (internalDevice->ProcessMessage(Device::StateMachine::MSG_CONNECT)) {
154 result = GattStatus::GATT_SUCCESS;
155 } else {
156 result = GattStatus::INTERNAL_ERROR;
157 }
158 } else {
159 result = GattStatus::MAX_CONNECTIONS;
160 }
161 }
162 }
163
164 if (GattStatus::INTERNAL_ERROR == result) {
165 pimpl->RemoveDevice(device);
166 }
167
168 return result;
169 }
170
Disconnect(const GattDevice & device) const171 int GattConnectionManager::Disconnect(const GattDevice &device) const
172 {
173 LOG_DEBUG("%{public}s:%{public}s:%{public}d Entry!", __FILE__, __FUNCTION__, __LINE__);
174 int ret = GattStatus::INVALID_PARAMETER;
175 std::unique_lock<std::mutex> devLock;
176 auto internalDevice = pimpl->FindDevice(device, devLock);
177 if (internalDevice != nullptr) {
178 internalDevice->AutoConnect() = false;
179 if (internalDevice->ProcessMessage(Device::StateMachine::MSG_DISCONNECT)) {
180 ret = GattStatus::GATT_SUCCESS;
181 } else {
182 ret = GattStatus::INTERNAL_ERROR;
183 }
184 }
185 return ret;
186 }
187
RegisterObserver(GattConnectionObserver & observer) const188 int GattConnectionManager::RegisterObserver(GattConnectionObserver &observer) const
189 {
190 std::lock_guard<std::mutex> lck(pimpl->registerMutex_);
191 int id = -1;
192 for (int i = 0; i < MAX_OBSERVER_NUM; i++) {
193 if (!pimpl->observers_[i].first) {
194 pimpl->observers_[i].first = true;
195 pimpl->observers_[i].second = &observer;
196 id = i;
197 break;
198 }
199 }
200 return id;
201 }
202
DeregisterObserver(int registerId) const203 void GattConnectionManager::DeregisterObserver(int registerId) const
204 {
205 std::lock_guard<std::mutex> lck(pimpl->registerMutex_);
206 if (registerId >= 0 && registerId < MAX_OBSERVER_NUM) {
207 pimpl->observers_[registerId] = std::make_pair(false, nullptr);
208 }
209 }
210
GetDeviceState(const GattDevice & device) const211 const std::string &GattConnectionManager::GetDeviceState(const GattDevice &device) const
212 {
213 std::unique_lock<std::mutex> devLock;
214 auto internalDevice = pimpl->FindDevice(device, devLock);
215 if (internalDevice != nullptr) {
216 return internalDevice->SM().GetState()->Name();
217 }
218 return Device::STATE_IDLE;
219 }
220
GetDevices(std::vector<GattDevice> & devices) const221 void GattConnectionManager::GetDevices(std::vector<GattDevice> &devices) const
222 {
223 std::lock_guard<std::mutex> lck(pimpl->devicelistRWMutex_);
224 std::transform(
225 pimpl->devices_.begin(), pimpl->devices_.end(), std::back_inserter(devices), [&](auto &item) -> GattDevice {
226 return GattDevice(item->Info().addr_,
227 item->Info().addressType_,
228 item->Info().transport_,
229 pimpl->ConvertConnectionState(item->SM().GetState()->Name()));
230 });
231 }
232
GetMaximumNumberOfConnections() const233 std::pair<uint16_t, uint16_t> GattConnectionManager::GetMaximumNumberOfConnections() const
234 {
235 return std::pair<uint16_t, uint16_t>(
236 pimpl->connectionParameter_.classicMaxConnections_, pimpl->connectionParameter_.bleMaxConnections_);
237 }
238
GetDeviceInformation(const GattDevice & device) const239 std::tuple<std::string, uint16_t, uint16_t> GattConnectionManager::GetDeviceInformation(const GattDevice &device) const
240 {
241 std::unique_lock<std::mutex> devLock;
242 auto internalDevice = pimpl->FindDevice(device, devLock);
243 if (internalDevice != nullptr) {
244 return std::make_tuple(
245 internalDevice->SM().GetState()->Name(), internalDevice->Handle(), internalDevice->MTU());
246 }
247
248 return std::make_tuple(Device::STATE_IDLE, 0, 0);
249 }
250
GetDeviceTransport(uint16_t handle) const251 uint8_t GattConnectionManager::GetDeviceTransport(uint16_t handle) const
252 {
253 std::unique_lock<std::mutex> devLock;
254 auto internalDevice = pimpl->FindDevice(handle, devLock);
255 if (internalDevice != nullptr) {
256 return internalDevice->Info().transport_;
257 }
258
259 return GATT_TRANSPORT_TYPE_AUTO;
260 }
261
RequestConnectionPriority(uint16_t handle,int connPriority) const262 int GattConnectionManager::RequestConnectionPriority(uint16_t handle, int connPriority) const
263 {
264 std::unique_lock<std::mutex> devLock;
265 auto internalDevice = pimpl->FindDevice(handle, devLock);
266 if (internalDevice != nullptr) {
267 return (
268 (internalDevice->Info().transport_ != GATT_TRANSPORT_TYPE_LE)
269 ? GattStatus::INVALID_PARAMETER
270 : (internalDevice->ProcessMessage(Device::StateMachine::MSG_REQUEST_CONNECTION_PRIORITY, connPriority)
271 ? GattStatus::GATT_SUCCESS
272 : GattStatus::GATT_FAILURE));
273 }
274
275 return GattStatus::REQUEST_NOT_SUPPORT;
276 }
277
GetEncryptionInfo(uint16_t connectHandle) const278 bool GattConnectionManager::GetEncryptionInfo(uint16_t connectHandle) const
279 {
280 std::unique_lock<std::mutex> devLock;
281 auto device = pimpl->FindDevice(connectHandle, devLock);
282 if (device != nullptr) {
283 device->CheckEncryption();
284 return device->Info().isEncryption_;
285 }
286
287 return false;
288 }
289
GetEncryptionInfo(const GattDevice & device) const290 bool GattConnectionManager::GetEncryptionInfo(const GattDevice &device) const
291 {
292 std::unique_lock<std::mutex> devLock;
293 auto dev = pimpl->FindDevice(device, devLock);
294 if (dev != nullptr) {
295 dev->CheckEncryption();
296 return dev->Info().isEncryption_;
297 }
298
299 return false;
300 }
301
SetConnectionType(const GattDevice & device,bool autoConnect) const302 int GattConnectionManager::SetConnectionType(const GattDevice &device, bool autoConnect) const
303 {
304 std::unique_lock<std::mutex> devLock;
305 auto dev = pimpl->FindDevice(device, devLock);
306 if (dev != nullptr) {
307 dev->AutoConnect() = autoConnect;
308 return GattStatus::GATT_SUCCESS;
309 }
310
311 return GattStatus::GATT_FAILURE;
312 }
313
StartUp(utility::Dispatcher & dispatcher)314 int GattConnectionManager::StartUp(utility::Dispatcher &dispatcher)
315 {
316 if (pimpl->InRunningState()) {
317 return GattStatus::GATT_SUCCESS;
318 }
319
320 pimpl->dispatcher_ = &dispatcher;
321
322 ATT_ConnectRegister(pimpl->BuildAttConnectCallback(), this);
323
324 GapServiceSecurityInfo clientServiceInfo = {OUTGOING, GATT_CLIENT, SEC_PROTOCOL_L2CAP, {BT_PSM_GATT}};
325 GapServiceSecurityInfo serverServiceInfo = {INCOMING, GATT_SERVER, SEC_PROTOCOL_L2CAP, {BT_PSM_GATT}};
326
327 if (GAPIF_RegisterServiceSecurity(nullptr, &clientServiceInfo, GAP_SEC_OUT_AUTHENTICATION | GAP_SEC_OUT_ENCRYPTION)
328 != BT_SUCCESS) {
329 LOG_WARN("%{public}s:%{public}d:%{public}s GAPIF_RegisterServiceSecurity client failed!",
330 __FILE__, __LINE__, __FUNCTION__);
331 }
332
333 if (GAPIF_RegisterServiceSecurity(nullptr, &serverServiceInfo, GAP_SEC_IN_AUTHENTICATION | GAP_SEC_IN_ENCRYPTION)
334 != BT_SUCCESS) {
335 LOG_WARN("%{public}s:%{public}d:%{public}s GAPIF_RegisterServiceSecurity server failed!",
336 __FILE__, __LINE__, __FUNCTION__);
337 }
338
339 GapLeConnCallback callback = {impl::LEConnectionParamterReq, impl::LEConnectionUpdateComplete, nullptr, nullptr};
340 if (GAPIF_RegisterLeConnCallback(&callback, nullptr) != BT_SUCCESS) {
341 LOG_WARN("%{public}s:%{public}d:%{public}s GAPIF_RegisterLeConnCallback failed!",
342 __FILE__, __LINE__, __FUNCTION__);
343 }
344
345 pimpl->Start();
346
347 return GattStatus::GATT_SUCCESS;
348 }
349
ShutDown() const350 int GattConnectionManager::ShutDown() const
351 {
352 LOG_DEBUG("%{public}s:%{public}s:%{public}d Entry!", __FILE__, __FUNCTION__, __LINE__);
353
354 if (!pimpl->InRunningState()) {
355 return GattStatus::GATT_SUCCESS;
356 }
357
358 GapServiceSecurityInfo clientServiceInfo = {OUTGOING, GATT_CLIENT, SEC_PROTOCOL_L2CAP, {BT_PSM_GATT}};
359 GapServiceSecurityInfo serverServiceInfo = {INCOMING, GATT_SERVER, SEC_PROTOCOL_L2CAP, {BT_PSM_GATT}};
360
361 GAPIF_DeregisterServiceSecurity(nullptr, &clientServiceInfo);
362 GAPIF_DeregisterServiceSecurity(nullptr, &serverServiceInfo);
363
364 GAPIF_DeregisterLeConnCallback();
365
366 pimpl->Stop();
367
368 pimpl->DisconnectAllDevice();
369 pimpl->DoShutDown();
370
371 LOG_DEBUG("%{public}s:%{public}s:%{public}d Exit!", __FILE__, __FUNCTION__, __LINE__);
372
373 return GattStatus::GATT_SUCCESS;
374 }
375
impl()376 GattConnectionManager::impl::impl()
377 {
378 connectionParameter_.connIntervalMin_ =
379 GetBleMinConnectionInterval(static_cast<int>(GattConnectionPriority::BALANCED));
380 connectionParameter_.connIntervalMax_ =
381 GetBleMaxConnectionInterval(static_cast<int>(GattConnectionPriority::BALANCED));
382 connectionParameter_.connLatency_ = GetBleConnectionLatency(static_cast<int>(GattConnectionPriority::BALANCED));
383 connectionParameter_.supervisionTimeout_ =
384 GetBleConnectionSupervisionTimeout(static_cast<int>(GattConnectionPriority::BALANCED));
385 connectionParameter_.mtu_ = GetClassicConnectionMtu();
386 connectionParameter_.flushTimeout_ = GetClassicConnectionFlushTimeout();
387 connectionParameter_.mode_ = GetClassicConnectionMode();
388 connectionParameter_.securityMode_ = GetClassicConnectionSecurityMode();
389 connectionParameter_.bleMaxConnections_ = GetBleMaxConnectedDevices();
390 connectionParameter_.classicMaxConnections_ = GetClassicMaxConnectedDevices();
391 }
392
FindOrRegister(const GattDevice & device,bool autoConnect,std::unique_lock<std::mutex> & deviceLock)393 GattConnectionManager::Device *GattConnectionManager::impl::FindOrRegister(
394 const GattDevice &device, bool autoConnect, std::unique_lock<std::mutex> &deviceLock)
395 {
396 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
397
398 for (auto &dev : devices_) {
399 if (dev->Info() == device) {
400 deviceLock = std::unique_lock<std::mutex>(dev->DeviceRWMutex());
401 dev->AutoConnect() = autoConnect;
402 return dev.get();
403 }
404 }
405
406 if (HasSpareDeviceSpace(device.transport_)) {
407 auto &dev = devices_.emplace_back(std::make_unique<GattConnectionManager::Device>(device, autoConnect));
408 deviceLock = std::unique_lock<std::mutex>(dev->DeviceRWMutex());
409 return dev.get();
410 }
411
412 LOG_INFO("%{public}s: The maximum number of device connections has been reached", __FUNCTION__);
413 return nullptr;
414 }
415
FindOrRegister(const BtAddr & addr,uint8_t transport,std::unique_lock<std::mutex> & deviceLock)416 GattConnectionManager::Device *GattConnectionManager::impl::FindOrRegister(
417 const BtAddr &addr, uint8_t transport, std::unique_lock<std::mutex> &deviceLock)
418 {
419 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
420
421 for (auto &dev : devices_) {
422 if (dev->Info().transport_ == transport &&
423 memcmp(addr.addr, dev->Addr(), RawAddress::BT_ADDRESS_BYTE_LEN) == 0) {
424 deviceLock = std::unique_lock<std::mutex>(dev->DeviceRWMutex());
425 return dev.get();
426 }
427 }
428
429 if (HasSpareDeviceSpace(transport)) {
430 auto &device =
431 devices_.emplace_back(std::make_unique<GattConnectionManager::Device>(addr.addr, transport, addr.type));
432 deviceLock = std::unique_lock<std::mutex>(device->DeviceRWMutex());
433 return device.get();
434 }
435
436 LOG_INFO("%{public}s: The maximum number of device connections has been reached", __FUNCTION__);
437 return nullptr;
438 }
439
HasSpareDeviceSpace(uint8_t transport)440 bool GattConnectionManager::impl::HasSpareDeviceSpace(uint8_t transport)
441 {
442 size_t count = 0;
443 for (auto &device : devices_) {
444 if (device->Info().transport_ == transport) {
445 count++;
446 }
447 }
448 return ((transport == GATT_TRANSPORT_TYPE_CLASSIC) ? (count < connectionParameter_.classicMaxConnections_)
449 : (count < connectionParameter_.bleMaxConnections_));
450 }
451
FindDevice(const BtAddr & addr,uint8_t transport,std::unique_lock<std::mutex> & deviceLock)452 GattConnectionManager::Device *GattConnectionManager::impl::FindDevice(
453 const BtAddr &addr, uint8_t transport, std::unique_lock<std::mutex> &deviceLock)
454 {
455 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
456
457 for (auto &dev : devices_) {
458 if (dev->Info().transport_ == transport &&
459 memcmp(addr.addr, dev->Addr(), RawAddress::BT_ADDRESS_BYTE_LEN) == 0) {
460 deviceLock = std::unique_lock<std::mutex>(dev->DeviceRWMutex());
461 return dev.get();
462 }
463 }
464
465 return nullptr;
466 }
467
FindDevice(const GattDevice & device,std::unique_lock<std::mutex> & deviceLock)468 GattConnectionManager::Device *GattConnectionManager::impl::FindDevice(
469 const GattDevice &device, std::unique_lock<std::mutex> &deviceLock)
470 {
471 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
472 for (auto &dev : devices_) {
473 if (dev->Info() == device) {
474 deviceLock = std::unique_lock<std::mutex>(dev->DeviceRWMutex());
475 return dev.get();
476 }
477 }
478 return nullptr;
479 }
480
FindDevice(uint16_t handle,std::unique_lock<std::mutex> & deviceLock)481 GattConnectionManager::Device *GattConnectionManager::impl::FindDevice(
482 uint16_t handle, std::unique_lock<std::mutex> &deviceLock)
483 {
484 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
485 for (auto &device : devices_) {
486 if (device->Handle() == handle) {
487 deviceLock = std::unique_lock<std::mutex>(device->DeviceRWMutex());
488 return device.get();
489 }
490 }
491 return nullptr;
492 }
493
RemoveDevice(const GattDevice & device)494 void GattConnectionManager::impl::RemoveDevice(const GattDevice &device)
495 {
496 LOG_INFO("%{public}s: enter", __FUNCTION__);
497 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
498 for (auto dev = devices_.begin(); dev != devices_.end(); ++dev) {
499 if ((*dev)->Info() == device) {
500 devices_.erase(dev);
501 LOG_INFO("%{public}s: device is found and removed", __FUNCTION__);
502 return;
503 }
504 }
505 LOG_INFO("%{public}s: can not find device", __FUNCTION__);
506 }
507
ClearDeviceList()508 void GattConnectionManager::impl::ClearDeviceList()
509 {
510 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
511 devices_.clear();
512 }
513
DisconnectAllDevice()514 void GattConnectionManager::impl::DisconnectAllDevice()
515 {
516 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
517 for (auto &device : devices_) {
518 std::lock_guard<std::mutex> lock(device->DeviceRWMutex());
519 device->AutoConnect() = false;
520 device->Info().role_ = GATT_ROLE_MASTER;
521 device->ProcessMessage(Device::StateMachine::MSG_DISCONNECT);
522 }
523 }
524
NotifyObserver(const GattDevice & device,uint8_t event,uint16_t connectionHandle,int ret)525 void GattConnectionManager::impl::NotifyObserver(
526 const GattDevice &device, uint8_t event, uint16_t connectionHandle, int ret)
527 {
528 std::lock_guard<std::mutex> lck(registerMutex_);
529 HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::BT_SERVICE, "GATT_CONNECT_STATE",
530 OHOS::HiviewDFX::HiSysEvent::EventType::STATISTIC, "ADDRESS", device.addr_.GetAddress(), "STATE",
531 event, "ROLE", device.role_);
532 for (auto &item : observers_) {
533 if (item.first) {
534 switch (event) {
535 case OBSERVER_EVENT_CONNECTED:
536 item.second->OnConnect(device, connectionHandle, ret);
537 break;
538 case OBSERVER_EVENT_DISCONNECTED:
539 item.second->OnDisconnect(device, connectionHandle, ret);
540 break;
541 case OBSERVER_EVENT_CONNECTING:
542 item.second->OnConnectionChanged(device,
543 connectionHandle, static_cast<int>(BTConnectState::CONNECTING));
544 break;
545 case OBSERVER_EVENT_DISCONNECTING:
546 item.second->OnConnectionChanged(device,
547 connectionHandle, static_cast<int>(BTConnectState::DISCONNECTING));
548 break;
549 case OBSERVER_EVENT_RECONNECTED:
550 item.second->OnConnectionChanged(device,
551 connectionHandle, static_cast<int>(BTConnectState::CONNECTED));
552 item.second->OnReconnect(device,
553 connectionHandle, static_cast<int>(BTConnectState::CONNECTED));
554 break;
555 case OBSERVER_EVENT_DISCONNECTED_INTER:
556 item.second->OnDisconnectInter(device,
557 connectionHandle, static_cast<int>(BTConnectState::CONNECTED));
558 break;
559 default:
560 break;
561 }
562 }
563 }
564 }
565
LEConnectCompletedImpl(uint16_t connectHandle,AttLeConnectCallback data)566 void GattConnectionManager::impl::LEConnectCompletedImpl(uint16_t connectHandle, AttLeConnectCallback data)
567 {
568 ConnectionInComming(data.addr, GATT_TRANSPORT_TYPE_LE, connectHandle, &data);
569 }
570
LEConnectCompleted(uint16_t connectHandle,AttLeConnectCallback * data,void * context)571 void GattConnectionManager::impl::LEConnectCompleted(uint16_t connectHandle, AttLeConnectCallback *data, void *context)
572 {
573 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(
574 &impl::LEConnectCompletedImpl, GattConnectionManager::GetInstance().pimpl.get(), connectHandle, *data));
575
576 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(
577 std::bind(&impl::DoShutDown, GattConnectionManager::GetInstance().pimpl.get()));
578 }
579
LEDisconnectCompletedImpl(uint16_t connectHandle,AttLeDisconnectCallback data)580 void GattConnectionManager::impl::LEDisconnectCompletedImpl(uint16_t connectHandle, AttLeDisconnectCallback data)
581 {
582 bool ret = false;
583 GattConnectionManager::Device *device = nullptr;
584 {
585 std::unique_lock<std::mutex> devLock;
586 device = FindDevice(connectHandle, devLock);
587 if (device != nullptr) {
588 LOG_DEBUG("%{public}s: disconnect reason:%{public}d", __FUNCTION__, data.reason);
589 if (data.reason == HCI_CONNECTION_FAILED_TO_BE_ESTABLISHED &&
590 device->Role() == 0 && device->RetryTimes() < MAX_RETRY_CONNECT_TIMES) {
591 device->RetryTimes() ++;
592 ret = device->ProcessMessage(Device::StateMachine::MSG_RECONNECT_CAUSE_0X3E, connectHandle, &data);
593 } else {
594 device->RetryTimes() = 0;
595 ret = device->ProcessMessage(Device::StateMachine::MSG_DISCONNECT_COMPLETE, connectHandle, &data);
596 }
597 } else {
598 LOG_ERROR("%{public}s: Call - FindDevice - Fail!", __FUNCTION__);
599 }
600 }
601
602 if (ret && device->RetryTimes() == 0 && !device->AutoConnect()) {
603 GattConnectionManager::GetInstance().pimpl->RemoveDevice(device->Info());
604 }
605 }
606
LEDisconnectCompleted(uint16_t connectHandle,AttLeDisconnectCallback * data,void * context)607 void GattConnectionManager::impl::LEDisconnectCompleted(
608 uint16_t connectHandle, AttLeDisconnectCallback *data, void *context)
609 {
610 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(
611 &impl::LEDisconnectCompletedImpl, GattConnectionManager::GetInstance().pimpl.get(), connectHandle, *data));
612
613 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(
614 std::bind(&impl::DoShutDown, GattConnectionManager::GetInstance().pimpl.get()));
615 }
616
BREDRConnectCompletedImpl(uint16_t connectHandle,AttBredrConnectCallback data)617 void GattConnectionManager::impl::BREDRConnectCompletedImpl(uint16_t connectHandle, AttBredrConnectCallback data)
618 {
619 ConnectionInComming(data.addr, GATT_TRANSPORT_TYPE_CLASSIC, connectHandle, &data);
620 }
621
BREDRConnectCompleted(uint16_t connectHandle,AttBredrConnectCallback * data,void * context)622 void GattConnectionManager::impl::BREDRConnectCompleted(
623 uint16_t connectHandle, AttBredrConnectCallback *data, void *context)
624 {
625 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(
626 &impl::BREDRConnectCompletedImpl, GattConnectionManager::GetInstance().pimpl.get(), connectHandle, *data));
627
628 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(
629 std::bind(&impl::DoShutDown, GattConnectionManager::GetInstance().pimpl.get()));
630 }
631
BREDRDisconnectCompletedImpl(uint16_t connectHandle,AttBredrDisconnectCallback data)632 void GattConnectionManager::impl::BREDRDisconnectCompletedImpl(uint16_t connectHandle, AttBredrDisconnectCallback data)
633 {
634 bool ret = false;
635 GattConnectionManager::Device *device = nullptr;
636 {
637 std::unique_lock<std::mutex> devLock;
638 device = FindDevice(connectHandle, devLock);
639 if (device != nullptr) {
640 ret = device->ProcessMessage(Device::StateMachine::MSG_DISCONNECT_COMPLETE, connectHandle, &data);
641 } else {
642 LOG_ERROR("%{public}s: Call - FindDevice - Fail!", __FUNCTION__);
643 }
644 }
645
646 if (ret && !device->AutoConnect()) {
647 GattConnectionManager::GetInstance().pimpl->RemoveDevice(device->Info());
648 }
649 }
650
BREDRDisconnectCompleted(uint16_t connectHandle,AttBredrDisconnectCallback * data,void * context)651 void GattConnectionManager::impl::BREDRDisconnectCompleted(
652 uint16_t connectHandle, AttBredrDisconnectCallback *data, void *context)
653 {
654 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(
655 &impl::BREDRDisconnectCompletedImpl, GattConnectionManager::GetInstance().pimpl.get(), connectHandle, *data));
656
657 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(
658 std::bind(&impl::DoShutDown, GattConnectionManager::GetInstance().pimpl.get()));
659 }
660
BREDRConnectInd(uint16_t connectHandle,void * context)661 void GattConnectionManager::impl::BREDRConnectInd(uint16_t connectHandle, void *context)
662 {
663 GattConnectionManager &instance = GattConnectionManager::GetInstance();
664 if (!instance.pimpl->InRunningState()) {
665 ATT_ConnectRsp(connectHandle, BREDR_CONNECT_REJECTED, 0, nullptr);
666 }
667
668 AttConnect connectionParameter;
669 connectionParameter.bredrConnParaVar.mtu = instance.pimpl->connectionParameter_.mtu_;
670 connectionParameter.bredrConnParaVar.mode = instance.pimpl->connectionParameter_.mode_;
671 connectionParameter.bredrConnParaVar.flushTimeout = instance.pimpl->connectionParameter_.flushTimeout_;
672 /* When passively connected, GATT will not reject the connection request */
673 ATT_ConnectRsp(connectHandle, BREDR_CONNECT_ACCEPT, 0, &connectionParameter);
674 }
675
LEConnectionParamterReqImpl(BtAddr addr,uint16_t connIntervalMin,uint16_t connIntervalMax,uint16_t connLatency,uint16_t timeout)676 void GattConnectionManager::impl::LEConnectionParamterReqImpl(BtAddr addr, uint16_t connIntervalMin,
677 uint16_t connIntervalMax, uint16_t connLatency, uint16_t timeout)
678 {
679 static const std::pair<uint16_t, uint16_t> connIntervalMinRange(0x0006, 0x0C80);
680 static const std::pair<uint16_t, uint16_t> connIntervalMaxRange(0x0006, 0x0C80);
681 static const std::pair<uint16_t, uint16_t> connLatencyRange(0x0000, 0x01F3);
682 static const std::pair<uint16_t, uint16_t> timeoutRange(0x000A, 0x0C80);
683
684 std::unique_lock<std::mutex> devLock;
685 auto Device = FindDevice(addr, GATT_TRANSPORT_TYPE_LE, devLock);
686 if (Device == nullptr ||
687 connIntervalMin < connIntervalMinRange.first || connIntervalMin > connIntervalMinRange.second ||
688 connIntervalMax < connIntervalMaxRange.first || connIntervalMax > connIntervalMaxRange.second ||
689 connLatency < connLatencyRange.first || connLatency > connLatencyRange.second ||
690 timeout < timeoutRange.first || timeout > timeoutRange.second) {
691 GAPIF_LeConnectionParameterRsp(&addr, GAP_NOT_ACCEPT, nullptr);
692 }
693
694 GapLeConnectionParameter connParam = {connIntervalMin, connIntervalMax, connLatency, timeout, 0, 0};
695 GAPIF_LeConnectionParameterRsp(&addr, GAP_ACCEPT, &connParam);
696 }
697
LEConnectionParamterReq(const BtAddr * addr,uint16_t connIntervalMin,uint16_t connIntervalMax,uint16_t connLatency,uint16_t timeout,void * context)698 void GattConnectionManager::impl::LEConnectionParamterReq(const BtAddr *addr, uint16_t connIntervalMin,
699 uint16_t connIntervalMax, uint16_t connLatency, uint16_t timeout, void *context)
700 {
701 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(&impl::LEConnectionParamterReqImpl,
702 GattConnectionManager::GetInstance().pimpl.get(),
703 *addr,
704 connIntervalMin,
705 connIntervalMax,
706 connLatency,
707 timeout));
708 }
709
LEConnectionUpdateCompleteImpl(uint8_t status,BtAddr addr,uint16_t connInterval,uint16_t connLatency,uint16_t timeout)710 void GattConnectionManager::impl::LEConnectionUpdateCompleteImpl(uint8_t status, BtAddr addr, uint16_t connInterval,
711 uint16_t connLatency, uint16_t timeout)
712 {
713 Device::ConnectionPriorityResult res = {
714 .interval_ = connInterval,
715 .latency_ = connLatency,
716 .timeout_ = timeout,
717 .status = status == GAP_STATUS_SUCCESS ? GattStatus::GATT_SUCCESS : GattStatus::GATT_FAILURE
718 };
719
720 std::unique_lock<std::mutex> devLock;
721 auto Device = FindDevice(addr, GATT_TRANSPORT_TYPE_LE, devLock);
722 if (Device != nullptr) {
723 Device->ProcessMessage(Device::StateMachine::MSG_RESPONSE_CONNECTION_PRIORITY, 0, &res);
724 }
725 }
726
LEConnectionUpdateComplete(uint8_t status,const BtAddr * addr,uint16_t connInterval,uint16_t connLatency,uint16_t timeout,void * context)727 void GattConnectionManager::impl::LEConnectionUpdateComplete(uint8_t status, const BtAddr *addr, uint16_t connInterval,
728 uint16_t connLatency, uint16_t timeout, void *context)
729 {
730 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(&impl::LEConnectionUpdateCompleteImpl,
731 GattConnectionManager::GetInstance().pimpl.get(),
732 status,
733 *addr,
734 connInterval,
735 connLatency,
736 timeout));
737 }
738
DoConnect(GattConnectionManager::Device & device)739 int GattConnectionManager::impl::DoConnect(GattConnectionManager::Device &device)
740 {
741 int result = GattStatus::GATT_SUCCESS;
742 const GattConnectionManager &instance = GattConnectionManager::GetInstance();
743
744 AttConnect connectionParameter;
745 BtAddr addr;
746 if (memcpy_s(addr.addr, RawAddress::BT_ADDRESS_BYTE_LEN, device.Addr(), RawAddress::BT_ADDRESS_BYTE_LEN) != EOK) {
747 return GattStatus::INTERNAL_ERROR;
748 }
749
750 if (device.Info().transport_ == GATT_TRANSPORT_TYPE_CLASSIC) {
751 device.Info().role_ = GATT_ROLE_MASTER;
752 device.Info().addressType_ = addr.type = BT_PUBLIC_DEVICE_ADDRESS;
753 connectionParameter.bredrConnParaVar.mtu = instance.pimpl->connectionParameter_.mtu_;
754 connectionParameter.bredrConnParaVar.mode = instance.pimpl->connectionParameter_.mode_;
755 connectionParameter.bredrConnParaVar.flushTimeout = instance.pimpl->connectionParameter_.flushTimeout_;
756 ATT_ConnectReq(ConvertTransport(GATT_TRANSPORT_TYPE_CLASSIC), &connectionParameter, &addr, &device.Handle());
757 } else if (device.Info().transport_ == GATT_TRANSPORT_TYPE_LE) {
758 auto adapter = IAdapterManager::GetInstance()->GetBleAdapterInterface();
759 if (adapter != nullptr && adapter->GetPeerDeviceAddrType(device.Info().addr_) <= BLE_ADDR_TYPE_RANDOM) {
760 device.Info().role_ = GATT_ROLE_MASTER;
761 device.Info().addressType_ = addr.type = adapter->GetPeerDeviceAddrType(device.Info().addr_);
762 connectionParameter.leConnParaVar.connIntervalMin = instance.pimpl->connectionParameter_.connIntervalMin_;
763 connectionParameter.leConnParaVar.connIntervalMax = instance.pimpl->connectionParameter_.connIntervalMax_;
764 connectionParameter.leConnParaVar.connLatency = instance.pimpl->connectionParameter_.connLatency_;
765 connectionParameter.leConnParaVar.supervisionTimeout =
766 instance.pimpl->connectionParameter_.supervisionTimeout_;
767
768 ChangeConnectionMode(!device.AutoConnect());
769 if (!device.AutoConnect()) {
770 device.DirectConnect().Start(DIRECT_CONNECT_TIMEOUT);
771 }
772 ATT_ConnectReq(ConvertTransport(GATT_TRANSPORT_TYPE_LE), &connectionParameter, &addr, &device.Handle());
773 } else {
774 device.Info().role_ = GATT_ROLE_INVALID;
775 result = GattStatus::REQUEST_NOT_SUPPORT;
776 }
777 } else {
778 device.Info().role_ = GATT_ROLE_INVALID;
779 result = GattStatus::INTERNAL_ERROR;
780 LOG_ERROR("%{public}s: Call - Connect - Fail! - Return: %{public}d - Parameter(1): transportType: %{public}d",
781 __FUNCTION__,
782 result,
783 device.Info().transport_);
784 }
785
786 return result;
787 }
788
DoConnectComplete(GattConnectionManager::Device & device,const utility::Message & msg)789 int GattConnectionManager::impl::DoConnectComplete(GattConnectionManager::Device &device, const utility::Message &msg)
790 {
791 int result = GattStatus::INTERNAL_ERROR;
792
793 if (GATT_TRANSPORT_TYPE_CLASSIC == device.Info().transport_ &&
794 ((AttBredrConnectCallback *)msg.arg2_)->status == BREDR_CONNECT_SUCCESS) {
795 device.Handle() = msg.arg1_;
796 device.MTU() = ((AttBredrConnectCallback *)msg.arg2_)->mtu;
797 if (device.Info().role_ != GATT_ROLE_MASTER) {
798 device.Info().role_ = GATT_ROLE_SLAVE;
799 }
800
801 result = GattStatus::GATT_SUCCESS;
802 } else if (GATT_TRANSPORT_TYPE_LE == device.Info().transport_ &&
803 ((AttLeConnectCallback *)msg.arg2_)->status == LE_CONNECT_SUCCESS) {
804 device.Handle() = msg.arg1_;
805 device.Info().role_ = ((AttLeConnectCallback *)msg.arg2_)->role;
806
807 if (device.Info().role_ == GATT_ROLE_MASTER && !device.AutoConnect()) {
808 device.DirectConnect().Stop();
809 ChangeConnectionMode(false);
810 }
811 result = GattStatus::GATT_SUCCESS;
812 } else {
813 device.AutoConnect() = false;
814 }
815
816 return result;
817 }
818
DoDisconnect(uint16_t handle)819 void GattConnectionManager::impl::DoDisconnect(uint16_t handle)
820 {
821 ATT_DisconnectReq(handle);
822 }
823
DoDisconnectComplete(GattConnectionManager::Device & device,const utility::Message & msg)824 int GattConnectionManager::impl::DoDisconnectComplete(
825 GattConnectionManager::Device &device, const utility::Message &msg)
826 {
827 int result = GattStatus::INTERNAL_ERROR;
828
829 if (device.Info().transport_ == GATT_TRANSPORT_TYPE_CLASSIC) {
830 if (((AttBredrDisconnectCallback *)msg.arg2_)->reason == INITIATIVECONNECT_DISCONNECT_SUCCESS ||
831 ((AttBredrDisconnectCallback *)msg.arg2_)->reason == PASSIVECONNECT_DISCONNECT_SUCCESS ||
832 ((AttBredrDisconnectCallback *)msg.arg2_)->reason == DISCONNECT_ABNORMAL) {
833 result = GattStatus::GATT_SUCCESS;
834 }
835 } else if (device.Info().transport_ == GATT_TRANSPORT_TYPE_LE) {
836 if (((AttLeDisconnectCallback *)msg.arg2_)->status == LE_DISCONNECT_SUCCESS) {
837 result = GattStatus::GATT_SUCCESS;
838 }
839 }
840
841 return result;
842 }
843
DoRequestConnectionPriority(GattConnectionManager::Device & device,int connPriority)844 int GattConnectionManager::impl::DoRequestConnectionPriority(GattConnectionManager::Device &device, int connPriority)
845 {
846 BtAddr addr;
847 addr.type = device.Info().addressType_;
848 if (memcpy_s(addr.addr, RawAddress::BT_ADDRESS_BYTE_LEN, device.Addr(), RawAddress::BT_ADDRESS_BYTE_LEN) != EOK) {
849 return GattStatus::INTERNAL_ERROR;
850 }
851
852 GapLeConnectionParameter connParam = {
853 GetBleMinConnectionInterval(connPriority),
854 GetBleMaxConnectionInterval(connPriority),
855 GetBleConnectionLatency(connPriority),
856 GetBleConnectionSupervisionTimeout(connPriority),
857 0,
858 0
859 };
860 if (GAPIF_LeConnParamUpdate(&addr, &connParam) != BT_SUCCESS) {
861 return GattStatus::GATT_FAILURE;
862 }
863
864 return GattStatus::GATT_SUCCESS;
865 }
866
NotifyPriorityUpdated(const GattDevice & device,uint16_t connInterval,uint16_t connLatency,uint16_t timeout,int status)867 void GattConnectionManager::impl::NotifyPriorityUpdated(
868 const GattDevice &device, uint16_t connInterval, uint16_t connLatency, uint16_t timeout, int status)
869 {
870 std::lock_guard<std::mutex> lck(registerMutex_);
871 for (auto &item : observers_) {
872 if (item.first) {
873 item.second->OnConnectionParameterChanged(device, connInterval, connLatency, timeout, status);
874 }
875 }
876 }
877
ConnectionInComming(const BtAddr & addr,uint8_t transport,uint16_t connectHandle,void * data)878 void GattConnectionManager::impl::ConnectionInComming(
879 const BtAddr &addr, uint8_t transport, uint16_t connectHandle, void *data)
880 {
881 GattConnectionManager &instance = GattConnectionManager::GetInstance();
882
883 std::unique_lock<std::mutex> devLock;
884 auto Device = instance.pimpl->FindOrRegister(addr, transport, devLock);
885 if (Device != nullptr) {
886 Device->Info().addressType_ = addr.type;
887 Device->ProcessMessage(Device::StateMachine::MSG_CONNECT_COMPLETE, connectHandle, data);
888 } else {
889 instance.pimpl->DoDisconnect(connectHandle);
890 LOG_INFO("%{public}s: The maximum number of device connections has been reached", __FUNCTION__);
891 }
892 LOG_DEBUG("%{public}s:%{public}s:%{public}d Exit!", __FILE__, __FUNCTION__, __LINE__);
893 }
894
CheckDeviceParameter(const GattDevice & device)895 int GattConnectionManager::impl::CheckDeviceParameter(const GattDevice &device)
896 {
897 int result = GattStatus::REQUEST_NOT_SUPPORT;
898
899 if ((device.transport_ == GATT_TRANSPORT_TYPE_LE &&
900 IAdapterManager::GetInstance()->GetState(ADAPTER_BLE) == STATE_TURN_ON) ||
901 (device.transport_ == GATT_TRANSPORT_TYPE_CLASSIC &&
902 IAdapterManager::GetInstance()->GetState(ADAPTER_BREDR) == STATE_TURN_ON)) {
903 return GattStatus::GATT_SUCCESS;
904 }
905
906 return result;
907 }
908
ConvertTransport(int transport)909 int GattConnectionManager::impl::ConvertTransport(int transport)
910 {
911 int type = BT_TRANSPORT_INVALID;
912 switch (transport) {
913 case GATT_TRANSPORT_TYPE_LE:
914 type = BT_TRANSPORT_LE;
915 break;
916 case GATT_TRANSPORT_TYPE_CLASSIC:
917 type = BT_TRANSPORT_BR_EDR;
918 break;
919 default:
920 ASSERT(false);
921 break;
922 }
923 return type;
924 }
925
ConvertConnectionState(const std::string & state)926 int GattConnectionManager::impl::ConvertConnectionState(const std::string &state)
927 {
928 BTConnectState result = BTConnectState::DISCONNECTED;
929 if (state.compare(GattConnectionManager::Device::STATE_CONNECTED) == 0) {
930 result = BTConnectState::CONNECTED;
931 } else if (state.compare(GattConnectionManager::Device::STATE_CONNECTING) == 0) {
932 result = BTConnectState::CONNECTING;
933 } else if (state.compare(GattConnectionManager::Device::STATE_DISCONNECTING) == 0) {
934 result = BTConnectState::DISCONNECTING;
935 }
936 return static_cast<int>(result);
937 }
938
DoShutDown()939 void GattConnectionManager::impl::DoShutDown()
940 {
941 if (InRunningState()) {
942 return;
943 }
944
945 std::lock_guard<std::mutex> lck(devicelistRWMutex_);
946 for (auto &dev : devices_) {
947 std::string state = dev->SM().GetState()->Name();
948 if (state == GattConnectionManager::Device::STATE_DISCONNECTED) {
949 continue;
950 }
951
952 if (state == GattConnectionManager::Device::STATE_CONNECTED) {
953 std::unique_lock<std::mutex> devLock;
954 dev->AutoConnect() = false;
955 dev->Info().role_ = GATT_ROLE_MASTER;
956 dev->ProcessMessage(Device::StateMachine::MSG_DISCONNECT);
957 }
958
959 return;
960 }
961
962 devices_.clear();
963
964 ATT_ConnectDeregister();
965
966 std::lock_guard<std::mutex> lg(registerMutex_);
967 for (auto &item : observers_) {
968 if (item.first) {
969 item.second->OnShutDown();
970 }
971 }
972 }
973
GetBleMaxConnectedDevices()974 uint16_t GattConnectionManager::impl::GetBleMaxConnectedDevices()
975 {
976 int result = DEFAULT_BLE_MAX_CONNECTED_DEVICES;
977 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, PROPERTY_BLE_MAX_CONNECTED_DEVICES, result);
978 return result;
979 }
980
GetBleMinConnectionInterval(int connPriority)981 uint16_t GattConnectionManager::impl::GetBleMinConnectionInterval(int connPriority)
982 {
983 int result = DEFAULT_BLE_MIN_CONNECTION_INTERVAL;
984 const std::string *property = &PROPERTY_BALANCED_PRIORITY_MIN_INTERVAL;
985 if (connPriority == static_cast<int>(GattConnectionPriority::LOW_POWER)) {
986 property = &PROPERTY_LOW_POWER_MIN_INTERVAL;
987 } else if (connPriority == static_cast<int>(GattConnectionPriority::HIGH)) {
988 property = &PROPERTY_HIGH_PRIORITY_MIN_INTERVAL;
989 }
990
991 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, *property, result);
992 return result;
993 }
994
GetBleMaxConnectionInterval(int connPriority)995 uint16_t GattConnectionManager::impl::GetBleMaxConnectionInterval(int connPriority)
996 {
997 int result = DEFAULT_BLE_MAX_CONNECTION_INTERVAL;
998 const std::string *property = &PROPERTY_BALANCED_PRIORITY_MAX_INTERVAL;
999 if (connPriority == static_cast<int>(GattConnectionPriority::LOW_POWER)) {
1000 property = &PROPERTY_LOW_POWER_MAX_INTERVAL;
1001 } else if (connPriority == static_cast<int>(GattConnectionPriority::HIGH)) {
1002 property = &PROPERTY_HIGH_PRIORITY_MAX_INTERVAL;
1003 }
1004
1005 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, *property, result);
1006 return result;
1007 }
1008
GetBleConnectionLatency(int connPriority)1009 uint16_t GattConnectionManager::impl::GetBleConnectionLatency(int connPriority)
1010 {
1011 int result = DEFAULT_BLE_CONNECTION_LATENCY;
1012 const std::string *property = &PROPERTY_BALANCED_PRIORITY_LATENCY;
1013 if (connPriority == static_cast<int>(GattConnectionPriority::LOW_POWER)) {
1014 property = &PROPERTY_LOW_POWER_LATENCY;
1015 } else if (connPriority == static_cast<int>(GattConnectionPriority::HIGH)) {
1016 property = &PROPERTY_HIGH_PRIORITY_LATENCY;
1017 }
1018
1019 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, *property, result);
1020 return result;
1021 }
1022
GetBleConnectionSupervisionTimeout(int connPriority)1023 uint16_t GattConnectionManager::impl::GetBleConnectionSupervisionTimeout(int connPriority)
1024 {
1025 int result = DEFAULT_BLE_CONNECTION_SUPERVISION_TIMEOUT;
1026 const std::string *property = &PROPERTY_BALANCED_PRIORITY_TIMEOUT;
1027 if (connPriority == static_cast<int>(GattConnectionPriority::LOW_POWER)) {
1028 property = &PROPERTY_LOW_POWER_TIMEOUT;
1029 } else if (connPriority == static_cast<int>(GattConnectionPriority::HIGH)) {
1030 property = &PROPERTY_HIGH_PRIORITY_TIMEOUT;
1031 }
1032
1033 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, *property, result);
1034 return result;
1035 }
1036
GetClassicMaxConnectedDevices()1037 uint16_t GattConnectionManager::impl::GetClassicMaxConnectedDevices()
1038 {
1039 int result = DEFAULT_CLASSIC_MAX_CONNECTED_DEVICES;
1040 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, PROPERTY_CLASSIC_MAX_CONNECTED_DEVICES, result);
1041 return result;
1042 }
1043
GetClassicConnectionMtu()1044 uint16_t GattConnectionManager::impl::GetClassicConnectionMtu()
1045 {
1046 int result = DEFAULT_CLASSIC_CONNECTION_MTU;
1047 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, PROPERTY_CLASSIC_CONNECTION_MTU, result);
1048 return result;
1049 }
1050
GetClassicConnectionMode()1051 uint8_t GattConnectionManager::impl::GetClassicConnectionMode()
1052 {
1053 int result = DEFAULT_CLASSIC_CONNECTION_MODE;
1054 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, PROPERTY_CLASSIC_CONNECTION_MODE, result);
1055 return result;
1056 }
1057
GetClassicConnectionFlushTimeout()1058 uint16_t GattConnectionManager::impl::GetClassicConnectionFlushTimeout()
1059 {
1060 int result = DEFAULT_CLASSIC_CONNECTION_FLUSH_TIMEOUT;
1061 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, PROPERTY_CLASSIC_CONNECTION_FLUSH_TIMEOUT, result);
1062 return result;
1063 }
1064
GetClassicConnectionSecurityMode()1065 uint8_t GattConnectionManager::impl::GetClassicConnectionSecurityMode()
1066 {
1067 int result = DEFAULT_CLASSIC_CONNECTION_SECURITY_MODE;
1068 AdapterConfig::GetInstance()->GetValue(SECTION_GATT_SERVICE, PROPERTY_CLASSIC_CONNECTION_SECURITY_MODE, result);
1069 return result;
1070 }
1071
BuildAttConnectCallback()1072 AttConnectCallback GattConnectionManager::impl::BuildAttConnectCallback()
1073 {
1074 AttConnectCallback callback;
1075 callback.attBREDRConnectCompleted = BREDRConnectCompleted;
1076 callback.attBREDRConnectInd = BREDRConnectInd;
1077 callback.attBREDRDisconnectCompleted = BREDRDisconnectCompleted;
1078 callback.attLEConnectCompleted = LEConnectCompleted;
1079 callback.attLEDisconnectCompleted = LEDisconnectCompleted;
1080
1081 return callback;
1082 }
1083
ChangeConnectionMode(bool isDirect)1084 void GattConnectionManager::impl::ChangeConnectionMode(bool isDirect)
1085 {
1086 static int directCount = 0;
1087 static std::mutex lock;
1088 {
1089 std::lock_guard<std::mutex> lg(lock);
1090 if (isDirect) {
1091 directCount++;
1092 } else if (directCount != 0) {
1093 directCount--;
1094 }
1095 }
1096 LOG_DEBUG("%{public}s: directCount is %{public}d", __FUNCTION__, directCount);
1097 if (directCount > 0) {
1098 BTM_SetLeConnectionModeToFast();
1099 } else {
1100 BTM_SetLeConnectionModeToSlow();
1101 }
1102 }
1103
DirectConnectTimeout(const GattDevice & device)1104 void GattConnectionManager::impl::DirectConnectTimeout(const GattDevice &device)
1105 {
1106 std::unique_lock<std::mutex> devLock;
1107 auto internalDevice = FindDevice(device, devLock);
1108 if (internalDevice != nullptr) {
1109 internalDevice->ProcessMessage(Device::StateMachine::MSG_DIRECT_CONNECT_TIMEOUT);
1110 }
1111 }
1112
Device(const uint8_t * addr,uint8_t transport,uint8_t type,bool autoConnect)1113 GattConnectionManager::Device::Device(const uint8_t *addr, uint8_t transport, uint8_t type, bool autoConnect)
1114 : autoConnect_(autoConnect),
1115 mtu_(GATT_DEFAULT_MTU),
1116 handle_(0),
1117 role_(0),
1118 retry_(0),
1119 info_(RawAddress::ConvertToString(addr), type, transport),
1120 deviceRWMutex_(),
1121 sm_(*this),
1122 directConnect_([rawAddr = RawAddress::ConvertToString(addr), transport]() {
1123 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(std::bind(&impl::DirectConnectTimeout,
1124 GattConnectionManager::GetInstance().pimpl.get(),
1125 GattDevice(rawAddr, transport)));
1126 })
1127 {
1128 CopyAddress(addr, RawAddress::BT_ADDRESS_BYTE_LEN);
1129 }
1130
Device(const GattDevice & device,bool autoConnect)1131 GattConnectionManager::Device::Device(const GattDevice &device, bool autoConnect)
1132 : autoConnect_(autoConnect),
1133 mtu_(GATT_DEFAULT_MTU),
1134 handle_(0),
1135 role_(0),
1136 retry_(0),
1137 info_(device),
1138 deviceRWMutex_(),
1139 sm_(*this),
1140 directConnect_([device]() {
1141 GattConnectionManager::GetInstance().pimpl->dispatcher_->PostTask(
1142 std::bind(&impl::DirectConnectTimeout, GattConnectionManager::GetInstance().pimpl.get(), device));
1143 })
1144 {
1145 uint8_t addr[RawAddress::BT_ADDRESS_BYTE_LEN] = {0};
1146 device.addr_.ConvertToUint8(addr, sizeof(addr));
1147 CopyAddress(addr, RawAddress::BT_ADDRESS_BYTE_LEN);
1148 }
1149
CopyAddress(const uint8_t * addr,size_t length)1150 void GattConnectionManager::Device::CopyAddress(const uint8_t *addr, size_t length)
1151 {
1152 for (size_t i = 0; i < length; i++) {
1153 addr_[i] = addr[i];
1154 }
1155 }
1156
CheckEncryption()1157 void GattConnectionManager::Device::CheckEncryption()
1158 {
1159 if (Info().transport_ == GATT_TRANSPORT_TYPE_CLASSIC) {
1160 return;
1161 }
1162
1163 BtAddr addr;
1164 uint8_t encKeySize = 0;
1165 GAP_LeSecurityStatus status = GAP_LE_NO_ENCRYPTION;
1166 auto adapter = IAdapterManager::GetInstance()->GetBleAdapterInterface();
1167 if (adapter != nullptr) {
1168 (void)memcpy_s(addr.addr, RawAddress::BT_ADDRESS_BYTE_LEN, addr_, RawAddress::BT_ADDRESS_BYTE_LEN);
1169 addr.type = Info().addressType_;
1170 if (GAPIF_LeGetSecurityStatus(&addr, &status, &encKeySize) ==
1171 BT_SUCCESS && encKeySize != GAP_LE_NO_ENCRYPTION) {
1172 Info().isEncryption_ = true;
1173 } else {
1174 Info().isEncryption_ = false;
1175 }
1176 }
1177 }
1178
~Device()1179 GattConnectionManager::Device::~Device()
1180 {
1181 std::lock_guard<std::mutex> lck(deviceRWMutex_);
1182 }
1183
StateMachine(GattConnectionManager::Device & device)1184 GattConnectionManager::Device::StateMachine::StateMachine(GattConnectionManager::Device &device)
1185 {
1186 std::unique_ptr<State> idle = std::make_unique<Idle>(*this, device);
1187 Move(idle);
1188 std::unique_ptr<State> connecting = std::make_unique<Connecting>(*this, device);
1189 Move(connecting);
1190 std::unique_ptr<State> connected = std::make_unique<Connected>(*this, device);
1191 Move(connected);
1192 std::unique_ptr<State> disconnecting = std::make_unique<Disconnecting>(*this, device);
1193 Move(disconnecting);
1194 std::unique_ptr<State> disconnected = std::make_unique<Disconnected>(*this, device);
1195 Move(disconnected);
1196
1197 InitState(STATE_IDLE);
1198 }
1199
~StateMachine()1200 GattConnectionManager::Device::StateMachine::~StateMachine()
1201 {}
1202
ProcessMessage(int messageId,int arg1,void * arg2)1203 bool GattConnectionManager::Device::ProcessMessage(int messageId, int arg1, void *arg2)
1204 {
1205 HILOGI("Call Massage ID: %{public}d, Device Address:[%{public}s] Transport:[%{public}d]", messageId,
1206 GetEncryptAddr(this->Info().addr_.GetAddress()).c_str(), this->Info().transport_);
1207
1208 return SM().ProcessMessage(utility::Message(messageId, arg1, arg2));
1209 }
1210
AutoConnect()1211 bool &GattConnectionManager::Device::AutoConnect()
1212 {
1213 return autoConnect_;
1214 }
1215
Addr()1216 uint8_t *GattConnectionManager::Device::Addr()
1217 {
1218 return addr_;
1219 }
1220
Info()1221 GattDevice &GattConnectionManager::Device::Info()
1222 {
1223 return info_;
1224 }
1225
SM()1226 GattConnectionManager::Device::StateMachine &GattConnectionManager::Device::SM()
1227 {
1228 return sm_;
1229 }
1230
MTU()1231 uint16_t &GattConnectionManager::Device::MTU()
1232 {
1233 return mtu_;
1234 }
1235
Handle()1236 uint16_t &GattConnectionManager::Device::Handle()
1237 {
1238 return handle_;
1239 }
1240
RetryTimes()1241 uint8_t &GattConnectionManager::Device::RetryTimes()
1242 {
1243 return retry_;
1244 }
1245
Role()1246 uint8_t &GattConnectionManager::Device::Role()
1247 {
1248 return role_;
1249 }
1250
DeviceRWMutex()1251 std::mutex &GattConnectionManager::Device::DeviceRWMutex()
1252 {
1253 return deviceRWMutex_;
1254 }
1255
DirectConnect()1256 utility::Timer &GattConnectionManager::Device::DirectConnect()
1257 {
1258 return directConnect_;
1259 }
1260
StateBase(const std::string & name,utility::StateMachine & stateMachine,GattConnectionManager::Device & device)1261 GattConnectionManager::Device::StateMachine::StateBase::StateBase(
1262 const std::string &name, utility::StateMachine &stateMachine, GattConnectionManager::Device &device)
1263 : State(name, stateMachine), device_(device)
1264 {}
1265
Idle(utility::StateMachine & stateMachine,GattConnectionManager::Device & device)1266 GattConnectionManager::Device::StateMachine::Idle::Idle(
1267 utility::StateMachine &stateMachine, GattConnectionManager::Device &device)
1268 : StateBase(STATE_IDLE, stateMachine, device)
1269 {}
1270
Entry()1271 void GattConnectionManager::Device::StateMachine::Idle::Entry()
1272 {
1273 HILOGI("Device Address:[%{public}s] Transport:[%{public}d], Entry %{public}s State",
1274 GetEncryptAddr(device_.Info().addr_.GetAddress()).c_str(), device_.Info().transport_, "Idle");
1275 }
1276
Dispatch(const utility::Message & msg)1277 bool GattConnectionManager::Device::StateMachine::Idle::Dispatch(const utility::Message &msg)
1278 {
1279 LOG_DEBUG("%{public}s:%{public}d:%{public}s : Call Massage ID: %{public}d",
1280 __FILE__, __LINE__, __PRETTY_FUNCTION__, msg.what_);
1281 bool result = false;
1282
1283 switch (msg.what_) {
1284 case MSG_CONNECT:
1285 if (GattConnectionManager::GetInstance().pimpl->DoConnect(device_) == GattStatus::GATT_SUCCESS) {
1286 Transition(STATE_CONNECTING);
1287 result = true;
1288 } else {
1289 Transition(STATE_DISCONNECTED);
1290 }
1291 break;
1292 case MSG_CONNECT_COMPLETE:
1293 if (GattConnectionManager::GetInstance().pimpl->DoConnectComplete(device_, msg) ==
1294 GattStatus::GATT_SUCCESS) {
1295 Transition(STATE_CONNECTED);
1296 } else {
1297 Transition(STATE_DISCONNECTED);
1298 }
1299 result = true;
1300 break;
1301 case MSG_DISCONNECT:
1302 Transition(STATE_DISCONNECTED);
1303 break;
1304 case MSG_DISCONNECT_COMPLETE:
1305 case MSG_DIRECT_CONNECT_TIMEOUT:
1306 default:
1307 LOG_ERROR("Idle::%{public}s, StateMachine is %{public}d", __FUNCTION__, msg.what_);
1308 break;
1309 }
1310 return result;
1311 }
1312
Connecting(utility::StateMachine & stateMachine,GattConnectionManager::Device & device)1313 GattConnectionManager::Device::StateMachine::Connecting::Connecting(
1314 utility::StateMachine &stateMachine, GattConnectionManager::Device &device)
1315 : StateBase(STATE_CONNECTING, stateMachine, device)
1316 {}
1317
Entry()1318 void GattConnectionManager::Device::StateMachine::Connecting::Entry()
1319 {
1320 HILOGI("Device Address:[%{public}s] Transport:[%{public}d], Entry %{public}s State",
1321 GetEncryptAddr(device_.Info().addr_.GetAddress()).c_str(), device_.Info().transport_, "Connecting");
1322 GattConnectionManager::GetInstance().pimpl->NotifyObserver(
1323 device_.Info(), OBSERVER_EVENT_CONNECTING, device_.handle_, GattStatus::GATT_SUCCESS);
1324 }
1325
Dispatch(const utility::Message & msg)1326 bool GattConnectionManager::Device::StateMachine::Connecting::Dispatch(const utility::Message &msg)
1327 {
1328 LOG_DEBUG("%{public}s:%{public}d:%{public}s : Call Massage ID: %{public}d",
1329 __FILE__, __LINE__, __PRETTY_FUNCTION__, msg.what_);
1330 bool result = false;
1331
1332 switch (msg.what_) {
1333 case MSG_CONNECT_COMPLETE:
1334 if (GattConnectionManager::GetInstance().pimpl->DoConnectComplete(device_, msg) ==
1335 GattStatus::GATT_SUCCESS) {
1336 Transition(STATE_CONNECTED);
1337 } else {
1338 Transition(STATE_DISCONNECTED);
1339 }
1340 result = true;
1341 break;
1342 case MSG_DISCONNECT_COMPLETE:
1343 Transition(STATE_DISCONNECTED);
1344 result = true;
1345 break;
1346 case MSG_DIRECT_CONNECT_TIMEOUT:
1347 case MSG_DISCONNECT:
1348 BtAddr addr;
1349 if (memcpy_s(addr.addr, RawAddress::BT_ADDRESS_BYTE_LEN, device_.addr_, RawAddress::BT_ADDRESS_BYTE_LEN)
1350 == EOK) {
1351 addr.type = device_.info_.addressType_;
1352 ATT_LeConnectCancel(&addr);
1353 result = true;
1354 }
1355 break;
1356 case MSG_CONNECT:
1357 default:
1358 LOG_ERROR("Connecting::%{public}s, StateMachine is %{public}d", __FUNCTION__, msg.what_);
1359 break;
1360 }
1361 return result;
1362 }
1363
Connected(utility::StateMachine & stateMachine,GattConnectionManager::Device & device)1364 GattConnectionManager::Device::StateMachine::Connected::Connected(
1365 utility::StateMachine &stateMachine, GattConnectionManager::Device &device)
1366 : StateBase(STATE_CONNECTED, stateMachine, device)
1367 {}
1368
Entry()1369 void GattConnectionManager::Device::StateMachine::Connected::Entry()
1370 {
1371 HILOGI("Device Address:[%{public}s] Transport:[%{public}d], Entry %{public}s State",
1372 GetEncryptAddr(device_.Info().addr_.GetAddress()).c_str(), device_.Info().transport_, "Connected");
1373
1374 device_.CheckEncryption();
1375
1376 GattConnectionManager::GetInstance().pimpl->NotifyObserver(
1377 device_.Info(), OBSERVER_EVENT_CONNECTED, device_.handle_, GattStatus::GATT_SUCCESS);
1378 }
1379
Dispatch(const utility::Message & msg)1380 bool GattConnectionManager::Device::StateMachine::Connected::Dispatch(const utility::Message &msg)
1381 {
1382 LOG_DEBUG("%{public}s:%{public}d:%{public}s : Call Massage ID: %{public}d",
1383 __FILE__, __LINE__, __PRETTY_FUNCTION__, msg.what_);
1384 bool result = false;
1385
1386 switch (msg.what_) {
1387 case MSG_DISCONNECT:
1388 GattConnectionManager::GetInstance().pimpl->DoDisconnect(device_.handle_);
1389 Transition(STATE_DISCONNECTING);
1390 result = true;
1391 break;
1392 case MSG_DISCONNECT_COMPLETE:
1393 GattConnectionManager::GetInstance().pimpl->DoDisconnectComplete(device_, msg);
1394 Transition(STATE_DISCONNECTED);
1395 result = true;
1396 break;
1397 case MSG_REQUEST_CONNECTION_PRIORITY:
1398 if (GattConnectionManager::GetInstance().pimpl->DoRequestConnectionPriority(device_, msg.arg1_) ==
1399 GattStatus::GATT_SUCCESS) {
1400 result = true;
1401 }
1402 break;
1403 case MSG_RESPONSE_CONNECTION_PRIORITY:
1404 GattConnectionManager::GetInstance().pimpl->NotifyPriorityUpdated(device_.Info(),
1405 ((ConnectionPriorityResult *)msg.arg2_)->interval_,
1406 ((ConnectionPriorityResult *)msg.arg2_)->latency_,
1407 ((ConnectionPriorityResult *)msg.arg2_)->timeout_,
1408 ((ConnectionPriorityResult *)msg.arg2_)->status);
1409 result = true;
1410 break;
1411 case MSG_DIRECT_CONNECT_TIMEOUT:
1412 BtAddr addr;
1413 if (memcpy_s(addr.addr, RawAddress::BT_ADDRESS_BYTE_LEN, device_.addr_, RawAddress::BT_ADDRESS_BYTE_LEN)
1414 == EOK) {
1415 addr.type = device_.info_.addressType_;
1416 ATT_LeConnectCancel(&addr);
1417 result = true;
1418 }
1419 break;
1420 case MSG_RECONNECT_CAUSE_0X3E:
1421 GattConnectionManager::GetInstance().pimpl->NotifyObserver(
1422 device_.Info(), OBSERVER_EVENT_DISCONNECTED_INTER, device_.handle_, GattStatus::GATT_SUCCESS);
1423 if (GattConnectionManager::GetInstance().pimpl->DoConnect(device_) == GattStatus::GATT_SUCCESS) {
1424 result = true;
1425 }
1426 break;
1427 case MSG_CONNECT_COMPLETE:
1428 if (GattConnectionManager::GetInstance().pimpl->DoConnectComplete(device_, msg) !=
1429 GattStatus::GATT_SUCCESS) {
1430 Transition(STATE_DISCONNECTED);
1431 } else {
1432 GattConnectionManager::GetInstance().pimpl->NotifyObserver(
1433 device_.Info(), OBSERVER_EVENT_RECONNECTED, device_.handle_, GattStatus::GATT_SUCCESS);
1434 }
1435 result = true;
1436 break;
1437 case MSG_CONNECT:
1438 default:
1439 LOG_INFO("Connected::%{public}s, StateMachine is %{public}d", __FUNCTION__, msg.what_);
1440 break;
1441 }
1442 return result;
1443 }
1444
Disconnecting(utility::StateMachine & stateMachine,GattConnectionManager::Device & device)1445 GattConnectionManager::Device::StateMachine::Disconnecting::Disconnecting(
1446 utility::StateMachine &stateMachine, GattConnectionManager::Device &device)
1447 : StateBase(STATE_DISCONNECTING, stateMachine, device)
1448 {}
1449
Entry()1450 void GattConnectionManager::Device::StateMachine::Disconnecting::Entry()
1451 {
1452 HILOGI("Device Address:[%{public}s] Transport:[%{public}d], Entry %{public}s State",
1453 GetEncryptAddr(device_.Info().addr_.GetAddress()).c_str(), device_.Info().transport_, "Disconnecting");
1454
1455 GattConnectionManager::GetInstance().pimpl->NotifyObserver(
1456 device_.Info(), OBSERVER_EVENT_DISCONNECTING, device_.handle_, GattStatus::GATT_SUCCESS);
1457 }
1458
Dispatch(const utility::Message & msg)1459 bool GattConnectionManager::Device::StateMachine::Disconnecting::Dispatch(const utility::Message &msg)
1460 {
1461 LOG_DEBUG("%{public}s:%{public}d:%{public}s : Call Massage ID: %{public}d",
1462 __FILE__, __LINE__, __PRETTY_FUNCTION__, msg.what_);
1463 bool result = false;
1464
1465 switch (msg.what_) {
1466 case MSG_DISCONNECT_COMPLETE:
1467 if (GattConnectionManager::GetInstance().pimpl->DoDisconnectComplete(device_, msg) ==
1468 GattStatus::GATT_SUCCESS) {
1469 Transition(STATE_DISCONNECTED);
1470 } else {
1471 Transition(STATE_CONNECTED);
1472 }
1473 result = true;
1474 break;
1475 case MSG_CONNECT:
1476 case MSG_CONNECT_COMPLETE:
1477 case MSG_DISCONNECT:
1478 case MSG_DIRECT_CONNECT_TIMEOUT:
1479 default:
1480 LOG_ERROR("Disconnecting::%{public}s, StateMachine is %{public}d", __FUNCTION__, msg.what_);
1481 break;
1482 }
1483 return result;
1484 }
1485
Disconnected(utility::StateMachine & stateMachine,GattConnectionManager::Device & device)1486 GattConnectionManager::Device::StateMachine::Disconnected::Disconnected(
1487 utility::StateMachine &stateMachine, GattConnectionManager::Device &device)
1488 : StateBase(STATE_DISCONNECTED, stateMachine, device)
1489 {}
1490
Entry()1491 void GattConnectionManager::Device::StateMachine::Disconnected::Entry()
1492 {
1493 HILOGI("Device Address:[%{public}s] Transport:[%{public}d], Entry %{public}s State",
1494 GetEncryptAddr(device_.Info().addr_.GetAddress()).c_str(), device_.Info().transport_, "Disconnected");
1495
1496 device_.CheckEncryption();
1497
1498 GattConnectionManager::GetInstance().pimpl->NotifyObserver(
1499 device_.Info(), OBSERVER_EVENT_DISCONNECTED, device_.handle_, GattStatus::GATT_SUCCESS);
1500
1501 device_.mtu_ = GATT_DEFAULT_MTU;
1502 device_.handle_ = 0;
1503
1504 if (device_.autoConnect_) {
1505 device_.sm_.ProcessMessage(utility::Message(MSG_CONNECT));
1506 }
1507 }
1508
Dispatch(const utility::Message & msg)1509 bool GattConnectionManager::Device::StateMachine::Disconnected::Dispatch(const utility::Message &msg)
1510 {
1511 LOG_DEBUG("%{public}s:%{public}d:%{public}s : Call Massage ID: %{public}d",
1512 __FILE__, __LINE__, __PRETTY_FUNCTION__, msg.what_);
1513 bool result = false;
1514
1515 GattConnectionManager &instance = GattConnectionManager::GetInstance();
1516
1517 switch (msg.what_) {
1518 case MSG_CONNECT:
1519 if (instance.pimpl->DoConnect(device_) == GattStatus::GATT_SUCCESS) {
1520 Transition(STATE_CONNECTING);
1521 result = true;
1522 }
1523 break;
1524 case MSG_CONNECT_COMPLETE:
1525 if (instance.pimpl->DoConnectComplete(device_, msg) == GattStatus::GATT_SUCCESS) {
1526 Transition(STATE_CONNECTED);
1527 }
1528 result = true;
1529 break;
1530 case MSG_DIRECT_CONNECT_TIMEOUT:
1531 break;
1532 case MSG_DISCONNECT:
1533 case MSG_DISCONNECT_COMPLETE:
1534 default:
1535 LOG_INFO("Disconnected::%{public}s, StateMachine is %{public}d", __FUNCTION__, msg.what_);
1536 break;
1537 }
1538 return result;
1539 }
1540 } // namespace bluetooth
1541 } // namespace OHOS
1542