|
1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Implements the state machine which drives backup and restore support for the |
|
15 // Bluetooth Manager server. |
|
16 // |
|
17 |
|
18 /** |
|
19 @file |
|
20 @internalAll |
|
21 */ |
|
22 |
|
23 #ifndef BTMANSERVERBURSTATEMACHINE_H |
|
24 #define BTMANSERVERBURSTATEMACHINE_H |
|
25 |
|
26 /** |
|
27 TBTBURState - records the state of the BUR manager. |
|
28 **/ |
|
29 enum TBTBURState |
|
30 { |
|
31 EBTBURStateNormal, // Waiting for a BUR event |
|
32 |
|
33 EBTBURStateBackupRequest, // Processing a backup request |
|
34 EBTBURStateBackupOngoing, // Taking part in a backup operation |
|
35 EBTBURStateBackupIgnore, // Not taking part in a backup operation (e.g. operation may not affect us) |
|
36 |
|
37 EBTBURStateRestoreRequest, // Processing a restore request |
|
38 EBTBURStateRestoreOngoing, // Taking part in a restore operation |
|
39 EBTBURStateRestoreIgnore, // Not taking part in a restore operation (e.g. operation may not affect us) |
|
40 |
|
41 EBTBURStateProcessRestoreFile, // Processing an available restore file. |
|
42 EBTBURStateRestoreFileProcessingComplete, // Processing of restore file has completed and registry has been updated |
|
43 |
|
44 EBTBURStateUnknown, // Used to indicate an invalid transition |
|
45 }; |
|
46 |
|
47 /** |
|
48 TBTBUREvent - Events which can cause transitions in the state of the BUR manager |
|
49 **/ |
|
50 enum TBTBUREvent |
|
51 { |
|
52 // Events relating to P&S key changes from BUR engine |
|
53 EBTBUREventUnset, // Unset notification event received from the Secure Backup Engine |
|
54 EBTBUREventNormal, // Normal mode notification event received from the Secure Backup Engine |
|
55 EBTBUREventBackup, // Backup notification event received from the Secure Backup Engine |
|
56 EBTBUREventRestore, // Restore notification event received from the Secure Backup Engine |
|
57 |
|
58 // Internally generated events |
|
59 EBTBUREventBackupProceed, // BUR manager should proceed with backup operation |
|
60 EBTBUREventBackupReject, // BUR manager should not proceed with backup operation |
|
61 EBTBUREventRestoreProceed, // BUR manager should proceed with restore operation |
|
62 EBTBUREventRestoreReject, // BUR manager should not proceed with restore operation |
|
63 EBTBUREventProcessRestoreFile, // Request to process an available restore file |
|
64 EBTBUREventProcessRestoreFileComplete, // Parsing of restore file has completed |
|
65 EBTBUREventRestoreFileTransitionNormal, // Parsing of restore file has been completed, transition should be made to normal state. |
|
66 |
|
67 EBTBUREventAbortStateAction, // A state action has encountered an error which requires an abort back to normal state. |
|
68 }; |
|
69 |
|
70 /** |
|
71 State handling mechanisms - these classes support the state machine used by the BUR manager. |
|
72 **/ |
|
73 |
|
74 class CBTManServerBURMgr; |
|
75 class CBTManServerBURMgrStateAction; |
|
76 |
|
77 NONSHARABLE_CLASS(CBTManServerBURMgrStateFactory) : public CBase |
|
78 { |
|
79 public: |
|
80 static CBTManServerBURMgrStateFactory* NewL(CBTManServerBURMgr& aBURMgr); |
|
81 ~CBTManServerBURMgrStateFactory(); |
|
82 |
|
83 inline TBTBURState GetCurrentState(); |
|
84 TInt TransitionState(TBTBUREvent aTransitionEvent); |
|
85 void ExecuteAction(); |
|
86 |
|
87 private: |
|
88 CBTManServerBURMgrStateFactory(CBTManServerBURMgr& aBURMgr); |
|
89 void ConstructL(); |
|
90 |
|
91 void ConstructStateMachineL(); |
|
92 CBTManServerBURMgrStateAction* ConstructStateLC(TBTBURState aState); |
|
93 |
|
94 private: |
|
95 RPointerArray<CBTManServerBURMgrStateAction> iStateActions; |
|
96 CBTManServerBURMgr& iBURMgr; |
|
97 TBTBURState iState; |
|
98 |
|
99 }; |
|
100 |
|
101 NONSHARABLE_CLASS(CBTManServerBURMgrStateAction) : public CBase |
|
102 { |
|
103 public: |
|
104 ~CBTManServerBURMgrStateAction(); |
|
105 |
|
106 inline TBTBURState GetThisState(); |
|
107 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent)=0; |
|
108 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr)=0; |
|
109 virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError); |
|
110 |
|
111 protected: |
|
112 CBTManServerBURMgrStateAction(TBTBURState aState); |
|
113 |
|
114 protected: |
|
115 TBTBURState iState; |
|
116 |
|
117 }; |
|
118 |
|
119 /** |
|
120 Normal state |
|
121 **/ |
|
122 |
|
123 NONSHARABLE_CLASS(CBTManServerBURMgrStateNormal) : public CBTManServerBURMgrStateAction |
|
124 { |
|
125 public: |
|
126 static CBTManServerBURMgrStateNormal* NewLC(); |
|
127 ~CBTManServerBURMgrStateNormal(); |
|
128 |
|
129 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
130 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
131 |
|
132 protected: |
|
133 CBTManServerBURMgrStateNormal(); |
|
134 |
|
135 }; |
|
136 |
|
137 /** |
|
138 Backup states |
|
139 **/ |
|
140 |
|
141 NONSHARABLE_CLASS(CBTManServerBURMgrStateBackupRequest) : public CBTManServerBURMgrStateAction |
|
142 { |
|
143 public: |
|
144 static CBTManServerBURMgrStateBackupRequest* NewLC(); |
|
145 ~CBTManServerBURMgrStateBackupRequest(); |
|
146 |
|
147 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
148 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
149 virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError); |
|
150 |
|
151 protected: |
|
152 CBTManServerBURMgrStateBackupRequest(); |
|
153 |
|
154 }; |
|
155 |
|
156 NONSHARABLE_CLASS(CBTManServerBURMgrStateBackupOngoing) : public CBTManServerBURMgrStateAction |
|
157 { |
|
158 public: |
|
159 static CBTManServerBURMgrStateBackupOngoing* NewLC(); |
|
160 ~CBTManServerBURMgrStateBackupOngoing(); |
|
161 |
|
162 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
163 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
164 virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError); |
|
165 |
|
166 protected: |
|
167 CBTManServerBURMgrStateBackupOngoing(); |
|
168 |
|
169 }; |
|
170 |
|
171 |
|
172 NONSHARABLE_CLASS(CBTManServerBURMgrStateBackupIgnore) : public CBTManServerBURMgrStateAction |
|
173 { |
|
174 public: |
|
175 static CBTManServerBURMgrStateBackupIgnore* NewLC(); |
|
176 ~CBTManServerBURMgrStateBackupIgnore(); |
|
177 |
|
178 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
179 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
180 |
|
181 protected: |
|
182 CBTManServerBURMgrStateBackupIgnore(); |
|
183 |
|
184 }; |
|
185 |
|
186 /** |
|
187 Restore states |
|
188 **/ |
|
189 |
|
190 NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreRequest) : public CBTManServerBURMgrStateAction |
|
191 { |
|
192 public: |
|
193 static CBTManServerBURMgrStateRestoreRequest* NewLC(); |
|
194 ~CBTManServerBURMgrStateRestoreRequest(); |
|
195 |
|
196 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
197 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
198 virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError); |
|
199 |
|
200 protected: |
|
201 CBTManServerBURMgrStateRestoreRequest(); |
|
202 |
|
203 }; |
|
204 |
|
205 NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreOngoing) : public CBTManServerBURMgrStateAction |
|
206 { |
|
207 public: |
|
208 static CBTManServerBURMgrStateRestoreOngoing* NewLC(); |
|
209 ~CBTManServerBURMgrStateRestoreOngoing(); |
|
210 |
|
211 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
212 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
213 virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError); |
|
214 |
|
215 protected: |
|
216 CBTManServerBURMgrStateRestoreOngoing(); |
|
217 |
|
218 }; |
|
219 |
|
220 NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreIgnore) : public CBTManServerBURMgrStateAction |
|
221 { |
|
222 public: |
|
223 static CBTManServerBURMgrStateRestoreIgnore* NewLC(); |
|
224 ~CBTManServerBURMgrStateRestoreIgnore(); |
|
225 |
|
226 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
227 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
228 |
|
229 protected: |
|
230 CBTManServerBURMgrStateRestoreIgnore(); |
|
231 |
|
232 }; |
|
233 |
|
234 /** |
|
235 Restore file processing states |
|
236 **/ |
|
237 |
|
238 NONSHARABLE_CLASS(CBTManServerBURMgrStateProcessRestoreFile) : public CBTManServerBURMgrStateAction |
|
239 { |
|
240 public: |
|
241 static CBTManServerBURMgrStateProcessRestoreFile* NewLC(); |
|
242 ~CBTManServerBURMgrStateProcessRestoreFile(); |
|
243 |
|
244 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
245 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
246 virtual void HandleActionError(CBTManServerBURMgr& aBURMgr, TInt aError); |
|
247 |
|
248 protected: |
|
249 CBTManServerBURMgrStateProcessRestoreFile(); |
|
250 |
|
251 }; |
|
252 |
|
253 NONSHARABLE_CLASS(CBTManServerBURMgrStateRestoreFileProcessingComplete) : public CBTManServerBURMgrStateAction |
|
254 { |
|
255 public: |
|
256 static CBTManServerBURMgrStateRestoreFileProcessingComplete* NewLC(); |
|
257 ~CBTManServerBURMgrStateRestoreFileProcessingComplete(); |
|
258 |
|
259 virtual TBTBURState GetNextState(TBTBUREvent aTransitionEvent); |
|
260 virtual void ExecuteActionL(CBTManServerBURMgr& aBURMgr); |
|
261 |
|
262 protected: |
|
263 CBTManServerBURMgrStateRestoreFileProcessingComplete(); |
|
264 |
|
265 }; |
|
266 |
|
267 #endif // BTMANSERVERBURSTATEMACHINE_H |