1 /*
2 * Copyright (C) 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 "hid_host_statemachine.h"
17 #include "hid_host_service.h"
18
19 namespace OHOS {
20 namespace bluetooth {
HidHostStateMachine(const std::string & address)21 HidHostStateMachine::HidHostStateMachine(const std::string &address)
22 : address_(address), uhid_(address)
23 {}
24
Init()25 void HidHostStateMachine::Init()
26 {
27 connTimer_ = std::make_unique<utility::Timer>(
28 std::bind(&bluetooth::HidHostStateMachine::ConnectionTimeout, this));
29
30 disconnTimer_ = std::make_unique<utility::Timer>(
31 std::bind(&bluetooth::HidHostStateMachine::DisonnectionTimeout, this));
32
33 std::unique_ptr<utility::StateMachine::State> disconnectedState =
34 std::make_unique<HidHostDisconnectedState>(DISCONNECTED, *this);
35 std::unique_ptr<utility::StateMachine::State> connectingState =
36 std::make_unique<HidHostConnectingState>(CONNECTING, *this);
37 std::unique_ptr<utility::StateMachine::State> disconnectingState =
38 std::make_unique<HidHostDisconnectingState>(DISCONNECTING, *this);
39 std::unique_ptr<utility::StateMachine::State> connectedState =
40 std::make_unique<HidHostConnectedState>(CONNECTED, *this);
41
42 Move(disconnectedState);
43 Move(connectingState);
44 Move(disconnectingState);
45 Move(connectedState);
46
47 InitState(DISCONNECTED);
48 SetDeviceType();
49 }
50
SetDeviceType()51 void HidHostStateMachine::SetDeviceType()
52 {
53 auto adapterClassic = IAdapterManager::GetInstance()->GetClassicAdapterInterface();
54 if (adapterClassic != nullptr) {
55 std::vector<RawAddress> devices = adapterClassic->GetPairedDevices();
56 if (std::find(devices.begin(), devices.end(), RawAddress(address_)) != devices.end()) {
57 deviceType_ = HID_HOST_DEVICE_TYPE_BREDR;
58 l2capConnection_ = std::make_unique<HidHostL2capConnection>(address_);
59 sdpClient_ = std::make_unique<HidHostSdpClient>(address_);
60 LOG_DEBUG("[HIDH Machine]%{public}s():Device is br/edr device", __FUNCTION__);
61 return;
62 }
63 }
64
65 auto adapterBle = IAdapterManager::GetInstance()->GetBleAdapterInterface();
66 if (adapterBle != nullptr) {
67 std::vector<RawAddress> devices = adapterBle->GetPairedDevices();
68 if (std::find(devices.begin(), devices.end(), RawAddress(address_)) != devices.end()) {
69 deviceType_ = HID_HOST_DEVICE_TYPE_BLE;
70 hogp_ = std::make_unique<HidHostHogp>(address_);
71 LOG_DEBUG("[HIDH Machine]%{public}s():Device is ble device", __FUNCTION__);
72 return;
73 }
74 }
75 deviceType_ = HID_HOST_DEVICE_TYPE_UNKNOWN;
76 LOG_ERROR("[HIDH Machine]%{public}s():Unknown device!", __FUNCTION__);
77 }
78
GetDeviceType()79 int HidHostStateMachine::GetDeviceType()
80 {
81 LOG_DEBUG("[HIDH Machine]%{public}s(), deviceType_:%{public}d", __FUNCTION__, deviceType_);
82 return deviceType_;
83 }
84
IsRemoving() const85 bool HidHostStateMachine::IsRemoving() const
86 {
87 return isRemoving_;
88 }
89
SetRemoving(bool isRemoving)90 void HidHostStateMachine::SetRemoving(bool isRemoving)
91 {
92 isRemoving_ = isRemoving;
93 }
94
GetDeviceControlLcid()95 uint16_t HidHostStateMachine::GetDeviceControlLcid()
96 {
97 if (l2capConnection_ == nullptr) {
98 return 0;
99 }
100 return l2capConnection_->GetControlLcid();
101 }
102
GetDeviceInterruptLcid()103 uint16_t HidHostStateMachine::GetDeviceInterruptLcid()
104 {
105 if (l2capConnection_ == nullptr) {
106 return 0;
107 }
108 return l2capConnection_->GetInterruptLcid();
109 }
110
ProcessL2capConnectionEvent(const HidHostMessage & event)111 void HidHostStateMachine::ProcessL2capConnectionEvent(
112 const HidHostMessage &event)
113 {
114 if (l2capConnection_ == nullptr) {
115 LOG_ERROR("[HIDH Machine]%{public}s(): L2CAP IS NULL", __FUNCTION__);
116 return;
117 }
118 l2capConnection_->ProcessEvent(event);
119 }
120
ProcessHogpEvent(const HidHostMessage & event)121 void HidHostStateMachine::ProcessHogpEvent(
122 const HidHostMessage &event)
123 {
124 if (hogp_ == nullptr) {
125 LOG_ERROR("[HIDH Machine]%{public}s(): HOGP IS NULL", __FUNCTION__);
126 return;
127 }
128 hogp_->ProcessEvent(event);
129 }
130
GetDeviceAdress()131 std::string HidHostStateMachine::GetDeviceAdress()
132 {
133 return address_;
134 }
135
Entry()136 void HidHostDisconnectedState::Entry()
137 {
138 stateMachine_.ProcessDeferredMessage();
139
140 if (isReentry_) {
141 stateMachine_.SetRemoving(true);
142 HidHostService *service = HidHostService::GetService();
143 if (service != nullptr) {
144 service->RemoveStateMachine(stateMachine_.GetDeviceAdress());
145 } else {
146 LOG_ERROR("[HIDH Machine]%{public}s():HidHostService is nullptr!", __FUNCTION__);
147 }
148 stateMachine_.NotifyStateTransitions();
149 }
150 }
151
Exit()152 void HidHostDisconnectedState::Exit()
153 {
154 isReentry_ = true;
155 }
156
Dispatch(const utility::Message & msg)157 bool HidHostDisconnectedState::Dispatch(const utility::Message &msg)
158 {
159 int deviceType = stateMachine_.GetDeviceType();
160 if (deviceType == HID_HOST_DEVICE_TYPE_UNKNOWN) {
161 LOG_ERROR("[HIDH Machine]%{public}s():[Disconnected]Unknown device!", __FUNCTION__);
162 HidHostService::GetService()->RemoveStateMachine(stateMachine_.GetDeviceAdress());
163 return false;
164 }
165 if (deviceType == HID_HOST_DEVICE_TYPE_BLE) {
166 return DispatchBle(msg);
167 }
168 HidHostMessage &event = (HidHostMessage &)msg;
169 LOG_DEBUG("[HIDH Machine]%{public}s():[Disconnected][%{public}s]",
170 __FUNCTION__, HidHostStateMachine::GetEventName(event.what_).c_str());
171 switch (event.what_) {
172 case HID_HOST_API_OPEN_EVT:
173 stateMachine_.ProcessStartSdp(event);
174 Transition(HidHostStateMachine::CONNECTING);
175 break;
176 case HID_HOST_INT_OPEN_EVT:
177 stateMachine_.ProcessOpenDevice(event);
178 Transition(HidHostStateMachine::CONNECTING);
179 break;
180 case HID_HOST_INT_CLOSE_EVT:
181 stateMachine_.ProcessCloseDevice(event);
182 break;
183 case HID_HOST_INT_DATA_EVT:
184 break;
185 case HID_HOST_INT_CTRL_DATA:
186 break;
187 case HID_HOST_API_WRITE_DEV_EVT:
188 break;
189 case HID_HOST_OPEN_CMPL_EVT:
190 stateMachine_.ProcessOpenComplete(event);
191 Transition(HidHostStateMachine::CONNECTED);
192 break;
193 case HID_HOST_L2CAP_CONNECT_REQ_EVT:
194 Transition(HidHostStateMachine::CONNECTING);
195 break;
196 default:
197 break;
198 }
199 return true;
200 }
201
DispatchBle(const utility::Message & msg)202 bool HidHostDisconnectedState::DispatchBle(const utility::Message &msg)
203 {
204 HidHostMessage &event = (HidHostMessage &)msg;
205 LOG_DEBUG("[HIDH Machine]%{public}s():[Disconnected][%{public}s]",
206 __FUNCTION__, HidHostStateMachine::GetEventName(event.what_).c_str());
207 switch (event.what_) {
208 case HID_HOST_API_OPEN_EVT:
209 stateMachine_.ProcessBleOpenDeviceReq(event);
210 Transition(HidHostStateMachine::CONNECTING);
211 break;
212 case HID_HOST_API_CLOSE_EVT:
213 break;
214 case HID_HOST_INT_OPEN_EVT:
215 break;
216 case HID_HOST_INT_CLOSE_EVT:
217 break;
218 case HID_HOST_INT_DATA_EVT:
219 break;
220 case HID_HOST_INT_CTRL_DATA:
221 break;
222 case HID_HOST_INT_HANDSK_EVT:
223 break;
224 case HID_HOST_SDP_CMPL_EVT:
225 break;
226 case HID_HOST_API_WRITE_DEV_EVT:
227 break;
228 case HID_HOST_OPEN_CMPL_EVT:
229 stateMachine_.ProcessBleOpenComplete(event);
230 Transition(HidHostStateMachine::CONNECTED);
231 break;
232 default:
233 break;
234 }
235 return true;
236 }
237
Entry()238 void HidHostConnectingState::Entry()
239 {
240 stateMachine_.NotifyStateTransitions();
241 stateMachine_.StartConnectionTimer();
242 }
Exit()243 void HidHostConnectingState::Exit()
244 {
245 stateMachine_.StopConnectionTimer();
246 }
247
Dispatch(const utility::Message & msg)248 bool HidHostConnectingState::Dispatch(const utility::Message &msg)
249 {
250 int deviceType = stateMachine_.GetDeviceType();
251 if (deviceType == HID_HOST_DEVICE_TYPE_UNKNOWN) {
252 LOG_ERROR("[HIDH Machine]%{public}s():[Connecting]Unknown device!", __FUNCTION__);
253 return false;
254 }
255 if (deviceType == HID_HOST_DEVICE_TYPE_BLE) {
256 return DispatchBle(msg);
257 }
258 HidHostMessage &event = (HidHostMessage &)msg;
259 LOG_DEBUG("[HIDH Machine]%{public}s():[Connecting][%{public}s]", __FUNCTION__,
260 HidHostStateMachine::GetEventName(event.what_).c_str());
261 switch (event.what_) {
262 case HID_HOST_API_OPEN_EVT:
263 break;
264 case HID_HOST_API_CLOSE_EVT:
265 stateMachine_.AddDeferredMessage(event);
266 break;
267 case HID_HOST_INT_OPEN_EVT:
268 stateMachine_.ProcessOpenDevice(event);
269 break;
270 case HID_HOST_INT_CLOSE_EVT:
271 Transition(HidHostStateMachine::DISCONNECTED);
272 break;
273 case HID_HOST_INT_DATA_EVT:
274 break;
275 case HID_HOST_INT_CTRL_DATA:
276 break;
277 case HID_HOST_INT_HANDSK_EVT:
278 break;
279 case HID_HOST_SDP_CMPL_EVT:
280 stateMachine_.ProcessSdpComplete(event);
281 break;
282 case HID_HOST_API_WRITE_DEV_EVT:
283 break;
284 case HID_HOST_OPEN_CMPL_EVT:
285 stateMachine_.ProcessOpenComplete(event);
286 Transition(HidHostStateMachine::CONNECTED);
287 break;
288 case HID_HOST_CONNECTION_TIMEOUT_EVT:
289 Transition(HidHostStateMachine::DISCONNECTED);
290 break;
291 default:
292 break;
293 }
294 return true;
295 }
296
DispatchBle(const utility::Message & msg)297 bool HidHostConnectingState::DispatchBle(const utility::Message &msg)
298 {
299 HidHostMessage &event = (HidHostMessage &)msg;
300 LOG_DEBUG("[HIDH Machine]%{public}s():[Connecting][%{public}s]", __FUNCTION__,
301 HidHostStateMachine::GetEventName(event.what_).c_str());
302 switch (event.what_) {
303 case HID_HOST_API_OPEN_EVT:
304 break;
305 case HID_HOST_API_CLOSE_EVT:
306 stateMachine_.AddDeferredMessage(event);
307 break;
308 case HID_HOST_INT_OPEN_EVT:
309 break;
310 case HID_HOST_INT_CLOSE_EVT:
311 Transition(HidHostStateMachine::DISCONNECTED);
312 break;
313 case HID_HOST_INT_DATA_EVT:
314 break;
315 case HID_HOST_INT_CTRL_DATA:
316 break;
317 case HID_HOST_INT_HANDSK_EVT:
318 break;
319 case HID_HOST_API_WRITE_DEV_EVT:
320 break;
321 case HID_HOST_OPEN_CMPL_EVT:
322 stateMachine_.ProcessBleOpenComplete(event);
323 Transition(HidHostStateMachine::CONNECTED);
324 break;
325 case HID_HOST_CONNECTION_TIMEOUT_EVT:
326 Transition(HidHostStateMachine::DISCONNECTED);
327 break;
328 default:
329 break;
330 }
331 return true;
332 }
333
Entry()334 void HidHostDisconnectingState::Entry()
335 {
336 stateMachine_.NotifyStateTransitions();
337 stateMachine_.StartDisconnectionTimer();
338 }
339
Exit()340 void HidHostDisconnectingState::Exit()
341 {
342 stateMachine_.StopDisconnectionTimer();
343 }
344
Dispatch(const utility::Message & msg)345 bool HidHostDisconnectingState::Dispatch(const utility::Message &msg)
346 {
347 int deviceType = stateMachine_.GetDeviceType();
348 if (deviceType == HID_HOST_DEVICE_TYPE_UNKNOWN) {
349 LOG_ERROR("[HIDH Machine]%{public}s():[Disconnecting]Unknown device!", __FUNCTION__);
350 return false;
351 }
352 if (deviceType == HID_HOST_DEVICE_TYPE_BLE) {
353 return DispatchBle(msg);
354 }
355 HidHostMessage &event = (HidHostMessage &)msg;
356 LOG_DEBUG("[HIDH Machine]%{public}s():[Disconnecting][%{public}s]", __FUNCTION__,
357 HidHostStateMachine::GetEventName(event.what_).c_str());
358 switch (event.what_) {
359 case HID_HOST_API_OPEN_EVT:
360 stateMachine_.AddDeferredMessage(event);
361 break;
362 case HID_HOST_INT_OPEN_EVT:
363 stateMachine_.ProcessOpenDevice(event);
364 Transition(HidHostStateMachine::CONNECTING);
365 break;
366 case HID_HOST_INT_CLOSE_EVT:
367 stateMachine_.ProcessCloseDevice(event);
368 Transition(HidHostStateMachine::DISCONNECTED);
369 break;
370 case HID_HOST_INT_DATA_EVT:
371 break;
372 case HID_HOST_INT_CTRL_DATA:
373 break;
374 case HID_HOST_API_WRITE_DEV_EVT:
375 break;
376 case HID_HOST_OPEN_CMPL_EVT:
377 stateMachine_.ProcessOpenComplete(event);
378 Transition(HidHostStateMachine::CONNECTED);
379 break;
380 case HID_HOST_DISCONNECTION_TIMEOUT_EVT:
381 Transition(HidHostStateMachine::CONNECTED);
382 break;
383 default:
384 break;
385 }
386 return true;
387 }
388
DispatchBle(const utility::Message & msg)389 bool HidHostDisconnectingState::DispatchBle(const utility::Message &msg)
390 {
391 HidHostMessage &event = (HidHostMessage &)msg;
392 LOG_DEBUG("[HIDH Machine]%{public}s():[Disconnecting][%{public}s]", __FUNCTION__,
393 HidHostStateMachine::GetEventName(event.what_).c_str());
394 switch (event.what_) {
395 case HID_HOST_API_OPEN_EVT:
396 stateMachine_.AddDeferredMessage(event);
397 break;
398 case HID_HOST_API_CLOSE_EVT:
399 break;
400 case HID_HOST_INT_OPEN_EVT:
401 break;
402 case HID_HOST_INT_CLOSE_EVT:
403 stateMachine_.ProcessBleCloseDevice(event);
404 Transition(HidHostStateMachine::DISCONNECTED);
405 break;
406 case HID_HOST_INT_DATA_EVT:
407 break;
408 case HID_HOST_INT_CTRL_DATA:
409 break;
410 case HID_HOST_INT_HANDSK_EVT:
411 break;
412 case HID_HOST_API_WRITE_DEV_EVT:
413 break;
414 case HID_HOST_OPEN_CMPL_EVT:
415 stateMachine_.ProcessBleOpenComplete(event);
416 Transition(HidHostStateMachine::CONNECTED);
417 break;
418 case HID_HOST_DISCONNECTION_TIMEOUT_EVT:
419 Transition(HidHostStateMachine::CONNECTED);
420 break;
421 default:
422 break;
423 }
424 return true;
425 }
426
Entry()427 void HidHostConnectedState::Entry()
428 {
429 stateMachine_.ProcessDeferredMessage();
430 stateMachine_.NotifyStateTransitions();
431 }
432
Exit()433 void HidHostConnectedState::Exit()
434 {
435 }
436
Dispatch(const utility::Message & msg)437 bool HidHostConnectedState::Dispatch(const utility::Message &msg)
438 {
439 int deviceType = stateMachine_.GetDeviceType();
440 if (deviceType == HID_HOST_DEVICE_TYPE_UNKNOWN) {
441 LOG_ERROR("[HIDH Machine]%{public}s():[Connected]Unknown device!", __FUNCTION__);
442 return false;
443 }
444 if (deviceType == HID_HOST_DEVICE_TYPE_BLE) {
445 return DispatchBle(msg);
446 }
447 HidHostMessage &event = (HidHostMessage &)msg;
448 LOG_DEBUG("[HIDH Machine]%{public}s():[Connected][%{public}s]", __FUNCTION__,
449 HidHostStateMachine::GetEventName(event.what_).c_str());
450 switch (event.what_) {
451 case HID_HOST_API_OPEN_EVT:
452 break;
453 case HID_HOST_API_CLOSE_EVT:
454 stateMachine_.ProcessCloseDeviceReq(event);
455 Transition(HidHostStateMachine::DISCONNECTING);
456 break;
457 case HID_HOST_INT_OPEN_EVT:
458 break;
459 case HID_HOST_INT_CLOSE_EVT:
460 stateMachine_.ProcessCloseDevice(event);
461 Transition(HidHostStateMachine::DISCONNECTED);
462 break;
463 case HID_HOST_INT_DATA_EVT:
464 stateMachine_.ProcessReciveData(event);
465 break;
466 case HID_HOST_INT_CTRL_DATA:
467 stateMachine_.ProcessReciveControlData(event);
468 break;
469 case HID_HOST_INT_HANDSK_EVT:
470 stateMachine_.ProcessReciveHandshake(event);
471 break;
472 case HID_HOST_SDP_CMPL_EVT:
473 break;
474 case HID_HOST_API_WRITE_DEV_EVT:
475 stateMachine_.ProcessWriteData(event);
476 break;
477 case HID_HOST_OPEN_CMPL_EVT:
478 break;
479 default:
480 break;
481 }
482 return true;
483 }
484
DispatchBle(const utility::Message & msg)485 bool HidHostConnectedState::DispatchBle(const utility::Message &msg)
486 {
487 HidHostMessage &event = (HidHostMessage &)msg;
488 LOG_DEBUG("[HIDH Machine]%{public}s():[Connected][%{public}s]", __FUNCTION__,
489 HidHostStateMachine::GetEventName(event.what_).c_str());
490 switch (event.what_) {
491 case HID_HOST_API_OPEN_EVT:
492 break;
493 case HID_HOST_API_CLOSE_EVT:
494 stateMachine_.ProcessBleCloseDeviceReq(event);
495 Transition(HidHostStateMachine::DISCONNECTING);
496 break;
497 case HID_HOST_INT_OPEN_EVT:
498 break;
499 case HID_HOST_INT_CLOSE_EVT:
500 stateMachine_.ProcessBleCloseDevice(event);
501 Transition(HidHostStateMachine::DISCONNECTED);
502 break;
503 case HID_HOST_INT_DATA_EVT:
504 stateMachine_.ProcessBleReciveData(event);
505 break;
506 case HID_HOST_INT_CTRL_DATA:
507 stateMachine_.ProcessBleReciveControlData(event);
508 break;
509 case HID_HOST_INT_HANDSK_EVT:
510 stateMachine_.ProcessBleReciveHandshake(event);
511 break;
512 case HID_HOST_API_WRITE_DEV_EVT:
513 stateMachine_.ProcessBleWriteData(event);
514 break;
515 case HID_HOST_OPEN_CMPL_EVT:
516 break;
517 default:
518 break;
519 }
520 return true;
521 }
522
ProcessStartSdp(const HidHostMessage & msg)523 void HidHostStateMachine::ProcessStartSdp(const HidHostMessage &msg)
524 {
525 if (sdpClient_ == nullptr) {
526 LOG_ERROR("[HIDH Machine]%{public}s(): SDP IS NULL", __FUNCTION__);
527 return;
528 }
529 if (sdpClient_->CheckIsSdpDone()) {
530 HidHostMessage event(HID_HOST_SDP_CMPL_EVT, HID_HOST_SDP_SUCCESS);
531 event.dev_ = address_;
532 HidHostService::GetService()->PostEvent(event);
533 } else {
534 sdpClient_->DoDiscovery(address_);
535 }
536 }
537
ProcessOpenDevice(const HidHostMessage & msg)538 void HidHostStateMachine::ProcessOpenDevice(const HidHostMessage &msg)
539 {
540 if (sdpClient_ == nullptr) {
541 LOG_ERROR("[HIDH Machine]%{public}s(): SDP IS NULL", __FUNCTION__);
542 return;
543 }
544 if (sdpClient_->CheckIsSdpDone()) {
545 HidHostMessage event(HID_HOST_OPEN_CMPL_EVT);
546 event.dev_ = address_;
547 HidHostService::GetService()->PostEvent(event);
548 } else {
549 sdpClient_->DoDiscovery(address_);
550 }
551 }
552
ProcessCloseDeviceReq(const HidHostMessage & msg)553 void HidHostStateMachine::ProcessCloseDeviceReq(const HidHostMessage &msg)
554 {
555 if (l2capConnection_ == nullptr) {
556 LOG_ERROR("[HIDH Machine]%{public}s(): L2CAP IS NULL", __FUNCTION__);
557 return;
558 }
559 l2capConnection_->Disconnect();
560 }
561
ProcessCloseDevice(const HidHostMessage & msg)562 void HidHostStateMachine::ProcessCloseDevice(const HidHostMessage &msg)
563 {
564 uhid_.Close();
565 uhid_.Destroy();
566 }
567
ProcessReciveData(const HidHostMessage & msg)568 void HidHostStateMachine::ProcessReciveData(const HidHostMessage &msg)
569 {
570 uhid_.SendData(msg.data_.get(), msg.dataLength_);
571 }
572
ProcessReciveControlData(const HidHostMessage & msg)573 void HidHostStateMachine::ProcessReciveControlData(const HidHostMessage &msg)
574 {
575 uhid_.SendControlData(msg.data_.get(), msg.dataLength_);
576 }
577
ProcessReciveHandshake(const HidHostMessage & msg)578 void HidHostStateMachine::ProcessReciveHandshake(const HidHostMessage &msg)
579 {
580 uhid_.SendHandshake(msg.arg1_);
581 }
582
ProcessWriteData(const HidHostMessage & msg)583 void HidHostStateMachine::ProcessWriteData(const HidHostMessage &msg)
584 {
585 if (l2capConnection_ == nullptr) {
586 LOG_ERROR("[HIDH Machine]%{public}s(): L2CAP IS NULL", __FUNCTION__);
587 return;
588 }
589 l2capConnection_->SendData(msg.sendData_, msg.dataLength_, msg.data_.get());
590 }
591
ProcessSdpComplete(const HidHostMessage & msg)592 void HidHostStateMachine::ProcessSdpComplete(const HidHostMessage &msg)
593 {
594 if (l2capConnection_ == nullptr || sdpClient_ == nullptr) {
595 LOG_ERROR("[HIDH Machine]%{public}s(): L2CAP OR SDP IS NULL", __FUNCTION__);
596 return;
597 }
598 LOG_INFO("[HIDH Machine]%{public}s():result=%{public}d", __FUNCTION__, msg.arg1_);
599 if ((msg.arg1_ == HID_HOST_SDP_SUCCESS) && sdpClient_->CheckIsSdpDone()) {
600 l2capConnection_->Connect();
601 } else if ((msg.arg1_ == HID_HOST_SDP_SUCCESS) && !sdpClient_->CheckIsSdpDone()) {
602 sdpClient_->DoDiscovery(address_);
603 } else {
604 l2capConnection_->Disconnect();
605 }
606 }
607
ProcessOpenComplete(const HidHostMessage & msg)608 void HidHostStateMachine::ProcessOpenComplete(const HidHostMessage &msg)
609 {
610 if (sdpClient_ == nullptr) {
611 LOG_ERROR("[HIDH Machine]%{public}s(): SDP IS NULL", __FUNCTION__);
612 return;
613 }
614 uhid_.Open();
615 PnpInformation& pnpInf = sdpClient_->GetRemoteSdpPnpInfo();
616 HidInformation& hidInf = sdpClient_->GetRemoteSdpHidInfo();
617
618 char cachedName[] = { "Bluetooth HID" };
619 LOG_INFO("[HIDH Machine]%{public}s():cachedName[%{public}s],vendorId[%{public}d],productId[%{public}d]",
620 __FUNCTION__, cachedName, pnpInf.vendorId, pnpInf.productId);
621 LOG_INFO("[HIDH Machine]%{public}s():version[%{public}d],ctryCode[%{public}d],descLength[%{public}d]",
622 __FUNCTION__, pnpInf.version, hidInf.ctryCode, hidInf.descLength);
623 uhid_.SendHidInfo(cachedName, pnpInf, hidInf);
624 }
625
ProcessBleOpenDeviceReq(const HidHostMessage & msg)626 void HidHostStateMachine::ProcessBleOpenDeviceReq(const HidHostMessage &msg)
627 {
628 if (hogp_ == nullptr) {
629 LOG_ERROR("[HIDH Machine]%{public}s(): HOGP IS NULL", __FUNCTION__);
630 return;
631 }
632 hogp_->Connect();
633 }
634
ProcessBleCloseDeviceReq(const HidHostMessage & msg)635 void HidHostStateMachine::ProcessBleCloseDeviceReq(const HidHostMessage &msg)
636 {
637 if (hogp_ == nullptr) {
638 LOG_ERROR("[HIDH Machine]%{public}s(): HOGP IS NULL", __FUNCTION__);
639 return;
640 }
641 hogp_->Disconnect();
642 }
643
ProcessBleCloseDevice(const HidHostMessage & msg)644 void HidHostStateMachine::ProcessBleCloseDevice(const HidHostMessage &msg)
645 {
646 uhid_.Close();
647 uhid_.Destroy();
648 }
649
ProcessBleReciveData(const HidHostMessage & msg)650 void HidHostStateMachine::ProcessBleReciveData(const HidHostMessage &msg)
651 {
652 uhid_.SendData(msg.data_.get(), msg.dataLength_);
653 }
654
ProcessBleReciveControlData(const HidHostMessage & msg)655 void HidHostStateMachine::ProcessBleReciveControlData(const HidHostMessage &msg)
656 {
657 uhid_.SendControlData(msg.data_.get(), msg.dataLength_);
658 }
659
ProcessBleReciveHandshake(const HidHostMessage & msg)660 void HidHostStateMachine::ProcessBleReciveHandshake(const HidHostMessage &msg)
661 {
662 uhid_.SendHandshake(msg.arg1_);
663 }
664
ProcessBleWriteData(const HidHostMessage & msg)665 void HidHostStateMachine::ProcessBleWriteData(const HidHostMessage &msg)
666 {
667 if (hogp_ == nullptr) {
668 LOG_ERROR("[HIDH Machine]%{public}s(): HOGP IS NULL", __FUNCTION__);
669 return;
670 }
671 hogp_->SendData(msg);
672 }
673
ProcessBleOpenComplete(const HidHostMessage & msg)674 void HidHostStateMachine::ProcessBleOpenComplete(const HidHostMessage &msg)
675 {
676 if (hogp_ == nullptr) {
677 LOG_ERROR("[HIDH Machine]%{public}s(): HOGP IS NULL", __FUNCTION__);
678 return;
679 }
680 uhid_.Open();
681 PnpInformation& pnpInf = hogp_->GetRemotePnpInfo();
682 HidInformation& hidInf = hogp_->GetRemoteHidInfo();
683
684 char cachedName[] = { "Bluetooth HID" };
685 LOG_INFO("[HIDH Machine]%{public}s():cachedName[%{public}s],vendorId[%{public}d],productId[%{public}d]",
686 __FUNCTION__, cachedName, pnpInf.vendorId, pnpInf.productId);
687 LOG_INFO("[HIDH Machine]%{public}s():version[%{public}d],ctryCode[%{public}d],descLength[%{public}d]",
688 __FUNCTION__, pnpInf.version, hidInf.ctryCode, hidInf.descLength);
689 uhid_.SendHidInfo(cachedName, pnpInf, hidInf);
690 }
691
GetDeviceStateInt() const692 int HidHostStateMachine::GetDeviceStateInt() const
693 {
694 return static_cast<const HidHostState*>(GetState())->GetStateInt();
695 }
696
StartConnectionTimer() const697 void HidHostStateMachine::StartConnectionTimer() const
698 {
699 connTimer_->Start(CONNECTION_TIMEOUT_MS);
700 LOG_INFO("[HIDH Machine]%{public}s():Start connection timer!", __FUNCTION__);
701 }
702
StopConnectionTimer() const703 void HidHostStateMachine::StopConnectionTimer() const
704 {
705 connTimer_->Stop();
706 LOG_INFO("[HIDH Machine]%{public}s():Stop connection timer!", __FUNCTION__);
707 }
708
ConnectionTimeout() const709 void HidHostStateMachine::ConnectionTimeout() const
710 {
711 HidHostMessage event(HID_HOST_CONNECTION_TIMEOUT_EVT);
712 event.dev_ = address_;
713 HidHostService::GetService()->PostEvent(event);
714 }
715
StartDisconnectionTimer() const716 void HidHostStateMachine::StartDisconnectionTimer() const
717 {
718 disconnTimer_->Start(DISCONNECTION_TIMEOUT_MS);
719 LOG_INFO("[HIDH Machine]%{public}s():Start disconnection timer!", __FUNCTION__);
720 }
721
StopDisconnectionTimer() const722 void HidHostStateMachine::StopDisconnectionTimer() const
723 {
724 disconnTimer_->Stop();
725 LOG_INFO("[HIDH Machine]%{public}s():Stop disconnection timer!", __FUNCTION__);
726 }
727
DisonnectionTimeout() const728 void HidHostStateMachine::DisonnectionTimeout() const
729 {
730 HidHostMessage event(HID_HOST_DISCONNECTION_TIMEOUT_EVT);
731 event.dev_ = address_;
732 HidHostService::GetService()->PostEvent(event);
733 }
734
GetEventName(int what)735 std::string HidHostStateMachine::GetEventName(int what)
736 {
737 switch (what) {
738 case HID_HOST_SERVICE_STARTUP_EVT:
739 return "HID_HOST_SERVICE_STARTUP_EVT";
740 case HID_HOST_SERVICE_SHUTDOWN_EVT:
741 return "HID_HOST_SERVICE_SHUTDOWN_EVT";
742 case HID_HOST_API_OPEN_EVT:
743 return "HID_HOST_API_OPEN_EVT";
744 case HID_HOST_API_CLOSE_EVT:
745 return "HID_HOST_API_CLOSE_EVT";
746 case HID_HOST_INT_OPEN_EVT:
747 return "HID_HOST_INT_OPEN_EVT";
748 case HID_HOST_INT_CLOSE_EVT:
749 return "HID_HOST_INT_CLOSE_EVT";
750 case HID_HOST_INT_DATA_EVT:
751 return "HID_HOST_INT_DATA_EVT";
752 case HID_HOST_INT_CTRL_DATA:
753 return "HID_HOST_INT_CTRL_DATA";
754 case HID_HOST_INT_HANDSK_EVT:
755 return "HID_HOST_INT_HANDSK_EVT";
756 case HID_HOST_SDP_CMPL_EVT:
757 return "HID_HOST_SDP_CMPL_EVT";
758 case HID_HOST_API_WRITE_DEV_EVT:
759 return "HID_HOST_API_WRITE_DEV_EVT";
760 case HID_HOST_OPEN_CMPL_EVT:
761 return "HID_HOST_OPEN_CMPL_EVT";
762 case HID_HOST_L2CAP_CONNECT_REQ_EVT:
763 return "HID_HOST_L2CAP_CONNECT_REQ_EVT";
764 case HID_HOST_CONNECTION_TIMEOUT_EVT:
765 return "HID_HOST_CONNECTION_TIMEOUT_EVT";
766 case HID_HOST_DISCONNECTION_TIMEOUT_EVT:
767 return "HID_HOST_DISCONNECTION_TIMEOUT_EVT";
768 default:
769 return "Unknown";
770 }
771 }
772
NotifyStateTransitions()773 void HidHostStateMachine::NotifyStateTransitions()
774 {
775 HidHostService *service = HidHostService::GetService();
776 int toState = GetDeviceStateInt();
777 if (service != nullptr) {
778 RawAddress device(address_);
779 if ((preState_ != toState) && (preState_ <= HID_HOST_STATE_CONNECTED)
780 && (toState <= HID_HOST_STATE_CONNECTED)) {
781 service->NotifyStateChanged(device, toState);
782 }
783 }
784
785 preState_ = toState;
786 }
787
AddDeferredMessage(const HidHostMessage & msg)788 void HidHostStateMachine::AddDeferredMessage(const HidHostMessage &msg)
789 {
790 deferMsgs_.push_back(msg);
791 }
792
ProcessDeferredMessage()793 void HidHostStateMachine::ProcessDeferredMessage()
794 {
795 auto size = deferMsgs_.size();
796 while (size-- > 0 && !deferMsgs_.empty()) {
797 HidHostMessage event = deferMsgs_.front();
798 deferMsgs_.pop_front();
799 HidHostService::GetService()->PostEvent(event);
800 }
801 }
802 } // namespace bluetooth
803 } // namespace OHOS
804