30 #include "tphonecmdparamcallstatedata.h" |
30 #include "tphonecmdparamcallstatedata.h" |
31 #include "cphonemainresourceresolver.h" |
31 #include "cphonemainresourceresolver.h" |
32 #include "phonerssbase.h" |
32 #include "phonerssbase.h" |
33 #include "tphonecmdparamglobalnote.h" |
33 #include "tphonecmdparamglobalnote.h" |
34 #include "phoneui.hrh" |
34 #include "phoneui.hrh" |
|
35 #include "mphonestorage.h" |
|
36 #include "cphonecenrepproxy.h" |
|
37 #include <telephonyvariant.hrh> |
35 |
38 |
36 // ================= MEMBER FUNCTIONS ======================= |
39 // ================= MEMBER FUNCTIONS ======================= |
37 |
40 |
38 // C++ default constructor can NOT contain any code, that |
41 // C++ default constructor can NOT contain any code, that |
39 // might leave. |
42 // might leave. |
40 // |
43 // |
41 CPhoneConferenceAndSingleAndWaiting::CPhoneConferenceAndSingleAndWaiting( |
44 CPhoneConferenceAndSingleAndWaiting::CPhoneConferenceAndSingleAndWaiting( |
42 MPhoneStateMachine* aStateMachine, |
45 MPhoneStateMachine* aStateMachine, |
43 MPhoneViewCommandHandle* aViewCommandHandle, |
46 MPhoneViewCommandHandle* aViewCommandHandle, |
44 MPhoneCustomization* aPhoneCustomization ) : |
47 MPhoneCustomization* aPhoneCustomization ) : |
45 CPhoneConferenceAndSingle( aStateMachine, aViewCommandHandle, aPhoneCustomization ) |
48 CPhoneConferenceAndSingle( aStateMachine, aViewCommandHandle, aPhoneCustomization ) |
46 { |
49 { |
47 } |
50 } |
48 |
51 |
49 // ----------------------------------------------------------- |
52 // ----------------------------------------------------------- |
81 // CPhoneConferenceAndSingleAndWaiting::NewL() |
74 // CPhoneConferenceAndSingleAndWaiting::NewL() |
82 // Constructor |
75 // Constructor |
83 // (other items were commented in a header). |
76 // (other items were commented in a header). |
84 // ----------------------------------------------------------- |
77 // ----------------------------------------------------------- |
85 // |
78 // |
86 CPhoneConferenceAndSingleAndWaiting* CPhoneConferenceAndSingleAndWaiting::NewL( |
79 CPhoneConferenceAndSingleAndWaiting* CPhoneConferenceAndSingleAndWaiting::NewL( |
87 MPhoneStateMachine* aStateMachine, |
80 MPhoneStateMachine* aStateMachine, |
88 MPhoneViewCommandHandle* aViewCommandHandle, |
81 MPhoneViewCommandHandle* aViewCommandHandle, |
89 MPhoneCustomization* aPhoneCustomization ) |
82 MPhoneCustomization* aPhoneCustomization ) |
90 { |
83 { |
91 CPhoneConferenceAndSingleAndWaiting* self = new( ELeave ) CPhoneConferenceAndSingleAndWaiting( |
84 CPhoneConferenceAndSingleAndWaiting* self = new( ELeave ) CPhoneConferenceAndSingleAndWaiting( |
92 aStateMachine, aViewCommandHandle, aPhoneCustomization ); |
85 aStateMachine, aViewCommandHandle, aPhoneCustomization ); |
93 |
86 |
94 CleanupStack::PushL( self ); |
87 CleanupStack::PushL( self ); |
95 self->ConstructL(); |
88 self->ConstructL(); |
96 CleanupStack::Pop( self ); |
89 CleanupStack::Pop( self ); |
97 |
90 |
98 return self; |
91 return self; |
99 } |
92 } |
100 |
93 |
101 // ----------------------------------------------------------- |
94 // ----------------------------------------------------------- |
102 // CPhoneConferenceAndSingleAndWaiting::HandlePhoneEngineMessageL |
95 // CPhoneConferenceAndSingleAndWaiting::HandlePhoneEngineMessageL |
103 // ----------------------------------------------------------- |
96 // ----------------------------------------------------------- |
104 // |
97 // |
105 void CPhoneConferenceAndSingleAndWaiting::HandlePhoneEngineMessageL( |
98 void CPhoneConferenceAndSingleAndWaiting::HandlePhoneEngineMessageL( |
106 const TInt aMessage, |
99 const TInt aMessage, |
107 TInt aCallId ) |
100 TInt aCallId ) |
108 { |
101 { |
109 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneConferenceAndSingleAndWaiting::HandlePhoneEngineMessageL()"); |
102 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneConferenceAndSingleAndWaiting::HandlePhoneEngineMessageL()"); |
110 switch ( aMessage ) |
103 switch ( aMessage ) |
111 { |
104 { |
112 case MEngineMonitor::EPEMessageAddedConferenceMember: |
105 case MEngineMonitor::EPEMessageAddedConferenceMember: |
113 HandleAddedConferenceMemberL( aCallId ); |
106 HandleAddedConferenceMemberL( aCallId ); |
114 break; |
107 break; |
115 |
108 |
116 case MEngineMonitor::EPEMessageIdle: |
109 case MEngineMonitor::EPEMessageIdle: |
117 HandleIdleL( aCallId ); |
110 HandleIdleL( aCallId ); |
118 break; |
111 break; |
119 |
112 |
120 default: |
113 default: |
121 CPhoneConferenceAndSingle::HandlePhoneEngineMessageL( aMessage, |
114 CPhoneConferenceAndSingle::HandlePhoneEngineMessageL( aMessage, |
122 aCallId ); |
115 aCallId ); |
123 break; |
116 break; |
124 } |
117 } |
125 } |
118 } |
126 |
119 |
127 // ----------------------------------------------------------- |
120 // ----------------------------------------------------------- |
128 // CPhoneConferenceAndSingleAndWaiting::OpenMenuBarL |
|
129 // ----------------------------------------------------------- |
|
130 // |
|
131 void CPhoneConferenceAndSingleAndWaiting::OpenMenuBarL() |
|
132 { |
|
133 __LOGMETHODSTARTEND( EPhoneUIStates, |
|
134 "CPhoneConferenceAndSingleAndWaiting::OpenMenuBarL()"); |
|
135 TInt resourceId = NULL; |
|
136 |
|
137 // Set specific flag to view so that DTMF menu item available |
|
138 TPhoneCmdParamBoolean dtmfSendFlag; |
|
139 dtmfSendFlag.SetBoolean( ETrue ); |
|
140 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetDtmfOptionsFlag, |
|
141 &dtmfSendFlag ); |
|
142 |
|
143 |
|
144 TPhoneCmdParamCallStateData callStateData; |
|
145 callStateData.SetCallState( EPEStateHeld ); |
|
146 iViewCommandHandle->HandleCommandL( EPhoneViewGetCallIdByState, |
|
147 &callStateData ); |
|
148 if( callStateData.CallId() == KConferenceCallId ) |
|
149 { |
|
150 // Conference call is on hold and single is active |
|
151 if ( IsNumberEntryVisibleL() ) |
|
152 { |
|
153 resourceId = EPhoneCallActiveHeldConfAndWaitingMenubarWithNumberEntry; |
|
154 } |
|
155 else if ( IsConferenceBubbleInSelectionMode() ) |
|
156 { |
|
157 resourceId = EPhoneConfCallParticipantsDropMenubar; |
|
158 } |
|
159 else |
|
160 { |
|
161 resourceId = EPhoneCallActiveHeldConfAndWaitingMenubar; |
|
162 } |
|
163 } |
|
164 else if( callStateData.CallId() >= 0 ) |
|
165 { |
|
166 // Single call is on hold and conference is active |
|
167 if ( IsNumberEntryVisibleL() ) |
|
168 { |
|
169 resourceId = EPhoneConfCallActiveHeldAndWaitingMenubarWithNumberEntry; |
|
170 } |
|
171 else if ( IsConferenceBubbleInSelectionMode() ) |
|
172 { |
|
173 resourceId = EPhoneConfCallParticipantsDropMenubar; |
|
174 } |
|
175 else |
|
176 { |
|
177 resourceId = EPhoneConfCallActiveHeldAndWaitingMenubar; |
|
178 } |
|
179 } |
|
180 else |
|
181 { |
|
182 return; // negative call id, don't do anything |
|
183 } |
|
184 |
|
185 TPhoneCmdParamInteger integerParam; |
|
186 integerParam.SetInteger( |
|
187 CPhoneMainResourceResolver::Instance()-> |
|
188 ResolveResourceID( resourceId ) ); |
|
189 iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarOpen, |
|
190 &integerParam ); |
|
191 } |
|
192 |
|
193 // ----------------------------------------------------------- |
|
194 // CPhoneConferenceAndSingleAndWaiting::HandleIdleL |
121 // CPhoneConferenceAndSingleAndWaiting::HandleIdleL |
195 // ----------------------------------------------------------- |
122 // ----------------------------------------------------------- |
196 // |
123 // |
197 void CPhoneConferenceAndSingleAndWaiting::HandleIdleL( TInt aCallId ) |
124 void CPhoneConferenceAndSingleAndWaiting::HandleIdleL( TInt aCallId ) |
198 { |
125 { |
199 __LOGMETHODSTARTEND( EPhoneUIStates, |
126 __LOGMETHODSTARTEND( EPhoneUIStates, |
200 "CPhoneConferenceAndSingleAndWaiting::HandleIdleL()"); |
127 "CPhoneConferenceAndSingleAndWaiting::HandleIdleL()"); |
|
128 |
201 BeginUiUpdateLC(); |
129 BeginUiUpdateLC(); |
202 SetTouchPaneButtonEnabled( EPhoneCallComingCmdAnswer ); |
130 // Set touch controls |
203 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
131 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
|
132 |
204 |
133 |
205 TPhoneCmdParamBoolean conferenceExistsForCallId; |
134 TPhoneCmdParamBoolean conferenceExistsForCallId; |
206 iViewCommandHandle->ExecuteCommandL( EPhoneViewGetCallExistsInConference, |
135 iViewCommandHandle->ExecuteCommandL( EPhoneViewGetCallExistsInConference, |
207 aCallId, &conferenceExistsForCallId ); |
136 aCallId, &conferenceExistsForCallId ); |
|
137 |
208 if( conferenceExistsForCallId.Boolean() ) |
138 if( conferenceExistsForCallId.Boolean() ) |
209 { |
139 { |
210 // Remove conference member from conference bubble |
140 // Remove conference member from conference bubble |
211 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveFromConference, |
141 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveFromConference, |
212 aCallId ); |
142 aCallId ); |
213 } |
143 } |
214 else |
144 else |
215 { |
145 { |
|
146 // Remove call |
216 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId ); |
147 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId ); |
|
148 |
217 TPhoneCmdParamBoolean conferenceBubbleExists; |
149 TPhoneCmdParamBoolean conferenceBubbleExists; |
218 iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsConference, |
150 iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsConference, |
219 &conferenceBubbleExists ); |
151 &conferenceBubbleExists ); |
220 if( !conferenceBubbleExists.Boolean() ) |
152 if( !conferenceBubbleExists.Boolean() ) |
221 { |
153 { |
222 // Idle message came for conference member. |
154 // Idle message came for conference member. |
223 MakeTransitionAccordingToActiveCallsL(); |
155 MakeTransitionAccordingToActiveCallsL(); |
224 } |
156 } |
225 else |
157 else |
226 { |
158 { |
227 TPhoneCmdParamCallStateData callStateData; |
159 TPhoneCmdParamCallStateData callStateData; |
228 callStateData.SetCallState( EPEStateRinging ); |
160 callStateData.SetCallState( EPEStateRinging ); |
229 iViewCommandHandle->HandleCommandL( EPhoneViewGetCallIdByState, |
161 iViewCommandHandle->HandleCommandL( EPhoneViewGetCallIdByState, |
253 // Update conference bubble |
185 // Update conference bubble |
254 iViewCommandHandle->ExecuteCommandL( EPhoneViewAddToConference ); |
186 iViewCommandHandle->ExecuteCommandL( EPhoneViewAddToConference ); |
255 |
187 |
256 UpdateConferenceSecurityStatusL( aCallId ); |
188 UpdateConferenceSecurityStatusL( aCallId ); |
257 |
189 |
258 MakeStateTransitionToConferenceAndWaitingL( KConferenceCallId ); |
190 MakeStateTransitionToConferenceAndWaitingL( KConferenceCallId ); |
259 } |
191 } |
260 |
192 |
261 // ----------------------------------------------------------- |
193 // ----------------------------------------------------------- |
262 // CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndWaitingL |
194 // CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndWaitingL |
263 // ----------------------------------------------------------- |
195 // ----------------------------------------------------------- |
264 // |
196 // |
265 void CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndWaitingL( TInt /*aCallId*/ ) |
197 void CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndWaitingL( TInt /*aCallId*/ ) |
266 { |
198 { |
267 __LOGMETHODSTARTEND( EPhoneUIStates, |
199 __LOGMETHODSTARTEND( EPhoneUIStates, |
268 "CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndWaitingL()"); |
200 "CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndWaitingL()"); |
269 if ( !IsNumberEntryUsedL() ) |
201 |
270 { |
202 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
271 // Close menu bar, if number entry isnt open. |
203 |
272 iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose ); |
204 // Check if HW Keys or Call UI should be disabled |
273 } |
205 CheckDisableHWKeysAndCallUIL(); |
274 |
206 |
275 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
|
276 SetTouchPaneButtonEnabled( EPhoneCallComingCmdAnswer ); |
|
277 |
|
278 // Go to Conference And Waiting state |
207 // Go to Conference And Waiting state |
279 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA ); |
208 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA ); |
280 iStateMachine->ChangeState( EPhoneStateConferenceAndWaiting ); |
209 iStateMachine->ChangeState( EPhoneStateConferenceAndWaiting ); |
281 } |
210 } |
282 |
211 |
284 // CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndSingleL |
213 // CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndSingleL |
285 // ----------------------------------------------------------- |
214 // ----------------------------------------------------------- |
286 // |
215 // |
287 void CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndSingleL( TInt /*aCallId*/ ) |
216 void CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndSingleL( TInt /*aCallId*/ ) |
288 { |
217 { |
289 __LOGMETHODSTARTEND( EPhoneUIStates, |
218 __LOGMETHODSTARTEND( EPhoneUIStates, |
290 "CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndSingleL()"); |
219 "CPhoneConferenceAndSingleAndWaiting::MakeStateTransitionToConferenceAndSingleL()"); |
291 |
220 |
292 if ( !IsNumberEntryUsedL() ) |
221 if( /*FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke ) |
293 { |
222 */ 1 && iStateMachine->PhoneStorage()->IsScreenLocked() ) |
294 // Close menu bar, if number entry isnt open. |
223 { |
295 iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose ); |
224 EnableCallUIL(); |
296 } |
225 } |
|
226 |
|
227 // Reset blocked keys list |
|
228 iStateMachine->PhoneStorage()->ResetBlockedKeysList(); |
297 |
229 |
298 if ( IsNumberEntryUsedL() ) |
230 if ( IsNumberEntryUsedL() ) |
299 { |
231 { |
300 if ( NeedToReturnToForegroundAppL() ) |
232 if ( NeedToSendToBackgroundL() ) |
301 { |
233 { |
302 // Return phone to the background if send to background is needed. |
234 // Return phone to the background if send to background is needed. |
303 iViewCommandHandle->ExecuteCommandL( EPhoneViewSendToBackground ); |
235 iViewCommandHandle->ExecuteCommandL( EPhoneViewSendToBackground ); |
304 |
236 |
305 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetControlAndVisibility ); |
|
306 |
|
307 UpdateCbaL( EPhoneCallHandlingInCallCBA ); |
237 UpdateCbaL( EPhoneCallHandlingInCallCBA ); |
308 } |
238 } |
309 else |
239 else |
310 { |
240 { |
311 // Show the number entry if it exists |
241 // Show the number entry if it exists |
312 SetNumberEntryVisibilityL(ETrue); |
242 SetNumberEntryVisibilityL(ETrue); |
313 } |
243 } |
314 } |
244 } |
315 else |
245 else |
316 { |
246 { |
317 UpdateCbaL( EPhoneCallHandlingNewCallSwapCBA ); |
247 UpdateCbaL( EPhoneCallHandlingNewCallSwapCBA ); |
318 // If numberentry is not open just check NeedToReturnToForegroundAppL and |
248 // If numberentry is not open just check NeedToSendToBackgroundL and |
319 // sendbackround if needed. |
249 // sendbackround if needed. |
320 if ( NeedToReturnToForegroundAppL() ) |
250 if ( NeedToSendToBackgroundL() ) |
321 { |
251 { |
322 // Return phone to the background if send to background is needed. |
252 // Return phone to the background if send to background is needed. |
323 iViewCommandHandle->ExecuteCommandL( EPhoneViewSendToBackground ); |
253 iViewCommandHandle->ExecuteCommandL( EPhoneViewSendToBackground ); |
324 } |
254 } |
325 } |
255 } |
326 |
256 |
327 SetTouchPaneButtons( EPhoneConferenceAndSingleButtons ); |
257 SetTouchPaneButtons( EPhoneConferenceAndSingleButtons ); |
328 SetTouchPaneButtonEnabled( EPhoneCallComingCmdAnswer ); |
|
329 SetTouchPaneButtonDisabled( EPhoneInCallCmdPrivate ); |
|
330 // Go to conference and single state |
258 // Go to conference and single state |
331 // CBA updates in above if-else conditions |
259 // CBA updates in above if-else conditions |
332 iStateMachine->ChangeState( EPhoneStateConferenceAndSingle ); |
260 iStateMachine->ChangeState( EPhoneStateConferenceAndSingle ); |
333 } |
261 } |
334 |
262 |
335 // ----------------------------------------------------------- |
263 // ----------------------------------------------------------- |
336 // CPhoneConferenceAndSingleAndWaiting::HandleConferenceIdleL |
264 // CPhoneConferenceAndSingleAndWaiting::HandleConferenceIdleL |
337 // ----------------------------------------------------------- |
265 // ----------------------------------------------------------- |
338 // |
266 // |
339 void CPhoneConferenceAndSingleAndWaiting::HandleConferenceIdleL() |
267 void CPhoneConferenceAndSingleAndWaiting::HandleConferenceIdleL() |
340 { |
268 { |
341 __LOGMETHODSTARTEND( EPhoneUIStates, |
269 __LOGMETHODSTARTEND( EPhoneUIStates, |
342 "CPhoneConferenceAndSingleAndWaiting::HandleConferenceIdleL()"); |
270 "CPhoneConferenceAndSingleAndWaiting::HandleConferenceIdleL()"); |
343 |
271 |
344 BeginUiUpdateLC(); |
272 BeginUiUpdateLC(); |
345 |
273 |
346 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveConferenceBubble ); |
274 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveConferenceBubble ); |
347 |
|
348 // Close menu bar, if it is displayed |
|
349 iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose ); |
|
350 |
275 |
351 // Remove any phone dialogs if they are displayed |
276 // Remove any phone dialogs if they are displayed |
352 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs ); |
277 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs ); |
353 |
278 |
354 MakeTransitionAccordingToActiveCallsL(); |
279 MakeTransitionAccordingToActiveCallsL(); |
355 |
280 |
356 EndUiUpdate(); |
281 EndUiUpdate(); |
357 } |
282 } |
358 |
283 |
359 // -------------------------------------------------------------- |
284 // -------------------------------------------------------------- |
360 // CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL |
285 // CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL |
361 // -------------------------------------------------------------- |
286 // -------------------------------------------------------------- |
362 // |
287 // |
363 void CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL( |
288 void CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL( |
364 TPhoneKeyEventMessages aMessage, |
289 TPhoneKeyEventMessages aMessage, |
365 TKeyCode aCode ) |
290 TKeyCode aCode ) |
366 { |
291 { |
367 __LOGMETHODSTARTEND( EPhoneUIStates, |
292 __LOGMETHODSTARTEND( EPhoneUIStates, |
368 "CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL()"); |
293 "CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL()"); |
369 switch ( aCode ) |
294 switch ( aCode ) |
370 { |
295 { |
371 // send-key |
296 // send-key |
372 case EKeyYes: |
297 case EKeyYes: |
373 if( IsNumberEntryVisibleL() ) |
298 if( IsNumberEntryVisibleL() ) |
374 { |
299 { |
375 CallFromNumberEntryL(); |
300 CallFromNumberEntryL(); |
376 } |
301 } |
377 else |
302 else |
378 { |
303 { |
379 // Not allowed to answer |
304 // Not allowed to answer |
380 SendGlobalWarningNoteL( |
305 SendGlobalWarningNoteL( |
381 EPhoneNoteTextCallNotAllowed ); |
306 EPhoneNoteTextCallNotAllowed, ETrue ); |
382 } |
307 } |
383 break; |
308 break; |
384 |
309 |
385 default: |
310 default: |
386 // do base operation |
311 // do base operation |
387 CPhoneConferenceAndSingle::HandleKeyMessageL( aMessage, aCode ); |
312 CPhoneConferenceAndSingle::HandleKeyMessageL( aMessage, aCode ); |
388 break; |
313 break; |
389 } |
314 } |
390 } |
315 } |
391 |
316 |
392 // ----------------------------------------------------------- |
317 // ----------------------------------------------------------- |
393 // CPhoneConferenceAndSingleAndWaiting::HandleErrorL |
318 // CPhoneConferenceAndSingleAndWaiting::HandleKeyEventL |
394 // ----------------------------------------------------------- |
319 // ----------------------------------------------------------- |
395 // |
320 // |
396 EXPORT_C void CPhoneConferenceAndSingleAndWaiting::HandleErrorL( |
321 void CPhoneConferenceAndSingleAndWaiting::HandleKeyEventL( |
397 const TPEErrorInfo& aErrorInfo ) |
322 const TKeyEvent& aKeyEvent, |
398 { |
323 TEventCode /*aEventCode*/ ) |
399 __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneConferenceAndSingleAndWaiting::HandleErrorL()"); |
324 { |
400 |
325 if( EKeyDeviceF == aKeyEvent.iCode ) |
401 if( aErrorInfo.iErrorCode == ECCPErrorCCUserAlertingNoAnswer ) |
326 { |
402 { |
327 __PHONELOG( EBasic, EPhoneUIStates, |
403 // Should not shown "No Answer" note |
328 "CPhoneConferenceAndSingleAndWaiting::HandleKeyMessageL-deviceF" ); |
404 __PHONELOG1( EBasic, EPhoneUIStates, |
329 HandleHoldSwitchL(); |
405 "PhoneUIStates: CPhoneConferenceAndSingleAndWaiting::HandleErrorL - aErrorInfo.iErrorCode =%d ", |
|
406 aErrorInfo.iErrorCode); |
|
407 } |
|
408 else |
|
409 { |
|
410 CPhoneState::HandleErrorL( aErrorInfo ); |
|
411 } |
330 } |
412 } |
331 } |
413 |
332 |
414 // ----------------------------------------------------------- |
333 // ----------------------------------------------------------- |
415 // CPhoneConferenceAndSingleAndWaiting::UpdateInCallCbaL |
334 // CPhoneConferenceAndSingleAndWaiting::UpdateInCallCbaL |
416 // ----------------------------------------------------------- |
335 // ----------------------------------------------------------- |
417 // |
336 // |
418 void CPhoneConferenceAndSingleAndWaiting::UpdateInCallCbaL() |
337 void CPhoneConferenceAndSingleAndWaiting::UpdateInCallCbaL() |
419 { |
338 { |
420 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneConferenceAndSingleAndWaiting::UpdateInCallCbaL() "); |
339 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneConferenceAndSingleAndWaiting::UpdateInCallCbaL() "); |
421 |
340 |
422 UpdateCbaL ( EPhoneCallHandlingCallWaitingCBA ); |
341 UpdateCbaL ( EPhoneCallHandlingCallWaitingCBA ); |
423 } |
342 } |
424 |
343 |
425 // ----------------------------------------------------------- |
344 // ----------------------------------------------------------- |
426 // CPhoneConferenceAndSingleAndWaiting::MakeTransitionAccordingToActiveCallsL |
345 // CPhoneConferenceAndSingleAndWaiting::MakeTransitionAccordingToActiveCallsL |
429 void CPhoneConferenceAndSingleAndWaiting::MakeTransitionAccordingToActiveCallsL() |
348 void CPhoneConferenceAndSingleAndWaiting::MakeTransitionAccordingToActiveCallsL() |
430 { |
349 { |
431 TPhoneCmdParamInteger activeCallCount; |
350 TPhoneCmdParamInteger activeCallCount; |
432 iViewCommandHandle->ExecuteCommandL( |
351 iViewCommandHandle->ExecuteCommandL( |
433 EPhoneViewGetCountOfActiveCalls, &activeCallCount ); |
352 EPhoneViewGetCountOfActiveCalls, &activeCallCount ); |
434 |
353 |
435 switch( activeCallCount.Integer() ) |
354 switch( activeCallCount.Integer() ) |
436 { |
355 { |
437 case ENoActiveCalls: // Go to incoming state |
356 case ENoActiveCalls: // Go to incoming state |
438 { |
357 { |
439 // Get Waiting call's Call Id |
358 // Get Waiting call's Call Id |
440 TPhoneCmdParamCallStateData callStateData; |
359 TPhoneCmdParamCallStateData callStateData; |
441 callStateData.SetCallState( EPEStateRinging ); |
360 callStateData.SetCallState( EPEStateRinging ); |
442 iViewCommandHandle->HandleCommandL( EPhoneViewGetCallIdByState, |
361 iViewCommandHandle->HandleCommandL( EPhoneViewGetCallIdByState, |
443 &callStateData ); |
362 &callStateData ); |
444 |
363 |
445 if ( callStateData.CallId() != KErrNotFound ) |
364 if ( callStateData.CallId() != KErrNotFound ) |
446 { |
365 { |
447 // Display ringing bubble |
366 // Display ringing bubble |
448 TPhoneCmdParamCallHeaderData callHeaderParam; |
367 TPhoneCmdParamCallHeaderData callHeaderParam; |
449 callHeaderParam.SetCallState( EPEStateRinging ); |
368 callHeaderParam.SetCallState( EPEStateRinging ); |
450 |
369 |
451 SetCallHeaderTextsForCallComingInL( callStateData.CallId(), EFalse, &callHeaderParam ); |
370 SetCallHeaderTextsForCallComingInL( callStateData.CallId(), EFalse, &callHeaderParam ); |
452 |
371 |
453 iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, |
372 iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, |
454 callStateData.CallId(), |
373 callStateData.CallId(), |
455 &callHeaderParam ); |
374 &callHeaderParam ); |
456 |
375 |
457 // Capture keys when there is an incoming call |
376 // Capture keys when there is an incoming call |
458 CaptureKeysDuringCallNotificationL( ETrue ); |
377 CaptureKeysDuringCallNotificationL( ETrue ); |
459 |
378 |
460 // Go to Incoming state |
379 // Go to Incoming state |
461 iCbaManager->UpdateIncomingCbaL( callStateData.CallId() ); |
380 iCbaManager->UpdateIncomingCbaL( callStateData.CallId() ); |
|
381 |
|
382 // Check if HW Keys or Call UI should be disabled |
|
383 CheckDisableHWKeysAndCallUIL(); |
|
384 |
462 SetTouchPaneButtons( EPhoneIncomingCallButtons ); |
385 SetTouchPaneButtons( EPhoneIncomingCallButtons ); |
463 UpdateSilenceButtonDimming(); |
386 SetRingingTonePlaybackL( callStateData.CallId() ); |
464 SetTouchPaneButtonEnabled( EPhoneCallComingCmdAnswer ); |
387 SetBackButtonActive(EFalse); |
465 SetRingingTonePlaybackL( callStateData.CallId() ); |
388 iStateMachine->ChangeState( EPhoneStateIncoming ); |
466 SetToolbarDimming( ETrue ); |
|
467 iStateMachine->ChangeState( EPhoneStateIncoming ); |
|
468 } |
389 } |
469 else |
390 else |
470 { |
391 { |
471 SetDefaultFlagsL(); |
392 SetDefaultFlagsL(); |
472 UpdateCbaL( EPhoneEmptyCBA ); |
393 UpdateCbaL( EPhoneEmptyCBA ); |
473 iStateMachine->ChangeState( EPhoneStateIdle ); |
394 iStateMachine->ChangeState( EPhoneStateIdle ); |
474 } |
395 } |
475 } |
396 } |
476 break; |
397 break; |
477 case EOneActiveCall: |
398 case EOneActiveCall: |
478 { |
399 { |
479 // Go to Single And Waiting state |
400 // Go to Single And Waiting state |
480 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA ); |
401 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA ); |
481 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
402 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
482 SetTouchPaneButtonEnabled( EPhoneCallComingCmdAnswer ); |
403 |
483 iStateMachine->ChangeState( EPhoneStateWaitingInSingle ); |
404 // Check if HW Keys or Call UI should be disabled |
|
405 CheckDisableHWKeysAndCallUIL(); |
|
406 |
|
407 iStateMachine->ChangeState( EPhoneStateWaitingInSingle ); |
484 } |
408 } |
485 break; |
409 break; |
486 case ETwoActiveCalls: |
410 case ETwoActiveCalls: |
487 { |
411 { |
488 // Go to Two Singles And Waiting state |
412 // Go to Two Singles And Waiting state |
489 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA ); |
413 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA ); |
490 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
414 |
|
415 // Check if HW Keys or Call UI should be disabled |
|
416 CheckDisableHWKeysAndCallUIL(); |
|
417 |
|
418 SetTouchPaneButtons( EPhoneWaitingCallButtons ); |
491 iStateMachine->ChangeState( EPhoneStateTwoSinglesAndWaiting ); |
419 iStateMachine->ChangeState( EPhoneStateTwoSinglesAndWaiting ); |
492 } |
420 } |
493 break; |
421 break; |
494 default: |
422 default: |
495 // Too many active calls to handle reliable state change now. |
423 // Too many active calls to handle reliable state change now. |
496 // Waiting for all conference member idles |
424 // Waiting for all conference member idles |
497 // This case may happen when 'End all calls' because conferenceIdle may |
425 // This case may happen when 'End all calls' because conferenceIdle may |
498 // come earlier than idle for conference member |
426 // come earlier than idle for conference member |
499 break; |
427 break; |
500 } |
428 } |
501 |
429 |
502 } |
430 } |
503 |
431 |
504 // End of File |
432 // End of File |