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