21 #include "calenstate.h" // Calendar States |
21 #include "calenstate.h" // Calendar States |
22 #include "calencontroller.h" |
22 #include "calencontroller.h" |
23 #include "calenstatemachine.h" |
23 #include "calenstatemachine.h" |
24 #include "calennotifier.h" |
24 #include "calennotifier.h" |
25 #include "calenasynccallback.h" |
25 #include "calenasynccallback.h" |
|
26 #include "OstTraceDefinitions.h" |
|
27 #ifdef OST_TRACE_COMPILER_IN_USE |
|
28 #include "calenstateTraces.h" |
|
29 #endif |
26 |
30 |
27 // ---------------------------------------------------------------------------- |
31 // ---------------------------------------------------------------------------- |
28 // CCalenState::CCalenState |
32 // CCalenState::CCalenState |
29 // C++ constructor |
33 // C++ constructor |
30 // ---------------------------------------------------------------------------- |
34 // ---------------------------------------------------------------------------- |
31 CCalenState::CCalenState( CCalenController& aController,RHashSet<TCalenNotification>& aOutstandingNotifications ) |
35 CCalenState::CCalenState( CCalenController& aController,RHashSet<TCalenNotification>& aOutstandingNotifications ) |
32 : iController( aController ), |
36 : iController( aController ), |
33 iOutstandingNotifications( aOutstandingNotifications ), |
37 iOutstandingNotifications( aOutstandingNotifications ), |
34 iPreviousState( CCalenStateMachine::ECalenIdleState ) |
38 iPreviousState( CCalenStateMachine::ECalenIdleState ) |
35 { |
39 { |
36 TRACE_ENTRY_POINT; |
40 OstTraceFunctionEntry0( CCALENSTATE_CCALENSTATE_ENTRY ); |
37 |
41 |
38 TRACE_EXIT_POINT; |
42 OstTraceFunctionExit0( CCALENSTATE_CCALENSTATE_EXIT ); |
39 } |
43 } |
40 |
44 |
41 // ---------------------------------------------------------------------------- |
45 // ---------------------------------------------------------------------------- |
42 // CCalenState::ConstructL |
46 // CCalenState::ConstructL |
43 // second phase construction |
47 // second phase construction |
44 // ---------------------------------------------------------------------------- |
48 // ---------------------------------------------------------------------------- |
45 void CCalenState::BaseConstructL() |
49 void CCalenState::BaseConstructL() |
46 { |
50 { |
47 TRACE_ENTRY_POINT; |
51 OstTraceFunctionEntry0( CCALENSTATE_BASECONSTRUCTL_ENTRY ); |
48 |
52 |
49 TCalenCommand command; |
53 TCalenCommand command; |
50 MCalenCommandHandler* handler( NULL ); |
54 MCalenCommandHandler* handler( NULL ); |
51 iCallBackPackage = new( ELeave ) CalenCallbackPackage( this, command, handler ); |
55 iCallBackPackage = new( ELeave ) CalenCallbackPackage( this, command, handler ); |
52 |
56 |
53 TRACE_EXIT_POINT; |
57 OstTraceFunctionExit0( CCALENSTATE_BASECONSTRUCTL_EXIT ); |
54 } |
58 } |
55 |
59 |
56 // ---------------------------------------------------------------------------- |
60 // ---------------------------------------------------------------------------- |
57 // CCalenState::~CCalenState |
61 // CCalenState::~CCalenState |
58 // Destructor |
62 // Destructor |
59 // ---------------------------------------------------------------------------- |
63 // ---------------------------------------------------------------------------- |
60 CCalenState::~CCalenState() |
64 CCalenState::~CCalenState() |
61 { |
65 { |
62 TRACE_ENTRY_POINT; |
66 OstTraceFunctionEntry0( DUP1_CCALENSTATE_CCALENSTATE_ENTRY ); |
63 |
67 |
64 delete iCallBackPackage; |
68 delete iCallBackPackage; |
65 iCallBackPackage = NULL; |
69 iCallBackPackage = NULL; |
66 delete iCmdCallback; |
70 delete iCmdCallback; |
67 |
71 |
68 TRACE_EXIT_POINT; |
72 OstTraceFunctionExit0( DUP1_CCALENSTATE_CCALENSTATE_EXIT ); |
69 } |
73 } |
70 |
74 |
71 // ---------------------------------------------------------------------------- |
75 // ---------------------------------------------------------------------------- |
72 // CCalenState::RequestCallback |
76 // CCalenState::RequestCallback |
73 // Request a callback |
77 // Request a callback |
74 // ---------------------------------------------------------------------------- |
78 // ---------------------------------------------------------------------------- |
75 void CCalenState::RequestCallbackL( MCalenCommandHandler* aCommandHandler, const TCalenCommand& aCommand ) |
79 void CCalenState::RequestCallbackL( MCalenCommandHandler* aCommandHandler, const TCalenCommand& aCommand ) |
76 { |
80 { |
77 TRACE_ENTRY_POINT; |
81 OstTraceFunctionEntry0( CCALENSTATE_REQUESTCALLBACKL_ENTRY ); |
78 |
82 |
79 iCallBackPackage->SetCommandHandler(this, aCommand, aCommandHandler); |
83 iCallBackPackage->SetCommandHandler(this, aCommand, aCommandHandler); |
80 |
84 |
81 if( !iCmdCallback ) |
85 if( !iCmdCallback ) |
82 { |
86 { |
83 TCallBack callback( CommandCallback, iCallBackPackage ); |
87 TCallBack callback( CommandCallback, iCallBackPackage ); |
88 |
92 |
89 iCmdCallback->Cancel(); |
93 iCmdCallback->Cancel(); |
90 iCmdCallback->Set( callback ); |
94 iCmdCallback->Set( callback ); |
91 iCmdCallback->CallBack(); |
95 iCmdCallback->CallBack(); |
92 |
96 |
93 TRACE_EXIT_POINT; |
97 OstTraceFunctionExit0( CCALENSTATE_REQUESTCALLBACKL_EXIT ); |
94 } |
98 } |
95 |
99 |
96 |
100 |
97 |
101 |
98 // ---------------------------------------------------------------------------- |
102 // ---------------------------------------------------------------------------- |
99 // CCalenState::CommandCallback |
103 // CCalenState::CommandCallback |
100 // Static callback function |
104 // Static callback function |
101 // ---------------------------------------------------------------------------- |
105 // ---------------------------------------------------------------------------- |
102 TInt CCalenState::CommandCallback( TAny* aCommandStruct ) |
106 TInt CCalenState::CommandCallback( TAny* aCommandStruct ) |
103 { |
107 { |
104 TRACE_ENTRY_POINT; |
108 OstTraceFunctionEntry0( CCALENSTATE_COMMANDCALLBACK_ENTRY ); |
|
109 |
105 TBool continueCommand(EFalse); |
110 TBool continueCommand(EFalse); |
106 |
111 |
107 CalenCallbackPackage* package = static_cast<CalenCallbackPackage*>( aCommandStruct ); |
112 CalenCallbackPackage* package = static_cast<CalenCallbackPackage*>( aCommandStruct ); |
108 continueCommand = package->HandleCallBack(); |
113 continueCommand = package->HandleCallBack(); |
109 |
114 |
110 TRACE_EXIT_POINT; |
115 OstTraceFunctionExit0( CCALENSTATE_COMMANDCALLBACK_EXIT ); |
111 return continueCommand; |
116 return continueCommand; |
112 } |
117 } |
113 |
118 |
114 // ---------------------------------------------------------------------------- |
119 // ---------------------------------------------------------------------------- |
115 // CCalenState::HandleNotificationL |
120 // CCalenState::HandleNotificationL |
137 default: |
142 default: |
138 iController.Notifier().BroadcastApprovedNotification( aNotification ); |
143 iController.Notifier().BroadcastApprovedNotification( aNotification ); |
139 break; |
144 break; |
140 } |
145 } |
141 |
146 |
142 |
147 OstTraceFunctionExit0( CCALENSTATE_HANDLENOTIFICATIONL_EXIT ); |
143 TRACE_EXIT_POINT; |
|
144 |
|
145 } |
148 } |
146 |
149 |
147 |
150 |
148 // ---------------------------------------------------------------------------- |
151 // ---------------------------------------------------------------------------- |
149 // CCalenState::PreviousState |
152 // CCalenState::PreviousState |
150 // C++ constructor |
153 // C++ constructor |
151 // ---------------------------------------------------------------------------- |
154 // ---------------------------------------------------------------------------- |
152 CCalenStateMachine::TCalenStateIndex CCalenState::PreviousState() |
155 CCalenStateMachine::TCalenStateIndex CCalenState::PreviousState() |
153 { |
156 { |
154 TRACE_ENTRY_POINT; |
157 OstTraceFunctionEntry0( CCALENSTATE_PREVIOUSSTATE_ENTRY ); |
155 |
158 |
156 TRACE_EXIT_POINT; |
159 OstTraceFunctionExit0( CCALENSTATE_PREVIOUSSTATE_EXIT ); |
157 return iPreviousState; |
160 return iPreviousState; |
158 } |
161 } |
159 |
162 |
160 // ---------------------------------------------------------------------------- |
163 // ---------------------------------------------------------------------------- |
161 // CCalenState::SetPreviousState |
164 // CCalenState::SetPreviousState |
162 // Sets previous state. |
165 // Sets previous state. |
163 // ---------------------------------------------------------------------------- |
166 // ---------------------------------------------------------------------------- |
164 void CCalenState::SetPreviousState(const CCalenStateMachine::TCalenStateIndex& aPreviousState ) |
167 void CCalenState::SetPreviousState(const CCalenStateMachine::TCalenStateIndex& aPreviousState ) |
165 { |
168 { |
166 TRACE_ENTRY_POINT; |
169 OstTraceFunctionEntry0( CCALENSTATE_SETPREVIOUSSTATE_ENTRY ); |
167 |
170 |
168 iPreviousState = aPreviousState; |
171 iPreviousState = aPreviousState; |
169 |
172 |
170 TRACE_EXIT_POINT; |
173 OstTraceFunctionExit0( CCALENSTATE_SETPREVIOUSSTATE_EXIT ); |
171 } |
174 } |
172 |
175 |
173 // ---------------------------------------------------------------------------- |
176 // ---------------------------------------------------------------------------- |
174 // CCalenState::CommandExecuting |
177 // CCalenState::CommandExecuting |
175 // From CCalenState |
178 // From CCalenState |
176 // ---------------------------------------------------------------------------- |
179 // ---------------------------------------------------------------------------- |
177 void CCalenState::CommandExecuting() |
180 void CCalenState::CommandExecuting() |
178 { |
181 { |
179 TRACE_ENTRY_POINT; |
182 OstTraceFunctionEntry0( CCALENSTATE_COMMANDEXECUTING_ENTRY ); |
180 TRACE_EXIT_POINT; |
183 |
|
184 OstTraceFunctionExit0( CCALENSTATE_COMMANDEXECUTING_EXIT ); |
181 } |
185 } |
182 |
186 |
183 // ---------------------------------------------------------------------------- |
187 // ---------------------------------------------------------------------------- |
184 // CCalenState::CalenCallbackPackage::CalenCallbackPackage |
188 // CCalenState::CalenCallbackPackage::CalenCallbackPackage |
185 // C++ constructor |
189 // C++ constructor |
186 // ---------------------------------------------------------------------------- |
190 // ---------------------------------------------------------------------------- |
187 CCalenState::CalenCallbackPackage::CalenCallbackPackage( CCalenState* aSelf, |
191 CCalenState::CalenCallbackPackage::CalenCallbackPackage( CCalenState* aSelf, |
188 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
192 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
189 : iSelf( aSelf ), iCommand( aCommand ), iCommandHandler( aCommandHandler ) |
193 : iSelf( aSelf ), iCommand( aCommand ), iCommandHandler( aCommandHandler ) |
190 { |
194 { |
191 TRACE_ENTRY_POINT; |
195 OstTraceFunctionEntry0( CALENCALLBACKPACKAGE_CALENCALLBACKPACKAGE_ENTRY ); |
192 TRACE_EXIT_POINT; |
196 |
|
197 OstTraceFunctionExit0( CALENCALLBACKPACKAGE_CALENCALLBACKPACKAGE_EXIT ); |
193 } |
198 } |
194 |
199 |
195 // ---------------------------------------------------------------------------- |
200 // ---------------------------------------------------------------------------- |
196 // CCalenState::CalenCallbackPackage::HandleCallBack |
201 // CCalenState::CalenCallbackPackage::HandleCallBack |
197 // Handles a callback |
202 // Handles a callback |
198 // ---------------------------------------------------------------------------- |
203 // ---------------------------------------------------------------------------- |
199 TBool CCalenState::CalenCallbackPackage::HandleCallBack() |
204 TBool CCalenState::CalenCallbackPackage::HandleCallBack() |
200 { |
205 { |
201 TRACE_ENTRY_POINT; |
206 OstTraceFunctionEntry0( CALENCALLBACKPACKAGE_HANDLECALLBACK_ENTRY ); |
|
207 |
202 TBool continueCommand(EFalse); |
208 TBool continueCommand(EFalse); |
203 |
209 |
204 iSelf->CommandExecuting(); |
210 iSelf->CommandExecuting(); |
205 PIM_TRAPD_HANDLE ( continueCommand = iCommandHandler->HandleCommandL( iCommand ) ); |
211 PIM_TRAPD_HANDLE ( continueCommand = iCommandHandler->HandleCommandL( iCommand ) ); |
206 |
212 |
207 TRACE_EXIT_POINT; |
213 OstTraceFunctionExit0( CALENCALLBACKPACKAGE_HANDLECALLBACK_EXIT ); |
208 return continueCommand; |
214 return continueCommand; |
209 } |
215 } |
210 |
216 |
211 // ---------------------------------------------------------------------------- |
217 // ---------------------------------------------------------------------------- |
212 // CCalenState::CalenCallbackPackage::SetCommandHandler |
218 // CCalenState::CalenCallbackPackage::SetCommandHandler |
213 // Sets the command handler and command |
219 // Sets the command handler and command |
214 // ---------------------------------------------------------------------------- |
220 // ---------------------------------------------------------------------------- |
215 void CCalenState::CalenCallbackPackage::SetCommandHandler(CCalenState* aSelf, |
221 void CCalenState::CalenCallbackPackage::SetCommandHandler(CCalenState* aSelf, |
216 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
222 TCalenCommand aCommand, MCalenCommandHandler* aCommandHandler) |
217 { |
223 { |
218 TRACE_ENTRY_POINT; |
224 OstTraceFunctionEntry0( CALENCALLBACKPACKAGE_SETCOMMANDHANDLER_ENTRY ); |
219 |
225 |
220 iSelf = aSelf; |
226 iSelf = aSelf; |
221 iCommand = aCommand; |
227 iCommand = aCommand; |
222 iCommandHandler = aCommandHandler; |
228 iCommandHandler = aCommandHandler; |
223 |
229 |
224 TRACE_EXIT_POINT; |
230 OstTraceFunctionExit0( CALENCALLBACKPACKAGE_SETCOMMANDHANDLER_EXIT ); |
225 } |
231 } |
226 |
232 |
227 // ---------------------------------------------------------------------------- |
233 // ---------------------------------------------------------------------------- |
228 // CCalenState::HandleStateActivationL |
234 // CCalenState::HandleStateActivationL |
229 // Default behavior when state is activated. Check and issue any outstanding |
235 // Default behavior when state is activated. Check and issue any outstanding |
230 // notifications |
236 // notifications |
231 // ---------------------------------------------------------------------------- |
237 // ---------------------------------------------------------------------------- |
232 void CCalenState::HandleStateActivationL(CCalenStateMachine& /*aStateMachine*/) |
238 void CCalenState::HandleStateActivationL(CCalenStateMachine& /*aStateMachine*/) |
233 { |
239 { |
234 TRACE_ENTRY_POINT; |
240 OstTraceFunctionEntry0( CCALENSTATE_HANDLESTATEACTIVATIONL_ENTRY ); |
235 |
241 |
236 // Can only issue one of the following Notifications |
242 // Can only issue one of the following Notifications |
237 // ECalenNotifySettingsChanged or |
243 // ECalenNotifySettingsChanged or |
238 // ECalenNotifySystemLocaleChanged or |
244 // ECalenNotifySystemLocaleChanged or |
239 // ECalenNotifySettingsClosed |
245 // ECalenNotifySettingsClosed |
256 notification = iterator.Next(); |
262 notification = iterator.Next(); |
257 } |
263 } |
258 |
264 |
259 iOutstandingNotifications.Close(); |
265 iOutstandingNotifications.Close(); |
260 |
266 |
261 TRACE_EXIT_POINT; |
267 OstTraceFunctionExit0( CCALENSTATE_HANDLESTATEACTIVATIONL_EXIT ); |
262 } |
268 } |
263 |
269 |
264 // ---------------------------------------------------------------------------- |
270 // ---------------------------------------------------------------------------- |
265 // CCalenState::SetCurrentState |
271 // CCalenState::SetCurrentState |
266 // Sets the current state |
272 // Sets the current state |
267 // ---------------------------------------------------------------------------- |
273 // ---------------------------------------------------------------------------- |
268 void CCalenState::SetCurrentState(CCalenStateMachine& aStateMachine, |
274 void CCalenState::SetCurrentState(CCalenStateMachine& aStateMachine, |
269 const CCalenStateMachine::TCalenStateIndex& aState ) |
275 const CCalenStateMachine::TCalenStateIndex& aState ) |
270 { |
276 { |
271 TRACE_ENTRY_POINT; |
277 OstTraceFunctionEntry0( CCALENSTATE_SETCURRENTSTATE_ENTRY ); |
272 |
278 |
273 aStateMachine.SetCurrentState(aState); |
279 aStateMachine.SetCurrentState(aState); |
274 |
280 |
275 TRACE_EXIT_POINT; |
281 OstTraceFunctionExit0( CCALENSTATE_SETCURRENTSTATE_EXIT ); |
276 } |
282 } |
277 |
283 |
278 // ---------------------------------------------------------------------------- |
284 // ---------------------------------------------------------------------------- |
279 // CCalenState::GetCurrentState |
285 // CCalenState::GetCurrentState |
280 // Gets the current state |
286 // Gets the current state |
281 // ---------------------------------------------------------------------------- |
287 // ---------------------------------------------------------------------------- |
282 CCalenStateMachine::TCalenStateIndex CCalenState::GetCurrentState( |
288 CCalenStateMachine::TCalenStateIndex CCalenState::GetCurrentState( |
283 CCalenStateMachine& aStateMachine) |
289 CCalenStateMachine& aStateMachine) |
284 { |
290 { |
285 TRACE_ENTRY_POINT; |
291 OstTraceFunctionEntry0( CCALENSTATE_GETCURRENTSTATE_ENTRY ); |
286 TRACE_EXIT_POINT; |
292 |
287 |
293 OstTraceFunctionExit0( CCALENSTATE_GETCURRENTSTATE_EXIT ); |
288 return aStateMachine.GetCurrentState(); |
294 return aStateMachine.GetCurrentState(); |
289 } |
295 } |
290 |
296 |
291 // ---------------------------------------------------------------------------- |
297 // ---------------------------------------------------------------------------- |
292 // CCalenState::SetPreviousState |
298 // CCalenState::SetPreviousState |
293 // Sets the previous state through state machine |
299 // Sets the previous state through state machine |
294 // ---------------------------------------------------------------------------- |
300 // ---------------------------------------------------------------------------- |
295 void CCalenState::SetCurrentPreviousState(CCalenStateMachine& aStateMachine, |
301 void CCalenState::SetCurrentPreviousState(CCalenStateMachine& aStateMachine, |
296 const CCalenStateMachine::TCalenStateIndex& aState) |
302 const CCalenStateMachine::TCalenStateIndex& aState) |
297 { |
303 { |
298 TRACE_ENTRY_POINT; |
304 OstTraceFunctionEntry0( CCALENSTATE_SETCURRENTPREVIOUSSTATE_ENTRY ); |
299 |
305 |
300 aStateMachine.SetCurrentPreviousState(aState); |
306 aStateMachine.SetCurrentPreviousState(aState); |
301 |
307 |
302 TRACE_EXIT_POINT; |
308 OstTraceFunctionExit0( CCALENSTATE_SETCURRENTPREVIOUSSTATE_EXIT ); |
303 } |
309 } |
304 |
310 |
305 // ---------------------------------------------------------------------------- |
311 // ---------------------------------------------------------------------------- |
306 // CCalenState::ActivateCurrentStateL |
312 // CCalenState::ActivateCurrentStateL |
307 // Activate current state |
313 // Activate current state |
308 // ---------------------------------------------------------------------------- |
314 // ---------------------------------------------------------------------------- |
309 void CCalenState::ActivateCurrentStateL(CCalenStateMachine& aStateMachine) |
315 void CCalenState::ActivateCurrentStateL(CCalenStateMachine& aStateMachine) |
310 { |
316 { |
311 TRACE_ENTRY_POINT; |
317 OstTraceFunctionEntry0( CCALENSTATE_ACTIVATECURRENTSTATEL_ENTRY ); |
312 |
318 |
313 aStateMachine.ActivateCurrentStateL(); |
319 aStateMachine.ActivateCurrentStateL(); |
314 |
320 |
315 TRACE_EXIT_POINT; |
321 OstTraceFunctionExit0( CCALENSTATE_ACTIVATECURRENTSTATEL_EXIT ); |
316 } |
322 } |
317 // ---------------------------------------------------------------------------- |
323 // ---------------------------------------------------------------------------- |
318 // CCalenState::CancelPreviousCmd |
324 // CCalenState::CancelPreviousCmd |
319 // Cancel the previous command |
325 // Cancel the previous command |
320 // ---------------------------------------------------------------------------- |
326 // ---------------------------------------------------------------------------- |
321 void CCalenState::CancelPreviousCmd(CCalenStateMachine& aStateMachine) |
327 void CCalenState::CancelPreviousCmd(CCalenStateMachine& aStateMachine) |
322 { |
328 { |
323 TRACE_ENTRY_POINT; |
329 OstTraceFunctionEntry0( CCALENSTATE_CANCELPREVIOUSCMD_ENTRY ); |
324 |
330 |
325 aStateMachine.CancelPreviousCmd(); |
331 aStateMachine.CancelPreviousCmd(); |
326 |
332 |
327 TRACE_EXIT_POINT; |
333 OstTraceFunctionExit0( CCALENSTATE_CANCELPREVIOUSCMD_EXIT ); |
328 } |
334 } |
329 |
335 |
330 // ---------------------------------------------------------------------------- |
336 // ---------------------------------------------------------------------------- |
331 // CCalenState::CancelExecutingCmd |
337 // CCalenState::CancelExecutingCmd |
332 // Cancels executing command |
338 // Cancels executing command |
333 // ---------------------------------------------------------------------------- |
339 // ---------------------------------------------------------------------------- |
334 void CCalenState::CancelExecutingCmd() |
340 void CCalenState::CancelExecutingCmd() |
335 { |
341 { |
336 TRACE_ENTRY_POINT; |
342 OstTraceFunctionEntry0( CCALENSTATE_CANCELEXECUTINGCMD_ENTRY ); |
337 |
343 |
338 if(iCmdCallback) |
344 if(iCmdCallback) |
339 { |
345 { |
340 iCmdCallback->Cancel(); |
346 iCmdCallback->Cancel(); |
341 } |
347 } |
342 |
348 |
343 TRACE_EXIT_POINT; |
349 OstTraceFunctionExit0( CCALENSTATE_CANCELEXECUTINGCMD_EXIT ); |
344 } |
350 } |
345 // End of file |
351 // End of file |