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 "classic_adapter.h"
17
18 #include <algorithm>
19 #include <sys/time.h>
20 #include "adapter_manager.h"
21 #include "base_observer_list.h"
22 #include "btstack.h"
23 #include "class_creator.h"
24 #include "classic_data_structure.h"
25 #include "classic_data_type_defs.h"
26 #include "classic_defs.h"
27 #include "classic_utils.h"
28 #include "compat.h"
29 #include "dialog/dialog_pair.h"
30 #include "interface_profile_manager.h"
31 #include "securec.h"
32
33 namespace OHOS {
34 namespace bluetooth {
35 struct ClassicAdapter::impl {
36 std::recursive_mutex syncMutex_ {};
37 BaseObserverList<IAdapterClassicObserver> adapterObservers_ {};
38 BaseObserverList<IClassicRemoteDeviceObserver> remoteObservers_ {};
39 };
40
ClassicAdapter()41 ClassicAdapter::ClassicAdapter()
42 : utility::Context(ADAPTER_NAME_CLASSIC, "5.0"),
43 adapterProperties_(ClassicAdapterProperties::GetInstance()),
44 batteryObserverHf_(std::make_unique<ClassicBatteryObserverHf>(*GetDispatcher())),
45 batteryObserverAg_(std::make_unique<ClassicBatteryObserverAg>(*GetDispatcher())),
46 pimpl(std::make_unique<ClassicAdapter::impl>())
47 {
48 HILOGI("%{public}s Constructor", Name().c_str());
49 discoveryState_ = DISCOVERY_STOPED;
50 scanMode_ = SCAN_MODE_NONE;
51 }
52
~ClassicAdapter()53 ClassicAdapter::~ClassicAdapter()
54 {
55 HILOGI("%{public}s Destructor", Name().c_str());
56 }
57
Enable()58 void ClassicAdapter::Enable()
59 {
60 HILOGI("%{public}s Enable", Name().c_str());
61
62 GetDispatcher()->PostTask(std::bind(&ClassicAdapter::StartUp, this));
63 }
64
StartUp()65 void ClassicAdapter::StartUp()
66 {
67 HILOGI("enter");
68
69 isDisable_ = false;
70 bool result = adapterProperties_.LoadConfigInfo();
71 ClassicUtils::CheckReturnValue("ClassicAdapter", "LoadConfigInfo", result);
72
73 btmEnableSuccess_ = (BTM_Enable(BREDR_CONTROLLER) == BT_SUCCESS);
74 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_Enable", btmEnableSuccess_);
75 if (!btmEnableSuccess_) {
76 GetContext()->OnEnable(ADAPTER_NAME_CLASSIC, false);
77 return;
78 }
79
80 eirData_.SetDataMaxLength(MAX_EXTEND_INQUIRY_RESPONSE_LEN);
81 timer_ = std::make_unique<utility::Timer>(std::bind(&ClassicAdapter::ScanModeTimeout, this));
82 hwTimer_ = std::make_unique<utility::Timer>(std::bind(&ClassicAdapter::HwProcessTimeout, this));
83
84 bool ret = RegisterCallback();
85 ClassicUtils::CheckReturnValue("ClassicAdapter", "RegisterCallback", ret);
86
87 ret &= adapterProperties_.ConfigProperties();
88 ClassicUtils::CheckReturnValue("ClassicAdapter", "ConfigProperties", ret);
89
90 ret &= adapterProperties_.SetSecurityMode();
91 ClassicUtils::CheckReturnValue("ClassicAdapter", "SetSecurityMode", ret);
92
93 LoadPairedDeviceInfo();
94
95 GetContext()->OnEnable(ADAPTER_NAME_CLASSIC, ret);
96 }
97
Disable()98 void ClassicAdapter::Disable()
99 {
100 HILOGI("%{public}s Disable", Name().c_str());
101
102 GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ShutDown, this));
103 }
104
ShutDown()105 void ClassicAdapter::ShutDown()
106 {
107 HILOGI("enter");
108
109 if (!btmEnableSuccess_) {
110 GetContext()->OnDisable(ADAPTER_NAME_CLASSIC, true);
111 return;
112 }
113
114 isDisable_ = true;
115 SavePairedDevices();
116
117 if (hfService_ != nullptr) {
118 hfService_->DeregisterObserver(*(HfpHfServiceObserver *)batteryObserverHf_.get());
119 }
120 if (agService_ != nullptr) {
121 agService_->DeregisterObserver(*(HfpAgServiceObserver *)batteryObserverAg_.get());
122 }
123
124 if (IsBtDiscovering()) {
125 CancelBtDiscovery();
126 return;
127 }
128
129 DisablePairProcess();
130 }
131
InitMode()132 void ClassicAdapter::InitMode()
133 {
134 if (waitPairResult_) {
135 return;
136 }
137
138 bool ret = adapterProperties_.InitMode();
139 ClassicUtils::CheckReturnValue("ClassicAdapter", "InitMode", ret);
140
141 if (scanMode_ != SCAN_MODE_NONE) {
142 ret = SetScanMode(SCAN_MODE_NONE);
143 ClassicUtils::CheckReturnValue("ClassicAdapter", "SetScanMode", ret);
144 if (ret) {
145 return;
146 }
147 }
148
149 DisableBTM();
150 }
151
DisablePairProcess()152 void ClassicAdapter::DisablePairProcess()
153 {
154 HILOGI("enter");
155 for (auto &device : devices_) {
156 if (device.second->GetPairedStatus() == PAIR_PAIRING) {
157 bool result =
158 (BTM_AclDisconnect(device.second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_SUCCESS);
159 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", result);
160 device.second->SetPairedStatus(PAIR_NONE);
161 if (device.second->IsBondedFromLocal() && (!pinMode_)) {
162 waitPairResult_ = true;
163 }
164 }
165 }
166 InitMode();
167 }
168
FreeMemory()169 void ClassicAdapter::FreeMemory()
170 {
171 devices_.clear();
172
173 hfService_ = nullptr;
174 agService_ = nullptr;
175
176 if (hwTimer_ != nullptr) {
177 hwTimer_->Stop();
178 }
179
180 if (timer_ != nullptr) {
181 timer_->Stop();
182 }
183 }
184
DisableBTM()185 void ClassicAdapter::DisableBTM()
186 {
187 /// Unregister Callback.
188 bool ret = DeregisterCallback();
189 ClassicUtils::CheckReturnValue("ClassicAdapter", "DeregisterCallback", ret);
190
191 /// Disable BTM
192 ret &= (BTM_Disable(BREDR_CONTROLLER) == BT_SUCCESS);
193 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_Disable", ret);
194
195 FreeMemory();
196 btmEnableSuccess_ = false;
197 GetContext()->OnDisable(ADAPTER_NAME_CLASSIC, ret);
198 }
199
PostEnable()200 void ClassicAdapter::PostEnable()
201 {
202 HILOGI("%{public}s PostEnable", Name().c_str());
203
204 GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ProcessPostEnable, this));
205 }
206
ProcessPostEnable()207 void ClassicAdapter::ProcessPostEnable()
208 {
209 HILOGI("enter");
210
211 UpdateSupportedUuids();
212
213 hfService_ = (IProfileHfpHf *)IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_HFP_HF);
214 if (hfService_ != nullptr) {
215 hfService_->RegisterObserver(*(HfpHfServiceObserver *)batteryObserverHf_.get());
216 }
217
218 agService_ = (IProfileHfpAg *)IProfileManager::GetInstance()->GetProfileService(PROFILE_NAME_HFP_AG);
219 if (agService_ != nullptr) {
220 agService_->RegisterObserver(*(HfpAgServiceObserver *)batteryObserverAg_.get());
221 }
222 }
223
UpdateSupportedUuids() const224 void ClassicAdapter::UpdateSupportedUuids() const
225 {
226 HILOGI("enter");
227
228 /// Get Supported UUID for AdapterManager.
229 std::vector<std::string> stringUuids;
230 IProfileManager::GetInstance()->GetProfileServicesSupportedUuids(stringUuids);
231
232 /// convert String to Uuid.
233 std::vector<Uuid> uuids;
234 for (auto &value : stringUuids) {
235 Uuid uuid = Uuid::ConvertFromString(value);
236 uuids.push_back(uuid);
237 }
238
239 bool ret = adapterProperties_.SaveSupportUuids(uuids);
240 ClassicUtils::CheckReturnValue("ClassicAdapter", "SaveSupportUuids", ret);
241 }
242
LoadPairedDeviceInfo()243 void ClassicAdapter::LoadPairedDeviceInfo()
244 {
245 std::vector<std::string> pairedAddrList = adapterProperties_.GetPairedAddrList();
246 for (auto &pairedAddr : pairedAddrList) {
247 std::string addr = pairedAddr;
248 if (addr.empty() || addr == INVALID_MAC_ADDRESS) {
249 continue;
250 } else {
251 std::shared_ptr<ClassicRemoteDevice> remote = adapterProperties_.GetPairedDevice(addr);
252 if (remote != nullptr) {
253 devices_.insert(std::make_pair(addr, remote));
254 }
255 }
256 }
257 }
258
SavePairedDevices() const259 void ClassicAdapter::SavePairedDevices() const
260 {
261 for (auto &device : devices_) {
262 if (device.second->IsPaired()) {
263 adapterProperties_.SavePairedDeviceInfo(device.second);
264 }
265 }
266 adapterProperties_.SaveConfigFile();
267 }
268
RegisterCallback()269 bool ClassicAdapter::RegisterCallback()
270 {
271 /// Register GAP discovery series callback.
272 GapDiscoveryCallback discoveryCbs {};
273 discoveryCbs.inquiryResult = InquiryResultCallback;
274 discoveryCbs.inquiryResultRssi = InquiryResultRssiCallback;
275 discoveryCbs.extendedInquiryResult = ExtendedInquiryResultCallback;
276 discoveryCbs.remoteName = RemoteNameCallback;
277 discoveryCbs.inquiryComplete = InquiryCompleteCallback;
278 bool ret = (GAPIF_RegisterDiscoveryCallback(&discoveryCbs, this) == BT_SUCCESS);
279 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_RegisterDiscoveryCallback", ret);
280
281 /// Register GAP Pair series callback.
282 GapAuthenticationCallback authenticationCbs {};
283 authenticationCbs.authenticationComplete = AuthenticationCompleteCallback;
284 authenticationCbs.encryptionChangeCallback = EncryptionChangeCallback;
285 authenticationCbs.IOCapabilityReq = IoCapabilityReqCallback;
286 authenticationCbs.IOCapabilityRsp = IoCapabilityRspCallback;
287 authenticationCbs.linkKeyNotification = LinkKeyNotification;
288 authenticationCbs.linkKeyReq = LinkKeyReqCallback;
289 authenticationCbs.pinCodeReq = PinCodeReqCallback;
290 authenticationCbs.remoteOobReq = RemoteOobReqCallback;
291 authenticationCbs.simplePairComplete = SimplePairCompleteCallback;
292 authenticationCbs.userConfirmReq = UserConfirmReqCallback;
293 authenticationCbs.userPasskeyReq = UserPasskeyReqCallback;
294 authenticationCbs.userPasskeyNotification = UserPasskeyNotificationCallback;
295 ret &= (GAPIF_RegisterAuthenticationCallback(&authenticationCbs, this) == BT_SUCCESS);
296 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_RegisterAuthenticationCallback", ret);
297
298 /// Register GAP security callback.
299 GapSecurityCallback securityCb {};
300 securityCb.authorizeInd = AuthorizeIndCallback;
301 ret &= (GAPIF_RegisterSecurityCallback(&securityCb, this) == BT_SUCCESS);
302 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_RegisterSecurityCallback", ret);
303
304 /// Register BTM ACL Change status callback.
305 btmAclCbs_.connectionComplete = ConnectionComplete;
306 btmAclCbs_.disconnectionComplete = DisconnectionComplete;
307 btmAclCbs_.leConnectionComplete = nullptr;
308 btmAclCbs_.leDisconnectionComplete = nullptr;
309 btmAclCbs_.readRssiComplete = nullptr;
310 ret &= (BTM_RegisterAclCallbacks(&btmAclCbs_, this) == BT_SUCCESS);
311 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_RegisterAclCallbacks", ret);
312
313 return ret;
314 }
315
DeregisterCallback() const316 bool ClassicAdapter::DeregisterCallback() const
317 {
318 /// Deregister GAP discovery callback.
319 bool ret = (GAPIF_DeregisterDiscoveryCallback() == BT_SUCCESS);
320 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_DeregisterDiscoveryCallback", ret);
321
322 /// Deregister GAP Pair series callback.
323 ret &= (GAPIF_DeregisterAuthenticationCallback() == BT_SUCCESS);
324 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_DeregisterAuthenticationCallback", ret);
325
326 /// Deregister GAP security callback.
327 ret &= (GAPIF_DeregisterSecurityCallback() == BT_SUCCESS);
328 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_DeregisterSecurityCallback", ret);
329
330 /// Deregister BTM ACL Change status callback.
331 ret &= (BTM_DeregisterAclCallbacks(&btmAclCbs_) == BT_SUCCESS);
332 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_DeregisterAclCallbacks", ret);
333
334 return ret;
335 }
336
GetLocalAddress() const337 std::string ClassicAdapter::GetLocalAddress() const
338 {
339 return adapterProperties_.GetLocalAddress();
340 }
341
GetLocalName() const342 std::string ClassicAdapter::GetLocalName() const
343 {
344 return adapterProperties_.GetLocalName();
345 }
346
SetLocalName(const std::string & name) const347 bool ClassicAdapter::SetLocalName(const std::string &name) const
348 {
349 HILOGI("name: %{public}s", name.c_str());
350
351 if (name.empty()) {
352 HILOGE("failed, because of name is NULL!");
353 return false;
354 }
355
356 std::string localName = adapterProperties_.GetLocalName();
357 if (localName == name) {
358 HILOGW("same name!");
359 return true;
360 }
361
362 return adapterProperties_.SetLocalName(name);
363 }
364
GetLocalDeviceClass() const365 int ClassicAdapter::GetLocalDeviceClass() const
366 {
367 return adapterProperties_.GetLocalDeviceClass();
368 }
369
SetLocalDeviceClass(int deviceClass) const370 bool ClassicAdapter::SetLocalDeviceClass(int deviceClass) const
371 {
372 return adapterProperties_.SetLocalDeviceClass(deviceClass);
373 }
374
GetBtScanMode() const375 int ClassicAdapter::GetBtScanMode() const
376 {
377 return scanMode_;
378 }
379
SetBtScanMode(int mode,int duration)380 bool ClassicAdapter::SetBtScanMode(int mode, int duration)
381 {
382 HILOGI("mode: %{public}d, duration: %{public}d", mode, duration);
383
384 if (mode < SCAN_MODE_NONE || mode > SCAN_MODE_CONNECTABLE_LIMITED_DISCOVERABLE) {
385 HILOGE("failed. Invalid Parameter[mode]");
386 return false;
387 }
388
389 if (INVALID_VALUE > duration) {
390 HILOGE("failed. Invalid parameter[duration].");
391 return false;
392 }
393
394 bool ret = adapterProperties_.SetDiscoverableTimeout(duration);
395 ClassicUtils::CheckReturnValue("ClassicAdapter", "SetDiscoverableTimeout", ret);
396
397 GetDispatcher()->PostTask(std::bind(&ClassicAdapter::SetScanMode, this, mode));
398
399 return ret;
400 }
401
SetScanMode(int mode)402 bool ClassicAdapter::SetScanMode(int mode)
403 {
404 scanMode_ = mode;
405 GapDiscoverModeInfo discoverMode;
406 GapConnectableModeInfo connectableMode;
407 GapSetScanModeResultCallback cb = SetScanModeResultCallback;
408 switch (mode) {
409 case SCAN_MODE_NONE:
410 discoverMode.mode = GAP_DISCOVERABLE_MODE_NON;
411 connectableMode.mode = GAP_CONNECTABLE_MODE_NON;
412 break;
413 case SCAN_MODE_CONNECTABLE:
414 discoverMode.mode = GAP_DISCOVERABLE_MODE_NON;
415 connectableMode.mode = GAP_CONNECTABLE_MODE;
416 break;
417 case SCAN_MODE_GENERAL_DISCOVERABLE:
418 discoverMode.mode = GAP_DISCOVERABLE_MODE_GENERAL;
419 connectableMode.mode = GAP_CONNECTABLE_MODE_NON;
420 break;
421 case SCAN_MODE_LIMITED_DISCOVERABLE:
422 discoverMode.mode = GAP_DISCOVERABLE_MODE_LIMITED;
423 connectableMode.mode = GAP_CONNECTABLE_MODE_NON;
424 break;
425 case SCAN_MODE_CONNECTABLE_GENERAL_DISCOVERABLE:
426 discoverMode.mode = GAP_DISCOVERABLE_MODE_GENERAL;
427 connectableMode.mode = GAP_CONNECTABLE_MODE;
428 break;
429 case SCAN_MODE_CONNECTABLE_LIMITED_DISCOVERABLE:
430 discoverMode.mode = GAP_DISCOVERABLE_MODE_LIMITED;
431 connectableMode.mode = GAP_CONNECTABLE_MODE;
432 break;
433 default:
434 discoverMode.mode = GAP_DISCOVERABLE_MODE_NON;
435 connectableMode.mode = GAP_CONNECTABLE_MODE_NON;
436 break;
437 }
438 discoverMode.type = GAP_INQUIRY_SCAN_TYPE_GENERAL;
439 connectableMode.type = GAP_PAGE_SCAN_TYPE_GENERAL;
440 discoverMode.scanInterval = GAP_INQUIRY_SCAN_INTERVAL_DEFAULT;
441 discoverMode.scanWindow = GAP_INQUIRY_SCAN_WINDOW_DEFAULT;
442 connectableMode.scanInterval = GAP_PAGE_SCAN_INTERVAL_DEFAULT;
443 connectableMode.scanWindow = GAP_PAGE_SCAN_WINDOW_DEFAULT;
444 bool ret = (GAPIF_SetScanMode(&discoverMode, &connectableMode, cb, this) == BT_SUCCESS);
445
446 if (timer_ != nullptr) {
447 timer_->Stop();
448 }
449
450 return ret;
451 }
452
SetScanModeResultCallback(uint8_t status,void * context)453 void ClassicAdapter::SetScanModeResultCallback(uint8_t status, void *context)
454 {
455 HILOGI("status: %{public}u", status);
456
457 auto adapter = static_cast<ClassicAdapter *>(context);
458 if (adapter != nullptr) {
459 adapter->GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ReceiveSetScanModeCallback, adapter, status));
460 }
461 }
462
ReceiveSetScanModeCallback(uint8_t status)463 void ClassicAdapter::ReceiveSetScanModeCallback(uint8_t status)
464 {
465 HILOGI("status: %{public}u", status);
466
467 if (status != NOERROR) {
468 HILOGE("failed, status is %{public}u", status);
469 return;
470 }
471
472 SendScanModeChanged(scanMode_);
473
474 if ((scanMode_ != SCAN_MODE_NONE) && (scanMode_ != SCAN_MODE_CONNECTABLE) &&
475 (adapterProperties_.GetDiscoverableTimeout() != 0) && (timer_ != nullptr)) {
476 timer_->Start(adapterProperties_.GetDiscoverableTimeout());
477 }
478
479 if (isDisable_) {
480 DisableBTM();
481 }
482 }
483
SendScanModeChanged(int mode) const484 void ClassicAdapter::SendScanModeChanged(int mode) const
485 {
486 HILOGI("mode: %{public}d", mode);
487
488 pimpl->adapterObservers_.ForEach([mode](IAdapterClassicObserver &observer) { observer.OnScanModeChanged(mode); });
489 }
490
ScanModeTimeout()491 void ClassicAdapter::ScanModeTimeout()
492 {
493 HILOGI("enter");
494
495 if (GetDispatcher() != nullptr) {
496 GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ResetScanMode, this));
497 }
498 }
499
ResetScanMode()500 void ClassicAdapter::ResetScanMode()
501 {
502 int mode = SCAN_MODE_NONE;
503 switch (scanMode_) {
504 case SCAN_MODE_GENERAL_DISCOVERABLE:
505 case SCAN_MODE_LIMITED_DISCOVERABLE:
506 mode = SCAN_MODE_NONE;
507 break;
508 case SCAN_MODE_CONNECTABLE_GENERAL_DISCOVERABLE:
509 case SCAN_MODE_CONNECTABLE_LIMITED_DISCOVERABLE:
510 mode = SCAN_MODE_CONNECTABLE;
511 break;
512 default:
513 break;
514 }
515 SetScanMode(mode);
516 }
517
HwProcessTimeout()518 void ClassicAdapter::HwProcessTimeout()
519 {
520 HILOGI("enter");
521
522 if (GetDispatcher() != nullptr) {
523 GetDispatcher()->PostTask(std::bind(&ClassicAdapter::HwTimeout, this));
524 }
525 }
526
HwTimeout()527 void ClassicAdapter::HwTimeout()
528 {
529 HILOGI("enter");
530 bool ret = CancelGetRemoteName();
531 ClassicUtils::CheckReturnValue("ClassicAdapter", "CancelGetRemoteName", ret);
532 }
533
GetBondableMode() const534 int ClassicAdapter::GetBondableMode() const
535 {
536 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
537 return adapterProperties_.GetBondableMode();
538 }
539
SetBondableMode(int mode) const540 bool ClassicAdapter::SetBondableMode(int mode) const
541 {
542 HILOGI("mode: %{public}d", mode);
543
544 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
545 for (auto &device : devices_) {
546 if (device.second->GetPairedStatus() == PAIR_PAIRING) {
547 HILOGW("failed, because of PAIR_PAIRING.");
548 return false;
549 }
550 }
551
552 return adapterProperties_.SetBondableMode(mode);
553 }
554
StartBtDiscovery()555 bool ClassicAdapter::StartBtDiscovery()
556 {
557 HILOGI("enter");
558
559 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
560 if (discoveryState_ == DISCOVERYING || discoveryState_ == DISCOVERY_STARTED) {
561 HILOGE("failed, because of DISCOVERYING or DISCOVERY_STARTED!");
562 return false;
563 }
564
565 int ret = GAPIF_Inquiry(GAP_INQUIRY_MODE_GENERAL, DEFAULT_INQ_MAX_DURATION);
566 if (ret == BT_SUCCESS) {
567 discoveryState_ = DISCOVERY_STARTED;
568 struct timeval tv {};
569 gettimeofday(&tv, nullptr);
570 long currentTime = (tv.tv_sec * MILLISECOND_UNIT + tv.tv_usec / MILLISECOND_UNIT);
571 discoveryEndMs_ = currentTime + DEFAULT_DISCOVERY_TIMEOUT_MS;
572 SendDiscoveryStateChanged(discoveryState_);
573 } else {
574 HILOGE("failed, because of GAPIF_Inquiry failed!");
575 return false;
576 }
577
578 return true;
579 }
580
CancelBtDiscovery()581 bool ClassicAdapter::CancelBtDiscovery()
582 {
583 HILOGI("enter");
584
585 bool ret = false;
586 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
587 if (discoveryState_ == DISCOVERY_STOPED) {
588 HILOGE("failed, because of DISCOVERY_STOPED!");
589 return ret;
590 }
591 cancelDiscovery_ = true;
592
593 if (!receiveInquiryComplete_) {
594 ret = (GAPIF_InquiryCancel() == BT_SUCCESS);
595 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_InquiryCancel", ret);
596 } else {
597 discoveryState_ = DISCOVERY_STOPED;
598 ret = CancelGetRemoteName();
599 ClassicUtils::CheckReturnValue("ClassicAdapter", "CancelGetRemoteName", ret);
600 }
601
602 return ret;
603 }
604
IsBtDiscovering() const605 bool ClassicAdapter::IsBtDiscovering() const
606 {
607 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
608 HILOGI("discoveryState %{public}d", discoveryState_);
609
610 return (DISCOVERY_STOPED > discoveryState_);
611 }
612
GetBtDiscoveryEndMillis() const613 long ClassicAdapter::GetBtDiscoveryEndMillis() const
614 {
615 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
616 return discoveryEndMs_;
617 }
618
InquiryResultCallback(const BtAddr * addr,uint32_t classOfDevice,void * context)619 void ClassicAdapter::InquiryResultCallback(const BtAddr *addr, uint32_t classOfDevice, void *context)
620 {
621 HILOGI("enter");
622
623 GapCallbackParam param = {};
624 (void)memcpy_s((void *)¶m.iniquiryResultParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
625 param.iniquiryResultParam_.classOfDevice = classOfDevice;
626
627 auto adapter = static_cast<ClassicAdapter *>(context);
628 if (adapter != nullptr) {
629 adapter->GetDispatcher()->PostTask(
630 std::bind(&ClassicAdapter::HandleInquiryEvent, adapter, GAP_INQUIRY_RESULT_EVT, param));
631 }
632 }
633
InquiryResultRssiCallback(const BtAddr * addr,uint32_t classOfDevice,int8_t rssi,void * context)634 void ClassicAdapter::InquiryResultRssiCallback(const BtAddr *addr, uint32_t classOfDevice, int8_t rssi, void *context)
635 {
636 HILOGI("enter");
637
638 GapCallbackParam param = {};
639 (void)memcpy_s((void *)¶m.iniquiryResultParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
640 param.iniquiryResultRssiParam_.classOfDevice = classOfDevice;
641 param.iniquiryResultRssiParam_.rssi = rssi;
642
643 auto adapter = static_cast<ClassicAdapter *>(context);
644 if (adapter != nullptr) {
645 adapter->GetDispatcher()->PostTask(
646 std::bind(&ClassicAdapter::HandleInquiryEvent, adapter, GAP_INQUIRY_RESULT_RSSI_EVT, param));
647 }
648 }
649
ExtendedInquiryResultCallback(const BtAddr * addr,uint32_t classOfDevice,int8_t rssi,const uint8_t eir[MAX_EXTEND_INQUIRY_RESPONSE_LEN],void * context)650 void ClassicAdapter::ExtendedInquiryResultCallback(const BtAddr *addr, uint32_t classOfDevice, int8_t rssi,
651 const uint8_t eir[MAX_EXTEND_INQUIRY_RESPONSE_LEN], void *context)
652 {
653 HILOGI("enter");
654
655 GapCallbackParam param = {};
656 (void)memcpy_s(static_cast<void *>(const_cast<BtAddr *>(¶m.iniquiryResultParam_.addr)),
657 sizeof(BtAddr), addr, sizeof(BtAddr));
658 param.extendedInquiryResultParam_.classOfDevice = classOfDevice;
659 param.extendedInquiryResultParam_.rssi = rssi;
660 (void)memcpy_s(static_cast<void *>(¶m.extendedInquiryResultParam_.eir),
661 MAX_EXTEND_INQUIRY_RESPONSE_LEN,
662 eir,
663 MAX_EXTEND_INQUIRY_RESPONSE_LEN);
664
665 auto adapter = static_cast<ClassicAdapter *>(context);
666 if (adapter != nullptr) {
667 adapter->GetDispatcher()->PostTask(
668 std::bind(&ClassicAdapter::HandleInquiryEvent, adapter, GAP_EXTENDED_INQUIRY_RESULT_EVT, param));
669 }
670 }
671
InquiryCompleteCallback(uint8_t status,void * context)672 void ClassicAdapter::InquiryCompleteCallback(uint8_t status, void *context)
673 {
674 HILOGI("status: %{public}u", status);
675
676 GapCallbackParam param = {};
677 param.inquiryCompleteParam_.status = status;
678
679 auto adapter = static_cast<ClassicAdapter *>(context);
680 if (adapter != nullptr) {
681 adapter->GetDispatcher()->PostTask(
682 std::bind(&ClassicAdapter::HandleInquiryEvent, adapter, GAP_INQUIRY_COMPLETE_EVT, param));
683 }
684 }
685
RemoteNameCallback(uint8_t status,const BtAddr * addr,const uint8_t name[MAX_LOC_BT_NAME_LEN],void * context)686 void ClassicAdapter::RemoteNameCallback(
687 uint8_t status, const BtAddr *addr, const uint8_t name[MAX_LOC_BT_NAME_LEN], void *context)
688 {
689 HILOGI("enter");
690
691 GapCallbackParam param = {};
692 param.remoteNameCallbackParam_.status = status;
693 (void)memcpy_s(static_cast<void *>(const_cast<BtAddr *>(¶m.remoteNameCallbackParam_.addr)),
694 sizeof(BtAddr), addr, sizeof(BtAddr));
695 (void)memcpy_s(static_cast<void *>(const_cast<uint8_t *>(param.remoteNameCallbackParam_.name)),
696 MAX_LOC_BT_NAME_LEN, name, MAX_LOC_BT_NAME_LEN);
697
698 auto adapter = static_cast<ClassicAdapter *>(context);
699 if (adapter != nullptr) {
700 adapter->GetDispatcher()->PostTask(
701 std::bind(&ClassicAdapter::HandleInquiryEvent, adapter, GAP_REMOTE_NAME_CALLBACK_EVT, param));
702 }
703 }
704
UserConfirmReqCallback(const BtAddr * addr,uint32_t number,int localMitmRequired,int remoteMitmRequired,void * context)705 void ClassicAdapter::UserConfirmReqCallback(const BtAddr *addr, uint32_t number,
706 int localMitmRequired, int remoteMitmRequired, void *context)
707 {
708 HILOGI("enter");
709
710 GapCallbackParam param = {};
711 (void)memcpy_s((void *)¶m.userConfirmReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
712 param.userConfirmReqParam_.number = number;
713 param.userConfirmReqParam_.reqType = PAIR_CONFIRM_TYPE_NUMERIC;
714 param.userConfirmReqParam_.localMitmRequired = localMitmRequired;
715 param.userConfirmReqParam_.remoteMitmRequired = remoteMitmRequired;
716
717 auto adapter = static_cast<ClassicAdapter *>(context);
718 if (adapter != nullptr) {
719 adapter->GetDispatcher()->PostTask(
720 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SSP_CONFIRM_REQ_EVT, param));
721 }
722 }
723
UserPasskeyReqCallback(const BtAddr * addr,void * context)724 void ClassicAdapter::UserPasskeyReqCallback(const BtAddr *addr, void *context)
725 {
726 HILOGI("enter");
727
728 GapCallbackParam param = {};
729 (void)memcpy_s((void *)¶m.userConfirmReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
730 param.userConfirmReqParam_.reqType = PAIR_CONFIRM_TYPE_PASSKEY_INPUT;
731 param.userConfirmReqParam_.number = 0;
732 param.userConfirmReqParam_.localMitmRequired = GAP_MITM_REQUIRED;
733 param.userConfirmReqParam_.remoteMitmRequired = GAP_MITM_REQUIRED;
734
735 auto adapter = static_cast<ClassicAdapter *>(context);
736 if (adapter != nullptr) {
737 adapter->GetDispatcher()->PostTask(
738 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SSP_CONFIRM_REQ_EVT, param));
739 }
740 }
741
UserPasskeyNotificationCallback(const BtAddr * addr,uint32_t number,void * context)742 void ClassicAdapter::UserPasskeyNotificationCallback(const BtAddr *addr, uint32_t number, void *context)
743 {
744 HILOGI("enter");
745
746 GapCallbackParam param = {};
747 (void)memcpy_s((void *)¶m.userConfirmReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
748 param.userConfirmReqParam_.reqType = PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY;
749 param.userConfirmReqParam_.number = number;
750 param.userConfirmReqParam_.localMitmRequired = GAP_MITM_REQUIRED;
751 param.userConfirmReqParam_.remoteMitmRequired = GAP_MITM_REQUIRED;
752
753 auto adapter = static_cast<ClassicAdapter *>(context);
754 if (adapter != nullptr) {
755 adapter->GetDispatcher()->PostTask(
756 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SSP_CONFIRM_REQ_EVT, param));
757 }
758 }
759
RemoteOobReqCallback(const BtAddr * addr,void * context)760 void ClassicAdapter::RemoteOobReqCallback(const BtAddr *addr, void *context)
761 {
762 HILOGI("enter");
763
764 /// OOB Pair not support for current framework api.
765 /// This is used for extending.
766 GapCallbackParam param = {};
767 (void)memcpy_s((void *)¶m.remoteOobReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
768
769 auto adapter = static_cast<ClassicAdapter *>(context);
770 if (adapter != nullptr) {
771 adapter->GetDispatcher()->PostTask(
772 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_REMOTE_OOB_REQ_EVT, param));
773 }
774 }
775
PinCodeReqCallback(const BtAddr * addr,void * context)776 void ClassicAdapter::PinCodeReqCallback(const BtAddr *addr, void *context)
777 {
778 HILOGI("enter");
779
780 GapCallbackParam param = {};
781 (void)memcpy_s((void *)¶m.pinCodeReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
782
783 auto adapter = static_cast<ClassicAdapter *>(context);
784 if (adapter != nullptr) {
785 adapter->GetDispatcher()->PostTask(
786 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_PIN_CODE_REQ_EVT, param));
787 }
788 }
789
LinkKeyReqCallback(const BtAddr * addr,void * context)790 void ClassicAdapter::LinkKeyReqCallback(const BtAddr *addr, void *context)
791 {
792 HILOGI("enter");
793
794 GapCallbackParam param = {};
795 (void)memcpy_s((void *)¶m.linkKeyReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
796
797 auto adapter = static_cast<ClassicAdapter *>(context);
798 if (adapter != nullptr) {
799 adapter->GetDispatcher()->PostTask(
800 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_LINK_KEY_REQ_EVT, param));
801 }
802 }
803
IoCapabilityReqCallback(const BtAddr * addr,void * context)804 void ClassicAdapter::IoCapabilityReqCallback(const BtAddr *addr, void *context)
805 {
806 HILOGI("enter");
807
808 GapCallbackParam param = {};
809 (void)memcpy_s((void *)¶m.ioCapabilityReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
810
811 auto adapter = static_cast<ClassicAdapter *>(context);
812 if (adapter != nullptr) {
813 adapter->GetDispatcher()->PostTask(
814 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_IO_CAPABILITY_REQ_EVT, param));
815 }
816 }
817
IoCapabilityRspCallback(const BtAddr * addr,uint8_t ioCapability,void * context)818 void ClassicAdapter::IoCapabilityRspCallback(const BtAddr *addr, uint8_t ioCapability, void *context)
819 {
820 HILOGI("enter");
821
822 GapCallbackParam param = {};
823 (void)memcpy_s((void *)¶m.ioCapabilityRspParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
824 param.ioCapabilityRspParam_.ioCapability = ioCapability;
825
826 auto adapter = static_cast<ClassicAdapter *>(context);
827 if (adapter != nullptr) {
828 adapter->GetDispatcher()->PostTask(
829 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_IO_CAPABILITY_RSP_EVT, param));
830 }
831 }
832
LinkKeyNotification(const BtAddr * addr,const uint8_t linkKey[GAP_LINKKEY_SIZE],uint8_t keyType,void * context)833 void ClassicAdapter::LinkKeyNotification(
834 const BtAddr *addr, const uint8_t linkKey[GAP_LINKKEY_SIZE], uint8_t keyType, void *context)
835 {
836 HILOGI("enter");
837
838 GapCallbackParam param = {};
839 (void)memcpy_s((void *)¶m.linkKeyNotificationParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
840 param.linkKeyNotificationParam_.keyType = keyType;
841 (void)memcpy_s((void *)param.linkKeyNotificationParam_.linkKey, GAP_LINKKEY_SIZE, linkKey, GAP_LINKKEY_SIZE);
842
843 auto adapter = static_cast<ClassicAdapter *>(context);
844 if (adapter != nullptr) {
845 adapter->GetDispatcher()->PostTask(
846 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_LINK_KEY_NOTIFICATION_EVT, param));
847 }
848 }
849
SimplePairCompleteCallback(const BtAddr * addr,uint8_t status,void * context)850 void ClassicAdapter::SimplePairCompleteCallback(const BtAddr *addr, uint8_t status, void *context)
851 {
852 HILOGI("status = %{public}u", status);
853
854 GapCallbackParam param = {};
855 (void)memcpy_s((void *)¶m.simplePairCompleteParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
856 param.simplePairCompleteParam_.status = status;
857
858 auto adapter = static_cast<ClassicAdapter *>(context);
859 if (adapter != nullptr) {
860 adapter->GetDispatcher()->PostTask(
861 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SIMPLE_PAIR_COMPLETE_EVT, param));
862 }
863 }
864
AuthenticationCompleteCallback(const BtAddr * addr,uint8_t status,void * context)865 void ClassicAdapter::AuthenticationCompleteCallback(const BtAddr *addr, uint8_t status, void *context)
866 {
867 HILOGI("status: %{public}u", status);
868
869 GapCallbackParam param = {};
870 (void)memcpy_s((void *)¶m.authenticationCompleteParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
871 param.authenticationCompleteParam_.status = status;
872
873 auto adapter = static_cast<ClassicAdapter *>(context);
874 if (adapter != nullptr) {
875 adapter->GetDispatcher()->PostTask(
876 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_AUTHENTICATION_COMPLETE_EVT, param));
877 }
878 }
879
EncryptionChangeCallback(const BtAddr * addr,uint8_t status,void * context)880 void ClassicAdapter::EncryptionChangeCallback(const BtAddr *addr, uint8_t status, void *context)
881 {
882 HILOGI("enter");
883
884 GapCallbackParam param = {};
885 (void)memcpy_s((void *)¶m.encryptionChangeCallbackParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
886 param.encryptionChangeCallbackParam_.status = status;
887
888 auto adapter = static_cast<ClassicAdapter *>(context);
889 if (adapter != nullptr) {
890 adapter->GetDispatcher()->PostTask(
891 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_ENCRYPTION_CHANGE_CALLBACK_EVT, param));
892 }
893 }
894
AuthorizeIndCallback(const BtAddr * addr,GAP_Service service,void * context)895 void ClassicAdapter::AuthorizeIndCallback(const BtAddr *addr, GAP_Service service, void *context)
896 {
897 HILOGI("enter");
898
899 GapCallbackParam param = {};
900 (void)memcpy_s((void *)¶m.authorizeIndParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
901 param.authorizeIndParam_.service = service;
902
903 auto adapter = static_cast<ClassicAdapter *>(context);
904 if (adapter != nullptr) {
905 adapter->GetDispatcher()->PostTask(
906 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_AUTHORIZE_IND_CALLBACK_EVT, param));
907 }
908 }
909
HandleInquiryEvent(GAP_CB_EVENT event,const GapCallbackParam & param)910 void ClassicAdapter::HandleInquiryEvent(GAP_CB_EVENT event, const GapCallbackParam ¶m)
911 {
912 std::vector<uint8_t> eirData;
913 switch (event) {
914 case GAP_INQUIRY_RESULT_EVT:
915 HandleInquiryResult(param.iniquiryResultParam_.addr, param.iniquiryResultParam_.classOfDevice, eirData);
916 break;
917 case GAP_INQUIRY_RESULT_RSSI_EVT:
918 HandleInquiryResult(param.iniquiryResultRssiParam_.addr,
919 param.iniquiryResultRssiParam_.classOfDevice,
920 eirData,
921 param.iniquiryResultRssiParam_.rssi);
922 break;
923 case GAP_EXTENDED_INQUIRY_RESULT_EVT:
924 eirData.resize(MAX_EXTEND_INQUIRY_RESPONSE_LEN);
925 (void)memcpy_s(&eirData[0],
926 MAX_EXTEND_INQUIRY_RESPONSE_LEN,
927 param.extendedInquiryResultParam_.eir,
928 MAX_EXTEND_INQUIRY_RESPONSE_LEN);
929 HandleInquiryResult(param.extendedInquiryResultParam_.addr,
930 param.extendedInquiryResultParam_.classOfDevice,
931 eirData,
932 param.extendedInquiryResultParam_.rssi);
933 break;
934 case GAP_INQUIRY_COMPLETE_EVT:
935 HandleInquiryComplete(param.inquiryCompleteParam_.status);
936 break;
937 case GAP_REMOTE_NAME_CALLBACK_EVT:
938 ReceiveRemoteName(param.remoteNameCallbackParam_.status,
939 param.remoteNameCallbackParam_.addr,
940 param.remoteNameCallbackParam_.name);
941 break;
942 default:
943 break;
944 }
945 }
946
HandleSecurityEvent(GAP_CB_EVENT event,const GapCallbackParam & param)947 void ClassicAdapter::HandleSecurityEvent(GAP_CB_EVENT event, const GapCallbackParam ¶m)
948 {
949 switch (event) {
950 case GAP_SSP_CONFIRM_REQ_EVT:
951 SSPConfirmReq(
952 param.userConfirmReqParam_.addr, param.userConfirmReqParam_.reqType, param.userConfirmReqParam_.number,
953 param.userConfirmReqParam_.localMitmRequired, param.userConfirmReqParam_.remoteMitmRequired);
954 break;
955 case GAP_PIN_CODE_REQ_EVT:
956 PinCodeReq(param.pinCodeReqParam_.addr);
957 break;
958 case GAP_REMOTE_OOB_REQ_EVT:
959 /// OOB Pair not support for current framework api.
960 /// This is used for extending.
961 break;
962 case GAP_IO_CAPABILITY_REQ_EVT:
963 SetIoCapability(param.ioCapabilityReqParam_.addr);
964 break;
965 case GAP_IO_CAPABILITY_RSP_EVT:
966 SaveRemoteIoCapability(param.ioCapabilityRspParam_.addr, param.ioCapabilityRspParam_.ioCapability);
967 break;
968 case GAP_LINK_KEY_REQ_EVT:
969 SetLinkKey(param.linkKeyReqParam_.addr);
970 break;
971 case GAP_LINK_KEY_NOTIFICATION_EVT:
972 ReceiveLinkKeyNotification(param.linkKeyNotificationParam_.addr,
973 param.linkKeyNotificationParam_.linkKey,
974 param.linkKeyNotificationParam_.keyType);
975 break;
976 case GAP_SIMPLE_PAIR_COMPLETE_EVT:
977 ReceiveSimplePairComplete(param.simplePairCompleteParam_.addr, param.simplePairCompleteParam_.status);
978 break;
979 case GAP_AUTHENTICATION_COMPLETE_EVT:
980 ReceiveAuthenticationComplete(
981 param.authenticationCompleteParam_.addr, param.authenticationCompleteParam_.status);
982 break;
983 case GAP_ENCRYPTION_CHANGE_CALLBACK_EVT:
984 ReceiveEncryptionChange(
985 param.encryptionChangeCallbackParam_.addr, param.encryptionChangeCallbackParam_.status);
986 break;
987 case GAP_AUTHORIZE_IND_CALLBACK_EVT:
988 SetAuthorizeRes(param.authorizeIndParam_.addr, param.authorizeIndParam_.service);
989 break;
990 default:
991 break;
992 }
993 }
994
HandleInquiryResult(const BtAddr & addr,uint32_t classOfDevice,std::vector<uint8_t> eir,int8_t rssi)995 void ClassicAdapter::HandleInquiryResult(
996 const BtAddr &addr, uint32_t classOfDevice, std::vector<uint8_t> eir, int8_t rssi)
997 {
998 HILOGI("enter");
999
1000 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1001 if (discoveryState_ == DISCOVERY_STOPED) {
1002 HILOGE("Faild, discoveryState_ == DISCOVERY_STOPED");
1003 return;
1004 } else if (discoveryState_ == DISCOVERY_STARTED) {
1005 discoveryState_ = DISCOVERYING;
1006 HILOGI("Start, change discoveryState_ from DISCOVERY_STARTED to DISCOVERYING");
1007 }
1008
1009 RawAddress device = RawAddress::ConvertToString(addr.addr);
1010 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1011 int cod = (classOfDevice & CLASS_OF_DEVICE_RANGE);
1012 if (cod != remoteDevice->GetDeviceClass()) {
1013 remoteDevice->SetDeviceClass(cod);
1014 SendRemoteCodChanged(device, cod);
1015 }
1016
1017 remoteDevice->SetDeviceType(REMOTE_TYPE_BREDR);
1018 remoteDevice->SetRssi(rssi);
1019 if (!eir.empty()) {
1020 ParserEirData(remoteDevice, eir);
1021 } else {
1022 if (remoteDevice->GetRemoteName().empty()) {
1023 remoteDevice->SetNameNeedGet(true);
1024 }
1025 }
1026
1027 SendDiscoveryResult(device, rssi, remoteDevice->GetRemoteName(), cod);
1028 }
1029
FindRemoteDevice(const RawAddress & device)1030 std::shared_ptr<ClassicRemoteDevice> ClassicAdapter::FindRemoteDevice(const RawAddress &device)
1031 {
1032 std::shared_ptr<ClassicRemoteDevice> remoteDevice;
1033 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1034 auto it = devices_.find(device.GetAddress());
1035 if (it != devices_.end()) {
1036 remoteDevice = it->second;
1037 } else {
1038 remoteDevice = std::make_shared<ClassicRemoteDevice>(device.GetAddress());
1039 devices_.insert(std::make_pair(device.GetAddress(), remoteDevice));
1040 }
1041
1042 return remoteDevice;
1043 }
1044
HandleInquiryComplete(uint8_t status)1045 void ClassicAdapter::HandleInquiryComplete(uint8_t status)
1046 {
1047 HILOGI("status: %{public}u", status);
1048
1049 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1050 receiveInquiryComplete_ = true;
1051 struct timeval tv {};
1052 gettimeofday(&tv, nullptr);
1053 long currentTime = (tv.tv_sec * MILLISECOND_UNIT + tv.tv_usec / MILLISECOND_UNIT);
1054 discoveryEndMs_ = currentTime;
1055
1056 if ((cancelDiscovery_) || (!DiscoverRemoteName())) {
1057 discoveryState_ = DISCOVERY_STOPED;
1058 SendDiscoveryStateChanged(discoveryState_);
1059 receiveInquiryComplete_ = false;
1060 cancelDiscovery_ = false;
1061 }
1062
1063 if (isDisable_) {
1064 DisablePairProcess();
1065 return;
1066 }
1067 }
1068
DiscoverRemoteName()1069 bool ClassicAdapter::DiscoverRemoteName()
1070 {
1071 HILOGI("enter");
1072
1073 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1074 if (cancelDiscovery_) {
1075 HILOGI("failed, because of CancelDiscovery");
1076 return false;
1077 }
1078
1079 for (auto device : devices_) {
1080 if (device.second->GetNameNeedGet()) {
1081 device.second->SetNameNeedGet(false);
1082 remoteNameAddr_ = device.second->GetAddress();
1083 RawAddress rawAddr = RawAddress(remoteNameAddr_);
1084 BtAddr btAddr = ConvertToBtAddr(rawAddr);
1085 bool ret = GetRemoteName(btAddr);
1086 ClassicUtils::CheckReturnValue("ClassicAdapter", "GetRemoteName", ret);
1087 return true;
1088 }
1089 }
1090
1091 return false;
1092 }
1093
ConvertToBtAddr(const RawAddress & device) const1094 BtAddr ClassicAdapter::ConvertToBtAddr(const RawAddress &device) const
1095 {
1096 BtAddr btAddr;
1097 device.ConvertToUint8(btAddr.addr);
1098 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
1099 return btAddr;
1100 }
1101
ReceiveRemoteName(uint8_t status,const BtAddr & addr,const uint8_t name[MAX_LOC_BT_NAME_LEN])1102 void ClassicAdapter::ReceiveRemoteName(uint8_t status, const BtAddr &addr, const uint8_t name[MAX_LOC_BT_NAME_LEN])
1103 {
1104 HILOGI("status: %{public}u", status);
1105
1106 if (hwTimer_ != nullptr) {
1107 hwTimer_->Stop();
1108 }
1109
1110 if (status == BT_SUCCESS) {
1111 std::vector<uint8_t> nameVec(name, (name + MAX_LOC_BT_NAME_LEN));
1112 std::string deviceName(nameVec.begin(), nameVec.end());
1113 deviceName = deviceName.c_str();
1114 RawAddress device = RawAddress::ConvertToString(addr.addr);
1115 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1116 if (deviceName != remoteDevice->GetRemoteName()) {
1117 remoteDevice->SetRemoteName(deviceName);
1118 SendRemoteNameChanged(device, deviceName);
1119 }
1120 }
1121
1122 if (receiveInquiryComplete_) {
1123 if (!DiscoverRemoteName()) {
1124 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1125 discoveryState_ = DISCOVERY_STOPED;
1126 SendDiscoveryStateChanged(discoveryState_);
1127 receiveInquiryComplete_ = false;
1128 }
1129 }
1130
1131 if (isDisable_) {
1132 DisablePairProcess();
1133 return;
1134 }
1135 }
1136
CancelGetRemoteName() const1137 bool ClassicAdapter::CancelGetRemoteName() const
1138 {
1139 HILOGI("enter");
1140
1141 RawAddress rawAddr = RawAddress(remoteNameAddr_);
1142 BtAddr btAddr = ConvertToBtAddr(rawAddr);
1143 bool ret = (GAPIF_GetRemoteNameCancel(&btAddr) == BT_SUCCESS);
1144 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_GetRemoteNameCancel", ret);
1145
1146 return ret;
1147 }
1148
SendDiscoveryStateChanged(int discoveryState) const1149 void ClassicAdapter::SendDiscoveryStateChanged(int discoveryState) const
1150 {
1151 HILOGI("state: %{public}d", discoveryState);
1152
1153 pimpl->adapterObservers_.ForEach(
1154 [discoveryState](IAdapterClassicObserver &observer) { observer.OnDiscoveryStateChanged(discoveryState); });
1155 }
1156
SendDiscoveryResult(const RawAddress & device,int rssi,const std::string deviceName,int deviceClass) const1157 void ClassicAdapter::SendDiscoveryResult(
1158 const RawAddress &device, int rssi, const std::string deviceName, int deviceClass) const
1159 {
1160 HILOGI("address: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
1161
1162 pimpl->adapterObservers_.ForEach(
1163 [device, rssi, deviceName, deviceClass](IAdapterClassicObserver &observer) {
1164 observer.OnDiscoveryResult(device, rssi, deviceName, deviceClass);
1165 });
1166 }
1167
SendRemoteCodChanged(const RawAddress & device,int cod) const1168 void ClassicAdapter::SendRemoteCodChanged(const RawAddress &device, int cod) const
1169 {
1170 HILOGI("address: %{public}s, cod: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), cod);
1171
1172 pimpl->remoteObservers_.ForEach(
1173 [device, cod](IClassicRemoteDeviceObserver &observer) { observer.OnRemoteCodChanged(device, cod); });
1174 }
1175
SSPConfirmReq(const BtAddr & addr,int reqType,int number,int localMitmRequired,int remoteMitmRequired)1176 void ClassicAdapter::SSPConfirmReq(const BtAddr &addr, int reqType, int number,
1177 int localMitmRequired, int remoteMitmRequired)
1178 {
1179 HILOGI("reqTyep: %{public}d", reqType);
1180
1181 RawAddress device = RawAddress::ConvertToString(addr.addr);
1182 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1183 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM);
1184 remoteDevice->SetPairConfirmType(reqType);
1185 int remoteIo = remoteDevice->GetIoCapability();
1186 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
1187 UserConfirmAutoReply(device, reqType, false);
1188 } else if (CheckAutoReply(remoteIo, localMitmRequired, remoteMitmRequired) == true) {
1189 UserConfirmAutoReply(device, reqType, true);
1190 } else {
1191 reqType = CheckSspConfirmType(remoteIo, reqType);
1192 SendPairConfirmed(device, reqType, number);
1193 }
1194 }
1195
PinCodeReq(const BtAddr & addr)1196 void ClassicAdapter::PinCodeReq(const BtAddr &addr)
1197 {
1198 HILOGI("enter");
1199
1200 RawAddress device = RawAddress::ConvertToString(addr.addr);
1201 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1202 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM);
1203 remoteDevice->SetPairConfirmType(PAIR_CONFIRM_TYPE_PIN_CODE);
1204 pinMode_ = true;
1205 if (remoteDevice->GetRemoteName().empty()) {
1206 GetRemoteName(addr);
1207 }
1208
1209 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
1210 UserConfirmAutoReply(device, PAIR_CONFIRM_TYPE_PIN_CODE, false);
1211 return;
1212 }
1213
1214 if ((remoteDevice->GetPairedStatus() != PAIR_PAIRING) && (remoteDevice->GetPairedStatus() != PAIR_CANCELING)) {
1215 remoteDevice->SetPairedStatus(PAIR_PAIRING);
1216 }
1217
1218 bool bondFromLocal = false;
1219 bool ret = (GAPIF_PairIsFromLocal(&addr, &bondFromLocal) == BT_SUCCESS);
1220 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_PairIsFromLocal", ret);
1221 remoteDevice->SetBondedFromLocal(bondFromLocal);
1222
1223 SendPairConfirmed(device, PAIR_CONFIRM_TYPE_PIN_CODE, 0);
1224 }
1225
SendPairConfirmed(const RawAddress & device,int reqType,int number) const1226 void ClassicAdapter::SendPairConfirmed(const RawAddress &device, int reqType, int number) const
1227 {
1228 HILOGI("reqType = %{public}d, number = %{public}d", reqType, number);
1229 BTTransport transport = ADAPTER_BREDR;
1230 if (DialogPair::RequestBluetoothPairDialog(device, reqType, number)) {
1231 HILOGI("ready to build dialog");
1232 }
1233 pimpl->adapterObservers_.ForEach([transport, device, reqType, number](IAdapterClassicObserver &observer) {
1234 observer.OnPairConfirmed(transport, device, reqType, number);
1235 });
1236 }
1237
UserConfirmAutoReply(const RawAddress & device,int reqType,bool accept) const1238 void ClassicAdapter::UserConfirmAutoReply(const RawAddress &device, int reqType, bool accept) const
1239 {
1240 HILOGI("address: %{public}s, accept: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), accept);
1241
1242 auto it = devices_.find(device.GetAddress());
1243 if (it != devices_.end()) {
1244 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1245 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1246 }
1247
1248 switch (reqType) {
1249 case PAIR_CONFIRM_TYPE_PIN_CODE: {
1250 std::string passkey = adapterProperties_.GetPasskey();
1251 HILOGI("PAIR_CONFIRM_TYPE_PIN_CODE, value = %{public}s", passkey.c_str());
1252 std::vector<uint8_t> pinCode(passkey.begin(), passkey.end());
1253 SetPinCode(device, pinCode, accept);
1254 break;
1255 }
1256 case PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY: {
1257 HILOGI("PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY, do nothing!!");
1258 break;
1259 }
1260 case PAIR_CONFIRM_TYPE_PASSKEY_INPUT: {
1261 HILOGI("PAIR_CONFIRM_TYPE_PASSKEY_INPUT");
1262 int passkey = 0;
1263 SetDevicePasskey(device, passkey, accept);
1264 break;
1265 }
1266 case PAIR_CONFIRM_TYPE_NUMERIC:
1267 case PAIR_CONFIRM_TYPE_CONSENT: {
1268 HILOGI("PAIR_CONFIRM_TYPE_NUMERIC");
1269 SetDevicePairingConfirmation(device, accept);
1270 break;
1271 }
1272 default:
1273 HILOGI("default case. reqType = %{public}d", reqType);
1274 break;
1275 }
1276 }
1277
ParserEirData(std::shared_ptr<ClassicRemoteDevice> remote,const std::vector<uint8_t> & data) const1278 void ClassicAdapter::ParserEirData(std::shared_ptr<ClassicRemoteDevice> remote, const std::vector<uint8_t> &data) const
1279 {
1280 std::vector<ClassicDataStructure> dataList = eirData_.ParserData(data);
1281 std::vector<Uuid> uuids;
1282 bool isGetRemoteName = false;
1283
1284 for (auto &dataStruc : dataList) {
1285 int type = dataStruc.GetType();
1286 std::vector<uint8_t> valueVec = dataStruc.GetDataValue();
1287 switch (type) {
1288 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME:
1289 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME:
1290 isGetRemoteName = ParserRemoteNameFromEir(remote, type, valueVec);
1291 break;
1292 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1293 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1294 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1295 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1296 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
1297 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: {
1298 std::vector<Uuid> parsedUuids = ParserUuidFromEir(type, valueVec);
1299 if (!parsedUuids.empty()) {
1300 uuids.insert(uuids.end(), parsedUuids.begin(), parsedUuids.end());
1301 }
1302 break;
1303 }
1304 /// Flags, TxPower, ManufacturerData, Uri are not support for current framework api.
1305 /// This is used for extending.
1306 case BLUETOOTH_DATA_TYPE_FLAGS:
1307 remote->SetFlags(valueVec[0]);
1308 break;
1309 case BLUETOOTH_DATA_TYPE_TX_POWER_LEVEL:
1310 remote->SetTxPower(valueVec[0]);
1311 break;
1312 case BLUETOOTH_DATA_TYPE_MANUFACTURER_SPECIFIC_DATA:
1313 remote->SetManufacturerSpecificData(valueVec);
1314 break;
1315 case BLUETOOTH_DATA_TYPE_URI: {
1316 std::string uri(valueVec.begin(), valueVec.end());
1317 remote->SetURI(uri);
1318 break;
1319 }
1320 default:
1321 break;
1322 }
1323 }
1324
1325 if (!isGetRemoteName) {
1326 remote->SetNameNeedGet(true);
1327 }
1328
1329 if (!uuids.empty()) {
1330 SaveRemoteDeviceUuids(remote, uuids);
1331 uuids.clear();
1332 }
1333 }
1334
ParserRemoteNameFromEir(std::shared_ptr<ClassicRemoteDevice> remote,int type,const std::vector<uint8_t> & value) const1335 bool ClassicAdapter::ParserRemoteNameFromEir(
1336 std::shared_ptr<ClassicRemoteDevice> remote, int type, const std::vector<uint8_t> &value) const
1337 {
1338 HILOGI("type %{public}d", type);
1339
1340 if (value.empty()) {
1341 return false;
1342 }
1343
1344 if (type == BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME) {
1345 remote->SetNameNeedGet(true);
1346 } else {
1347 remote->SetNameNeedGet(false);
1348 }
1349
1350 std::string remoteName(value.begin(), value.end());
1351 HILOGI("remoteName is %{public}s", remoteName.c_str());
1352 if (remoteName != remote->GetRemoteName()) {
1353 remote->SetRemoteName(remoteName);
1354 SendRemoteNameChanged(RawAddress(remote->GetAddress()), remoteName);
1355 }
1356
1357 return true;
1358 }
1359
ParserUuidFromEir(int type,const std::vector<uint8_t> & value) const1360 std::vector<Uuid> ClassicAdapter::ParserUuidFromEir(int type, const std::vector<uint8_t> &value) const
1361 {
1362 HILOGI("enter");
1363
1364 std::vector<Uuid> uuids;
1365 if (value.empty()) {
1366 HILOGI("ParserUuidFromEir invalid parameter.");
1367 return uuids;
1368 }
1369
1370 switch (type) {
1371 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1372 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS: {
1373 uuids = Parser16BitUuidFromEir(value);
1374 break;
1375 }
1376 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1377 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS: {
1378 uuids = Parser32BitUuidFromEir(value);
1379 break;
1380 }
1381 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
1382 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: {
1383 uuids = Parser128BitUuidFromEir(value);
1384 break;
1385 }
1386 default:
1387 break;
1388 }
1389
1390 return uuids;
1391 }
1392
Parser16BitUuidFromEir(const std::vector<uint8_t> & value) const1393 std::vector<Uuid> ClassicAdapter::Parser16BitUuidFromEir(const std::vector<uint8_t> &value) const
1394 {
1395 HILOGI("enter");
1396
1397 std::vector<Uuid> uuids;
1398 uint8_t offset = 0;
1399 while ((value.size() - offset) > 1) {
1400 uint8_t unitLen = sizeof(uint16_t);
1401 if (unitLen <= (value.size() - offset)) {
1402 uint16_t uuid16 = 0;
1403 (void)memcpy_s(&uuid16, unitLen, &value[offset], unitLen);
1404 Uuid uuid = Uuid::ConvertFrom16Bits(uuid16);
1405 if (uuid16 != 0) {
1406 uuids.push_back(uuid);
1407 HILOGI("remote 16bit UUID");
1408 }
1409 offset += unitLen;
1410 } else {
1411 break;
1412 }
1413 }
1414
1415 return uuids;
1416 }
1417
Parser32BitUuidFromEir(const std::vector<uint8_t> & value) const1418 std::vector<Uuid> ClassicAdapter::Parser32BitUuidFromEir(const std::vector<uint8_t> &value) const
1419 {
1420 HILOGI("enter");
1421
1422 std::vector<Uuid> uuids;
1423 int offset = 0;
1424 while ((value.size() - offset) > 1) {
1425 uint8_t unitLen = sizeof(uint32_t);
1426 if (unitLen <= (value.size() - offset)) {
1427 uint32_t uuid32 = 0;
1428 (void)memcpy_s(&uuid32, unitLen, &value[offset], unitLen);
1429 Uuid uuid = Uuid::ConvertFrom32Bits(uuid32);
1430 if (uuid32 != 0) {
1431 uuids.push_back(uuid);
1432 HILOGI("remote 32bit UUID");
1433 }
1434 offset += unitLen;
1435 } else {
1436 break;
1437 }
1438 }
1439
1440 return uuids;
1441 }
1442
Parser128BitUuidFromEir(const std::vector<uint8_t> & value) const1443 std::vector<Uuid> ClassicAdapter::Parser128BitUuidFromEir(const std::vector<uint8_t> &value) const
1444 {
1445 HILOGI("enter");
1446
1447 std::vector<Uuid> uuids;
1448 int offset = 0;
1449 while ((value.size() - offset) > 1) {
1450 if (UUID128_BYTES_TYPE <= (value.size() - offset)) {
1451 Uuid uuid = Uuid::ConvertFromBytesLE(&value[offset]);
1452 bluetooth::Uuid::UUID128Bit uuidCheck = {0};
1453 if (uuid.ConvertTo128Bits() != uuidCheck) {
1454 uuids.push_back(uuid);
1455 HILOGI("remote 128bit UUID");
1456 }
1457 offset += UUID128_BYTES_TYPE;
1458 } else {
1459 break;
1460 }
1461 }
1462
1463 return uuids;
1464 }
1465
SaveRemoteDeviceUuids(std::shared_ptr<ClassicRemoteDevice> remote,const std::vector<Uuid> & uuids) const1466 void ClassicAdapter::SaveRemoteDeviceUuids(
1467 std::shared_ptr<ClassicRemoteDevice> remote, const std::vector<Uuid> &uuids) const
1468 {
1469 HILOGI("enter");
1470
1471 if ((remote == nullptr) || (uuids.empty())) {
1472 return;
1473 }
1474
1475 std::vector<Uuid> prevUuids = remote->GetDeviceUuids();
1476 if (!IsUuidsEqual(uuids, prevUuids)) {
1477 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1478 remote->SetDeviceUuids(uuids);
1479 SendRemoteUuidChanged(RawAddress(remote->GetAddress()), uuids);
1480 }
1481 }
1482
IsUuidsEqual(const std::vector<Uuid> & uuids1,const std::vector<Uuid> & uuids2) const1483 bool ClassicAdapter::IsUuidsEqual(const std::vector<Uuid> &uuids1, const std::vector<Uuid> &uuids2) const
1484 {
1485 HILOGI("enter");
1486 if (uuids1.size() != uuids2.size()) {
1487 return false;
1488 }
1489
1490 for (auto uuid : uuids1) {
1491 auto it = std::find(uuids2.begin(), uuids2.end(), uuid);
1492 if (it == uuids2.end()) {
1493 return false;
1494 }
1495 }
1496
1497 for (auto uuid : uuids2) {
1498 auto it = std::find(uuids1.begin(), uuids1.end(), uuid);
1499 if (it == uuids1.end()) {
1500 return false;
1501 }
1502 }
1503
1504 return true;
1505 }
1506
SendRemoteNameChanged(const RawAddress & device,const std::string & deviceName) const1507 void ClassicAdapter::SendRemoteNameChanged(const RawAddress &device, const std::string &deviceName) const
1508 {
1509 HILOGI("enter");
1510 pimpl->remoteObservers_.ForEach([device, deviceName](IClassicRemoteDeviceObserver &observer) {
1511 observer.OnRemoteNameChanged(device, deviceName);
1512 });
1513 }
1514
SendPairStatusChanged(const BTTransport transport,const RawAddress & device,int status) const1515 void ClassicAdapter::SendPairStatusChanged(const BTTransport transport, const RawAddress &device, int status) const
1516 {
1517 HILOGI("status: %{public}d", status);
1518 pimpl->remoteObservers_.ForEach([transport, device, status](IClassicRemoteDeviceObserver &observer) {
1519 observer.OnPairStatusChanged(transport, device, status);
1520 });
1521 }
1522
ReceiveLinkKeyNotification(const BtAddr & addr,const uint8_t linkKey[GAP_LINKKEY_SIZE],uint8_t keyType)1523 void ClassicAdapter::ReceiveLinkKeyNotification(
1524 const BtAddr &addr, const uint8_t linkKey[GAP_LINKKEY_SIZE], uint8_t keyType)
1525 {
1526 HILOGI("enter");
1527
1528 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1529 /// Pairing success, save link key and sent notification to APP.
1530 if (pinMode_ == true) {
1531 pinMode_ = false;
1532 }
1533
1534 RawAddress device = RawAddress::ConvertToString(addr.addr);
1535 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1536 if (remoteDevice->GetRemoteName().empty()) {
1537 GetRemoteName(addr);
1538 }
1539 SearchRemoteUuids(device, PNP_SERVICE_CLASS_UUID);
1540
1541 /// Bondable mode is on, then save the linkKey and keyType
1542 if (adapterProperties_.GetBondableMode() == BONDABLE_MODE_ON) {
1543 std::vector<uint8_t> linkKeyVec(linkKey, (linkKey + GAP_LINKKEY_SIZE));
1544 remoteDevice->SetLinkKey(linkKeyVec);
1545 remoteDevice->SetLinkKeyType(keyType);
1546 remoteDevice->SetPairedStatus(PAIR_PAIRED);
1547 if (remoteDevice != nullptr) {
1548 adapterProperties_.SavePairedDeviceInfo(remoteDevice);
1549 adapterProperties_.SaveConfigFile();
1550 }
1551 } else {
1552 remoteDevice->SetPairedStatus(PAIR_NONE);
1553 HILOGW("Bondmode is off, so not save the link key");
1554 }
1555 }
1556
ReceiveSimplePairComplete(const BtAddr & addr,uint8_t status)1557 void ClassicAdapter::ReceiveSimplePairComplete(const BtAddr &addr, uint8_t status)
1558 {
1559 HILOGI("status: %{public}u", status);
1560
1561 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1562 if (status != SUCCESS) {
1563 RawAddress device = RawAddress::ConvertToString(addr.addr);
1564 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1565 bool bondFromLocal = remoteDevice->IsBondedFromLocal();
1566 /// Passive pairing failed, delete the link key.
1567 if (bondFromLocal == false) {
1568 DeleteLinkKey(remoteDevice);
1569 /// Set the pair flag and pair state.
1570 remoteDevice->SetPairedStatus(PAIR_NONE);
1571 /// Send the failed notification to APP.
1572 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
1573 }
1574 }
1575 }
1576
DeleteLinkKey(std::shared_ptr<ClassicRemoteDevice> remoteDevice) const1577 void ClassicAdapter::DeleteLinkKey(std::shared_ptr<ClassicRemoteDevice> remoteDevice) const
1578 {
1579 int keyType = remoteDevice->GetLinkKeyType();
1580 if (keyType != PAIR_INVALID_LINK_KEY_TYPE) {
1581 remoteDevice->DeleteLinkKey();
1582 remoteDevice->SetLinkKeyType(PAIR_INVALID_LINK_KEY_TYPE);
1583 }
1584 }
1585
ReceiveAuthenticationComplete(const BtAddr & addr,uint8_t status)1586 void ClassicAdapter::ReceiveAuthenticationComplete(const BtAddr &addr, uint8_t status)
1587 {
1588 HILOGI("status: %{public}u", status);
1589
1590 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1591 RawAddress device = RawAddress::ConvertToString(addr.addr);
1592 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1593 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_INVALID);
1594 remoteDevice->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1595
1596 if (status != SUCCESS) {
1597 /// Active pairing failed, delete the link key.
1598 DeleteLinkKey(remoteDevice);
1599 /// Set the pair flag and pair state.
1600 remoteDevice->SetPairedStatus(PAIR_NONE);
1601 /// Send the failed notification to APP.
1602 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
1603 } else {
1604 if (remoteDevice->GetPairedStatus() == PAIR_PAIRING) {
1605 remoteDevice->SetPairedStatus(PAIR_PAIRED);
1606 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRED);
1607 }
1608 }
1609
1610 if (waitPairResult_) {
1611 waitPairResult_ = false;
1612 InitMode();
1613 }
1614 }
1615
ReceiveEncryptionChange(const BtAddr & addr,uint8_t status)1616 void ClassicAdapter::ReceiveEncryptionChange(const BtAddr &addr, uint8_t status)
1617 {
1618 HILOGI("status: %{public}u", status);
1619
1620 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1621 RawAddress device = RawAddress::ConvertToString(addr.addr);
1622 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1623 if (status == GAP_ENCRYPTION_ON) {
1624 remoteDevice->SetAclConnectState(CONNECTION_STATE_ENCRYPTED_BREDR);
1625 } else {
1626 remoteDevice->SetAclConnectState(CONNECTION_STATE_CONNECTED);
1627 }
1628 }
1629
GetRemoteName(const BtAddr & addr) const1630 bool ClassicAdapter::GetRemoteName(const BtAddr &addr) const
1631 {
1632 HILOGI("enter");
1633
1634 bool ret = (GAPIF_GetRemoteName(&addr) == BT_SUCCESS);
1635 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_GetRemoteName", ret);
1636 if (ret && (hwTimer_ != nullptr)) {
1637 hwTimer_->Start(DEFAULT_HW_TIMEOUT);
1638 }
1639
1640 return ret;
1641 }
1642
GetDeviceName(const RawAddress & device) const1643 std::string ClassicAdapter::GetDeviceName(const RawAddress &device) const
1644 {
1645 HILOGI("enter");
1646
1647 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1648 std::string remoteName = "";
1649 auto it = devices_.find(device.GetAddress());
1650 if (it != devices_.end()) {
1651 remoteName = it->second->GetRemoteName();
1652 }
1653
1654 return remoteName;
1655 }
1656
GetDeviceUuids(const RawAddress & device) const1657 std::vector<Uuid> ClassicAdapter::GetDeviceUuids(const RawAddress &device) const
1658 {
1659 HILOGI("enter");
1660
1661 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1662 std::vector<Uuid> uuids;
1663 auto it = devices_.find(device.GetAddress());
1664 if (it != devices_.end()) {
1665 uuids = it->second->GetDeviceUuids();
1666 }
1667 return uuids;
1668 }
1669
SearchRemoteUuids(const RawAddress & device,uint16_t uuid)1670 void ClassicAdapter::SearchRemoteUuids(const RawAddress &device, uint16_t uuid)
1671 {
1672 BtAddr btAddr = ConvertToBtAddr(device);
1673
1674 BtUuid btUuid[SDP_UUDIID_NUM];
1675 btUuid[0].type = BT_UUID_16;
1676 btUuid[0].uuid16 = uuid;
1677 searchUuid_ = uuid;
1678
1679 SdpUuid uuidArray;
1680 uuidArray.uuid = &btUuid[0];
1681 uuidArray.uuidNum = 1;
1682
1683 SdpAttributeIdList attributeIdList;
1684 attributeIdList.type = SDP_TYPE_RANGE;
1685 attributeIdList.attributeIdRange.start = 0x0000;
1686 attributeIdList.attributeIdRange.end = 0xFFFF;
1687 int ret = SDP_ServiceSearchAttribute(&btAddr, &uuidArray, attributeIdList, (void *)this, ServiceSearchAttributeCb);
1688 if (ret != BT_SUCCESS) {
1689 HILOGE("SDP_ServiceSearchAttribute failed!");
1690 }
1691 }
1692
ServiceSearchAttributeCb(const BtAddr * addr,const SdpService * serviceArray,uint16_t serviceNum,void * context)1693 void ClassicAdapter::ServiceSearchAttributeCb(
1694 const BtAddr *addr, const SdpService *serviceArray, uint16_t serviceNum, void *context)
1695 {
1696 HILOGI("enter");
1697
1698 auto adapter = static_cast<ClassicAdapter *>(context);
1699 for (int index = 0; index < serviceNum; index++) {
1700 for (int num = 0; num < serviceArray[index].classIdNumber; num++) {
1701 Uuid uuid = adapter->GetUuidFromBtUuid(serviceArray[index].classId[num]);
1702 auto it = std::find(adapter->uuids_.begin(), adapter->uuids_.end(), uuid);
1703 if (it == adapter->uuids_.end()) {
1704 adapter->uuids_.push_back(uuid);
1705 }
1706 }
1707 }
1708
1709 RawAddress device = RawAddress::ConvertToString(addr->addr);
1710 if (adapter->searchUuid_ == UUID_PROTOCOL_L2CAP) {
1711 adapter->GetDispatcher()->PostTask(
1712 std::bind(&ClassicAdapter::SearchAttributeEnd, adapter, device, adapter->uuids_));
1713 } else {
1714 adapter->GetDispatcher()->PostTask(
1715 std::bind(&ClassicAdapter::SearchRemoteUuids, adapter, device, UUID_PROTOCOL_L2CAP));
1716 }
1717 }
1718
SearchAttributeEnd(const RawAddress & device,const std::vector<Uuid> & uuids)1719 void ClassicAdapter::SearchAttributeEnd(const RawAddress &device, const std::vector<Uuid> &uuids)
1720 {
1721 if (isDisable_) {
1722 return;
1723 }
1724 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1725 SaveRemoteDeviceUuids(remoteDevice, uuids);
1726 if (remoteDevice != nullptr) {
1727 adapterProperties_.SavePairedDeviceInfo(remoteDevice);
1728 adapterProperties_.SaveConfigFile();
1729 }
1730 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRED);
1731 }
1732
GetUuidFromBtUuid(const BtUuid & inUuid) const1733 Uuid ClassicAdapter::GetUuidFromBtUuid(const BtUuid &inUuid) const
1734 {
1735 Uuid uuid;
1736 if (inUuid.type == BT_UUID_16) {
1737 uuid = Uuid::ConvertFrom16Bits(inUuid.uuid16);
1738 } else if (inUuid.type == BT_UUID_32) {
1739 uuid = Uuid::ConvertFrom32Bits(inUuid.uuid32);
1740 } else {
1741 uuid = Uuid::ConvertFromBytesLE(inUuid.uuid128);
1742 }
1743
1744 return uuid;
1745 }
1746
SendRemoteUuidChanged(const RawAddress & device,const std::vector<Uuid> & uuids) const1747 void ClassicAdapter::SendRemoteUuidChanged(const RawAddress &device, const std::vector<Uuid> &uuids) const
1748 {
1749 pimpl->remoteObservers_.ForEach(
1750 [device, uuids](IClassicRemoteDeviceObserver &observer) { observer.OnRemoteUuidChanged(device, uuids); });
1751 }
1752
IsAclConnected(const RawAddress & device) const1753 bool ClassicAdapter::IsAclConnected(const RawAddress &device) const
1754 {
1755 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1756 bool isAclConnected = false;
1757 auto it = devices_.find(device.GetAddress());
1758 if (it != devices_.end()) {
1759 isAclConnected = it->second->IsAclConnected();
1760 }
1761
1762 HILOGI("isAclConnected: %{public}d", isAclConnected);
1763 return isAclConnected;
1764 }
1765
IsAclEncrypted(const RawAddress & device) const1766 bool ClassicAdapter::IsAclEncrypted(const RawAddress &device) const
1767 {
1768 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1769 bool isAclEncrypted = false;
1770 auto it = devices_.find(device.GetAddress());
1771 if (it != devices_.end()) {
1772 isAclEncrypted = it->second->IsAclEncrypted();
1773 }
1774
1775 HILOGI("isAclEncrypted: %{public}d", isAclEncrypted);
1776 return isAclEncrypted;
1777 }
1778
GetContext()1779 utility::Context *ClassicAdapter::GetContext()
1780 {
1781 return this;
1782 }
1783
IsBondedFromLocal(const RawAddress & device) const1784 bool ClassicAdapter::IsBondedFromLocal(const RawAddress &device) const
1785 {
1786 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1787 bool isBondedFromLocal = false;
1788 auto it = devices_.find(device.GetAddress());
1789 if (it != devices_.end()) {
1790 isBondedFromLocal = it->second->IsBondedFromLocal();
1791 }
1792
1793 HILOGI("isBondedFromLocal: %{public}d", isBondedFromLocal);
1794 return isBondedFromLocal;
1795 }
1796
GetPairedDevices() const1797 std::vector<RawAddress> ClassicAdapter::GetPairedDevices() const
1798 {
1799 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1800 std::vector<RawAddress> pairedList;
1801 if (devices_.empty()) {
1802 HILOGE("GetPairedDevices devices_ is empty!");
1803 return pairedList;
1804 }
1805 for (auto &device : devices_) {
1806 if ((device.second != nullptr) && (device.second->IsPaired() == true)) {
1807 RawAddress rawAddr(device.second->GetAddress());
1808 pairedList.push_back(rawAddr);
1809 }
1810 }
1811
1812 return pairedList;
1813 }
1814
StartPair(const RawAddress & device)1815 bool ClassicAdapter::StartPair(const RawAddress &device)
1816 {
1817 HILOGI("enter");
1818
1819 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1820 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1821 if (remoteDevice->GetPairedStatus() == PAIR_PAIRING) {
1822 HILOGE("StartPair failed, because of PAIR_NONE or PAIRING!");
1823 return false;
1824 }
1825
1826 if (discoveryState_ == DISCOVERYING) {
1827 bool ret = CancelBtDiscovery();
1828 ClassicUtils::CheckReturnValue("ClassicAdapter", "CancelBtDiscovery", ret);
1829 }
1830
1831 BtAddr btAddr = ConvertToBtAddr(device);
1832 int ret = GAPIF_AuthenticationReq(&btAddr);
1833 if (ret != BT_SUCCESS) {
1834 HILOGE("GAPIF_AuthenticationReq failed!");
1835 return false;
1836 }
1837
1838 DeleteLinkKey(remoteDevice);
1839 remoteDevice->SetPairedStatus(PAIR_PAIRING);
1840 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRING);
1841
1842 return true;
1843 }
1844
CancelPairing(const RawAddress & device)1845 bool ClassicAdapter::CancelPairing(const RawAddress &device)
1846 {
1847 HILOGI("enter");
1848
1849 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1850 auto it = devices_.find(device.GetAddress());
1851 if (it == devices_.end() || (it->second->GetPairedStatus() != PAIR_PAIRING)) {
1852 HILOGE("failed, because of not in PAIR_PAIRING!");
1853 return false;
1854 }
1855
1856 it->second->SetPairedStatus(PAIR_CANCELING);
1857 int pairConfirmState = it->second->GetPairConfirmState();
1858 if (pairConfirmState == PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY) {
1859 BtAddr btAddr = ConvertToBtAddr(device);
1860 bool ret = (GAPIF_CancelAuthenticationReq(&btAddr) == BT_SUCCESS);
1861 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_CancelAuthenticationReq", ret);
1862 return ret;
1863 }
1864
1865 if (pairConfirmState == PAIR_CONFIRM_STATE_USER_CONFIRM) {
1866 int pairConfirmType = it->second->GetPairConfirmType();
1867 RawAddress address(it->second->GetAddress());
1868 UserConfirmAutoReply(address, pairConfirmType, false);
1869 }
1870 return true;
1871 }
1872
RemovePair(const RawAddress & device)1873 bool ClassicAdapter::RemovePair(const RawAddress &device)
1874 {
1875 HILOGI("address %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
1876
1877 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1878 auto it = devices_.find(device.GetAddress());
1879 if ((it == devices_.end()) || (it->second->IsPaired() == false)) {
1880 HILOGW("RemovePair failed, because of not find the paired device!");
1881 return false;
1882 } else {
1883 it->second->SetPairedStatus(PAIR_NONE);
1884 DeleteLinkKey(it->second);
1885 adapterProperties_.RemovePairedDeviceInfo(it->second->GetAddress());
1886 adapterProperties_.SaveConfigFile();
1887 if (it->second->IsAclConnected()) {
1888 bool ret = (BTM_AclDisconnect(it->second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_SUCCESS);
1889 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", ret);
1890 }
1891 }
1892
1893 std::vector<RawAddress> removeDevices;
1894 removeDevices.push_back(device);
1895 AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BREDR, removeDevices);
1896 SendPairStatusChanged(BTTransport::ADAPTER_BREDR, device, PAIR_NONE);
1897 return true;
1898 }
1899
RemoveAllPairs()1900 bool ClassicAdapter::RemoveAllPairs()
1901 {
1902 HILOGI("enter");
1903 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1904 std::vector<RawAddress> removeDevices;
1905 for (auto it = devices_.begin(); it != devices_.end(); it++) {
1906 if (it->second->IsPaired() == true) {
1907 it->second->SetPairedStatus(PAIR_NONE);
1908 DeleteLinkKey(it->second);
1909 adapterProperties_.RemovePairedDeviceInfo(it->second->GetAddress());
1910 RawAddress device = RawAddress(it->second->GetAddress());
1911 removeDevices.push_back(device);
1912 if (it->second->IsAclConnected()) {
1913 bool ret =
1914 (BTM_AclDisconnect(it->second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_SUCCESS);
1915 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", ret);
1916 }
1917 }
1918 }
1919
1920 if (!removeDevices.empty()) {
1921 adapterProperties_.SaveConfigFile();
1922 AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BREDR, removeDevices);
1923 }
1924
1925 return true;
1926 }
1927
GetPairState(const RawAddress & device) const1928 int ClassicAdapter::GetPairState(const RawAddress &device) const
1929 {
1930 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1931 int pairState = PAIR_NONE;
1932 auto it = devices_.find(device.GetAddress());
1933 if (it == devices_.end()) {
1934 return pairState;
1935 } else {
1936 pairState = it->second->GetPairedStatus();
1937 }
1938
1939 HILOGI("state: %{public}d", pairState);
1940 return pairState;
1941 }
1942
SetDevicePairingConfirmation(const RawAddress & device,bool accept) const1943 bool ClassicAdapter::SetDevicePairingConfirmation(const RawAddress &device, bool accept) const
1944 {
1945 HILOGI("accept = %{public}d", accept);
1946
1947 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1948 bool ret = false;
1949 auto it = devices_.find(device.GetAddress());
1950 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_PAIRED) ||
1951 (it->second->GetPairedStatus() == PAIR_NONE)) {
1952 HILOGE("failed, not in pairing state.");
1953 return ret;
1954 }
1955
1956 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1957 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1958
1959 BtAddr btAddr = ConvertToBtAddr(device);
1960 if (it->second->GetPairedStatus() == PAIR_CANCELING || accept == false) {
1961 ret = (GAPIF_UserConfirmRsp(&btAddr, GAP_NOT_ACCEPT) == BT_SUCCESS);
1962 } else {
1963 ret = (GAPIF_UserConfirmRsp(&btAddr, GAP_ACCEPT) == BT_SUCCESS);
1964 }
1965 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_UserConfirmRsp", ret);
1966
1967 return ret;
1968 }
1969
SetDevicePasskey(const RawAddress & device,int passkey,bool accept) const1970 bool ClassicAdapter::SetDevicePasskey(const RawAddress &device, int passkey, bool accept) const
1971 {
1972 HILOGI("enter");
1973
1974 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1975 bool ret = false;
1976 auto it = devices_.find(device.GetAddress());
1977 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_NONE) ||
1978 (it->second->GetPairedStatus() == PAIR_PAIRED)) {
1979 HILOGE("failed, not in pairing state.");
1980 return ret;
1981 }
1982
1983 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1984 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1985
1986 BtAddr btAddr = ConvertToBtAddr(device);
1987 if (it->second->GetPairedStatus() == PAIR_CANCELING || accept == false) {
1988 ret = (GAPIF_UserPasskeyRsp(&btAddr, GAP_NOT_ACCEPT, passkey) == BT_SUCCESS);
1989 } else {
1990 ret = (GAPIF_UserPasskeyRsp(&btAddr, GAP_ACCEPT, passkey) == BT_SUCCESS);
1991 }
1992 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_UserPasskeyRsp", ret);
1993
1994 return ret;
1995 }
1996
PairRequestReply(const RawAddress & device,bool accept) const1997 bool ClassicAdapter::PairRequestReply(const RawAddress &device, bool accept) const
1998 {
1999 HILOGI("accept = %{public}d", accept);
2000
2001 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2002 auto it = devices_.find(device.GetAddress());
2003 if ((it == devices_.end()) || (it->second->GetPairedStatus() != PAIR_PAIRING)) {
2004 HILOGE("failed, not in pairing state.");
2005 return false;
2006 }
2007
2008 BtAddr btAddr = ConvertToBtAddr(device);
2009 int io = adapterProperties_.GetIoCapability();
2010 bool ret = (GAPIF_IOCapabilityRsp(&btAddr, accept, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_SUCCESS);
2011 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_IOCapabilityRsp", ret);
2012
2013 return ret;
2014 }
2015
ConnectionComplete(const BtmAclConnectCompleteParam * param,void * context)2016 void ClassicAdapter::ConnectionComplete(const BtmAclConnectCompleteParam *param, void *context)
2017 {
2018 HILOGI("status: %{public}u", param->status);
2019
2020 auto adapter = static_cast<ClassicAdapter *>(context);
2021 RawAddress device = RawAddress::ConvertToString(param->addr->addr);
2022 uint32_t classOfDevice = 0;
2023 (void)memcpy_s(&classOfDevice, COD_SIZE, param->classOfDevice, COD_SIZE);
2024 if (adapter != nullptr) {
2025 adapter->GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ReceiveConnectionComplete,
2026 adapter,
2027 param->status,
2028 param->connectionHandle,
2029 device,
2030 classOfDevice,
2031 param->encyptionEnabled));
2032 }
2033 }
2034
ReceiveConnectionComplete(uint8_t status,uint16_t connectionHandle,const RawAddress & device,uint32_t classOfDevice,bool encyptionEnabled)2035 void ClassicAdapter::ReceiveConnectionComplete(uint8_t status, uint16_t connectionHandle, const RawAddress &device,
2036 uint32_t classOfDevice, bool encyptionEnabled)
2037 {
2038 if (status == BTM_ACL_CONNECT_PAGE_TIMEOUT) {
2039 HILOGE("ACL Connection failed. Reason: ACL Page Timeout!");
2040 } else if (status == BTM_ACL_CONNECTION_TIMEOUT) {
2041 HILOGE("ACL Connection failed. Reason: ACL Supervision Timeout!");
2042 } else {
2043 HILOGI("ACL Connection result: %{public}u", status);
2044 }
2045
2046 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2047 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2048
2049 /// For compatibility
2050 /// Passive pairing failed and pair mode is PinCode.
2051 if (status != SUCCESS) {
2052 bool bondFromLocal = remoteDevice->IsBondedFromLocal();
2053 HILOGI("pinMode = %{public}d, bondFromLocal = %{public}d", pinMode_, bondFromLocal);
2054 if (pinMode_ == true && bondFromLocal == false) {
2055 pinMode_ = false;
2056 /// Passive pairing failed, delete the link key.
2057 DeleteLinkKey(remoteDevice);
2058 /// Set the pair flag and pair state.
2059 remoteDevice->SetPairedStatus(PAIR_NONE);
2060 /// Send the failed notification to APP.
2061 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
2062 }
2063 return;
2064 }
2065
2066 int connectState = CONNECTION_STATE_CONNECTED;
2067 if (encyptionEnabled == true) {
2068 connectState = CONNECTION_STATE_ENCRYPTED_BREDR;
2069 }
2070 remoteDevice->SetAclConnectState(connectState);
2071 remoteDevice->SetConnectionHandle(connectionHandle);
2072
2073 int cod = (classOfDevice & CLASS_OF_DEVICE_RANGE);
2074 if (cod != INVALID_VALUE) {
2075 remoteDevice->SetDeviceClass(cod);
2076 }
2077 }
2078
ReceiveDisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason)2079 void ClassicAdapter::ReceiveDisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason)
2080 {
2081 HILOGI("status: %{public}u", status);
2082
2083 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2084 if (status != SUCCESS) {
2085 HILOGW("failed");
2086 return;
2087 }
2088
2089 for (auto &device : devices_) {
2090 if (connectionHandle != device.second->GetConnectionHandle()) {
2091 continue;
2092 }
2093 device.second->SetAclConnectState(CONNECTION_STATE_DISCONNECTED);
2094
2095 HILOGI("pinMode = %{public}d", pinMode_);
2096 /// Passive pairing failed and pair mode is PinCode.
2097 /// For 960 compatibility
2098 /// When ACL disconnect and current pari state is in PAIR_PAIRING or PAIR_CANCELING, set pair state to
2099 /// PAIR_NONE.
2100 if ((pinMode_) || (device.second->GetPairedStatus() == PAIR_PAIRING) ||
2101 (device.second->GetPairedStatus() == PAIR_CANCELING)) {
2102 pinMode_ = false;
2103 /// Passive pairing failed, delete the link key.
2104 DeleteLinkKey(device.second);
2105 /// Set the pair flag and pair state.
2106 device.second->SetPairedStatus(PAIR_NONE);
2107 /// Send the failed notification to APP.
2108 bool bondFromLocal = device.second->IsBondedFromLocal();
2109 HILOGI("bondFromLocal = %{public}d", bondFromLocal);
2110 if (!bondFromLocal) {
2111 RawAddress address(device.second->GetAddress());
2112 SendPairStatusChanged(ADAPTER_BREDR, address, PAIR_NONE);
2113 }
2114 }
2115 break;
2116 }
2117 }
2118
DisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason,void * context)2119 void ClassicAdapter::DisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason, void *context)
2120 {
2121 HILOGI("status: %{public}u", status);
2122
2123 auto adapter = static_cast<ClassicAdapter *>(context);
2124 if (adapter != nullptr) {
2125 adapter->GetDispatcher()->PostTask(
2126 std::bind(&ClassicAdapter::ReceiveDisconnectionComplete, adapter, status, connectionHandle, reason));
2127 }
2128 }
2129
RegisterClassicAdapterObserver(IAdapterClassicObserver & observer) const2130 bool ClassicAdapter::RegisterClassicAdapterObserver(IAdapterClassicObserver &observer) const
2131 {
2132 HILOGI("enter");
2133
2134 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2135 adapterProperties_.RegisterClassicAdapterObserver(observer);
2136 return pimpl->adapterObservers_.Register(observer);
2137 }
2138
DeregisterClassicAdapterObserver(IAdapterClassicObserver & observer) const2139 bool ClassicAdapter::DeregisterClassicAdapterObserver(IAdapterClassicObserver &observer) const
2140 {
2141 HILOGI("enter");
2142
2143 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2144 adapterProperties_.DeregisterClassicAdapterObserver(observer);
2145 return pimpl->adapterObservers_.Deregister(observer);
2146 }
2147
SetLinkKey(const BtAddr & addr)2148 void ClassicAdapter::SetLinkKey(const BtAddr &addr)
2149 {
2150 HILOGI("enter");
2151
2152 RawAddress device = RawAddress::ConvertToString(addr.addr);
2153 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2154
2155 int keyType = remoteDevice->GetLinkKeyType();
2156 uint8_t key[PAIR_LINK_KEY_SIZE];
2157 (void)memset_s(key, PAIR_LINK_KEY_SIZE, 0x00, PAIR_LINK_KEY_SIZE);
2158 uint8_t accept = GAP_NOT_ACCEPT;
2159 if (keyType != PAIR_INVALID_LINK_KEY_TYPE) {
2160 std::vector<uint8_t> linkKey = remoteDevice->GetLinkKey();
2161 if (memcpy_s(key, linkKey.size(), &linkKey[0], linkKey.size()) != EOK) {
2162 HILOGI("memcpy_s fail");
2163 return;
2164 }
2165 accept = GAP_ACCEPT;
2166 }
2167
2168 bool ret = (GAPIF_LinkKeyRsp(&addr, accept, key, keyType) == BT_SUCCESS);
2169 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_LinkKeyRsp", ret);
2170 (void)memset_s(key, PAIR_LINK_KEY_SIZE, 0x00, PAIR_LINK_KEY_SIZE);
2171 }
2172
SendPairRequested(const BTTransport transport,const RawAddress & device) const2173 void ClassicAdapter::SendPairRequested(const BTTransport transport, const RawAddress &device) const
2174 {
2175 HILOGI("enter");
2176 pimpl->adapterObservers_.ForEach(
2177 [transport, device](IAdapterClassicObserver &observer) { observer.OnPairRequested(transport, device); });
2178 }
2179
SetIoCapability(const BtAddr & addr)2180 void ClassicAdapter::SetIoCapability(const BtAddr &addr)
2181 {
2182 HILOGI("enter");
2183
2184 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2185 RawAddress rawAddr = RawAddress::ConvertToString(addr.addr);
2186 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(rawAddr);
2187 if (remoteDevice->GetRemoteName().empty()) {
2188 GetRemoteName(addr);
2189 }
2190
2191 bool bondFromLocal = false;
2192 bool ret = (GAPIF_PairIsFromLocal(&addr, &bondFromLocal) == BT_SUCCESS);
2193 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_PairIsFromLocal", ret);
2194 remoteDevice->SetBondedFromLocal(bondFromLocal);
2195
2196 if ((remoteDevice->GetPairedStatus() != PAIR_PAIRING) && (remoteDevice->GetPairedStatus() != PAIR_CANCELING)) {
2197 remoteDevice->SetPairedStatus(PAIR_PAIRING);
2198 }
2199
2200 if (bondFromLocal == false) {
2201 SendPairRequested(ADAPTER_BREDR, rawAddr);
2202 } else {
2203 int io = adapterProperties_.GetIoCapability();
2204 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
2205 ret = (GAPIF_IOCapabilityRsp(&addr, false, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_SUCCESS);
2206 } else {
2207 ret = (GAPIF_IOCapabilityRsp(&addr, true, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_SUCCESS);
2208 }
2209 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_IOCapabilityRsp", ret);
2210 }
2211 }
2212
SaveRemoteIoCapability(const BtAddr & addr,uint8_t ioCapability)2213 void ClassicAdapter::SaveRemoteIoCapability(const BtAddr &addr, uint8_t ioCapability)
2214 {
2215 HILOGI("enter");
2216 RawAddress device = RawAddress::ConvertToString(addr.addr);
2217 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2218 remoteDevice->SetIoCapability(ioCapability);
2219 }
2220
SetDevicePin(const RawAddress & device,const std::string & pinCode) const2221 bool ClassicAdapter::SetDevicePin(const RawAddress &device, const std::string &pinCode) const
2222 {
2223 HILOGI("pinCode:%{public}s", pinCode.c_str());
2224 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2225 auto it = devices_.find(device.GetAddress());
2226 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_NONE) ||
2227 (it->second->GetPairedStatus() == PAIR_PAIRED)) {
2228 HILOGE("failed, not in pairing state.");
2229 return false;
2230 }
2231
2232 std::vector<uint8_t> pin(pinCode.begin(), pinCode.end());
2233 if (pin.empty()) {
2234 HILOGW("length is 0, reject it.");
2235 return SetPinCode(device, pin, GAP_NOT_ACCEPT);
2236 }
2237
2238 uint8_t accept = GAP_ACCEPT;
2239 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
2240 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
2241 if (it->second->GetPairedStatus() == PAIR_CANCELING) {
2242 accept = GAP_NOT_ACCEPT;
2243 }
2244
2245 return SetPinCode(device, pin, accept);
2246 }
2247
SetPinCode(const RawAddress & device,const std::vector<uint8_t> & pin,bool accept) const2248 bool ClassicAdapter::SetPinCode(const RawAddress &device, const std::vector<uint8_t> &pin, bool accept) const
2249 {
2250 HILOGI("accept: %{public}d", accept);
2251
2252 BtAddr btAddr;
2253 device.ConvertToUint8(btAddr.addr);
2254 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
2255 int result = GAPIF_PinCodeRsp(&btAddr, accept, pin.data(), pin.size());
2256 if (result != BT_SUCCESS) {
2257 HILOGE("GAPIF_PinCodeRsp failed!");
2258 return false;
2259 }
2260 return true;
2261 }
2262
SetAuthorizeRes(const BtAddr & addr,GAP_Service service) const2263 void ClassicAdapter::SetAuthorizeRes(const BtAddr &addr, GAP_Service service) const
2264 {
2265 HILOGI("enter");
2266 int result = GAPIF_AuthorizeRes(&addr, service, true);
2267 if (result != BT_SUCCESS) {
2268 HILOGE("GAPIF_AuthorizeRes failed!");
2269 }
2270 }
2271
GetDeviceType(const RawAddress & device) const2272 int ClassicAdapter::ClassicAdapter::GetDeviceType(const RawAddress &device) const
2273 {
2274 HILOGI("enter");
2275
2276 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2277 int type = INVALID_TYPE;
2278 auto it = devices_.find(device.GetAddress());
2279 if (it != devices_.end()) {
2280 type = it->second->GetDeviceType();
2281 }
2282
2283 return type;
2284 }
2285
GetDeviceClass(const RawAddress & device) const2286 int ClassicAdapter::GetDeviceClass(const RawAddress &device) const
2287 {
2288 HILOGI("enter");
2289
2290 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2291 int cod = INVALID_VALUE;
2292 auto it = devices_.find(device.GetAddress());
2293 if (it != devices_.end()) {
2294 cod = it->second->GetDeviceClass();
2295 }
2296
2297 return cod;
2298 }
2299
GetAliasName(const RawAddress & device) const2300 std::string ClassicAdapter::GetAliasName(const RawAddress &device) const
2301 {
2302 HILOGI("enter");
2303
2304 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2305 std::string alias = INVALID_NAME;
2306 auto it = devices_.find(device.GetAddress());
2307 if (it != devices_.end()) {
2308 alias = it->second->GetAliasName();
2309 }
2310
2311 return alias;
2312 }
2313
SetAliasName(const RawAddress & device,const std::string & name) const2314 bool ClassicAdapter::SetAliasName(const RawAddress &device, const std::string &name) const
2315 {
2316 HILOGI("enter");
2317
2318 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2319 bool ret = false;
2320 auto it = devices_.find(device.GetAddress());
2321 if (it != devices_.end()) {
2322 if (name != it->second->GetAliasName()) {
2323 ret = it->second->SetAliasName(name);
2324 if (ret == false) {
2325 HILOGE("failed");
2326 } else {
2327 SendRemoteAliasChanged(device, name);
2328 }
2329 }
2330 }
2331 return ret;
2332 }
2333
SendRemoteAliasChanged(const RawAddress & device,const std::string & aliasName) const2334 void ClassicAdapter::SendRemoteAliasChanged(const RawAddress &device, const std::string &aliasName) const
2335 {
2336 HILOGI("enter");
2337
2338 pimpl->remoteObservers_.ForEach([device, aliasName](IClassicRemoteDeviceObserver &observer) {
2339 observer.OnRemoteAliasChanged(device, aliasName);
2340 });
2341 }
2342
RegisterRemoteDeviceObserver(IClassicRemoteDeviceObserver & observer) const2343 bool ClassicAdapter::RegisterRemoteDeviceObserver(IClassicRemoteDeviceObserver &observer) const
2344 {
2345 HILOGI("enter");
2346 return pimpl->remoteObservers_.Register(observer);
2347 }
2348
DeregisterRemoteDeviceObserver(IClassicRemoteDeviceObserver & observer) const2349 bool ClassicAdapter::DeregisterRemoteDeviceObserver(IClassicRemoteDeviceObserver &observer) const
2350 {
2351 HILOGI("enter");
2352 return pimpl->remoteObservers_.Deregister(observer);
2353 }
2354
CheckAutoReply(int remoteIo,int localMitmRequired,int remoteMitmRequired) const2355 bool ClassicAdapter::CheckAutoReply(int remoteIo, int localMitmRequired, int remoteMitmRequired) const
2356 {
2357 HILOGI("enter");
2358
2359 bool autoReply = false;
2360 int localIo = adapterProperties_.GetIoCapability();
2361 HILOGI("local io capability = %{public}d <==> remote io capability = %{public}d"
2362 "local mitm = %{public}d <==> remote mitm = %{public}d", localIo, remoteIo,
2363 localMitmRequired, remoteMitmRequired);
2364
2365 if (localMitmRequired == GAP_MITM_NOT_REQUIRED && remoteMitmRequired == GAP_MITM_NOT_REQUIRED) {
2366 return true;
2367 }
2368
2369 switch (localIo) {
2370 case GAP_IO_DISPLAYONLY:
2371 autoReply = (remoteIo != GAP_IO_KEYBOARDONLY) ? true : false;
2372 break;
2373 case GAP_IO_KEYBOARDONLY:
2374 autoReply = (remoteIo == GAP_IO_NOINPUTNOOUTPUT) ? true : false;
2375 break;
2376 case GAP_IO_NOINPUTNOOUTPUT:
2377 autoReply = true;
2378 break;
2379 default:
2380 break;
2381 }
2382 return autoReply;
2383 }
2384
CheckSspConfirmType(int remoteIo,int type) const2385 int ClassicAdapter::CheckSspConfirmType(int remoteIo, int type) const
2386 {
2387 HILOGI("enter");
2388
2389 int confirmType = PAIR_CONFIRM_TYPE_CONSENT;
2390 int localIo = adapterProperties_.GetIoCapability();
2391 HILOGI("local io capability = %{public}d <==> remote io capability = %{public}d, type = %{public}d",
2392 localIo, remoteIo, type);
2393 if (type == PAIR_CONFIRM_TYPE_NUMERIC) {
2394 if ((localIo == GAP_IO_DISPLAYYESNO) && (remoteIo == GAP_IO_DISPLAYYESNO)) {
2395 confirmType = PAIR_CONFIRM_TYPE_NUMERIC;
2396 }
2397 } else {
2398 confirmType = type;
2399 }
2400 return confirmType;
2401 }
2402
SetDeviceBatteryLevel(const RawAddress & device,int batteryLevel) const2403 void ClassicAdapter::SetDeviceBatteryLevel(const RawAddress &device, int batteryLevel) const
2404 {
2405 HILOGI("addr: %{public}s, batteryLevel: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), batteryLevel);
2406
2407 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2408 auto it = devices_.find(device.GetAddress());
2409 if (it != devices_.end()) {
2410 it->second->SetBatteryLevel(batteryLevel);
2411 }
2412
2413 SendRemoteBatteryLevelChanged(device, batteryLevel);
2414 }
2415
SendRemoteBatteryLevelChanged(const RawAddress & device,int batteryLevel) const2416 void ClassicAdapter::SendRemoteBatteryLevelChanged(const RawAddress &device, int batteryLevel) const
2417 {
2418 HILOGI("addr: %{public}s, batteryLevel: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), batteryLevel);
2419 }
2420
IsHfpCodSupported(const RawAddress & device)2421 bool ClassicAdapter::IsHfpCodSupported(const RawAddress &device)
2422 {
2423 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2424 if (remoteDevice == nullptr) {
2425 HILOGE("remoteDevice is nullptr");
2426 return false;
2427 }
2428 uint32_t cod = static_cast<uint32_t>(remoteDevice->GetDeviceClass());
2429 /// Referenced from Assigned NUmbers,Class of Device format :
2430 /// 23-13 bit Major Service Classes
2431 /// 12-8 bit Major Device Class
2432 /// 7-2 bit Minor Device Class
2433 /// 1-0 bit 0b00
2434 /// The 21st bit indicates Audio.
2435 const uint32_t audioSerClassMask = 0x200000;
2436 if (cod & audioSerClassMask) {
2437 return true;
2438 }
2439 return false;
2440 }
2441
SetHidPnpInfo(const std::string & remoteAddr,int vendorId,int productId,int version)2442 bool ClassicAdapter::SetHidPnpInfo(const std::string &remoteAddr, int vendorId, int productId, int version)
2443 {
2444 return adapterProperties_.SetHidPnpInfo(remoteAddr, vendorId, productId, version);
2445 }
2446
SetHidDescInfo(const std::string & remoteAddr,int ctryCode,const std::vector<uint8_t> & descData,int descLength)2447 bool ClassicAdapter::SetHidDescInfo(
2448 const std::string &remoteAddr, int ctryCode, const std::vector<uint8_t> &descData, int descLength)
2449 {
2450 bool ret = adapterProperties_.SetHidDescInfo(remoteAddr, ctryCode, ClassicUtils::ConvertIntToHexString(descData));
2451 if (ret) {
2452 adapterProperties_.SaveConfigFile();
2453 }
2454 return ret;
2455 }
2456
GetHidPnpInfo(const std::string & remoteAddr,int & vendorId,int & productId,int & version)2457 void ClassicAdapter::GetHidPnpInfo(const std::string &remoteAddr, int &vendorId, int &productId, int &version)
2458 {
2459 adapterProperties_.GetHidPnpInfo(remoteAddr, vendorId, productId, version);
2460 }
2461
GetHidDescInfo(const std::string & remoteAddr,int & ctryCode,std::vector<uint8_t> & descData,int & descLength)2462 void ClassicAdapter::GetHidDescInfo(
2463 const std::string &remoteAddr, int &ctryCode, std::vector<uint8_t> &descData, int &descLength)
2464 {
2465 std::string descInfo = "";
2466 adapterProperties_.GetHidDescInfo(remoteAddr, ctryCode, descInfo);
2467 ClassicUtils::ConvertHexStringToInt(descInfo, descData);
2468 descLength = descData.size();
2469 }
2470 REGISTER_CLASS_CREATOR(ClassicAdapter);
2471 } // namespace bluetooth
2472 } // namespace OHOS