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