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_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR);
319 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_DeregisterDiscoveryCallback", ret);
320
321 /// Deregister GAP Pair series callback.
322 ret &= (GAPIF_DeregisterAuthenticationCallback() == BT_NO_ERROR);
323 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_DeregisterAuthenticationCallback", ret);
324
325 /// Deregister GAP security callback.
326 ret &= (GAPIF_DeregisterSecurityCallback() == BT_NO_ERROR);
327 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_DeregisterSecurityCallback", ret);
328
329 /// Deregister BTM ACL Change status callback.
330 ret &= (BTM_DeregisterAclCallbacks(&btmAclCbs_) == BT_NO_ERROR);
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_NO_ERROR);
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_NO_ERROR) {
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_NO_ERROR);
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,void * context)704 void ClassicAdapter::UserConfirmReqCallback(const BtAddr *addr, uint32_t number, void *context)
705 {
706 HILOGI("enter");
707
708 GapCallbackParam param = {};
709 (void)memcpy_s((void *)¶m.userConfirmReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
710 param.userConfirmReqParam_.number = number;
711 param.userConfirmReqParam_.reqType = PAIR_CONFIRM_TYPE_NUMERIC;
712
713 auto adapter = static_cast<ClassicAdapter *>(context);
714 if (adapter != nullptr) {
715 adapter->GetDispatcher()->PostTask(
716 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SSP_CONFIRM_REQ_EVT, param));
717 }
718 }
719
UserPasskeyReqCallback(const BtAddr * addr,void * context)720 void ClassicAdapter::UserPasskeyReqCallback(const BtAddr *addr, void *context)
721 {
722 HILOGI("enter");
723
724 GapCallbackParam param = {};
725 (void)memcpy_s((void *)¶m.userConfirmReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
726 param.userConfirmReqParam_.reqType = PAIR_CONFIRM_TYPE_PASSKEY_INPUT;
727 param.userConfirmReqParam_.number = 0;
728
729 auto adapter = static_cast<ClassicAdapter *>(context);
730 if (adapter != nullptr) {
731 adapter->GetDispatcher()->PostTask(
732 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SSP_CONFIRM_REQ_EVT, param));
733 }
734 }
735
UserPasskeyNotificationCallback(const BtAddr * addr,uint32_t number,void * context)736 void ClassicAdapter::UserPasskeyNotificationCallback(const BtAddr *addr, uint32_t number, void *context)
737 {
738 HILOGI("enter");
739
740 GapCallbackParam param = {};
741 (void)memcpy_s((void *)¶m.userConfirmReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
742 param.userConfirmReqParam_.reqType = PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY;
743 param.userConfirmReqParam_.number = number;
744
745 auto adapter = static_cast<ClassicAdapter *>(context);
746 if (adapter != nullptr) {
747 adapter->GetDispatcher()->PostTask(
748 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SSP_CONFIRM_REQ_EVT, param));
749 }
750 }
751
RemoteOobReqCallback(const BtAddr * addr,void * context)752 void ClassicAdapter::RemoteOobReqCallback(const BtAddr *addr, void *context)
753 {
754 HILOGI("enter");
755
756 /// OOB Pair not support for current framework api.
757 /// This is used for extending.
758 GapCallbackParam param = {};
759 (void)memcpy_s((void *)¶m.remoteOobReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
760
761 auto adapter = static_cast<ClassicAdapter *>(context);
762 if (adapter != nullptr) {
763 adapter->GetDispatcher()->PostTask(
764 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_REMOTE_OOB_REQ_EVT, param));
765 }
766 }
767
PinCodeReqCallback(const BtAddr * addr,void * context)768 void ClassicAdapter::PinCodeReqCallback(const BtAddr *addr, void *context)
769 {
770 HILOGI("enter");
771
772 GapCallbackParam param = {};
773 (void)memcpy_s((void *)¶m.pinCodeReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
774
775 auto adapter = static_cast<ClassicAdapter *>(context);
776 if (adapter != nullptr) {
777 adapter->GetDispatcher()->PostTask(
778 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_PIN_CODE_REQ_EVT, param));
779 }
780 }
781
LinkKeyReqCallback(const BtAddr * addr,void * context)782 void ClassicAdapter::LinkKeyReqCallback(const BtAddr *addr, void *context)
783 {
784 HILOGI("enter");
785
786 GapCallbackParam param = {};
787 (void)memcpy_s((void *)¶m.linkKeyReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
788
789 auto adapter = static_cast<ClassicAdapter *>(context);
790 if (adapter != nullptr) {
791 adapter->GetDispatcher()->PostTask(
792 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_LINK_KEY_REQ_EVT, param));
793 }
794 }
795
IoCapabilityReqCallback(const BtAddr * addr,void * context)796 void ClassicAdapter::IoCapabilityReqCallback(const BtAddr *addr, void *context)
797 {
798 HILOGI("enter");
799
800 GapCallbackParam param = {};
801 (void)memcpy_s((void *)¶m.ioCapabilityReqParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
802
803 auto adapter = static_cast<ClassicAdapter *>(context);
804 if (adapter != nullptr) {
805 adapter->GetDispatcher()->PostTask(
806 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_IO_CAPABILITY_REQ_EVT, param));
807 }
808 }
809
IoCapabilityRspCallback(const BtAddr * addr,uint8_t ioCapability,void * context)810 void ClassicAdapter::IoCapabilityRspCallback(const BtAddr *addr, uint8_t ioCapability, void *context)
811 {
812 HILOGI("enter");
813
814 GapCallbackParam param = {};
815 (void)memcpy_s((void *)¶m.ioCapabilityRspParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
816 param.ioCapabilityRspParam_.ioCapability = ioCapability;
817
818 auto adapter = static_cast<ClassicAdapter *>(context);
819 if (adapter != nullptr) {
820 adapter->GetDispatcher()->PostTask(
821 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_IO_CAPABILITY_RSP_EVT, param));
822 }
823 }
824
LinkKeyNotification(const BtAddr * addr,const uint8_t linkKey[GAP_LINKKEY_SIZE],uint8_t keyType,void * context)825 void ClassicAdapter::LinkKeyNotification(
826 const BtAddr *addr, const uint8_t linkKey[GAP_LINKKEY_SIZE], uint8_t keyType, void *context)
827 {
828 HILOGI("enter");
829
830 GapCallbackParam param = {};
831 (void)memcpy_s((void *)¶m.linkKeyNotificationParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
832 param.linkKeyNotificationParam_.keyType = keyType;
833 (void)memcpy_s((void *)param.linkKeyNotificationParam_.linkKey, GAP_LINKKEY_SIZE, linkKey, GAP_LINKKEY_SIZE);
834
835 auto adapter = static_cast<ClassicAdapter *>(context);
836 if (adapter != nullptr) {
837 adapter->GetDispatcher()->PostTask(
838 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_LINK_KEY_NOTIFICATION_EVT, param));
839 }
840 }
841
SimplePairCompleteCallback(const BtAddr * addr,uint8_t status,void * context)842 void ClassicAdapter::SimplePairCompleteCallback(const BtAddr *addr, uint8_t status, void *context)
843 {
844 HILOGI("status = %{public}u", status);
845
846 GapCallbackParam param = {};
847 (void)memcpy_s((void *)¶m.simplePairCompleteParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
848 param.simplePairCompleteParam_.status = status;
849
850 auto adapter = static_cast<ClassicAdapter *>(context);
851 if (adapter != nullptr) {
852 adapter->GetDispatcher()->PostTask(
853 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_SIMPLE_PAIR_COMPLETE_EVT, param));
854 }
855 }
856
AuthenticationCompleteCallback(const BtAddr * addr,uint8_t status,void * context)857 void ClassicAdapter::AuthenticationCompleteCallback(const BtAddr *addr, uint8_t status, void *context)
858 {
859 HILOGI("status: %{public}u", status);
860
861 GapCallbackParam param = {};
862 (void)memcpy_s((void *)¶m.authenticationCompleteParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
863 param.authenticationCompleteParam_.status = status;
864
865 auto adapter = static_cast<ClassicAdapter *>(context);
866 if (adapter != nullptr) {
867 adapter->GetDispatcher()->PostTask(
868 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_AUTHENTICATION_COMPLETE_EVT, param));
869 }
870 }
871
EncryptionChangeCallback(const BtAddr * addr,uint8_t status,void * context)872 void ClassicAdapter::EncryptionChangeCallback(const BtAddr *addr, uint8_t status, void *context)
873 {
874 HILOGI("enter");
875
876 GapCallbackParam param = {};
877 (void)memcpy_s((void *)¶m.encryptionChangeCallbackParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
878 param.encryptionChangeCallbackParam_.status = status;
879
880 auto adapter = static_cast<ClassicAdapter *>(context);
881 if (adapter != nullptr) {
882 adapter->GetDispatcher()->PostTask(
883 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_ENCRYPTION_CHANGE_CALLBACK_EVT, param));
884 }
885 }
886
AuthorizeIndCallback(const BtAddr * addr,GAP_Service service,void * context)887 void ClassicAdapter::AuthorizeIndCallback(const BtAddr *addr, GAP_Service service, void *context)
888 {
889 HILOGI("enter");
890
891 GapCallbackParam param = {};
892 (void)memcpy_s((void *)¶m.authorizeIndParam_.addr, sizeof(BtAddr), addr, sizeof(BtAddr));
893 param.authorizeIndParam_.service = service;
894
895 auto adapter = static_cast<ClassicAdapter *>(context);
896 if (adapter != nullptr) {
897 adapter->GetDispatcher()->PostTask(
898 std::bind(&ClassicAdapter::HandleSecurityEvent, adapter, GAP_AUTHORIZE_IND_CALLBACK_EVT, param));
899 }
900 }
901
HandleInquiryEvent(GAP_CB_EVENT event,const GapCallbackParam & param)902 void ClassicAdapter::HandleInquiryEvent(GAP_CB_EVENT event, const GapCallbackParam ¶m)
903 {
904 std::vector<uint8_t> eirData;
905 switch (event) {
906 case GAP_INQUIRY_RESULT_EVT:
907 HandleInquiryResult(param.iniquiryResultParam_.addr, param.iniquiryResultParam_.classOfDevice, eirData);
908 break;
909 case GAP_INQUIRY_RESULT_RSSI_EVT:
910 HandleInquiryResult(param.iniquiryResultRssiParam_.addr,
911 param.iniquiryResultRssiParam_.classOfDevice,
912 eirData,
913 param.iniquiryResultRssiParam_.rssi);
914 break;
915 case GAP_EXTENDED_INQUIRY_RESULT_EVT:
916 eirData.resize(MAX_EXTEND_INQUIRY_RESPONSE_LEN);
917 (void)memcpy_s(&eirData[0],
918 MAX_EXTEND_INQUIRY_RESPONSE_LEN,
919 param.extendedInquiryResultParam_.eir,
920 MAX_EXTEND_INQUIRY_RESPONSE_LEN);
921 HandleInquiryResult(param.extendedInquiryResultParam_.addr,
922 param.extendedInquiryResultParam_.classOfDevice,
923 eirData,
924 param.extendedInquiryResultParam_.rssi);
925 break;
926 case GAP_INQUIRY_COMPLETE_EVT:
927 HandleInquiryComplete(param.inquiryCompleteParam_.status);
928 break;
929 case GAP_REMOTE_NAME_CALLBACK_EVT:
930 ReceiveRemoteName(param.remoteNameCallbackParam_.status,
931 param.remoteNameCallbackParam_.addr,
932 param.remoteNameCallbackParam_.name);
933 break;
934 default:
935 break;
936 }
937 }
938
HandleSecurityEvent(GAP_CB_EVENT event,const GapCallbackParam & param)939 void ClassicAdapter::HandleSecurityEvent(GAP_CB_EVENT event, const GapCallbackParam ¶m)
940 {
941 switch (event) {
942 case GAP_SSP_CONFIRM_REQ_EVT:
943 SSPConfirmReq(
944 param.userConfirmReqParam_.addr, param.userConfirmReqParam_.reqType, param.userConfirmReqParam_.number);
945 break;
946 case GAP_PIN_CODE_REQ_EVT:
947 PinCodeReq(param.pinCodeReqParam_.addr);
948 break;
949 case GAP_REMOTE_OOB_REQ_EVT:
950 /// OOB Pair not support for current framework api.
951 /// This is used for extending.
952 break;
953 case GAP_IO_CAPABILITY_REQ_EVT:
954 SetIoCapability(param.ioCapabilityReqParam_.addr);
955 break;
956 case GAP_IO_CAPABILITY_RSP_EVT:
957 SaveRemoteIoCapability(param.ioCapabilityRspParam_.addr, param.ioCapabilityRspParam_.ioCapability);
958 break;
959 case GAP_LINK_KEY_REQ_EVT:
960 SetLinkKey(param.linkKeyReqParam_.addr);
961 break;
962 case GAP_LINK_KEY_NOTIFICATION_EVT:
963 ReceiveLinkKeyNotification(param.linkKeyNotificationParam_.addr,
964 param.linkKeyNotificationParam_.linkKey,
965 param.linkKeyNotificationParam_.keyType);
966 break;
967 case GAP_SIMPLE_PAIR_COMPLETE_EVT:
968 ReceiveSimplePairComplete(param.simplePairCompleteParam_.addr, param.simplePairCompleteParam_.status);
969 break;
970 case GAP_AUTHENTICATION_COMPLETE_EVT:
971 ReceiveAuthenticationComplete(
972 param.authenticationCompleteParam_.addr, param.authenticationCompleteParam_.status);
973 break;
974 case GAP_ENCRYPTION_CHANGE_CALLBACK_EVT:
975 ReceiveEncryptionChange(
976 param.encryptionChangeCallbackParam_.addr, param.encryptionChangeCallbackParam_.status);
977 break;
978 case GAP_AUTHORIZE_IND_CALLBACK_EVT:
979 SetAuthorizeRes(param.authorizeIndParam_.addr, param.authorizeIndParam_.service);
980 break;
981 default:
982 break;
983 }
984 }
985
HandleInquiryResult(const BtAddr & addr,uint32_t classOfDevice,std::vector<uint8_t> eir,int8_t rssi)986 void ClassicAdapter::HandleInquiryResult(
987 const BtAddr &addr, uint32_t classOfDevice, std::vector<uint8_t> eir, int8_t rssi)
988 {
989 HILOGI("enter");
990
991 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
992 discoveryState_ = DISCOVERYING;
993
994 RawAddress device = RawAddress::ConvertToString(addr.addr);
995 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
996 int cod = (classOfDevice & CLASS_OF_DEVICE_RANGE);
997 if (cod != remoteDevice->GetDeviceClass()) {
998 remoteDevice->SetDeviceClass(cod);
999 SendRemoteCodChanged(device, cod);
1000 }
1001
1002 remoteDevice->SetDeviceType(REMOTE_TYPE_BREDR);
1003 remoteDevice->SetRssi(rssi);
1004 if (!eir.empty()) {
1005 ParserEirData(remoteDevice, eir);
1006 } else {
1007 if (remoteDevice->GetRemoteName().empty()) {
1008 remoteDevice->SetNameNeedGet(true);
1009 }
1010 }
1011
1012 SendDiscoveryResult(device);
1013 }
1014
FindRemoteDevice(const RawAddress & device)1015 std::shared_ptr<ClassicRemoteDevice> ClassicAdapter::FindRemoteDevice(const RawAddress &device)
1016 {
1017 std::shared_ptr<ClassicRemoteDevice> remoteDevice;
1018 auto it = devices_.find(device.GetAddress());
1019 if (it != devices_.end()) {
1020 remoteDevice = it->second;
1021 } else {
1022 remoteDevice = std::make_shared<ClassicRemoteDevice>(device.GetAddress());
1023 devices_.insert(std::make_pair(device.GetAddress(), remoteDevice));
1024 }
1025
1026 return remoteDevice;
1027 }
1028
HandleInquiryComplete(uint8_t status)1029 void ClassicAdapter::HandleInquiryComplete(uint8_t status)
1030 {
1031 HILOGI("status: %{public}u", status);
1032
1033 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1034 receiveInquiryComplete_ = true;
1035 struct timeval tv {};
1036 gettimeofday(&tv, nullptr);
1037 long currentTime = (tv.tv_sec * MILLISECOND_UNIT + tv.tv_usec / MILLISECOND_UNIT);
1038 discoveryEndMs_ = currentTime;
1039
1040 if ((cancelDiscovery_) || (!DiscoverRemoteName())) {
1041 discoveryState_ = DISCOVERY_STOPED;
1042 SendDiscoveryStateChanged(discoveryState_);
1043 receiveInquiryComplete_ = false;
1044 cancelDiscovery_ = false;
1045 }
1046
1047 if (isDisable_) {
1048 DisablePairProcess();
1049 return;
1050 }
1051 }
1052
DiscoverRemoteName()1053 bool ClassicAdapter::DiscoverRemoteName()
1054 {
1055 HILOGI("enter");
1056
1057 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1058 if (cancelDiscovery_) {
1059 HILOGI("failed, because of CancelDiscovery");
1060 return false;
1061 }
1062
1063 for (auto device : devices_) {
1064 if (device.second->GetNameNeedGet()) {
1065 device.second->SetNameNeedGet(false);
1066 remoteNameAddr_ = device.second->GetAddress();
1067 RawAddress rawAddr = RawAddress(remoteNameAddr_);
1068 BtAddr btAddr = ConvertToBtAddr(rawAddr);
1069 bool ret = GetRemoteName(btAddr);
1070 ClassicUtils::CheckReturnValue("ClassicAdapter", "GetRemoteName", ret);
1071 return true;
1072 }
1073 }
1074
1075 return false;
1076 }
1077
ConvertToBtAddr(const RawAddress & device) const1078 BtAddr ClassicAdapter::ConvertToBtAddr(const RawAddress &device) const
1079 {
1080 BtAddr btAddr;
1081 device.ConvertToUint8(btAddr.addr);
1082 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
1083 return btAddr;
1084 }
1085
ReceiveRemoteName(uint8_t status,const BtAddr & addr,const uint8_t name[MAX_LOC_BT_NAME_LEN])1086 void ClassicAdapter::ReceiveRemoteName(uint8_t status, const BtAddr &addr, const uint8_t name[MAX_LOC_BT_NAME_LEN])
1087 {
1088 HILOGI("status: %{public}u", status);
1089
1090 if (hwTimer_ != nullptr) {
1091 hwTimer_->Stop();
1092 }
1093
1094 if (status == BT_NO_ERROR) {
1095 std::vector<uint8_t> nameVec(name, (name + MAX_LOC_BT_NAME_LEN));
1096 std::string deviceName(nameVec.begin(), nameVec.end());
1097 deviceName = deviceName.c_str();
1098 RawAddress device = RawAddress::ConvertToString(addr.addr);
1099 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1100 if (deviceName != remoteDevice->GetRemoteName()) {
1101 remoteDevice->SetRemoteName(deviceName);
1102 SendRemoteNameChanged(device, deviceName);
1103 }
1104 }
1105
1106 if (receiveInquiryComplete_) {
1107 if (!DiscoverRemoteName()) {
1108 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1109 discoveryState_ = DISCOVERY_STOPED;
1110 SendDiscoveryStateChanged(discoveryState_);
1111 receiveInquiryComplete_ = false;
1112 }
1113 }
1114
1115 if (isDisable_) {
1116 DisablePairProcess();
1117 return;
1118 }
1119 }
1120
CancelGetRemoteName() const1121 bool ClassicAdapter::CancelGetRemoteName() const
1122 {
1123 HILOGI("enter");
1124
1125 RawAddress rawAddr = RawAddress(remoteNameAddr_);
1126 BtAddr btAddr = ConvertToBtAddr(rawAddr);
1127 bool ret = (GAPIF_GetRemoteNameCancel(&btAddr) == BT_NO_ERROR);
1128 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_GetRemoteNameCancel", ret);
1129
1130 return ret;
1131 }
1132
SendDiscoveryStateChanged(int discoveryState) const1133 void ClassicAdapter::SendDiscoveryStateChanged(int discoveryState) const
1134 {
1135 HILOGI("state: %{public}d", discoveryState);
1136
1137 pimpl->adapterObservers_.ForEach(
1138 [discoveryState](IAdapterClassicObserver &observer) { observer.OnDiscoveryStateChanged(discoveryState); });
1139 }
1140
SendDiscoveryResult(const RawAddress & device) const1141 void ClassicAdapter::SendDiscoveryResult(const RawAddress &device) const
1142 {
1143 HILOGI("address: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
1144
1145 pimpl->adapterObservers_.ForEach(
1146 [device](IAdapterClassicObserver &observer) { observer.OnDiscoveryResult(device); });
1147 }
1148
SendRemoteCodChanged(const RawAddress & device,int cod) const1149 void ClassicAdapter::SendRemoteCodChanged(const RawAddress &device, int cod) const
1150 {
1151 HILOGI("address: %{public}s, cod: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), cod);
1152
1153 pimpl->remoteObservers_.ForEach(
1154 [device, cod](IClassicRemoteDeviceObserver &observer) { observer.OnRemoteCodChanged(device, cod); });
1155 }
1156
SSPConfirmReq(const BtAddr & addr,int reqType,int number)1157 void ClassicAdapter::SSPConfirmReq(const BtAddr &addr, int reqType, int number)
1158 {
1159 HILOGI("reqTyep: %{public}d", reqType);
1160
1161 RawAddress device = RawAddress::ConvertToString(addr.addr);
1162 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1163 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM);
1164 remoteDevice->SetPairConfirmType(reqType);
1165 int remoteIo = remoteDevice->GetIoCapability();
1166 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
1167 UserConfirmAutoReply(device, reqType, false);
1168 } else if (CheckAutoReply(remoteIo) == true) {
1169 UserConfirmAutoReply(device, reqType, true);
1170 } else {
1171 reqType = CheckSspConfirmType(remoteIo, reqType);
1172 SendPairConfirmed(device, reqType, number);
1173 }
1174 }
1175
PinCodeReq(const BtAddr & addr)1176 void ClassicAdapter::PinCodeReq(const BtAddr &addr)
1177 {
1178 HILOGI("enter");
1179
1180 RawAddress device = RawAddress::ConvertToString(addr.addr);
1181 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1182 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM);
1183 remoteDevice->SetPairConfirmType(PAIR_CONFIRM_TYPE_PIN_CODE);
1184 pinMode_ = true;
1185 if (remoteDevice->GetRemoteName().empty()) {
1186 GetRemoteName(addr);
1187 }
1188
1189 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
1190 UserConfirmAutoReply(device, PAIR_CONFIRM_TYPE_PIN_CODE, false);
1191 return;
1192 }
1193
1194 if ((remoteDevice->GetPairedStatus() != PAIR_PAIRING) && (remoteDevice->GetPairedStatus() != PAIR_CANCELING)) {
1195 remoteDevice->SetPairedStatus(PAIR_PAIRING);
1196 }
1197 bool bondFromLocal = false;
1198 bool ret = (GAPIF_PairIsFromLocal(&addr, &bondFromLocal) == BT_NO_ERROR);
1199 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_PairIsFromLocal", ret);
1200 remoteDevice->SetBondedFromLocal(bondFromLocal);
1201 if (bondFromLocal) {
1202 if (remoteDevice->CheckCod(CLASS_OF_DEVICE_AV_HEADSETS) ||
1203 remoteDevice->CheckCod(CLASS_OF_DEVICE_AV_HEADPHONES) ||
1204 remoteDevice->CheckCod(CLASS_OF_DEVICE_AV_PORTABLE_AUDIO) ||
1205 remoteDevice->CheckCod(CLASS_OF_DEVICE_AV_HIFI_AUDIO) ||
1206 remoteDevice->CheckCod(CLASS_OF_DEVICE_HID_POINTING)) {
1207 if ((!Compat::CompatCheck(CompatType::COMPAT_REJECT_AUTO_PAIRING, remoteDevice->GetAddress())) &&
1208 (!Compat::CompatCheck(CompatType::COMPAT_REJECT_AUTO_PAIRING, remoteDevice->GetRemoteName()))) {
1209 UserConfirmAutoReply(device, PAIR_CONFIRM_TYPE_PIN_CODE, true);
1210 return;
1211 }
1212 }
1213 if (remoteDevice->CheckCod(CLASS_OF_DEVICE_HID_KEYBOARD) || remoteDevice->CheckCod(CLASS_OF_DEVICE_HID_COMBO)) {
1214 if (Compat::CompatCheck(CompatType::COMPAT_KEYBOARD_REQUIRES_FIXED_PIN, remoteDevice->GetAddress())) {
1215 UserConfirmAutoReply(device, PAIR_CONFIRM_TYPE_PIN_CODE, true);
1216 return;
1217 }
1218 }
1219 }
1220
1221 SendPairConfirmed(device, PAIR_CONFIRM_TYPE_PIN_CODE, 0);
1222 }
1223
SendPairConfirmed(const RawAddress & device,int reqType,int number) const1224 void ClassicAdapter::SendPairConfirmed(const RawAddress &device, int reqType, int number) const
1225 {
1226 HILOGI("reqType = %{public}d, number = %{public}d", reqType, number);
1227 BTTransport transport = ADAPTER_BREDR;
1228 pimpl->adapterObservers_.ForEach([transport, device, reqType, number](IAdapterClassicObserver &observer) {
1229 observer.OnPairConfirmed(transport, device, reqType, number);
1230 });
1231 }
1232
UserConfirmAutoReply(const RawAddress & device,int reqType,bool accept) const1233 void ClassicAdapter::UserConfirmAutoReply(const RawAddress &device, int reqType, bool accept) const
1234 {
1235 HILOGI("address: %{public}s, accept: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), accept);
1236
1237 auto it = devices_.find(device.GetAddress());
1238 if (it != devices_.end()) {
1239 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1240 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1241 }
1242
1243 switch (reqType) {
1244 case PAIR_CONFIRM_TYPE_PIN_CODE: {
1245 std::string passkey = adapterProperties_.GetPasskey();
1246 HILOGI("PAIR_CONFIRM_TYPE_PIN_CODE, value = %{public}s", passkey.c_str());
1247 std::vector<uint8_t> pinCode(passkey.begin(), passkey.end());
1248 SetPinCode(device, pinCode, accept);
1249 break;
1250 }
1251 case PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY: {
1252 HILOGI("PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY, do nothing!!");
1253 break;
1254 }
1255 case PAIR_CONFIRM_TYPE_PASSKEY_INPUT: {
1256 HILOGI("PAIR_CONFIRM_TYPE_PASSKEY_INPUT");
1257 int passkey = 0;
1258 SetDevicePasskey(device, passkey, accept);
1259 break;
1260 }
1261 case PAIR_CONFIRM_TYPE_NUMERIC:
1262 case PAIR_CONFIRM_TYPE_CONSENT: {
1263 HILOGI("PAIR_CONFIRM_TYPE_NUMERIC");
1264 SetDevicePairingConfirmation(device, accept);
1265 break;
1266 }
1267 default:
1268 HILOGI("default case. reqType = %{public}d", reqType);
1269 break;
1270 }
1271 }
1272
ParserEirData(std::shared_ptr<ClassicRemoteDevice> remote,const std::vector<uint8_t> & data) const1273 void ClassicAdapter::ParserEirData(std::shared_ptr<ClassicRemoteDevice> remote, const std::vector<uint8_t> &data) const
1274 {
1275 std::vector<ClassicDataStructure> dataList = eirData_.ParserData(data);
1276 std::vector<Uuid> uuids;
1277 bool isGetRemoteName = false;
1278
1279 for (auto &dataStruc : dataList) {
1280 int type = dataStruc.GetType();
1281 std::vector<uint8_t> valueVec = dataStruc.GetDataValue();
1282 switch (type) {
1283 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME:
1284 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME:
1285 isGetRemoteName = ParserRemoteNameFromEir(remote, type, valueVec);
1286 break;
1287 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1288 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1289 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1290 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1291 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
1292 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: {
1293 std::vector<Uuid> parsedUuids = ParserUuidFromEir(type, valueVec);
1294 if (!parsedUuids.empty()) {
1295 uuids.insert(uuids.end(), parsedUuids.begin(), parsedUuids.end());
1296 }
1297 break;
1298 }
1299 /// Flags, TxPower, ManufacturerData, Uri are not support for current framework api.
1300 /// This is used for extending.
1301 case BLUETOOTH_DATA_TYPE_FLAGS:
1302 remote->SetFlags(valueVec[0]);
1303 break;
1304 case BLUETOOTH_DATA_TYPE_TX_POWER_LEVEL:
1305 remote->SetTxPower(valueVec[0]);
1306 break;
1307 case BLUETOOTH_DATA_TYPE_MANUFACTURER_SPECIFIC_DATA:
1308 remote->SetManufacturerSpecificData(valueVec);
1309 break;
1310 case BLUETOOTH_DATA_TYPE_URI: {
1311 std::string uri(valueVec.begin(), valueVec.end());
1312 remote->SetURI(uri);
1313 break;
1314 }
1315 default:
1316 break;
1317 }
1318 }
1319
1320 if (!isGetRemoteName) {
1321 remote->SetNameNeedGet(true);
1322 }
1323
1324 if (!uuids.empty()) {
1325 SaveRemoteDeviceUuids(remote, uuids);
1326 uuids.clear();
1327 }
1328 }
1329
ParserRemoteNameFromEir(std::shared_ptr<ClassicRemoteDevice> remote,int type,const std::vector<uint8_t> & value) const1330 bool ClassicAdapter::ParserRemoteNameFromEir(
1331 std::shared_ptr<ClassicRemoteDevice> remote, int type, const std::vector<uint8_t> &value) const
1332 {
1333 HILOGI("type %{public}d", type);
1334
1335 if (value.empty()) {
1336 return false;
1337 }
1338
1339 if (type == BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME) {
1340 remote->SetNameNeedGet(true);
1341 } else {
1342 remote->SetNameNeedGet(false);
1343 }
1344
1345 std::string remoteName(value.begin(), value.end());
1346 HILOGI("remoteName is %{public}s", remoteName.c_str());
1347 if (remoteName != remote->GetRemoteName()) {
1348 remote->SetRemoteName(remoteName);
1349 SendRemoteNameChanged(RawAddress(remote->GetAddress()), remoteName);
1350 }
1351
1352 return true;
1353 }
1354
ParserUuidFromEir(int type,const std::vector<uint8_t> & value) const1355 std::vector<Uuid> ClassicAdapter::ParserUuidFromEir(int type, const std::vector<uint8_t> &value) const
1356 {
1357 HILOGI("enter");
1358
1359 std::vector<Uuid> uuids;
1360 if (value.empty()) {
1361 HILOGI("ParserUuidFromEir invalid parameter.");
1362 return uuids;
1363 }
1364
1365 switch (type) {
1366 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1367 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS: {
1368 uuids = Parser16BitUuidFromEir(value);
1369 break;
1370 }
1371 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1372 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS: {
1373 uuids = Parser32BitUuidFromEir(value);
1374 break;
1375 }
1376 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
1377 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: {
1378 uuids = Parser128BitUuidFromEir(value);
1379 break;
1380 }
1381 default:
1382 break;
1383 }
1384
1385 return uuids;
1386 }
1387
Parser16BitUuidFromEir(const std::vector<uint8_t> & value) const1388 std::vector<Uuid> ClassicAdapter::Parser16BitUuidFromEir(const std::vector<uint8_t> &value) const
1389 {
1390 HILOGI("enter");
1391
1392 std::vector<Uuid> uuids;
1393 uint8_t offset = 0;
1394 while ((value.size() - offset) > 1) {
1395 uint8_t unitLen = sizeof(uint16_t);
1396 if (unitLen <= (value.size() - offset)) {
1397 uint16_t uuid16 = 0;
1398 (void)memcpy_s(&uuid16, unitLen, &value[offset], unitLen);
1399 Uuid uuid = Uuid::ConvertFrom16Bits(uuid16);
1400 if (uuid16 != 0) {
1401 uuids.push_back(uuid);
1402 HILOGI("remote 16bit UUID");
1403 }
1404 offset += unitLen;
1405 } else {
1406 break;
1407 }
1408 }
1409
1410 return uuids;
1411 }
1412
Parser32BitUuidFromEir(const std::vector<uint8_t> & value) const1413 std::vector<Uuid> ClassicAdapter::Parser32BitUuidFromEir(const std::vector<uint8_t> &value) const
1414 {
1415 HILOGI("enter");
1416
1417 std::vector<Uuid> uuids;
1418 int offset = 0;
1419 while ((value.size() - offset) > 1) {
1420 uint8_t unitLen = sizeof(uint32_t);
1421 if (unitLen <= (value.size() - offset)) {
1422 uint32_t uuid32 = 0;
1423 (void)memcpy_s(&uuid32, unitLen, &value[offset], unitLen);
1424 Uuid uuid = Uuid::ConvertFrom32Bits(uuid32);
1425 if (uuid32 != 0) {
1426 uuids.push_back(uuid);
1427 HILOGI("remote 32bit UUID");
1428 }
1429 offset += unitLen;
1430 } else {
1431 break;
1432 }
1433 }
1434
1435 return uuids;
1436 }
1437
Parser128BitUuidFromEir(const std::vector<uint8_t> & value) const1438 std::vector<Uuid> ClassicAdapter::Parser128BitUuidFromEir(const std::vector<uint8_t> &value) const
1439 {
1440 HILOGI("enter");
1441
1442 std::vector<Uuid> uuids;
1443 int offset = 0;
1444 while ((value.size() - offset) > 1) {
1445 if (UUID128_BYTES_TYPE <= (value.size() - offset)) {
1446 Uuid uuid = Uuid::ConvertFromBytesLE(&value[offset]);
1447 bluetooth::Uuid::UUID128Bit uuidCheck = {0};
1448 if (uuid.ConvertTo128Bits() != uuidCheck) {
1449 uuids.push_back(uuid);
1450 HILOGI("remote 128bit UUID");
1451 }
1452 offset += UUID128_BYTES_TYPE;
1453 } else {
1454 break;
1455 }
1456 }
1457
1458 return uuids;
1459 }
1460
SaveRemoteDeviceUuids(std::shared_ptr<ClassicRemoteDevice> remote,const std::vector<Uuid> & uuids) const1461 void ClassicAdapter::SaveRemoteDeviceUuids(
1462 std::shared_ptr<ClassicRemoteDevice> remote, const std::vector<Uuid> &uuids) const
1463 {
1464 HILOGI("enter");
1465
1466 if ((remote == nullptr) || (uuids.empty())) {
1467 return;
1468 }
1469
1470 std::vector<Uuid> prevUuids = remote->GetDeviceUuids();
1471 if (!IsUuidsEqual(uuids, prevUuids)) {
1472 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1473 remote->SetDeviceUuids(uuids);
1474 SendRemoteUuidChanged(RawAddress(remote->GetAddress()), uuids);
1475 }
1476 }
1477
IsUuidsEqual(const std::vector<Uuid> & uuids1,const std::vector<Uuid> & uuids2) const1478 bool ClassicAdapter::IsUuidsEqual(const std::vector<Uuid> &uuids1, const std::vector<Uuid> &uuids2) const
1479 {
1480 HILOGI("enter");
1481 if (uuids1.size() != uuids2.size()) {
1482 return false;
1483 }
1484
1485 for (auto uuid : uuids1) {
1486 auto it = std::find(uuids2.begin(), uuids2.end(), uuid);
1487 if (it == uuids2.end()) {
1488 return false;
1489 }
1490 }
1491
1492 for (auto uuid : uuids2) {
1493 auto it = std::find(uuids1.begin(), uuids1.end(), uuid);
1494 if (it == uuids1.end()) {
1495 return false;
1496 }
1497 }
1498
1499 return true;
1500 }
1501
SendRemoteNameChanged(const RawAddress & device,const std::string & deviceName) const1502 void ClassicAdapter::SendRemoteNameChanged(const RawAddress &device, const std::string &deviceName) const
1503 {
1504 HILOGI("enter");
1505 pimpl->remoteObservers_.ForEach([device, deviceName](IClassicRemoteDeviceObserver &observer) {
1506 observer.OnRemoteNameChanged(device, deviceName);
1507 });
1508 }
1509
SendPairStatusChanged(const BTTransport transport,const RawAddress & device,int status) const1510 void ClassicAdapter::SendPairStatusChanged(const BTTransport transport, const RawAddress &device, int status) const
1511 {
1512 HILOGI("status: %{public}d", status);
1513 pimpl->remoteObservers_.ForEach([transport, device, status](IClassicRemoteDeviceObserver &observer) {
1514 observer.OnPairStatusChanged(transport, device, status);
1515 });
1516 }
1517
ReceiveLinkKeyNotification(const BtAddr & addr,const uint8_t linkKey[GAP_LINKKEY_SIZE],uint8_t keyType)1518 void ClassicAdapter::ReceiveLinkKeyNotification(
1519 const BtAddr &addr, const uint8_t linkKey[GAP_LINKKEY_SIZE], uint8_t keyType)
1520 {
1521 HILOGI("enter");
1522
1523 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1524 /// Pairing success, save link key and sent notification to APP.
1525 if (pinMode_ == true) {
1526 pinMode_ = false;
1527 }
1528
1529 RawAddress device = RawAddress::ConvertToString(addr.addr);
1530 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1531 if (remoteDevice->GetRemoteName().empty()) {
1532 GetRemoteName(addr);
1533 }
1534 SearchRemoteUuids(device, PNP_SERVICE_CLASS_UUID);
1535
1536 /// Bondable mode is on, then save the linkKey and keyType
1537 if (adapterProperties_.GetBondableMode() == BONDABLE_MODE_ON) {
1538 std::vector<uint8_t> linkKeyVec(linkKey, (linkKey + GAP_LINKKEY_SIZE));
1539 remoteDevice->SetLinkKey(linkKeyVec);
1540 remoteDevice->SetLinkKeyType(keyType);
1541 remoteDevice->SetPairedStatus(PAIR_PAIRED);
1542 if (remoteDevice != nullptr) {
1543 adapterProperties_.SavePairedDeviceInfo(remoteDevice);
1544 adapterProperties_.SaveConfigFile();
1545 }
1546 } else {
1547 remoteDevice->SetPairedStatus(PAIR_NONE);
1548 HILOGW("Bondmode is off, so not save the link key");
1549 }
1550 }
1551
ReceiveSimplePairComplete(const BtAddr & addr,uint8_t status)1552 void ClassicAdapter::ReceiveSimplePairComplete(const BtAddr &addr, uint8_t status)
1553 {
1554 HILOGI("status: %{public}u", status);
1555
1556 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1557 if (status != SUCCESS) {
1558 RawAddress device = RawAddress::ConvertToString(addr.addr);
1559 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1560 bool bondFromLocal = remoteDevice->IsBondedFromLocal();
1561 /// Passive pairing failed, delete the link key.
1562 if (bondFromLocal == false) {
1563 DeleteLinkKey(remoteDevice);
1564 /// Set the pair flag and pair state.
1565 remoteDevice->SetPairedStatus(PAIR_NONE);
1566 /// Send the failed notification to APP.
1567 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
1568 }
1569 }
1570 }
1571
DeleteLinkKey(std::shared_ptr<ClassicRemoteDevice> remoteDevice) const1572 void ClassicAdapter::DeleteLinkKey(std::shared_ptr<ClassicRemoteDevice> remoteDevice) const
1573 {
1574 int keyType = remoteDevice->GetLinkKeyType();
1575 if (keyType != PAIR_INVALID_LINK_KEY_TYPE) {
1576 remoteDevice->DeleteLinkKey();
1577 remoteDevice->SetLinkKeyType(PAIR_INVALID_LINK_KEY_TYPE);
1578 }
1579 }
1580
ReceiveAuthenticationComplete(const BtAddr & addr,uint8_t status)1581 void ClassicAdapter::ReceiveAuthenticationComplete(const BtAddr &addr, uint8_t status)
1582 {
1583 HILOGI("status: %{public}u", status);
1584
1585 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1586 RawAddress device = RawAddress::ConvertToString(addr.addr);
1587 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1588 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_INVALID);
1589 remoteDevice->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1590
1591 if (status != SUCCESS) {
1592 /// Active pairing failed, delete the link key.
1593 DeleteLinkKey(remoteDevice);
1594 /// Set the pair flag and pair state.
1595 remoteDevice->SetPairedStatus(PAIR_NONE);
1596 /// Send the failed notification to APP.
1597 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
1598 } else {
1599 if (remoteDevice->GetPairedStatus() == PAIR_PAIRING) {
1600 remoteDevice->SetPairedStatus(PAIR_PAIRED);
1601 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRED);
1602 }
1603 }
1604
1605 if (waitPairResult_) {
1606 waitPairResult_ = false;
1607 InitMode();
1608 }
1609 }
1610
ReceiveEncryptionChange(const BtAddr & addr,uint8_t status)1611 void ClassicAdapter::ReceiveEncryptionChange(const BtAddr &addr, uint8_t status)
1612 {
1613 HILOGI("status: %{public}u", status);
1614
1615 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1616 RawAddress device = RawAddress::ConvertToString(addr.addr);
1617 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1618 if (status == GAP_ENCRYPTION_ON) {
1619 remoteDevice->SetAclConnectState(CONNECTION_STATE_ENCRYPTED_BREDR);
1620 } else {
1621 remoteDevice->SetAclConnectState(CONNECTION_STATE_CONNECTED);
1622 }
1623 }
1624
GetRemoteName(const BtAddr & addr) const1625 bool ClassicAdapter::GetRemoteName(const BtAddr &addr) const
1626 {
1627 HILOGI("enter");
1628
1629 bool ret = (GAPIF_GetRemoteName(&addr) == BT_NO_ERROR);
1630 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_GetRemoteName", ret);
1631 if (ret && (hwTimer_ != nullptr)) {
1632 hwTimer_->Start(DEFAULT_HW_TIMEOUT);
1633 }
1634
1635 return ret;
1636 }
1637
GetDeviceName(const RawAddress & device) const1638 std::string ClassicAdapter::GetDeviceName(const RawAddress &device) const
1639 {
1640 HILOGI("enter");
1641
1642 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1643 std::string remoteName = "";
1644 auto it = devices_.find(device.GetAddress());
1645 if (it != devices_.end()) {
1646 remoteName = it->second->GetRemoteName();
1647 }
1648
1649 return remoteName;
1650 }
1651
GetDeviceUuids(const RawAddress & device) const1652 std::vector<Uuid> ClassicAdapter::GetDeviceUuids(const RawAddress &device) const
1653 {
1654 HILOGI("enter");
1655
1656 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1657 std::vector<Uuid> uuids;
1658 auto it = devices_.find(device.GetAddress());
1659 if (it != devices_.end()) {
1660 uuids = it->second->GetDeviceUuids();
1661 }
1662 return uuids;
1663 }
1664
SearchRemoteUuids(const RawAddress & device,uint16_t uuid)1665 void ClassicAdapter::SearchRemoteUuids(const RawAddress &device, uint16_t uuid)
1666 {
1667 BtAddr btAddr = ConvertToBtAddr(device);
1668
1669 BtUuid btUuid[SDP_UUDIID_NUM];
1670 btUuid[0].type = BT_UUID_16;
1671 btUuid[0].uuid16 = uuid;
1672 searchUuid_ = uuid;
1673
1674 SdpUuid uuidArray;
1675 uuidArray.uuid = &btUuid[0];
1676 uuidArray.uuidNum = 1;
1677
1678 SdpAttributeIdList attributeIdList;
1679 attributeIdList.type = SDP_TYPE_RANGE;
1680 attributeIdList.attributeIdRange.start = 0x0000;
1681 attributeIdList.attributeIdRange.end = 0xFFFF;
1682 int ret = SDP_ServiceSearchAttribute(&btAddr, &uuidArray, attributeIdList, (void *)this, ServiceSearchAttributeCb);
1683 if (ret != BT_NO_ERROR) {
1684 HILOGE("SDP_ServiceSearchAttribute failed!");
1685 }
1686 }
1687
ServiceSearchAttributeCb(const BtAddr * addr,const SdpService * serviceArray,uint16_t serviceNum,void * context)1688 void ClassicAdapter::ServiceSearchAttributeCb(
1689 const BtAddr *addr, const SdpService *serviceArray, uint16_t serviceNum, void *context)
1690 {
1691 HILOGI("enter");
1692
1693 auto adapter = static_cast<ClassicAdapter *>(context);
1694 for (int index = 0; index < serviceNum; index++) {
1695 for (int num = 0; num < serviceArray[index].classIdNumber; num++) {
1696 Uuid uuid = adapter->GetUuidFromBtUuid(serviceArray[index].classId[num]);
1697 auto it = std::find(adapter->uuids_.begin(), adapter->uuids_.end(), uuid);
1698 if (it == adapter->uuids_.end()) {
1699 adapter->uuids_.push_back(uuid);
1700 }
1701 }
1702 }
1703
1704 RawAddress device = RawAddress::ConvertToString(addr->addr);
1705 if (adapter->searchUuid_ == UUID_PROTOCOL_L2CAP) {
1706 adapter->GetDispatcher()->PostTask(
1707 std::bind(&ClassicAdapter::SearchAttributeEnd, adapter, device, adapter->uuids_));
1708 } else {
1709 adapter->GetDispatcher()->PostTask(
1710 std::bind(&ClassicAdapter::SearchRemoteUuids, adapter, device, UUID_PROTOCOL_L2CAP));
1711 }
1712 }
1713
SearchAttributeEnd(const RawAddress & device,const std::vector<Uuid> & uuids)1714 void ClassicAdapter::SearchAttributeEnd(const RawAddress &device, const std::vector<Uuid> &uuids)
1715 {
1716 if (isDisable_) {
1717 return;
1718 }
1719 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1720 SaveRemoteDeviceUuids(remoteDevice, uuids);
1721 if (remoteDevice != nullptr) {
1722 adapterProperties_.SavePairedDeviceInfo(remoteDevice);
1723 adapterProperties_.SaveConfigFile();
1724 }
1725 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRED);
1726 }
1727
GetUuidFromBtUuid(const BtUuid & inUuid) const1728 Uuid ClassicAdapter::GetUuidFromBtUuid(const BtUuid &inUuid) const
1729 {
1730 Uuid uuid;
1731 if (inUuid.type == BT_UUID_16) {
1732 uuid = Uuid::ConvertFrom16Bits(inUuid.uuid16);
1733 } else if (inUuid.type == BT_UUID_32) {
1734 uuid = Uuid::ConvertFrom32Bits(inUuid.uuid32);
1735 } else {
1736 uuid = Uuid::ConvertFromBytesLE(inUuid.uuid128);
1737 }
1738
1739 return uuid;
1740 }
1741
SendRemoteUuidChanged(const RawAddress & device,const std::vector<Uuid> & uuids) const1742 void ClassicAdapter::SendRemoteUuidChanged(const RawAddress &device, const std::vector<Uuid> &uuids) const
1743 {
1744 pimpl->remoteObservers_.ForEach(
1745 [device, uuids](IClassicRemoteDeviceObserver &observer) { observer.OnRemoteUuidChanged(device, uuids); });
1746 }
1747
IsAclConnected(const RawAddress & device) const1748 bool ClassicAdapter::IsAclConnected(const RawAddress &device) const
1749 {
1750 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1751 bool isAclConnected = false;
1752 auto it = devices_.find(device.GetAddress());
1753 if (it != devices_.end()) {
1754 isAclConnected = it->second->IsAclConnected();
1755 }
1756
1757 HILOGI("isAclConnected: %{public}d", isAclConnected);
1758 return isAclConnected;
1759 }
1760
IsAclEncrypted(const RawAddress & device) const1761 bool ClassicAdapter::IsAclEncrypted(const RawAddress &device) const
1762 {
1763 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1764 bool isAclEncrypted = false;
1765 auto it = devices_.find(device.GetAddress());
1766 if (it != devices_.end()) {
1767 isAclEncrypted = it->second->IsAclEncrypted();
1768 }
1769
1770 HILOGI("isAclEncrypted: %{public}d", isAclEncrypted);
1771 return isAclEncrypted;
1772 }
1773
GetContext()1774 utility::Context *ClassicAdapter::GetContext()
1775 {
1776 return this;
1777 }
1778
IsBondedFromLocal(const RawAddress & device) const1779 bool ClassicAdapter::IsBondedFromLocal(const RawAddress &device) const
1780 {
1781 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1782 bool isBondedFromLocal = false;
1783 auto it = devices_.find(device.GetAddress());
1784 if (it != devices_.end()) {
1785 isBondedFromLocal = it->second->IsBondedFromLocal();
1786 }
1787
1788 HILOGI("isBondedFromLocal: %{public}d", isBondedFromLocal);
1789 return isBondedFromLocal;
1790 }
1791
GetPairedDevices() const1792 std::vector<RawAddress> ClassicAdapter::GetPairedDevices() const
1793 {
1794 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1795 std::vector<RawAddress> pairedList;
1796 for (auto &device : devices_) {
1797 if (device.second->IsPaired() == true) {
1798 RawAddress rawAddr(device.second->GetAddress());
1799 pairedList.push_back(rawAddr);
1800 }
1801 }
1802
1803 return pairedList;
1804 }
1805
StartPair(const RawAddress & device)1806 bool ClassicAdapter::StartPair(const RawAddress &device)
1807 {
1808 HILOGI("enter");
1809
1810 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1811 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1812 if (remoteDevice->GetPairedStatus() == PAIR_PAIRING) {
1813 HILOGE("StartPair failed, because of PAIR_NONE or PAIRING!");
1814 return false;
1815 }
1816
1817 if (discoveryState_ == DISCOVERYING) {
1818 bool ret = CancelBtDiscovery();
1819 ClassicUtils::CheckReturnValue("ClassicAdapter", "CancelBtDiscovery", ret);
1820 }
1821
1822 BtAddr btAddr = ConvertToBtAddr(device);
1823 int ret = GAPIF_AuthenticationReq(&btAddr);
1824 if (ret != BT_NO_ERROR) {
1825 HILOGE("GAPIF_AuthenticationReq failed!");
1826 return false;
1827 }
1828
1829 DeleteLinkKey(remoteDevice);
1830 remoteDevice->SetPairedStatus(PAIR_PAIRING);
1831 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRING);
1832
1833 return true;
1834 }
1835
CancelPairing(const RawAddress & device)1836 bool ClassicAdapter::CancelPairing(const RawAddress &device)
1837 {
1838 HILOGI("enter");
1839
1840 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1841 auto it = devices_.find(device.GetAddress());
1842 if (it == devices_.end() || (it->second->GetPairedStatus() != PAIR_PAIRING)) {
1843 HILOGE("failed, because of not in PAIR_PAIRING!");
1844 return false;
1845 }
1846
1847 it->second->SetPairedStatus(PAIR_CANCELING);
1848 int pairConfirmState = it->second->GetPairConfirmState();
1849 if (pairConfirmState == PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY) {
1850 BtAddr btAddr = ConvertToBtAddr(device);
1851 bool ret = (GAPIF_CancelAuthenticationReq(&btAddr) == BT_NO_ERROR);
1852 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_CancelAuthenticationReq", ret);
1853 return ret;
1854 }
1855
1856 if (pairConfirmState == PAIR_CONFIRM_STATE_USER_CONFIRM) {
1857 int pairConfirmType = it->second->GetPairConfirmType();
1858 RawAddress address(it->second->GetAddress());
1859 UserConfirmAutoReply(address, pairConfirmType, false);
1860 }
1861 return true;
1862 }
1863
RemovePair(const RawAddress & device)1864 bool ClassicAdapter::RemovePair(const RawAddress &device)
1865 {
1866 HILOGI("address %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
1867
1868 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1869 auto it = devices_.find(device.GetAddress());
1870 if ((it == devices_.end()) || (it->second->IsPaired() == false)) {
1871 HILOGW("RemovePair failed, because of not find the paired device!");
1872 return false;
1873 } else {
1874 it->second->SetPairedStatus(PAIR_NONE);
1875 DeleteLinkKey(it->second);
1876 adapterProperties_.RemovePairedDeviceInfo(it->second->GetAddress());
1877 adapterProperties_.SaveConfigFile();
1878 if (it->second->IsAclConnected()) {
1879 bool ret = (BTM_AclDisconnect(it->second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_NO_ERROR);
1880 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", ret);
1881 }
1882 }
1883
1884 std::vector<RawAddress> removeDevices;
1885 removeDevices.push_back(device);
1886 AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BREDR, removeDevices);
1887 SendPairStatusChanged(BTTransport::ADAPTER_BREDR, device, PAIR_NONE);
1888 return true;
1889 }
1890
RemoveAllPairs()1891 bool ClassicAdapter::RemoveAllPairs()
1892 {
1893 HILOGI("enter");
1894 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1895 std::vector<RawAddress> removeDevices;
1896 for (auto it = devices_.begin(); it != devices_.end(); it++) {
1897 if (it->second->IsPaired() == true) {
1898 it->second->SetPairedStatus(PAIR_NONE);
1899 DeleteLinkKey(it->second);
1900 adapterProperties_.RemovePairedDeviceInfo(it->second->GetAddress());
1901 RawAddress device = RawAddress(it->second->GetAddress());
1902 removeDevices.push_back(device);
1903 if (it->second->IsAclConnected()) {
1904 bool ret =
1905 (BTM_AclDisconnect(it->second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_NO_ERROR);
1906 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", ret);
1907 }
1908 }
1909 }
1910
1911 if (!removeDevices.empty()) {
1912 adapterProperties_.SaveConfigFile();
1913 AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BREDR, removeDevices);
1914 }
1915
1916 return true;
1917 }
1918
GetPairState(const RawAddress & device) const1919 int ClassicAdapter::GetPairState(const RawAddress &device) const
1920 {
1921 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1922 int pairState = PAIR_NONE;
1923 auto it = devices_.find(device.GetAddress());
1924 if (it == devices_.end()) {
1925 return pairState;
1926 } else {
1927 pairState = it->second->GetPairedStatus();
1928 }
1929
1930 HILOGI("state: %{public}d", pairState);
1931 return pairState;
1932 }
1933
SetDevicePairingConfirmation(const RawAddress & device,bool accept) const1934 bool ClassicAdapter::SetDevicePairingConfirmation(const RawAddress &device, bool accept) const
1935 {
1936 HILOGI("accept = %{public}d", accept);
1937
1938 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1939 bool ret = false;
1940 auto it = devices_.find(device.GetAddress());
1941 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_PAIRED) ||
1942 (it->second->GetPairedStatus() == PAIR_NONE)) {
1943 HILOGE("failed, not in pairing state.");
1944 return ret;
1945 }
1946
1947 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1948 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1949
1950 BtAddr btAddr = ConvertToBtAddr(device);
1951 if (it->second->GetPairedStatus() == PAIR_CANCELING || accept == false) {
1952 ret = (GAPIF_UserConfirmRsp(&btAddr, GAP_NOT_ACCEPT) == BT_NO_ERROR);
1953 } else {
1954 ret = (GAPIF_UserConfirmRsp(&btAddr, GAP_ACCEPT) == BT_NO_ERROR);
1955 }
1956 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_UserConfirmRsp", ret);
1957
1958 return ret;
1959 }
1960
SetDevicePasskey(const RawAddress & device,int passkey,bool accept) const1961 bool ClassicAdapter::SetDevicePasskey(const RawAddress &device, int passkey, bool accept) const
1962 {
1963 HILOGI("enter");
1964
1965 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1966 bool ret = false;
1967 auto it = devices_.find(device.GetAddress());
1968 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_NONE) ||
1969 (it->second->GetPairedStatus() == PAIR_PAIRED)) {
1970 HILOGE("failed, not in pairing state.");
1971 return ret;
1972 }
1973
1974 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1975 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1976
1977 BtAddr btAddr = ConvertToBtAddr(device);
1978 if (it->second->GetPairedStatus() == PAIR_CANCELING || accept == false) {
1979 ret = (GAPIF_UserPasskeyRsp(&btAddr, GAP_NOT_ACCEPT, passkey) == BT_NO_ERROR);
1980 } else {
1981 ret = (GAPIF_UserPasskeyRsp(&btAddr, GAP_ACCEPT, passkey) == BT_NO_ERROR);
1982 }
1983 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_UserPasskeyRsp", ret);
1984
1985 return ret;
1986 }
1987
PairRequestReply(const RawAddress & device,bool accept) const1988 bool ClassicAdapter::PairRequestReply(const RawAddress &device, bool accept) const
1989 {
1990 HILOGI("accept = %{public}d", accept);
1991
1992 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1993 auto it = devices_.find(device.GetAddress());
1994 if ((it == devices_.end()) || (it->second->GetPairedStatus() != PAIR_PAIRING)) {
1995 HILOGE("failed, not in pairing state.");
1996 return false;
1997 }
1998
1999 BtAddr btAddr = ConvertToBtAddr(device);
2000 int io = adapterProperties_.GetIoCapability();
2001 bool ret = (GAPIF_IOCapabilityRsp(&btAddr, accept, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_NO_ERROR);
2002 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_IOCapabilityRsp", ret);
2003
2004 return ret;
2005 }
2006
ConnectionComplete(const BtmAclConnectCompleteParam * param,void * context)2007 void ClassicAdapter::ConnectionComplete(const BtmAclConnectCompleteParam *param, void *context)
2008 {
2009 HILOGI("status: %{public}u", param->status);
2010
2011 auto adapter = static_cast<ClassicAdapter *>(context);
2012 RawAddress device = RawAddress::ConvertToString(param->addr->addr);
2013 uint32_t classOfDevice = 0;
2014 (void)memcpy_s(&classOfDevice, COD_SIZE, param->classOfDevice, COD_SIZE);
2015 if (adapter != nullptr) {
2016 adapter->GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ReceiveConnectionComplete,
2017 adapter,
2018 param->status,
2019 param->connectionHandle,
2020 device,
2021 classOfDevice,
2022 param->encyptionEnabled));
2023 }
2024 }
2025
ReceiveConnectionComplete(uint8_t status,uint16_t connectionHandle,const RawAddress & device,uint32_t classOfDevice,bool encyptionEnabled)2026 void ClassicAdapter::ReceiveConnectionComplete(uint8_t status, uint16_t connectionHandle, const RawAddress &device,
2027 uint32_t classOfDevice, bool encyptionEnabled)
2028 {
2029 if (status == BTM_ACL_CONNECT_PAGE_TIMEOUT) {
2030 HILOGE("ACL Connection failed. Reason: ACL Page Timeout!");
2031 } else if (status == BTM_ACL_CONNECTION_TIMEOUT) {
2032 HILOGE("ACL Connection failed. Reason: ACL Supervision Timeout!");
2033 } else {
2034 HILOGI("ACL Connection result: %{public}u", status);
2035 }
2036
2037 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2038 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2039
2040 /// For compatibility
2041 /// Passive pairing failed and pair mode is PinCode.
2042 if (status != SUCCESS) {
2043 bool bondFromLocal = remoteDevice->IsBondedFromLocal();
2044 HILOGI("pinMode = %{public}d, bondFromLocal = %{public}d", pinMode_, bondFromLocal);
2045 if (pinMode_ == true && bondFromLocal == false) {
2046 pinMode_ = false;
2047 /// Passive pairing failed, delete the link key.
2048 DeleteLinkKey(remoteDevice);
2049 /// Set the pair flag and pair state.
2050 remoteDevice->SetPairedStatus(PAIR_NONE);
2051 /// Send the failed notification to APP.
2052 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
2053 }
2054 return;
2055 }
2056
2057 int connectState = CONNECTION_STATE_CONNECTED;
2058 if (encyptionEnabled == true) {
2059 connectState = CONNECTION_STATE_ENCRYPTED_BREDR;
2060 }
2061 remoteDevice->SetAclConnectState(connectState);
2062 remoteDevice->SetConnectionHandle(connectionHandle);
2063
2064 int cod = (classOfDevice & CLASS_OF_DEVICE_RANGE);
2065 if (cod != INVALID_VALUE) {
2066 remoteDevice->SetDeviceClass(cod);
2067 }
2068 }
2069
ReceiveDisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason)2070 void ClassicAdapter::ReceiveDisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason)
2071 {
2072 HILOGI("status: %{public}u", status);
2073
2074 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2075 if (status != SUCCESS) {
2076 HILOGW("failed");
2077 return;
2078 }
2079
2080 for (auto &device : devices_) {
2081 if (connectionHandle != device.second->GetConnectionHandle()) {
2082 continue;
2083 }
2084 device.second->SetAclConnectState(CONNECTION_STATE_DISCONNECTED);
2085
2086 HILOGI("pinMode = %{public}d", pinMode_);
2087 /// Passive pairing failed and pair mode is PinCode.
2088 /// For 960 compatibility
2089 /// When ACL disconnect and current pari state is in PAIR_PAIRING or PAIR_CANCELING, set pair state to
2090 /// PAIR_NONE.
2091 if ((pinMode_) || (device.second->GetPairedStatus() == PAIR_PAIRING) ||
2092 (device.second->GetPairedStatus() == PAIR_CANCELING)) {
2093 pinMode_ = false;
2094 /// Passive pairing failed, delete the link key.
2095 DeleteLinkKey(device.second);
2096 /// Set the pair flag and pair state.
2097 device.second->SetPairedStatus(PAIR_NONE);
2098 /// Send the failed notification to APP.
2099 bool bondFromLocal = device.second->IsBondedFromLocal();
2100 HILOGI("bondFromLocal = %{public}d", bondFromLocal);
2101 if (!bondFromLocal) {
2102 RawAddress address(device.second->GetAddress());
2103 SendPairStatusChanged(ADAPTER_BREDR, address, PAIR_NONE);
2104 }
2105 }
2106 break;
2107 }
2108 }
2109
DisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason,void * context)2110 void ClassicAdapter::DisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason, void *context)
2111 {
2112 HILOGI("status: %{public}u", status);
2113
2114 auto adapter = static_cast<ClassicAdapter *>(context);
2115 if (adapter != nullptr) {
2116 adapter->GetDispatcher()->PostTask(
2117 std::bind(&ClassicAdapter::ReceiveDisconnectionComplete, adapter, status, connectionHandle, reason));
2118 }
2119 }
2120
RegisterClassicAdapterObserver(IAdapterClassicObserver & observer) const2121 bool ClassicAdapter::RegisterClassicAdapterObserver(IAdapterClassicObserver &observer) const
2122 {
2123 HILOGI("enter");
2124
2125 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2126 adapterProperties_.RegisterClassicAdapterObserver(observer);
2127 return pimpl->adapterObservers_.Register(observer);
2128 }
2129
DeregisterClassicAdapterObserver(IAdapterClassicObserver & observer) const2130 bool ClassicAdapter::DeregisterClassicAdapterObserver(IAdapterClassicObserver &observer) const
2131 {
2132 HILOGI("enter");
2133
2134 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2135 adapterProperties_.DeregisterClassicAdapterObserver(observer);
2136 return pimpl->adapterObservers_.Deregister(observer);
2137 }
2138
SetLinkKey(const BtAddr & addr)2139 void ClassicAdapter::SetLinkKey(const BtAddr &addr)
2140 {
2141 HILOGI("enter");
2142
2143 RawAddress device = RawAddress::ConvertToString(addr.addr);
2144 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2145
2146 int keyType = remoteDevice->GetLinkKeyType();
2147 uint8_t key[PAIR_LINK_KEY_SIZE];
2148 (void)memset_s(key, PAIR_LINK_KEY_SIZE, 0x00, PAIR_LINK_KEY_SIZE);
2149 uint8_t accept = GAP_NOT_ACCEPT;
2150 if (keyType != PAIR_INVALID_LINK_KEY_TYPE) {
2151 std::vector<uint8_t> linkKey = remoteDevice->GetLinkKey();
2152 if (memcpy_s(key, linkKey.size(), &linkKey[0], linkKey.size()) != EOK) {
2153 HILOGI("memcpy_s fail");
2154 return;
2155 }
2156 accept = GAP_ACCEPT;
2157 }
2158
2159 bool ret = (GAPIF_LinkKeyRsp(&addr, accept, key, keyType) == BT_NO_ERROR);
2160 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_LinkKeyRsp", ret);
2161 (void)memset_s(key, PAIR_LINK_KEY_SIZE, 0x00, PAIR_LINK_KEY_SIZE);
2162 }
2163
SendPairRequested(const BTTransport transport,const RawAddress & device) const2164 void ClassicAdapter::SendPairRequested(const BTTransport transport, const RawAddress &device) const
2165 {
2166 HILOGI("enter");
2167 pimpl->adapterObservers_.ForEach(
2168 [transport, device](IAdapterClassicObserver &observer) { observer.OnPairRequested(transport, device); });
2169 }
2170
SetIoCapability(const BtAddr & addr)2171 void ClassicAdapter::SetIoCapability(const BtAddr &addr)
2172 {
2173 HILOGI("enter");
2174
2175 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2176 RawAddress rawAddr = RawAddress::ConvertToString(addr.addr);
2177 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(rawAddr);
2178 if (remoteDevice->GetRemoteName().empty()) {
2179 GetRemoteName(addr);
2180 }
2181
2182 bool bondFromLocal = false;
2183 bool ret = (GAPIF_PairIsFromLocal(&addr, &bondFromLocal) == BT_NO_ERROR);
2184 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_PairIsFromLocal", ret);
2185 remoteDevice->SetBondedFromLocal(bondFromLocal);
2186
2187 if ((remoteDevice->GetPairedStatus() != PAIR_PAIRING) && (remoteDevice->GetPairedStatus() != PAIR_CANCELING)) {
2188 remoteDevice->SetPairedStatus(PAIR_PAIRING);
2189 }
2190
2191 if (bondFromLocal == false) {
2192 SendPairRequested(ADAPTER_BREDR, rawAddr);
2193 } else {
2194 int io = adapterProperties_.GetIoCapability();
2195 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
2196 ret = (GAPIF_IOCapabilityRsp(&addr, false, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_NO_ERROR);
2197 } else {
2198 ret = (GAPIF_IOCapabilityRsp(&addr, true, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_NO_ERROR);
2199 }
2200 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_IOCapabilityRsp", ret);
2201 }
2202 }
2203
SaveRemoteIoCapability(const BtAddr & addr,uint8_t ioCapability)2204 void ClassicAdapter::SaveRemoteIoCapability(const BtAddr &addr, uint8_t ioCapability)
2205 {
2206 HILOGI("enter");
2207 RawAddress device = RawAddress::ConvertToString(addr.addr);
2208 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2209 remoteDevice->SetIoCapability(ioCapability);
2210 }
2211
SetDevicePin(const RawAddress & device,const std::string & pinCode) const2212 bool ClassicAdapter::SetDevicePin(const RawAddress &device, const std::string &pinCode) const
2213 {
2214 HILOGI("enter");
2215
2216 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2217 auto it = devices_.find(device.GetAddress());
2218 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_NONE) ||
2219 (it->second->GetPairedStatus() == PAIR_PAIRED)) {
2220 HILOGE("failed, not in pairing state.");
2221 return false;
2222 }
2223
2224 std::vector<uint8_t> pin(pinCode.begin(), pinCode.end());
2225 if (pin.empty()) {
2226 HILOGW("length is 0, reject it.");
2227 return SetPinCode(device, pin, GAP_NOT_ACCEPT);
2228 }
2229
2230 uint8_t accept = GAP_ACCEPT;
2231 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
2232 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
2233 if (it->second->GetPairedStatus() == PAIR_CANCELING) {
2234 accept = GAP_NOT_ACCEPT;
2235 }
2236
2237 return SetPinCode(device, pin, accept);
2238 }
2239
SetPinCode(const RawAddress & device,const std::vector<uint8_t> & pin,bool accept) const2240 bool ClassicAdapter::SetPinCode(const RawAddress &device, const std::vector<uint8_t> &pin, bool accept) const
2241 {
2242 HILOGI("accept: %{public}d", accept);
2243
2244 BtAddr btAddr;
2245 device.ConvertToUint8(btAddr.addr);
2246 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
2247 int result = GAPIF_PinCodeRsp(&btAddr, accept, pin.data(), pin.size());
2248 if (result != BT_NO_ERROR) {
2249 HILOGE("GAPIF_PinCodeRsp failed!");
2250 return false;
2251 }
2252 return true;
2253 }
2254
SetAuthorizeRes(const BtAddr & addr,GAP_Service service) const2255 void ClassicAdapter::SetAuthorizeRes(const BtAddr &addr, GAP_Service service) const
2256 {
2257 HILOGI("enter");
2258 int result = GAPIF_AuthorizeRes(&addr, service, true);
2259 if (result != BT_NO_ERROR) {
2260 HILOGE("GAPIF_AuthorizeRes failed!");
2261 }
2262 }
2263
GetDeviceType(const RawAddress & device) const2264 int ClassicAdapter::ClassicAdapter::GetDeviceType(const RawAddress &device) const
2265 {
2266 HILOGI("enter");
2267
2268 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2269 int type = INVALID_VALUE;
2270 auto it = devices_.find(device.GetAddress());
2271 if (it != devices_.end()) {
2272 type = it->second->GetDeviceType();
2273 }
2274
2275 return type;
2276 }
2277
GetDeviceClass(const RawAddress & device) const2278 int ClassicAdapter::GetDeviceClass(const RawAddress &device) const
2279 {
2280 HILOGI("enter");
2281
2282 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2283 int cod = INVALID_VALUE;
2284 auto it = devices_.find(device.GetAddress());
2285 if (it != devices_.end()) {
2286 cod = it->second->GetDeviceClass();
2287 }
2288
2289 return cod;
2290 }
2291
GetAliasName(const RawAddress & device) const2292 std::string ClassicAdapter::GetAliasName(const RawAddress &device) const
2293 {
2294 HILOGI("enter");
2295
2296 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2297 std::string alias = INVALID_NAME;
2298 auto it = devices_.find(device.GetAddress());
2299 if (it != devices_.end()) {
2300 alias = it->second->GetAliasName();
2301 }
2302
2303 return alias;
2304 }
2305
SetAliasName(const RawAddress & device,const std::string & name) const2306 bool ClassicAdapter::SetAliasName(const RawAddress &device, const std::string &name) const
2307 {
2308 HILOGI("enter");
2309
2310 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2311 bool ret = false;
2312 auto it = devices_.find(device.GetAddress());
2313 if (it != devices_.end()) {
2314 if (name != it->second->GetAliasName()) {
2315 ret = it->second->SetAliasName(name);
2316 if (ret == false) {
2317 HILOGE("failed");
2318 } else {
2319 SendRemoteAliasChanged(device, name);
2320 }
2321 }
2322 }
2323 return ret;
2324 }
2325
SendRemoteAliasChanged(const RawAddress & device,const std::string & aliasName) const2326 void ClassicAdapter::SendRemoteAliasChanged(const RawAddress &device, const std::string &aliasName) const
2327 {
2328 HILOGI("enter");
2329
2330 pimpl->remoteObservers_.ForEach([device, aliasName](IClassicRemoteDeviceObserver &observer) {
2331 observer.OnRemoteAliasChanged(device, aliasName);
2332 });
2333 }
2334
RegisterRemoteDeviceObserver(IClassicRemoteDeviceObserver & observer) const2335 bool ClassicAdapter::RegisterRemoteDeviceObserver(IClassicRemoteDeviceObserver &observer) const
2336 {
2337 HILOGI("enter");
2338 return pimpl->remoteObservers_.Register(observer);
2339 }
2340
DeregisterRemoteDeviceObserver(IClassicRemoteDeviceObserver & observer) const2341 bool ClassicAdapter::DeregisterRemoteDeviceObserver(IClassicRemoteDeviceObserver &observer) const
2342 {
2343 HILOGI("enter");
2344 return pimpl->remoteObservers_.Deregister(observer);
2345 }
2346
CheckAutoReply(int remoteIo) const2347 bool ClassicAdapter::CheckAutoReply(int remoteIo) const
2348 {
2349 HILOGI("enter");
2350
2351 bool autoReply = false;
2352 int localIo = adapterProperties_.GetIoCapability();
2353 HILOGI("local io capability = %{public}d <==> remote io capability = %{public}d", localIo, remoteIo);
2354 switch (localIo) {
2355 case GAP_IO_DISPLAYONLY:
2356 autoReply = (remoteIo != GAP_IO_KEYBOARDONLY) ? true : false;
2357 break;
2358 case GAP_IO_KEYBOARDONLY:
2359 autoReply = (remoteIo == GAP_IO_NOINPUTNOOUTPUT) ? true : false;
2360 break;
2361 case GAP_IO_NOINPUTNOOUTPUT:
2362 autoReply = true;
2363 break;
2364 default:
2365 break;
2366 }
2367 return autoReply;
2368 }
2369
CheckSspConfirmType(int remoteIo,int type) const2370 int ClassicAdapter::CheckSspConfirmType(int remoteIo, int type) const
2371 {
2372 HILOGI("enter");
2373
2374 int confirmType = PAIR_CONFIRM_TYPE_CONSENT;
2375 int localIo = adapterProperties_.GetIoCapability();
2376 HILOGI("local io capability = %{public}d <==> remote io capability = %{public}d, type = %{public}d",
2377 localIo, remoteIo, type);
2378 if (type == PAIR_CONFIRM_TYPE_NUMERIC) {
2379 if ((localIo == GAP_IO_DISPLAYYESNO) && (remoteIo == GAP_IO_DISPLAYYESNO)) {
2380 confirmType = PAIR_CONFIRM_TYPE_NUMERIC;
2381 }
2382 } else {
2383 confirmType = type;
2384 }
2385 return confirmType;
2386 }
2387
GetDeviceBatteryLevel(const RawAddress & device) const2388 int ClassicAdapter::GetDeviceBatteryLevel(const RawAddress &device) const
2389 {
2390 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2391 int batteryLevel = 0;
2392 auto it = devices_.find(device.GetAddress());
2393 if (it != devices_.end()) {
2394 batteryLevel = it->second->GetBatteryLevel();
2395 }
2396 HILOGI("batteryLevel: %{public}d", batteryLevel);
2397 return batteryLevel;
2398 }
2399
SetDeviceBatteryLevel(const RawAddress & device,int batteryLevel) const2400 void ClassicAdapter::SetDeviceBatteryLevel(const RawAddress &device, int batteryLevel) const
2401 {
2402 HILOGI("addr: %{public}s, batteryLevel: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), batteryLevel);
2403
2404 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2405 auto it = devices_.find(device.GetAddress());
2406 if (it != devices_.end()) {
2407 it->second->SetBatteryLevel(batteryLevel);
2408 }
2409
2410 SendRemoteBatteryLevelChanged(device, batteryLevel);
2411 }
2412
SendRemoteBatteryLevelChanged(const RawAddress & device,int batteryLevel) const2413 void ClassicAdapter::SendRemoteBatteryLevelChanged(const RawAddress &device, int batteryLevel) const
2414 {
2415 HILOGI("addr: %{public}s, batteryLevel: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), batteryLevel);
2416
2417 pimpl->remoteObservers_.ForEach([device, batteryLevel](IClassicRemoteDeviceObserver &observer) {
2418 observer.OnRemoteBatteryLevelChanged(device, batteryLevel);
2419 });
2420 }
2421
2422 REGISTER_CLASS_CREATOR(ClassicAdapter);
2423 } // namespace bluetooth
2424 } // namespace OHOS