1 /*
2  * Copyright (C) 2021 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 "sys_state_machine.h"
17 #include "adapter_manager.h"
18 #include "log.h"
19 
20 namespace OHOS {
21 namespace bluetooth {
Init(AdapterManager & am)22 void SysStateMachine::Init(AdapterManager &am)
23 {
24     std::unique_ptr<utility::StateMachine::State> stopped = std::make_unique<SysStoppedState>(*this, am);
25     Move(stopped);
26     std::unique_ptr<utility::StateMachine::State> started = std::make_unique<SysStartedState>(*this, am);
27     Move(started);
28     std::unique_ptr<utility::StateMachine::State> stopping = std::make_unique<SysStoppingState>(*this, am);
29     Move(stopping);
30     std::unique_ptr<utility::StateMachine::State> resetting = std::make_unique<SysResettingState>(*this, am);
31     Move(resetting);
32     std::unique_ptr<utility::StateMachine::State> factoryResetting =
33         std::make_unique<SysFactoryResettingState>(*this, am);
34     Move(factoryResetting);
35     InitState(SYS_STATE_STOPPED);
36 }
37 
StoppingBaseProcess(int stateBREDR,int stateBLE)38 void SysStoppingBaseState::StoppingBaseProcess(int stateBREDR, int stateBLE)
39 {
40     LOG_DEBUG("%{public}s", __PRETTY_FUNCTION__);
41     if ((stateBREDR == BTStateID::STATE_TURN_OFF) && (stateBLE == BTStateID::STATE_TURN_OFF)) {
42         LOG_DEBUG("%{public}s all off", __PRETTY_FUNCTION__);
43         am_.AdapterStop();
44     } else if ((stateBREDR == BTStateID::STATE_TURNING_ON) || (stateBLE == BTStateID::STATE_TURNING_ON) ||
45                (stateBREDR == BTStateID::STATE_TURNING_OFF) || (stateBLE == BTStateID::STATE_TURNING_OFF)) {
46         // wait turn on/turn off
47         LOG_DEBUG("%{public}s at least one is *ing", __PRETTY_FUNCTION__);
48     } else {
49         am_.Disable(BTTransport::ADAPTER_BREDR);
50         am_.Disable(BTTransport::ADAPTER_BLE);
51     }
52 }
53 
Entry()54 void SysStoppedState::Entry()
55 {
56     LOG_DEBUG("%{public}s Entry", __PRETTY_FUNCTION__);
57 }
58 
Dispatch(const utility::Message & msg)59 bool SysStoppedState::Dispatch(const utility::Message &msg)
60 {
61     LOG_DEBUG("%{public}s Dispatch %{public}d", __PRETTY_FUNCTION__, msg.what_);
62     switch (msg.what_) {
63         case SysStateMachine::MSG_SYS_START_CMP:
64             Transition(SYS_STATE_STARTED);
65             return true;
66         default:
67             return false;
68     }
69 }
70 
Entry()71 void SysStartedState::Entry()
72 {
73     LOG_DEBUG("%{public}s Entry", __PRETTY_FUNCTION__);
74     am_.OnSysStateChange(SYS_STATE_STARTED);
75 }
76 
Dispatch(const utility::Message & msg)77 bool SysStartedState::Dispatch(const utility::Message &msg)
78 {
79     LOG_DEBUG("%{public}s Dispatch %{public}d", __PRETTY_FUNCTION__, msg.what_);
80     switch (msg.what_) {
81         case SysStateMachine::MSG_SYS_RESET_REQ:
82             Transition(SYS_STATE_RESETTING);
83             break;
84         case SysStateMachine::MSG_SYS_FACTORY_RESET_REQ:
85             Transition(SYS_STATE_FRESETTING);
86             break;
87         case SysStateMachine::MSG_SYS_STOP_REQ:
88             Transition(SYS_STATE_STOPPING);
89             break;
90         default:
91             return false;
92     }
93     return true;
94 }
95 
Entry()96 void SysStoppingState::Entry()
97 {
98     LOG_DEBUG("%{public}s Entry", __PRETTY_FUNCTION__);
99 
100     int stateBREDR = am_.GetState(BTTransport::ADAPTER_BREDR);
101     int stateBLE = am_.GetState(BTTransport::ADAPTER_BLE);
102 
103     am_.OnSysStateChange(SYS_STATE_STOPPING);
104     StoppingBaseProcess(stateBREDR, stateBLE);
105 }
106 
Exit()107 void SysStoppingState::Exit()
108 {
109     am_.OnSysStateExit(SYS_STATE_STOPPING);
110 }
111 
Dispatch(const utility::Message & msg)112 bool SysStoppingState::Dispatch(const utility::Message &msg)
113 {
114     LOG_DEBUG("%{public}s Dispatch %{public}d", __PRETTY_FUNCTION__, msg.what_);
115     int stateBREDR = BTStateID::STATE_TURN_OFF;
116     int stateBLE = BTStateID::STATE_TURN_OFF;
117     switch (msg.what_) {
118         case SysStateMachine::MSG_SYS_STOP_CMP:
119             am_.OnSysStateChange(SYS_STATE_STOPPED);
120             Transition(SYS_STATE_STOPPED);
121             return true;
122         case SysStateMachine::MSG_SYS_ADAPTER_STATE_CHANGE_REQ:
123             stateBREDR = ((unsigned int)msg.arg1_ & 0xF0) >> CLASSIC_ENABLE_STATE_BIT;
124             stateBLE = (unsigned int)msg.arg1_ & 0x0F;
125             StoppingBaseProcess(stateBREDR, stateBLE);
126             return true;
127         default:
128             return false;
129     }
130 }
131 
Entry()132 void SysResettingState::Entry()
133 {
134     LOG_DEBUG("%{public}s Entry", __PRETTY_FUNCTION__);
135 
136     int stateBREDR = am_.GetState(BTTransport::ADAPTER_BREDR);
137     int stateBLE = am_.GetState(BTTransport::ADAPTER_BLE);
138 
139     am_.OnSysStateChange(SYS_STATE_RESETTING);
140     StoppingBaseProcess(stateBREDR, stateBLE);
141 }
142 
Dispatch(const utility::Message & msg)143 bool SysResettingState::Dispatch(const utility::Message &msg)
144 {
145     LOG_DEBUG("%{public}s Dispatch %{public}d %{public}d", __PRETTY_FUNCTION__, msg.what_, msg.arg1_);
146     int stateBREDR = BTStateID::STATE_TURN_OFF;
147     int stateBLE = BTStateID::STATE_TURN_OFF;
148     switch (msg.what_) {
149         case SysStateMachine::MSG_SYS_ADAPTER_STATE_CHANGE_REQ:
150             stateBREDR = ((unsigned int)msg.arg1_ & 0xF0) >> CLASSIC_ENABLE_STATE_BIT;
151             stateBLE = (unsigned int)msg.arg1_ & 0x0F;
152             StoppingBaseProcess(stateBREDR, stateBLE);
153             break;
154         case SysStateMachine::MSG_SYS_STOP_CMP:
155             am_.Start();
156             Transition(SYS_STATE_STARTED);
157             break;
158         case SysStateMachine::MSG_SYS_STOP_REQ:
159             Transition(SYS_STATE_STOPPING);
160             break;
161         default:
162             return false;
163     }
164     return true;
165 }
166 
167 // SysResettingState
Entry()168 void SysFactoryResettingState::Entry()
169 {
170     LOG_DEBUG("%{public}s Entry", __PRETTY_FUNCTION__);
171 
172     int stateBREDR = am_.GetState(BTTransport::ADAPTER_BREDR);
173     int stateBLE = am_.GetState(BTTransport::ADAPTER_BLE);
174 
175     am_.OnSysStateChange(SYS_STATE_FRESETTING);
176     StoppingBaseProcess(stateBREDR, stateBLE);
177 }
178 
Exit()179 void SysFactoryResettingState::Exit()
180 {
181     am_.OnSysStateExit(SYS_STATE_FRESETTING);
182 }
183 
Dispatch(const utility::Message & msg)184 bool SysFactoryResettingState::Dispatch(const utility::Message &msg)
185 {
186     LOG_DEBUG("%{public}s Dispatch %{public}d", __PRETTY_FUNCTION__, msg.what_);
187     int stateBREDR = BTStateID::STATE_TURN_OFF;
188     int stateBLE = BTStateID::STATE_TURN_OFF;
189     switch (msg.what_) {
190         case SysStateMachine::MSG_SYS_ADAPTER_STATE_CHANGE_REQ:
191             stateBREDR = ((unsigned int)msg.arg1_ & 0xF0) >> CLASSIC_ENABLE_STATE_BIT;
192             stateBLE = (unsigned int)msg.arg1_ & 0x0F;
193             StoppingBaseProcess(stateBREDR, stateBLE);
194             break;
195         case SysStateMachine::MSG_SYS_STOP_CMP:
196             am_.ClearAllStorage();
197             break;
198         case SysStateMachine::MSG_SYS_STOP_REQ:
199             Transition(SYS_STATE_STOPPING);
200             break;
201         case SysStateMachine::MSG_SYS_CLEAR_ALL_STORAGE_CMP:
202             am_.Start();
203             Transition(SYS_STATE_STARTED);
204             break;
205         default:
206             return false;
207     }
208     return true;
209 }
210 }  // namespace bluetooth
211 }  // namespace OHOS