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);
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) const1150 void ClassicAdapter::SendDiscoveryResult(const RawAddress &device) const
1151 {
1152 HILOGI("address: %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
1153
1154 pimpl->adapterObservers_.ForEach(
1155 [device](IAdapterClassicObserver &observer) { observer.OnDiscoveryResult(device); });
1156 }
1157
SendRemoteCodChanged(const RawAddress & device,int cod) const1158 void ClassicAdapter::SendRemoteCodChanged(const RawAddress &device, int cod) const
1159 {
1160 HILOGI("address: %{public}s, cod: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), cod);
1161
1162 pimpl->remoteObservers_.ForEach(
1163 [device, cod](IClassicRemoteDeviceObserver &observer) { observer.OnRemoteCodChanged(device, cod); });
1164 }
1165
SSPConfirmReq(const BtAddr & addr,int reqType,int number,int localMitmRequired,int remoteMitmRequired)1166 void ClassicAdapter::SSPConfirmReq(const BtAddr &addr, int reqType, int number,
1167 int localMitmRequired, int remoteMitmRequired)
1168 {
1169 HILOGI("reqTyep: %{public}d", reqType);
1170
1171 RawAddress device = RawAddress::ConvertToString(addr.addr);
1172 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1173 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM);
1174 remoteDevice->SetPairConfirmType(reqType);
1175 int remoteIo = remoteDevice->GetIoCapability();
1176 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
1177 UserConfirmAutoReply(device, reqType, false);
1178 } else if (CheckAutoReply(remoteIo, localMitmRequired, remoteMitmRequired) == true) {
1179 UserConfirmAutoReply(device, reqType, true);
1180 } else {
1181 reqType = CheckSspConfirmType(remoteIo, reqType);
1182 SendPairConfirmed(device, reqType, number);
1183 }
1184 }
1185
PinCodeReq(const BtAddr & addr)1186 void ClassicAdapter::PinCodeReq(const BtAddr &addr)
1187 {
1188 HILOGI("enter");
1189
1190 RawAddress device = RawAddress::ConvertToString(addr.addr);
1191 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1192 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM);
1193 remoteDevice->SetPairConfirmType(PAIR_CONFIRM_TYPE_PIN_CODE);
1194 pinMode_ = true;
1195 if (remoteDevice->GetRemoteName().empty()) {
1196 GetRemoteName(addr);
1197 }
1198
1199 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
1200 UserConfirmAutoReply(device, PAIR_CONFIRM_TYPE_PIN_CODE, false);
1201 return;
1202 }
1203
1204 if ((remoteDevice->GetPairedStatus() != PAIR_PAIRING) && (remoteDevice->GetPairedStatus() != PAIR_CANCELING)) {
1205 remoteDevice->SetPairedStatus(PAIR_PAIRING);
1206 }
1207
1208 bool bondFromLocal = false;
1209 bool ret = (GAPIF_PairIsFromLocal(&addr, &bondFromLocal) == BT_SUCCESS);
1210 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_PairIsFromLocal", ret);
1211 remoteDevice->SetBondedFromLocal(bondFromLocal);
1212
1213 SendPairConfirmed(device, PAIR_CONFIRM_TYPE_PIN_CODE, 0);
1214 }
1215
SendPairConfirmed(const RawAddress & device,int reqType,int number) const1216 void ClassicAdapter::SendPairConfirmed(const RawAddress &device, int reqType, int number) const
1217 {
1218 HILOGI("reqType = %{public}d, number = %{public}d", reqType, number);
1219 BTTransport transport = ADAPTER_BREDR;
1220 pimpl->adapterObservers_.ForEach([transport, device, reqType, number](IAdapterClassicObserver &observer) {
1221 observer.OnPairConfirmed(transport, device, reqType, number);
1222 });
1223 }
1224
UserConfirmAutoReply(const RawAddress & device,int reqType,bool accept) const1225 void ClassicAdapter::UserConfirmAutoReply(const RawAddress &device, int reqType, bool accept) const
1226 {
1227 HILOGI("address: %{public}s, accept: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), accept);
1228
1229 auto it = devices_.find(device.GetAddress());
1230 if (it != devices_.end()) {
1231 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1232 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1233 }
1234
1235 switch (reqType) {
1236 case PAIR_CONFIRM_TYPE_PIN_CODE: {
1237 std::string passkey = adapterProperties_.GetPasskey();
1238 HILOGI("PAIR_CONFIRM_TYPE_PIN_CODE, value = %{public}s", passkey.c_str());
1239 std::vector<uint8_t> pinCode(passkey.begin(), passkey.end());
1240 SetPinCode(device, pinCode, accept);
1241 break;
1242 }
1243 case PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY: {
1244 HILOGI("PAIR_CONFIRM_TYPE_PASSKEY_DISPLAY, do nothing!!");
1245 break;
1246 }
1247 case PAIR_CONFIRM_TYPE_PASSKEY_INPUT: {
1248 HILOGI("PAIR_CONFIRM_TYPE_PASSKEY_INPUT");
1249 int passkey = 0;
1250 SetDevicePasskey(device, passkey, accept);
1251 break;
1252 }
1253 case PAIR_CONFIRM_TYPE_NUMERIC:
1254 case PAIR_CONFIRM_TYPE_CONSENT: {
1255 HILOGI("PAIR_CONFIRM_TYPE_NUMERIC");
1256 SetDevicePairingConfirmation(device, accept);
1257 break;
1258 }
1259 default:
1260 HILOGI("default case. reqType = %{public}d", reqType);
1261 break;
1262 }
1263 }
1264
ParserEirData(std::shared_ptr<ClassicRemoteDevice> remote,const std::vector<uint8_t> & data) const1265 void ClassicAdapter::ParserEirData(std::shared_ptr<ClassicRemoteDevice> remote, const std::vector<uint8_t> &data) const
1266 {
1267 std::vector<ClassicDataStructure> dataList = eirData_.ParserData(data);
1268 std::vector<Uuid> uuids;
1269 bool isGetRemoteName = false;
1270
1271 for (auto &dataStruc : dataList) {
1272 int type = dataStruc.GetType();
1273 std::vector<uint8_t> valueVec = dataStruc.GetDataValue();
1274 switch (type) {
1275 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME:
1276 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME:
1277 isGetRemoteName = ParserRemoteNameFromEir(remote, type, valueVec);
1278 break;
1279 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1280 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1281 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1282 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1283 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
1284 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: {
1285 std::vector<Uuid> parsedUuids = ParserUuidFromEir(type, valueVec);
1286 if (!parsedUuids.empty()) {
1287 uuids.insert(uuids.end(), parsedUuids.begin(), parsedUuids.end());
1288 }
1289 break;
1290 }
1291 /// Flags, TxPower, ManufacturerData, Uri are not support for current framework api.
1292 /// This is used for extending.
1293 case BLUETOOTH_DATA_TYPE_FLAGS:
1294 remote->SetFlags(valueVec[0]);
1295 break;
1296 case BLUETOOTH_DATA_TYPE_TX_POWER_LEVEL:
1297 remote->SetTxPower(valueVec[0]);
1298 break;
1299 case BLUETOOTH_DATA_TYPE_MANUFACTURER_SPECIFIC_DATA:
1300 remote->SetManufacturerSpecificData(valueVec);
1301 break;
1302 case BLUETOOTH_DATA_TYPE_URI: {
1303 std::string uri(valueVec.begin(), valueVec.end());
1304 remote->SetURI(uri);
1305 break;
1306 }
1307 default:
1308 break;
1309 }
1310 }
1311
1312 if (!isGetRemoteName) {
1313 remote->SetNameNeedGet(true);
1314 }
1315
1316 if (!uuids.empty()) {
1317 SaveRemoteDeviceUuids(remote, uuids);
1318 uuids.clear();
1319 }
1320 }
1321
ParserRemoteNameFromEir(std::shared_ptr<ClassicRemoteDevice> remote,int type,const std::vector<uint8_t> & value) const1322 bool ClassicAdapter::ParserRemoteNameFromEir(
1323 std::shared_ptr<ClassicRemoteDevice> remote, int type, const std::vector<uint8_t> &value) const
1324 {
1325 HILOGI("type %{public}d", type);
1326
1327 if (value.empty()) {
1328 return false;
1329 }
1330
1331 if (type == BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME) {
1332 remote->SetNameNeedGet(true);
1333 } else {
1334 remote->SetNameNeedGet(false);
1335 }
1336
1337 std::string remoteName(value.begin(), value.end());
1338 HILOGI("remoteName is %{public}s", remoteName.c_str());
1339 if (remoteName != remote->GetRemoteName()) {
1340 remote->SetRemoteName(remoteName);
1341 SendRemoteNameChanged(RawAddress(remote->GetAddress()), remoteName);
1342 }
1343
1344 return true;
1345 }
1346
ParserUuidFromEir(int type,const std::vector<uint8_t> & value) const1347 std::vector<Uuid> ClassicAdapter::ParserUuidFromEir(int type, const std::vector<uint8_t> &value) const
1348 {
1349 HILOGI("enter");
1350
1351 std::vector<Uuid> uuids;
1352 if (value.empty()) {
1353 HILOGI("ParserUuidFromEir invalid parameter.");
1354 return uuids;
1355 }
1356
1357 switch (type) {
1358 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
1359 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS: {
1360 uuids = Parser16BitUuidFromEir(value);
1361 break;
1362 }
1363 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
1364 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS: {
1365 uuids = Parser32BitUuidFromEir(value);
1366 break;
1367 }
1368 case BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
1369 case BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: {
1370 uuids = Parser128BitUuidFromEir(value);
1371 break;
1372 }
1373 default:
1374 break;
1375 }
1376
1377 return uuids;
1378 }
1379
Parser16BitUuidFromEir(const std::vector<uint8_t> & value) const1380 std::vector<Uuid> ClassicAdapter::Parser16BitUuidFromEir(const std::vector<uint8_t> &value) const
1381 {
1382 HILOGI("enter");
1383
1384 std::vector<Uuid> uuids;
1385 uint8_t offset = 0;
1386 while ((value.size() - offset) > 1) {
1387 uint8_t unitLen = sizeof(uint16_t);
1388 if (unitLen <= (value.size() - offset)) {
1389 uint16_t uuid16 = 0;
1390 (void)memcpy_s(&uuid16, unitLen, &value[offset], unitLen);
1391 Uuid uuid = Uuid::ConvertFrom16Bits(uuid16);
1392 if (uuid16 != 0) {
1393 uuids.push_back(uuid);
1394 HILOGI("remote 16bit UUID");
1395 }
1396 offset += unitLen;
1397 } else {
1398 break;
1399 }
1400 }
1401
1402 return uuids;
1403 }
1404
Parser32BitUuidFromEir(const std::vector<uint8_t> & value) const1405 std::vector<Uuid> ClassicAdapter::Parser32BitUuidFromEir(const std::vector<uint8_t> &value) const
1406 {
1407 HILOGI("enter");
1408
1409 std::vector<Uuid> uuids;
1410 int offset = 0;
1411 while ((value.size() - offset) > 1) {
1412 uint8_t unitLen = sizeof(uint32_t);
1413 if (unitLen <= (value.size() - offset)) {
1414 uint32_t uuid32 = 0;
1415 (void)memcpy_s(&uuid32, unitLen, &value[offset], unitLen);
1416 Uuid uuid = Uuid::ConvertFrom32Bits(uuid32);
1417 if (uuid32 != 0) {
1418 uuids.push_back(uuid);
1419 HILOGI("remote 32bit UUID");
1420 }
1421 offset += unitLen;
1422 } else {
1423 break;
1424 }
1425 }
1426
1427 return uuids;
1428 }
1429
Parser128BitUuidFromEir(const std::vector<uint8_t> & value) const1430 std::vector<Uuid> ClassicAdapter::Parser128BitUuidFromEir(const std::vector<uint8_t> &value) const
1431 {
1432 HILOGI("enter");
1433
1434 std::vector<Uuid> uuids;
1435 int offset = 0;
1436 while ((value.size() - offset) > 1) {
1437 if (UUID128_BYTES_TYPE <= (value.size() - offset)) {
1438 Uuid uuid = Uuid::ConvertFromBytesLE(&value[offset]);
1439 bluetooth::Uuid::UUID128Bit uuidCheck = {0};
1440 if (uuid.ConvertTo128Bits() != uuidCheck) {
1441 uuids.push_back(uuid);
1442 HILOGI("remote 128bit UUID");
1443 }
1444 offset += UUID128_BYTES_TYPE;
1445 } else {
1446 break;
1447 }
1448 }
1449
1450 return uuids;
1451 }
1452
SaveRemoteDeviceUuids(std::shared_ptr<ClassicRemoteDevice> remote,const std::vector<Uuid> & uuids) const1453 void ClassicAdapter::SaveRemoteDeviceUuids(
1454 std::shared_ptr<ClassicRemoteDevice> remote, const std::vector<Uuid> &uuids) const
1455 {
1456 HILOGI("enter");
1457
1458 if ((remote == nullptr) || (uuids.empty())) {
1459 return;
1460 }
1461
1462 std::vector<Uuid> prevUuids = remote->GetDeviceUuids();
1463 if (!IsUuidsEqual(uuids, prevUuids)) {
1464 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1465 remote->SetDeviceUuids(uuids);
1466 SendRemoteUuidChanged(RawAddress(remote->GetAddress()), uuids);
1467 }
1468 }
1469
IsUuidsEqual(const std::vector<Uuid> & uuids1,const std::vector<Uuid> & uuids2) const1470 bool ClassicAdapter::IsUuidsEqual(const std::vector<Uuid> &uuids1, const std::vector<Uuid> &uuids2) const
1471 {
1472 HILOGI("enter");
1473 if (uuids1.size() != uuids2.size()) {
1474 return false;
1475 }
1476
1477 for (auto uuid : uuids1) {
1478 auto it = std::find(uuids2.begin(), uuids2.end(), uuid);
1479 if (it == uuids2.end()) {
1480 return false;
1481 }
1482 }
1483
1484 for (auto uuid : uuids2) {
1485 auto it = std::find(uuids1.begin(), uuids1.end(), uuid);
1486 if (it == uuids1.end()) {
1487 return false;
1488 }
1489 }
1490
1491 return true;
1492 }
1493
SendRemoteNameChanged(const RawAddress & device,const std::string & deviceName) const1494 void ClassicAdapter::SendRemoteNameChanged(const RawAddress &device, const std::string &deviceName) const
1495 {
1496 HILOGI("enter");
1497 pimpl->remoteObservers_.ForEach([device, deviceName](IClassicRemoteDeviceObserver &observer) {
1498 observer.OnRemoteNameChanged(device, deviceName);
1499 });
1500 }
1501
SendPairStatusChanged(const BTTransport transport,const RawAddress & device,int status) const1502 void ClassicAdapter::SendPairStatusChanged(const BTTransport transport, const RawAddress &device, int status) const
1503 {
1504 HILOGI("status: %{public}d", status);
1505 pimpl->remoteObservers_.ForEach([transport, device, status](IClassicRemoteDeviceObserver &observer) {
1506 observer.OnPairStatusChanged(transport, device, status);
1507 });
1508 }
1509
ReceiveLinkKeyNotification(const BtAddr & addr,const uint8_t linkKey[GAP_LINKKEY_SIZE],uint8_t keyType)1510 void ClassicAdapter::ReceiveLinkKeyNotification(
1511 const BtAddr &addr, const uint8_t linkKey[GAP_LINKKEY_SIZE], uint8_t keyType)
1512 {
1513 HILOGI("enter");
1514
1515 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1516 /// Pairing success, save link key and sent notification to APP.
1517 if (pinMode_ == true) {
1518 pinMode_ = false;
1519 }
1520
1521 RawAddress device = RawAddress::ConvertToString(addr.addr);
1522 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1523 if (remoteDevice->GetRemoteName().empty()) {
1524 GetRemoteName(addr);
1525 }
1526 SearchRemoteUuids(device, PNP_SERVICE_CLASS_UUID);
1527
1528 /// Bondable mode is on, then save the linkKey and keyType
1529 if (adapterProperties_.GetBondableMode() == BONDABLE_MODE_ON) {
1530 std::vector<uint8_t> linkKeyVec(linkKey, (linkKey + GAP_LINKKEY_SIZE));
1531 remoteDevice->SetLinkKey(linkKeyVec);
1532 remoteDevice->SetLinkKeyType(keyType);
1533 remoteDevice->SetPairedStatus(PAIR_PAIRED);
1534 if (remoteDevice != nullptr) {
1535 adapterProperties_.SavePairedDeviceInfo(remoteDevice);
1536 adapterProperties_.SaveConfigFile();
1537 }
1538 } else {
1539 remoteDevice->SetPairedStatus(PAIR_NONE);
1540 HILOGW("Bondmode is off, so not save the link key");
1541 }
1542 }
1543
ReceiveSimplePairComplete(const BtAddr & addr,uint8_t status)1544 void ClassicAdapter::ReceiveSimplePairComplete(const BtAddr &addr, uint8_t status)
1545 {
1546 HILOGI("status: %{public}u", status);
1547
1548 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1549 if (status != SUCCESS) {
1550 RawAddress device = RawAddress::ConvertToString(addr.addr);
1551 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1552 bool bondFromLocal = remoteDevice->IsBondedFromLocal();
1553 /// Passive pairing failed, delete the link key.
1554 if (bondFromLocal == false) {
1555 DeleteLinkKey(remoteDevice);
1556 /// Set the pair flag and pair state.
1557 remoteDevice->SetPairedStatus(PAIR_NONE);
1558 /// Send the failed notification to APP.
1559 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
1560 }
1561 }
1562 }
1563
DeleteLinkKey(std::shared_ptr<ClassicRemoteDevice> remoteDevice) const1564 void ClassicAdapter::DeleteLinkKey(std::shared_ptr<ClassicRemoteDevice> remoteDevice) const
1565 {
1566 int keyType = remoteDevice->GetLinkKeyType();
1567 if (keyType != PAIR_INVALID_LINK_KEY_TYPE) {
1568 remoteDevice->DeleteLinkKey();
1569 remoteDevice->SetLinkKeyType(PAIR_INVALID_LINK_KEY_TYPE);
1570 }
1571 }
1572
ReceiveAuthenticationComplete(const BtAddr & addr,uint8_t status)1573 void ClassicAdapter::ReceiveAuthenticationComplete(const BtAddr &addr, uint8_t status)
1574 {
1575 HILOGI("status: %{public}u", status);
1576
1577 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1578 RawAddress device = RawAddress::ConvertToString(addr.addr);
1579 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1580 remoteDevice->SetPairConfirmState(PAIR_CONFIRM_STATE_INVALID);
1581 remoteDevice->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1582
1583 if (status != SUCCESS) {
1584 /// Active pairing failed, delete the link key.
1585 DeleteLinkKey(remoteDevice);
1586 /// Set the pair flag and pair state.
1587 remoteDevice->SetPairedStatus(PAIR_NONE);
1588 /// Send the failed notification to APP.
1589 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
1590 } else {
1591 if (remoteDevice->GetPairedStatus() == PAIR_PAIRING) {
1592 remoteDevice->SetPairedStatus(PAIR_PAIRED);
1593 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRED);
1594 }
1595 }
1596
1597 if (waitPairResult_) {
1598 waitPairResult_ = false;
1599 InitMode();
1600 }
1601 }
1602
ReceiveEncryptionChange(const BtAddr & addr,uint8_t status)1603 void ClassicAdapter::ReceiveEncryptionChange(const BtAddr &addr, uint8_t status)
1604 {
1605 HILOGI("status: %{public}u", status);
1606
1607 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1608 RawAddress device = RawAddress::ConvertToString(addr.addr);
1609 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1610 if (status == GAP_ENCRYPTION_ON) {
1611 remoteDevice->SetAclConnectState(CONNECTION_STATE_ENCRYPTED_BREDR);
1612 } else {
1613 remoteDevice->SetAclConnectState(CONNECTION_STATE_CONNECTED);
1614 }
1615 }
1616
GetRemoteName(const BtAddr & addr) const1617 bool ClassicAdapter::GetRemoteName(const BtAddr &addr) const
1618 {
1619 HILOGI("enter");
1620
1621 bool ret = (GAPIF_GetRemoteName(&addr) == BT_SUCCESS);
1622 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_GetRemoteName", ret);
1623 if (ret && (hwTimer_ != nullptr)) {
1624 hwTimer_->Start(DEFAULT_HW_TIMEOUT);
1625 }
1626
1627 return ret;
1628 }
1629
GetDeviceName(const RawAddress & device) const1630 std::string ClassicAdapter::GetDeviceName(const RawAddress &device) const
1631 {
1632 HILOGI("enter");
1633
1634 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1635 std::string remoteName = "";
1636 auto it = devices_.find(device.GetAddress());
1637 if (it != devices_.end()) {
1638 remoteName = it->second->GetRemoteName();
1639 }
1640
1641 return remoteName;
1642 }
1643
GetDeviceUuids(const RawAddress & device) const1644 std::vector<Uuid> ClassicAdapter::GetDeviceUuids(const RawAddress &device) const
1645 {
1646 HILOGI("enter");
1647
1648 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1649 std::vector<Uuid> uuids;
1650 auto it = devices_.find(device.GetAddress());
1651 if (it != devices_.end()) {
1652 uuids = it->second->GetDeviceUuids();
1653 }
1654 return uuids;
1655 }
1656
SearchRemoteUuids(const RawAddress & device,uint16_t uuid)1657 void ClassicAdapter::SearchRemoteUuids(const RawAddress &device, uint16_t uuid)
1658 {
1659 BtAddr btAddr = ConvertToBtAddr(device);
1660
1661 BtUuid btUuid[SDP_UUDIID_NUM];
1662 btUuid[0].type = BT_UUID_16;
1663 btUuid[0].uuid16 = uuid;
1664 searchUuid_ = uuid;
1665
1666 SdpUuid uuidArray;
1667 uuidArray.uuid = &btUuid[0];
1668 uuidArray.uuidNum = 1;
1669
1670 SdpAttributeIdList attributeIdList;
1671 attributeIdList.type = SDP_TYPE_RANGE;
1672 attributeIdList.attributeIdRange.start = 0x0000;
1673 attributeIdList.attributeIdRange.end = 0xFFFF;
1674 int ret = SDP_ServiceSearchAttribute(&btAddr, &uuidArray, attributeIdList, (void *)this, ServiceSearchAttributeCb);
1675 if (ret != BT_SUCCESS) {
1676 HILOGE("SDP_ServiceSearchAttribute failed!");
1677 }
1678 }
1679
ServiceSearchAttributeCb(const BtAddr * addr,const SdpService * serviceArray,uint16_t serviceNum,void * context)1680 void ClassicAdapter::ServiceSearchAttributeCb(
1681 const BtAddr *addr, const SdpService *serviceArray, uint16_t serviceNum, void *context)
1682 {
1683 HILOGI("enter");
1684
1685 auto adapter = static_cast<ClassicAdapter *>(context);
1686 for (int index = 0; index < serviceNum; index++) {
1687 for (int num = 0; num < serviceArray[index].classIdNumber; num++) {
1688 Uuid uuid = adapter->GetUuidFromBtUuid(serviceArray[index].classId[num]);
1689 auto it = std::find(adapter->uuids_.begin(), adapter->uuids_.end(), uuid);
1690 if (it == adapter->uuids_.end()) {
1691 adapter->uuids_.push_back(uuid);
1692 }
1693 }
1694 }
1695
1696 RawAddress device = RawAddress::ConvertToString(addr->addr);
1697 if (adapter->searchUuid_ == UUID_PROTOCOL_L2CAP) {
1698 adapter->GetDispatcher()->PostTask(
1699 std::bind(&ClassicAdapter::SearchAttributeEnd, adapter, device, adapter->uuids_));
1700 } else {
1701 adapter->GetDispatcher()->PostTask(
1702 std::bind(&ClassicAdapter::SearchRemoteUuids, adapter, device, UUID_PROTOCOL_L2CAP));
1703 }
1704 }
1705
SearchAttributeEnd(const RawAddress & device,const std::vector<Uuid> & uuids)1706 void ClassicAdapter::SearchAttributeEnd(const RawAddress &device, const std::vector<Uuid> &uuids)
1707 {
1708 if (isDisable_) {
1709 return;
1710 }
1711 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1712 SaveRemoteDeviceUuids(remoteDevice, uuids);
1713 if (remoteDevice != nullptr) {
1714 adapterProperties_.SavePairedDeviceInfo(remoteDevice);
1715 adapterProperties_.SaveConfigFile();
1716 }
1717 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRED);
1718 }
1719
GetUuidFromBtUuid(const BtUuid & inUuid) const1720 Uuid ClassicAdapter::GetUuidFromBtUuid(const BtUuid &inUuid) const
1721 {
1722 Uuid uuid;
1723 if (inUuid.type == BT_UUID_16) {
1724 uuid = Uuid::ConvertFrom16Bits(inUuid.uuid16);
1725 } else if (inUuid.type == BT_UUID_32) {
1726 uuid = Uuid::ConvertFrom32Bits(inUuid.uuid32);
1727 } else {
1728 uuid = Uuid::ConvertFromBytesLE(inUuid.uuid128);
1729 }
1730
1731 return uuid;
1732 }
1733
SendRemoteUuidChanged(const RawAddress & device,const std::vector<Uuid> & uuids) const1734 void ClassicAdapter::SendRemoteUuidChanged(const RawAddress &device, const std::vector<Uuid> &uuids) const
1735 {
1736 pimpl->remoteObservers_.ForEach(
1737 [device, uuids](IClassicRemoteDeviceObserver &observer) { observer.OnRemoteUuidChanged(device, uuids); });
1738 }
1739
IsAclConnected(const RawAddress & device) const1740 bool ClassicAdapter::IsAclConnected(const RawAddress &device) const
1741 {
1742 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1743 bool isAclConnected = false;
1744 auto it = devices_.find(device.GetAddress());
1745 if (it != devices_.end()) {
1746 isAclConnected = it->second->IsAclConnected();
1747 }
1748
1749 HILOGI("isAclConnected: %{public}d", isAclConnected);
1750 return isAclConnected;
1751 }
1752
IsAclEncrypted(const RawAddress & device) const1753 bool ClassicAdapter::IsAclEncrypted(const RawAddress &device) const
1754 {
1755 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1756 bool isAclEncrypted = false;
1757 auto it = devices_.find(device.GetAddress());
1758 if (it != devices_.end()) {
1759 isAclEncrypted = it->second->IsAclEncrypted();
1760 }
1761
1762 HILOGI("isAclEncrypted: %{public}d", isAclEncrypted);
1763 return isAclEncrypted;
1764 }
1765
GetContext()1766 utility::Context *ClassicAdapter::GetContext()
1767 {
1768 return this;
1769 }
1770
IsBondedFromLocal(const RawAddress & device) const1771 bool ClassicAdapter::IsBondedFromLocal(const RawAddress &device) const
1772 {
1773 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1774 bool isBondedFromLocal = false;
1775 auto it = devices_.find(device.GetAddress());
1776 if (it != devices_.end()) {
1777 isBondedFromLocal = it->second->IsBondedFromLocal();
1778 }
1779
1780 HILOGI("isBondedFromLocal: %{public}d", isBondedFromLocal);
1781 return isBondedFromLocal;
1782 }
1783
GetPairedDevices() const1784 std::vector<RawAddress> ClassicAdapter::GetPairedDevices() const
1785 {
1786 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1787 std::vector<RawAddress> pairedList;
1788 if (devices_.empty()) {
1789 HILOGE("GetPairedDevices devices_ is empty!");
1790 return pairedList;
1791 }
1792 for (auto &device : devices_) {
1793 if ((device.second != nullptr) && (device.second->IsPaired() == true)) {
1794 RawAddress rawAddr(device.second->GetAddress());
1795 pairedList.push_back(rawAddr);
1796 }
1797 }
1798
1799 return pairedList;
1800 }
1801
StartPair(const RawAddress & device)1802 bool ClassicAdapter::StartPair(const RawAddress &device)
1803 {
1804 HILOGI("enter");
1805
1806 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
1807 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1808 if (remoteDevice->GetPairedStatus() == PAIR_PAIRING) {
1809 HILOGE("StartPair failed, because of PAIR_NONE or PAIRING!");
1810 return false;
1811 }
1812
1813 if (discoveryState_ == DISCOVERYING) {
1814 bool ret = CancelBtDiscovery();
1815 ClassicUtils::CheckReturnValue("ClassicAdapter", "CancelBtDiscovery", ret);
1816 }
1817
1818 BtAddr btAddr = ConvertToBtAddr(device);
1819 int ret = GAPIF_AuthenticationReq(&btAddr);
1820 if (ret != BT_SUCCESS) {
1821 HILOGE("GAPIF_AuthenticationReq failed!");
1822 return false;
1823 }
1824
1825 DeleteLinkKey(remoteDevice);
1826 remoteDevice->SetPairedStatus(PAIR_PAIRING);
1827 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_PAIRING);
1828
1829 return true;
1830 }
1831
CancelPairing(const RawAddress & device)1832 bool ClassicAdapter::CancelPairing(const RawAddress &device)
1833 {
1834 HILOGI("enter");
1835
1836 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1837 auto it = devices_.find(device.GetAddress());
1838 if (it == devices_.end() || (it->second->GetPairedStatus() != PAIR_PAIRING)) {
1839 HILOGE("failed, because of not in PAIR_PAIRING!");
1840 return false;
1841 }
1842
1843 it->second->SetPairedStatus(PAIR_CANCELING);
1844 int pairConfirmState = it->second->GetPairConfirmState();
1845 if (pairConfirmState == PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY) {
1846 BtAddr btAddr = ConvertToBtAddr(device);
1847 bool ret = (GAPIF_CancelAuthenticationReq(&btAddr) == BT_SUCCESS);
1848 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_CancelAuthenticationReq", ret);
1849 return ret;
1850 }
1851
1852 if (pairConfirmState == PAIR_CONFIRM_STATE_USER_CONFIRM) {
1853 int pairConfirmType = it->second->GetPairConfirmType();
1854 RawAddress address(it->second->GetAddress());
1855 UserConfirmAutoReply(address, pairConfirmType, false);
1856 }
1857 return true;
1858 }
1859
RemovePair(const RawAddress & device)1860 bool ClassicAdapter::RemovePair(const RawAddress &device)
1861 {
1862 HILOGI("address %{public}s", GetEncryptAddr(device.GetAddress()).c_str());
1863
1864 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1865 auto it = devices_.find(device.GetAddress());
1866 if ((it == devices_.end()) || (it->second->IsPaired() == false)) {
1867 HILOGW("RemovePair failed, because of not find the paired device!");
1868 return false;
1869 } else {
1870 it->second->SetPairedStatus(PAIR_NONE);
1871 DeleteLinkKey(it->second);
1872 adapterProperties_.RemovePairedDeviceInfo(it->second->GetAddress());
1873 adapterProperties_.SaveConfigFile();
1874 if (it->second->IsAclConnected()) {
1875 bool ret = (BTM_AclDisconnect(it->second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_SUCCESS);
1876 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", ret);
1877 }
1878 }
1879
1880 std::vector<RawAddress> removeDevices;
1881 removeDevices.push_back(device);
1882 AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BREDR, removeDevices);
1883 SendPairStatusChanged(BTTransport::ADAPTER_BREDR, device, PAIR_NONE);
1884 return true;
1885 }
1886
RemoveAllPairs()1887 bool ClassicAdapter::RemoveAllPairs()
1888 {
1889 HILOGI("enter");
1890 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1891 std::vector<RawAddress> removeDevices;
1892 for (auto it = devices_.begin(); it != devices_.end(); it++) {
1893 if (it->second->IsPaired() == true) {
1894 it->second->SetPairedStatus(PAIR_NONE);
1895 DeleteLinkKey(it->second);
1896 adapterProperties_.RemovePairedDeviceInfo(it->second->GetAddress());
1897 RawAddress device = RawAddress(it->second->GetAddress());
1898 removeDevices.push_back(device);
1899 if (it->second->IsAclConnected()) {
1900 bool ret =
1901 (BTM_AclDisconnect(it->second->GetConnectionHandle(), BTM_ACL_DISCONNECT_REASON) == BT_SUCCESS);
1902 ClassicUtils::CheckReturnValue("ClassicAdapter", "BTM_AclDisconnect", ret);
1903 }
1904 }
1905 }
1906
1907 if (!removeDevices.empty()) {
1908 adapterProperties_.SaveConfigFile();
1909 AdapterManager::GetInstance()->OnPairDevicesRemoved(BTTransport::ADAPTER_BREDR, removeDevices);
1910 }
1911
1912 return true;
1913 }
1914
GetPairState(const RawAddress & device) const1915 int ClassicAdapter::GetPairState(const RawAddress &device) const
1916 {
1917 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1918 int pairState = PAIR_NONE;
1919 auto it = devices_.find(device.GetAddress());
1920 if (it == devices_.end()) {
1921 return pairState;
1922 } else {
1923 pairState = it->second->GetPairedStatus();
1924 }
1925
1926 HILOGI("state: %{public}d", pairState);
1927 return pairState;
1928 }
1929
SetDevicePairingConfirmation(const RawAddress & device,bool accept) const1930 bool ClassicAdapter::SetDevicePairingConfirmation(const RawAddress &device, bool accept) const
1931 {
1932 HILOGI("accept = %{public}d", accept);
1933
1934 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1935 bool ret = false;
1936 auto it = devices_.find(device.GetAddress());
1937 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_PAIRED) ||
1938 (it->second->GetPairedStatus() == PAIR_NONE)) {
1939 HILOGE("failed, not in pairing state.");
1940 return ret;
1941 }
1942
1943 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1944 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1945
1946 BtAddr btAddr = ConvertToBtAddr(device);
1947 if (it->second->GetPairedStatus() == PAIR_CANCELING || accept == false) {
1948 ret = (GAPIF_UserConfirmRsp(&btAddr, GAP_NOT_ACCEPT) == BT_SUCCESS);
1949 } else {
1950 ret = (GAPIF_UserConfirmRsp(&btAddr, GAP_ACCEPT) == BT_SUCCESS);
1951 }
1952 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_UserConfirmRsp", ret);
1953
1954 return ret;
1955 }
1956
SetDevicePasskey(const RawAddress & device,int passkey,bool accept) const1957 bool ClassicAdapter::SetDevicePasskey(const RawAddress &device, int passkey, bool accept) const
1958 {
1959 HILOGI("enter");
1960
1961 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1962 bool ret = false;
1963 auto it = devices_.find(device.GetAddress());
1964 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_NONE) ||
1965 (it->second->GetPairedStatus() == PAIR_PAIRED)) {
1966 HILOGE("failed, not in pairing state.");
1967 return ret;
1968 }
1969
1970 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
1971 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
1972
1973 BtAddr btAddr = ConvertToBtAddr(device);
1974 if (it->second->GetPairedStatus() == PAIR_CANCELING || accept == false) {
1975 ret = (GAPIF_UserPasskeyRsp(&btAddr, GAP_NOT_ACCEPT, passkey) == BT_SUCCESS);
1976 } else {
1977 ret = (GAPIF_UserPasskeyRsp(&btAddr, GAP_ACCEPT, passkey) == BT_SUCCESS);
1978 }
1979 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_UserPasskeyRsp", ret);
1980
1981 return ret;
1982 }
1983
PairRequestReply(const RawAddress & device,bool accept) const1984 bool ClassicAdapter::PairRequestReply(const RawAddress &device, bool accept) const
1985 {
1986 HILOGI("accept = %{public}d", accept);
1987
1988 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
1989 auto it = devices_.find(device.GetAddress());
1990 if ((it == devices_.end()) || (it->second->GetPairedStatus() != PAIR_PAIRING)) {
1991 HILOGE("failed, not in pairing state.");
1992 return false;
1993 }
1994
1995 BtAddr btAddr = ConvertToBtAddr(device);
1996 int io = adapterProperties_.GetIoCapability();
1997 bool ret = (GAPIF_IOCapabilityRsp(&btAddr, accept, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_SUCCESS);
1998 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_IOCapabilityRsp", ret);
1999
2000 return ret;
2001 }
2002
ConnectionComplete(const BtmAclConnectCompleteParam * param,void * context)2003 void ClassicAdapter::ConnectionComplete(const BtmAclConnectCompleteParam *param, void *context)
2004 {
2005 HILOGI("status: %{public}u", param->status);
2006
2007 auto adapter = static_cast<ClassicAdapter *>(context);
2008 RawAddress device = RawAddress::ConvertToString(param->addr->addr);
2009 uint32_t classOfDevice = 0;
2010 (void)memcpy_s(&classOfDevice, COD_SIZE, param->classOfDevice, COD_SIZE);
2011 if (adapter != nullptr) {
2012 adapter->GetDispatcher()->PostTask(std::bind(&ClassicAdapter::ReceiveConnectionComplete,
2013 adapter,
2014 param->status,
2015 param->connectionHandle,
2016 device,
2017 classOfDevice,
2018 param->encyptionEnabled));
2019 }
2020 }
2021
ReceiveConnectionComplete(uint8_t status,uint16_t connectionHandle,const RawAddress & device,uint32_t classOfDevice,bool encyptionEnabled)2022 void ClassicAdapter::ReceiveConnectionComplete(uint8_t status, uint16_t connectionHandle, const RawAddress &device,
2023 uint32_t classOfDevice, bool encyptionEnabled)
2024 {
2025 if (status == BTM_ACL_CONNECT_PAGE_TIMEOUT) {
2026 HILOGE("ACL Connection failed. Reason: ACL Page Timeout!");
2027 } else if (status == BTM_ACL_CONNECTION_TIMEOUT) {
2028 HILOGE("ACL Connection failed. Reason: ACL Supervision Timeout!");
2029 } else {
2030 HILOGI("ACL Connection result: %{public}u", status);
2031 }
2032
2033 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2034 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2035
2036 /// For compatibility
2037 /// Passive pairing failed and pair mode is PinCode.
2038 if (status != SUCCESS) {
2039 bool bondFromLocal = remoteDevice->IsBondedFromLocal();
2040 HILOGI("pinMode = %{public}d, bondFromLocal = %{public}d", pinMode_, bondFromLocal);
2041 if (pinMode_ == true && bondFromLocal == false) {
2042 pinMode_ = false;
2043 /// Passive pairing failed, delete the link key.
2044 DeleteLinkKey(remoteDevice);
2045 /// Set the pair flag and pair state.
2046 remoteDevice->SetPairedStatus(PAIR_NONE);
2047 /// Send the failed notification to APP.
2048 SendPairStatusChanged(ADAPTER_BREDR, device, PAIR_NONE);
2049 }
2050 return;
2051 }
2052
2053 int connectState = CONNECTION_STATE_CONNECTED;
2054 if (encyptionEnabled == true) {
2055 connectState = CONNECTION_STATE_ENCRYPTED_BREDR;
2056 }
2057 remoteDevice->SetAclConnectState(connectState);
2058 remoteDevice->SetConnectionHandle(connectionHandle);
2059
2060 int cod = (classOfDevice & CLASS_OF_DEVICE_RANGE);
2061 if (cod != INVALID_VALUE) {
2062 remoteDevice->SetDeviceClass(cod);
2063 }
2064 }
2065
ReceiveDisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason)2066 void ClassicAdapter::ReceiveDisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason)
2067 {
2068 HILOGI("status: %{public}u", status);
2069
2070 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2071 if (status != SUCCESS) {
2072 HILOGW("failed");
2073 return;
2074 }
2075
2076 for (auto &device : devices_) {
2077 if (connectionHandle != device.second->GetConnectionHandle()) {
2078 continue;
2079 }
2080 device.second->SetAclConnectState(CONNECTION_STATE_DISCONNECTED);
2081
2082 HILOGI("pinMode = %{public}d", pinMode_);
2083 /// Passive pairing failed and pair mode is PinCode.
2084 /// For 960 compatibility
2085 /// When ACL disconnect and current pari state is in PAIR_PAIRING or PAIR_CANCELING, set pair state to
2086 /// PAIR_NONE.
2087 if ((pinMode_) || (device.second->GetPairedStatus() == PAIR_PAIRING) ||
2088 (device.second->GetPairedStatus() == PAIR_CANCELING)) {
2089 pinMode_ = false;
2090 /// Passive pairing failed, delete the link key.
2091 DeleteLinkKey(device.second);
2092 /// Set the pair flag and pair state.
2093 device.second->SetPairedStatus(PAIR_NONE);
2094 /// Send the failed notification to APP.
2095 bool bondFromLocal = device.second->IsBondedFromLocal();
2096 HILOGI("bondFromLocal = %{public}d", bondFromLocal);
2097 if (!bondFromLocal) {
2098 RawAddress address(device.second->GetAddress());
2099 SendPairStatusChanged(ADAPTER_BREDR, address, PAIR_NONE);
2100 }
2101 }
2102 break;
2103 }
2104 }
2105
DisconnectionComplete(uint8_t status,uint16_t connectionHandle,uint8_t reason,void * context)2106 void ClassicAdapter::DisconnectionComplete(uint8_t status, uint16_t connectionHandle, uint8_t reason, void *context)
2107 {
2108 HILOGI("status: %{public}u", status);
2109
2110 auto adapter = static_cast<ClassicAdapter *>(context);
2111 if (adapter != nullptr) {
2112 adapter->GetDispatcher()->PostTask(
2113 std::bind(&ClassicAdapter::ReceiveDisconnectionComplete, adapter, status, connectionHandle, reason));
2114 }
2115 }
2116
RegisterClassicAdapterObserver(IAdapterClassicObserver & observer) const2117 bool ClassicAdapter::RegisterClassicAdapterObserver(IAdapterClassicObserver &observer) const
2118 {
2119 HILOGI("enter");
2120
2121 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2122 adapterProperties_.RegisterClassicAdapterObserver(observer);
2123 return pimpl->adapterObservers_.Register(observer);
2124 }
2125
DeregisterClassicAdapterObserver(IAdapterClassicObserver & observer) const2126 bool ClassicAdapter::DeregisterClassicAdapterObserver(IAdapterClassicObserver &observer) const
2127 {
2128 HILOGI("enter");
2129
2130 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2131 adapterProperties_.DeregisterClassicAdapterObserver(observer);
2132 return pimpl->adapterObservers_.Deregister(observer);
2133 }
2134
SetLinkKey(const BtAddr & addr)2135 void ClassicAdapter::SetLinkKey(const BtAddr &addr)
2136 {
2137 HILOGI("enter");
2138
2139 RawAddress device = RawAddress::ConvertToString(addr.addr);
2140 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2141
2142 int keyType = remoteDevice->GetLinkKeyType();
2143 uint8_t key[PAIR_LINK_KEY_SIZE];
2144 (void)memset_s(key, PAIR_LINK_KEY_SIZE, 0x00, PAIR_LINK_KEY_SIZE);
2145 uint8_t accept = GAP_NOT_ACCEPT;
2146 if (keyType != PAIR_INVALID_LINK_KEY_TYPE) {
2147 std::vector<uint8_t> linkKey = remoteDevice->GetLinkKey();
2148 if (memcpy_s(key, linkKey.size(), &linkKey[0], linkKey.size()) != EOK) {
2149 HILOGI("memcpy_s fail");
2150 return;
2151 }
2152 accept = GAP_ACCEPT;
2153 }
2154
2155 bool ret = (GAPIF_LinkKeyRsp(&addr, accept, key, keyType) == BT_SUCCESS);
2156 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_LinkKeyRsp", ret);
2157 (void)memset_s(key, PAIR_LINK_KEY_SIZE, 0x00, PAIR_LINK_KEY_SIZE);
2158 }
2159
SendPairRequested(const BTTransport transport,const RawAddress & device) const2160 void ClassicAdapter::SendPairRequested(const BTTransport transport, const RawAddress &device) const
2161 {
2162 HILOGI("enter");
2163 pimpl->adapterObservers_.ForEach(
2164 [transport, device](IAdapterClassicObserver &observer) { observer.OnPairRequested(transport, device); });
2165 }
2166
SetIoCapability(const BtAddr & addr)2167 void ClassicAdapter::SetIoCapability(const BtAddr &addr)
2168 {
2169 HILOGI("enter");
2170
2171 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2172 RawAddress rawAddr = RawAddress::ConvertToString(addr.addr);
2173 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(rawAddr);
2174 if (remoteDevice->GetRemoteName().empty()) {
2175 GetRemoteName(addr);
2176 }
2177
2178 bool bondFromLocal = false;
2179 bool ret = (GAPIF_PairIsFromLocal(&addr, &bondFromLocal) == BT_SUCCESS);
2180 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_PairIsFromLocal", ret);
2181 remoteDevice->SetBondedFromLocal(bondFromLocal);
2182
2183 if ((remoteDevice->GetPairedStatus() != PAIR_PAIRING) && (remoteDevice->GetPairedStatus() != PAIR_CANCELING)) {
2184 remoteDevice->SetPairedStatus(PAIR_PAIRING);
2185 }
2186
2187 if (bondFromLocal == false) {
2188 SendPairRequested(ADAPTER_BREDR, rawAddr);
2189 } else {
2190 int io = adapterProperties_.GetIoCapability();
2191 if (remoteDevice->GetPairedStatus() == PAIR_CANCELING) {
2192 ret = (GAPIF_IOCapabilityRsp(&addr, false, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_SUCCESS);
2193 } else {
2194 ret = (GAPIF_IOCapabilityRsp(&addr, true, io, GAP_OOB_DATA_NOT_PRESENT, GAP_MITM_REQUIRED) == BT_SUCCESS);
2195 }
2196 ClassicUtils::CheckReturnValue("ClassicAdapter", "GAPIF_IOCapabilityRsp", ret);
2197 }
2198 }
2199
SaveRemoteIoCapability(const BtAddr & addr,uint8_t ioCapability)2200 void ClassicAdapter::SaveRemoteIoCapability(const BtAddr &addr, uint8_t ioCapability)
2201 {
2202 HILOGI("enter");
2203 RawAddress device = RawAddress::ConvertToString(addr.addr);
2204 std::shared_ptr<ClassicRemoteDevice> remoteDevice = FindRemoteDevice(device);
2205 remoteDevice->SetIoCapability(ioCapability);
2206 }
2207
SetDevicePin(const RawAddress & device,const std::string & pinCode) const2208 bool ClassicAdapter::SetDevicePin(const RawAddress &device, const std::string &pinCode) const
2209 {
2210 HILOGI("pinCode:%{public}s", pinCode.c_str());
2211 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2212 auto it = devices_.find(device.GetAddress());
2213 if ((it == devices_.end()) || (it->second->GetPairedStatus() == PAIR_NONE) ||
2214 (it->second->GetPairedStatus() == PAIR_PAIRED)) {
2215 HILOGE("failed, not in pairing state.");
2216 return false;
2217 }
2218
2219 std::vector<uint8_t> pin(pinCode.begin(), pinCode.end());
2220 if (pin.empty()) {
2221 HILOGW("length is 0, reject it.");
2222 return SetPinCode(device, pin, GAP_NOT_ACCEPT);
2223 }
2224
2225 uint8_t accept = GAP_ACCEPT;
2226 it->second->SetPairConfirmState(PAIR_CONFIRM_STATE_USER_CONFIRM_REPLY);
2227 it->second->SetPairConfirmType(PAIR_CONFIRM_TYPE_INVALID);
2228 if (it->second->GetPairedStatus() == PAIR_CANCELING) {
2229 accept = GAP_NOT_ACCEPT;
2230 }
2231
2232 return SetPinCode(device, pin, accept);
2233 }
2234
SetPinCode(const RawAddress & device,const std::vector<uint8_t> & pin,bool accept) const2235 bool ClassicAdapter::SetPinCode(const RawAddress &device, const std::vector<uint8_t> &pin, bool accept) const
2236 {
2237 HILOGI("accept: %{public}d", accept);
2238
2239 BtAddr btAddr;
2240 device.ConvertToUint8(btAddr.addr);
2241 btAddr.type = BT_PUBLIC_DEVICE_ADDRESS;
2242 int result = GAPIF_PinCodeRsp(&btAddr, accept, pin.data(), pin.size());
2243 if (result != BT_SUCCESS) {
2244 HILOGE("GAPIF_PinCodeRsp failed!");
2245 return false;
2246 }
2247 return true;
2248 }
2249
SetAuthorizeRes(const BtAddr & addr,GAP_Service service) const2250 void ClassicAdapter::SetAuthorizeRes(const BtAddr &addr, GAP_Service service) const
2251 {
2252 HILOGI("enter");
2253 int result = GAPIF_AuthorizeRes(&addr, service, true);
2254 if (result != BT_SUCCESS) {
2255 HILOGE("GAPIF_AuthorizeRes failed!");
2256 }
2257 }
2258
GetDeviceType(const RawAddress & device) const2259 int ClassicAdapter::ClassicAdapter::GetDeviceType(const RawAddress &device) const
2260 {
2261 HILOGI("enter");
2262
2263 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2264 int type = INVALID_VALUE;
2265 auto it = devices_.find(device.GetAddress());
2266 if (it != devices_.end()) {
2267 type = it->second->GetDeviceType();
2268 }
2269
2270 return type;
2271 }
2272
GetDeviceClass(const RawAddress & device) const2273 int ClassicAdapter::GetDeviceClass(const RawAddress &device) const
2274 {
2275 HILOGI("enter");
2276
2277 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2278 int cod = INVALID_VALUE;
2279 auto it = devices_.find(device.GetAddress());
2280 if (it != devices_.end()) {
2281 cod = it->second->GetDeviceClass();
2282 }
2283
2284 return cod;
2285 }
2286
GetAliasName(const RawAddress & device) const2287 std::string ClassicAdapter::GetAliasName(const RawAddress &device) const
2288 {
2289 HILOGI("enter");
2290
2291 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2292 std::string alias = INVALID_NAME;
2293 auto it = devices_.find(device.GetAddress());
2294 if (it != devices_.end()) {
2295 alias = it->second->GetAliasName();
2296 }
2297
2298 return alias;
2299 }
2300
SetAliasName(const RawAddress & device,const std::string & name) const2301 bool ClassicAdapter::SetAliasName(const RawAddress &device, const std::string &name) const
2302 {
2303 HILOGI("enter");
2304
2305 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2306 bool ret = false;
2307 auto it = devices_.find(device.GetAddress());
2308 if (it != devices_.end()) {
2309 if (name != it->second->GetAliasName()) {
2310 ret = it->second->SetAliasName(name);
2311 if (ret == false) {
2312 HILOGE("failed");
2313 } else {
2314 SendRemoteAliasChanged(device, name);
2315 }
2316 }
2317 }
2318 return ret;
2319 }
2320
SendRemoteAliasChanged(const RawAddress & device,const std::string & aliasName) const2321 void ClassicAdapter::SendRemoteAliasChanged(const RawAddress &device, const std::string &aliasName) const
2322 {
2323 HILOGI("enter");
2324
2325 pimpl->remoteObservers_.ForEach([device, aliasName](IClassicRemoteDeviceObserver &observer) {
2326 observer.OnRemoteAliasChanged(device, aliasName);
2327 });
2328 }
2329
RegisterRemoteDeviceObserver(IClassicRemoteDeviceObserver & observer) const2330 bool ClassicAdapter::RegisterRemoteDeviceObserver(IClassicRemoteDeviceObserver &observer) const
2331 {
2332 HILOGI("enter");
2333 return pimpl->remoteObservers_.Register(observer);
2334 }
2335
DeregisterRemoteDeviceObserver(IClassicRemoteDeviceObserver & observer) const2336 bool ClassicAdapter::DeregisterRemoteDeviceObserver(IClassicRemoteDeviceObserver &observer) const
2337 {
2338 HILOGI("enter");
2339 return pimpl->remoteObservers_.Deregister(observer);
2340 }
2341
CheckAutoReply(int remoteIo,int localMitmRequired,int remoteMitmRequired) const2342 bool ClassicAdapter::CheckAutoReply(int remoteIo, int localMitmRequired, int remoteMitmRequired) const
2343 {
2344 HILOGI("enter");
2345
2346 bool autoReply = false;
2347 int localIo = adapterProperties_.GetIoCapability();
2348 HILOGI("local io capability = %{public}d <==> remote io capability = %{public}d"
2349 "local mitm = %{public}d <==> remote mitm = %{public}d", localIo, remoteIo,
2350 localMitmRequired, remoteMitmRequired);
2351
2352 if (localMitmRequired == GAP_MITM_NOT_REQUIRED && remoteMitmRequired == GAP_MITM_NOT_REQUIRED) {
2353 return true;
2354 }
2355
2356 switch (localIo) {
2357 case GAP_IO_DISPLAYONLY:
2358 autoReply = (remoteIo != GAP_IO_KEYBOARDONLY) ? true : false;
2359 break;
2360 case GAP_IO_KEYBOARDONLY:
2361 autoReply = (remoteIo == GAP_IO_NOINPUTNOOUTPUT) ? true : false;
2362 break;
2363 case GAP_IO_NOINPUTNOOUTPUT:
2364 autoReply = true;
2365 break;
2366 default:
2367 break;
2368 }
2369 return autoReply;
2370 }
2371
CheckSspConfirmType(int remoteIo,int type) const2372 int ClassicAdapter::CheckSspConfirmType(int remoteIo, int type) const
2373 {
2374 HILOGI("enter");
2375
2376 int confirmType = PAIR_CONFIRM_TYPE_CONSENT;
2377 int localIo = adapterProperties_.GetIoCapability();
2378 HILOGI("local io capability = %{public}d <==> remote io capability = %{public}d, type = %{public}d",
2379 localIo, remoteIo, type);
2380 if (type == PAIR_CONFIRM_TYPE_NUMERIC) {
2381 if ((localIo == GAP_IO_DISPLAYYESNO) && (remoteIo == GAP_IO_DISPLAYYESNO)) {
2382 confirmType = PAIR_CONFIRM_TYPE_NUMERIC;
2383 }
2384 } else {
2385 confirmType = type;
2386 }
2387 return confirmType;
2388 }
2389
GetDeviceBatteryLevel(const RawAddress & device) const2390 int ClassicAdapter::GetDeviceBatteryLevel(const RawAddress &device) const
2391 {
2392 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2393 int batteryLevel = 0;
2394 auto it = devices_.find(device.GetAddress());
2395 if (it != devices_.end()) {
2396 batteryLevel = it->second->GetBatteryLevel();
2397 }
2398 HILOGI("batteryLevel: %{public}d", batteryLevel);
2399 return batteryLevel;
2400 }
2401
SetDeviceBatteryLevel(const RawAddress & device,int batteryLevel) const2402 void ClassicAdapter::SetDeviceBatteryLevel(const RawAddress &device, int batteryLevel) const
2403 {
2404 HILOGI("addr: %{public}s, batteryLevel: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), batteryLevel);
2405
2406 std::lock_guard<std::recursive_mutex> lk(pimpl->syncMutex_);
2407 auto it = devices_.find(device.GetAddress());
2408 if (it != devices_.end()) {
2409 it->second->SetBatteryLevel(batteryLevel);
2410 }
2411
2412 SendRemoteBatteryLevelChanged(device, batteryLevel);
2413 }
2414
SendRemoteBatteryLevelChanged(const RawAddress & device,int batteryLevel) const2415 void ClassicAdapter::SendRemoteBatteryLevelChanged(const RawAddress &device, int batteryLevel) const
2416 {
2417 HILOGI("addr: %{public}s, batteryLevel: %{public}d", GetEncryptAddr(device.GetAddress()).c_str(), batteryLevel);
2418
2419 pimpl->remoteObservers_.ForEach([device, batteryLevel](IClassicRemoteDeviceObserver &observer) {
2420 observer.OnRemoteBatteryLevelChanged(device, batteryLevel);
2421 });
2422 }
2423
2424 REGISTER_CLASS_CREATOR(ClassicAdapter);
2425 } // namespace bluetooth
2426 } // namespace OHOS