FCL/sf/app/phone: comparison phoneapp/phoneuicontrol/src/cphonestate.cpp

equal deleted inserted replaced

-:1eef62f5c541
+:2a5d4ab426d3
 #include "cphonepubsubproxy.h"
 #include "phoneviewcommanddefinitions.h"
 #include "phonelogger.h"
 #include "phonestatedefinitions.h"
 #include "cphonetimer.h"
-#include "cphonereconnectquery.h"
 #include "mphoneerrormessageshandler.h"
 #include "cphoneclearblacklist.h"
 #include "mphonecustomization.h"
 #include "cphonemainerrormessageshandler.h"
 #include "cphoneaccessorybthandler.h"
 // Need to get current SimState for inherited classis
 iPreviousSimState = SimState();
 __ASSERT_ALWAYS(
 aStateMachine && aViewCommandHandle,
 Panic( EPhoneCtrlParameterNotInitialized ) );
-if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) )
-{
-iOnScreenDialer = ETrue;
-}
 }
 EXPORT_C void CPhoneState::BaseConstructL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::BaseConstructL() ");
 }
 }
 EXPORT_C CPhoneState::~CPhoneState()
 {
-if( iAlsLineChangeKeyPressTimer )
-{
-if( iAlsLineChangeKeyPressTimer->IsActive() )
-{
-iAlsLineChangeKeyPressTimer->CancelTimer();
-}
-delete iAlsLineChangeKeyPressTimer;
-}
 delete iNumberEntryManager;
 delete iCallHeaderManager;
 delete iCbaManager;
 }
 // <-------------------------- PHONE ENGINE EVENTS --------------------------->
 // -----------------------------------------------------------
 // CPhoneState::HandlePhoneEngineMessageL
 // Default handling for Phone Engine messages
 // (other items were commented in a header).
 // -----------------------------------------------------------
 EXPORT_C void CPhoneState::HandlePhoneEngineMessageL(
 const TInt aMessage,
 TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePhoneEngineMessageL() ");
 CPhoneAccessoryBTHandler* accessoryBtHandler;
 switch ( aMessage )
 {
 case MEngineMonitor::EPEMessageNetworkRegistrationStatusChange:
 {
 __PHONELOG1( EBasic, EPhoneControl,
 case MEngineMonitor::EPEMessageRemoteBusy:
 HandleRemoteBusyL( aCallId );
 break;
 case MEngineMonitor::EPEMessageCallWaiting:
-// No need to send waiting notification for user.
-//SendGlobalInfoNoteL( EPhoneWaitingText, ETrue );
-break;
 case MEngineMonitor::EPEMessageProfileChanged:
-{
-}
 break;
 case MEngineMonitor::EPEMessageRemoteTerminated:
 /* Flow through */
 case MEngineMonitor::EPEMessageDisconnecting:
 HandleInitiatedEmergencyWhileActiveVideoL();
 break;
 case MEngineMonitor::EPEMessageCallSecureStatusChanged:
 HandleCallSecureStatusChangeL( aCallId );
 if ( iCustomization )
 {
 iCustomization->HandlePhoneEngineMessageL( aMessage,
 aCallId );
 }
 break;
 case MEngineMonitor::EPEMessageIssuingUSSDRequest:
 {
-// Enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
+NumberEntryClearL();
-if ( !IsOnScreenDialerSupported() && IsNumberEntryUsedL() )
-{
-// Remove number entry from screen
-iViewCommandHandle->ExecuteCommandL(
-EPhoneViewRemoveNumberEntry );
-}
-else if ( IsOnScreenDialerSupported() )
-{
-NumberEntryClearL();
-}
 }
 break;
 case MEngineMonitor::EPEMessageIssuedUSSDRequest:
 // Go to current state implementation
 iCbaManager->UpdateInCallCbaL();
 break;
 // *#9990#
 case MEngineMonitor::EPEMessageShowBTLoopback:
-// Stop playing DTMF tone
 iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
 accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 accessoryBtHandler->ShowBTLoopbackL();
 CleanupStack::PopAndDestroy( accessoryBtHandler );
 break;
 // *#2820#
 case MEngineMonitor::EPEMessageShowBTDeviceAddress:
-// Stop playing DTMF tone
 iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
 accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 accessoryBtHandler->ShowBTAddressL();
 CleanupStack::PopAndDestroy( accessoryBtHandler );
 break;
 // *#7370#
 case MEngineMonitor::EPEMessageActivateRfsDeep:
-// Stop playing DTMF tone
 iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
-// Launch RFS
 iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsDeep );
-if ( !IsOnScreenDialerSupported() )
-{
-// Do state-specific operation when number entry is cleared
-HandleNumberEntryClearedL();
-}
 break;
 // *#7780#
 case MEngineMonitor::EPEMessageActivateRfsNormal:
-// Stop playing DTMF tone
 iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
-// Launch RFS
 iViewCommandHandle->ExecuteCommandL( EPhoneViewLaunchRfsNormal );
-if ( !IsOnScreenDialerSupported() )
+break;
-{
-// Do state-specific operation when number entry is cleared
-HandleNumberEntryClearedL();
-}
-break;
 // *#62209526#
 case MEngineMonitor::EPEMessageShowWlanMacAddress:
-// Stop playing DTMF tone
 iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
 ShowWlanMacAddressL();
 break;
 case MEngineMonitor::EPEMessageThumbnailLoadingCompleted:
-// Update call buble
 UpdateRemoteInfoDataL( aCallId );
 break;
 case MEngineMonitor::EPEMessageRemotePartyInfoChanged:
 UpdateRemoteInfoDataL ( aCallId );
 case MEngineMonitor::EPEMessageShowIncCallGroupIndex:
 HandleCugInUseNoteL();
 break;
 default:
 TBool handled( EFalse );
 if ( iCustomization )
 {
 handled = iCustomization->HandlePhoneEngineMessageL(
 aMessage, aCallId );
 }
 if ( EFalse == handled )
 {
 MPhoneMediatorMessage* mediatorMessage = CPhoneMediatorFactory::Instance()->MediatorMessage( aMessage, aCallId );
 if( mediatorMessage )
 {
 EXPORT_C void CPhoneState::HandleAudioMuteChangedL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioMuteChangedL() ");
 __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
 Panic( EPhoneCtrlInvariant ) );
 TPhoneCmdParamBoolean booleanParam;
 const TBool audioMute = iStateMachine->PhoneEngineInfo()->AudioMute();
 booleanParam.SetBoolean( audioMute );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateMuteUIChanges,
 &booleanParam );
 SetTouchPaneButtons(0);
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleAudioOutputChangedL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleAudioOutputChangedL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioOutputChangedL() ");
-__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
+__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );
-Panic( EPhoneCtrlInvariant ) );
 TPhoneCmdParamAudioOutput outputParam;
-// Output
 const TPEAudioOutput audioOutput =
 iStateMachine->PhoneEngineInfo()->AudioOutput();
 outputParam.SetAudioOutput( audioOutput );
-// view update
 iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateAudioPathUIChanges,
 &outputParam );
 // Previous Output
 TPEPhoneAudioRouteParameters RouteParameters = iStateMachine->
 PhoneEngineInfo()->RouteParameters();
 const TPEAudioOutput previousOutput =
 RouteParameters.iPreviousOutput;
-// BT availability
 TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
 EPEBTAudioAccessory );
 // Show note or BT disconnect handler
 if ( audioOutput != EPENotActive &&
 previousOutput == EPEBTAudioAccessory &&
 !btAvailable )
 {
 void CPhoneState::HandleSimStateChangedL()
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::HandleSimStateChangedL()" );
 CPhoneMainResourceResolver& resolver = *CPhoneMainResourceResolver::Instance();
 TPESimState simState = SimState();
 __PHONELOG2( EBasic, EPhoneControl, "SIM state was changed from %d to %d", iPreviousSimState, simState );
 switch ( simState )
 {
 case EPESimUsable: // Falls through.
 case EPESimReadable: // Falls through.
 case EPESimNotReady:
 {
 __PHONELOG( EBasic, EPhoneControl, "SIM card was inserted, rebooting the phone" );
 RStarterSession starterSession;
 User::LeaveIfError( starterSession.Connect() );
 CleanupClosePushL( starterSession );
 HBufC* queryText = StringLoader::LoadLC( resolver.ResolveResourceID( EPhoneRebootRequired ) );
 TPhoneCmdParamQuery queryParams;
 queryParams.SetCommandParamId( TPhoneCommandParam::EPhoneParamRebootQuery );
 queryParams.SetQueryPrompt( *queryText );
 queryParams.SetDefaultCba( R_AVKON_SOFTKEYS_OK_EMPTY );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery, &queryParams );
 starterSession.Reset( RStarterSession::ESIMStatusChangeReset );
 CleanupStack::PopAndDestroy( 2, &starterSession ); // queryText
 }
 break;
 }
 if ( iPreviousSimState == EPESimUsable ||
 iPreviousSimState == EPESimReadable ||
 iPreviousSimState == EPESimNotReady )
 {
 __PHONELOG( EBasic, EPhoneControl, "SIM card was removed" );
 TPhoneCmdParamGlobalNote globalNoteParam;
 globalNoteParam.SetType( EPhoneMessageBoxInformation );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneSimRemoved ) );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 // Show security note, if SIM not present and KFeatureIdFfSimlessOfflineSupport is disabled.
 else if ( !FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport ) &&
 ( iPreviousSimState != EPESimNotSupported ) )
 {
 break;
 }
 default:
 break;
 }
 iPreviousSimState = simState;
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::IsValidAlphaNumericKey
 //
 TBool CPhoneState::IsValidAlphaNumericKey( const TKeyEvent& aKeyEvent,
 TEventCode aEventCode )
 {
 TBool ret(EFalse);
 const TBool numericKeyEntered( CPhoneKeys::IsNumericKey(
 aKeyEvent, aEventCode ) );
 // a numeric key (1,2,3,4,6,7,8,9,0,+,*,p,w )
 // or
 // a letter from fullscreen qwerty, miniqwerty or handwriting
 // when voip is enabled
 if ( numericKeyEntered
 || IsAlphanumericSupportedAndCharInput( aKeyEvent ) )
 {
 ret= ETrue;
 }
 return ret;
 }
-// -----------------------------------------------------------------------------
-// CPhoneState::CustomizeCBAForPhoneNumber
-//
-// -----------------------------------------------------------------------------
-//
-void CPhoneState::CustomizeCbaForPhoneNumberL()
-{
-if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) &&
-iCustomization &&
-iCustomization->AllowAlphaNumericMode() )
-{
-// Get the number entry contents
-HBufC* phoneNumber = PhoneNumberFromEntryLC();
-TPhoneCmdParamInteger integerParam;
-//only charaters from set { 0, .., 9, *, #, +, p, w, P, W } used
-if ( CPhoneKeys::Validate( phoneNumber->Des()) )
-{
-integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
-ResolveResourceID( EPhoneNumberAcqCBA ) );
-}
-//other characters
-else
-{
-integerParam.SetInteger( iCustomization->CustomizeSoftKeys() );
-}
-iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateCba, &integerParam );
-CleanupStack::PopAndDestroy( phoneNumber );
-}
-}
-// -----------------------------------------------------------------------------
-// CPhoneState::IsTouchDTmfDialerOn
-// -----------------------------------------------------------------------------
-//
-TBool CPhoneState::IsTouchDTmfDialerOn() const
-{
-TBool status( EFalse );
-return status;
-}
 // -----------------------------------------------------------------------------
 // CPhoneState::SendDtmfKeyEventL
 // send dtmf event when,
 // -touch dtmf dialer is NOT visible
 // -query is not active
 // -----------------------------------------------------------------------------
 //
 void CPhoneState::SendDtmfKeyEventL( const TKeyEvent& aKeyEvent,
 TEventCode aEventCode  )
 {
+if ( !IsAnyQueryActiveL() )
-if ( !IsTouchDTmfDialerOn()
-&& !IsAnyQueryActiveL() )
 {
 // Send the key event to the phone engine.
 SendKeyEventL( aKeyEvent, aEventCode );
 }
-}
-// -----------------------------------------------------------------------------
-// CPhoneState::IsKeyEventFurtherProcessed
-// -----------------------------------------------------------------------------
-//
-TBool CPhoneState::IsKeyEventFurtherProcessedL( const TKeyEvent& /*aKeyEvent*/ ) const
-{
-return ETrue;
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleErrorL
 // Default handling for HandleError message
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleErrorL( const TPEErrorInfo& aErrorInfo )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleErrorL()");
 __PHONELOG1( EBasic, EPhoneControl,
 "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iErrorCode =%d ",
 aErrorInfo.iErrorCode );
 __PHONELOG1( EBasic, EPhoneControl,
 "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iCallId =%d ",
 aErrorInfo.iCallId );
 // Do the common error handling (display proper notes etc)
 CPhoneMainErrorMessagesHandler::Instance()->ShowErrorSpecificNoteL( aErrorInfo );
 switch( aErrorInfo.iErrorCode )
 {
-case ECCPErrorCCUserAlertingNoAnswer:
-case ECCPErrorCCResourceNotAvailable:
-{
-if( aErrorInfo.iCallId > KErrNotFound )
-{
-if ( iStateMachine->PhoneEngineInfo()->CallDirection(
-aErrorInfo.iCallId ) != RMobileCall::EMobileTerminated )
-{
-if( IsVideoCall( aErrorInfo.iCallId ) )
-{
-// Active MO video call lost 3G network.
-__PHONELOG1( EBasic, EPhoneControl,
-"PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 1, callid%d ",
-aErrorInfo.iCallId );
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );
-}
-else
-{
-__PHONELOG1( EBasic, EPhoneControl,
-"PhoneUIControl: CPhoneState::HandleErrorL - No video call =%d ",
-aErrorInfo.iCallId );
-}
-}
-}
-}
-break;
-case ECCPErrorCCServiceNotAvailable:
-{
-if( IsVideoCall( aErrorInfo.iCallId ) )
-{
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( EFalse );
-}
-}
-break;
-case ECCPErrorBadRequest:
-{
-TPECallType callType =
-iStateMachine->PhoneEngineInfo()->CallTypeCommand();
-if( callType == EPECallTypeVideo )
-{
-// Dialling MO video call cannot reach 3G network.
-__PHONELOG1( EBasic, EPhoneControl,
-"PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 2, callid%d ",
-aErrorInfo.iCallId );
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );
-}
-}
-break;
-case ECCPErrorVideoCallNotSupportedByNetwork:
-case ECCPErrorVideoCallSetupFailed:
-case ECCPErrorNotReached:
-// If call id found and seems to be Video Call
-if ( IsVideoCall( aErrorInfo.iCallId ) )
-{
-// Get active call count
-TPhoneCmdParamInteger activeCallCount;
-iViewCommandHandle->ExecuteCommandL(
-EPhoneViewGetCountOfActiveCalls, &activeCallCount );
-if ( activeCallCount.Integer() == 0
-|| iStateMachine->PhoneEngineInfo()->CallDirection(
-aErrorInfo.iCallId ) != RMobileCall::EMobileTerminated )
-{
-// Dialling MO video call attempted in 2G network or
-// dialing MO video to unvalid number
-// Reconnect query include video label if errorcode is unvalid number.
-__PHONELOG1( EBasic, EPhoneControl,
-"PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 3, callid%d ",
-aErrorInfo.iCallId );
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL(
-ECCPErrorNotReached == aErrorInfo.iErrorCode );
-}
-}
-break;
 case ECCPErrorNoService:
 // No network -> hide volume popup
 iViewCommandHandle->ExecuteCommandL( EPhoneViewHideNaviPaneAudioVolume );
 break;
 case ECCPErrorSatControl:
-{
+NumberEntryClearL();
-// check, that there really was a call established before completing SAT request
-if( aErrorInfo.iCallId != KPECallIdNotUsed )
-{
-}
-// remove number entry
-if ( !IsOnScreenDialerSupported() && IsNumberEntryUsedL() )
-{
-iViewCommandHandle->ExecuteCommandL(
-EPhoneViewRemoveNumberEntry );
-}
-else if ( IsOnScreenDialerSupported() )
-{
-NumberEntryClearL();
-}
-}
 break;
 default:
 break;
 }
 // clear call blacklist if call failure occurs
 CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();
 }
 // -----------------------------------------------------------
 // (other items were commented in a header).
 // -----------------------------------------------------------
 void CPhoneState::HandleChangedCallDurationL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleChangedCallDurationL() ");
 TInt ret = KErrNone;
 TInt isDisplayOn;
 ret = HAL::Get( HALData::EDisplayState, isDisplayOn );
 // Update only if the display is on or if HAL::Get returns an error,
 // in which case display value cannot be trusted.
 if ( ret || isDisplayOn )
 {
 // Get the call duration
 TTimeIntervalSeconds seconds =
 iStateMachine->PhoneEngineInfo()->CallDuration( aCallId );
 TPhoneCmdParamInteger time;
 time.SetInteger(seconds.Int());
 iViewCommandHandle->ExecuteCommandL(EPhoneViewUpdateCallHeaderCallDuration, aCallId, &time);
 }
 }
 // -----------------------------------------------------------------------------
 //
 void CPhoneState::HandleRemoteBusyL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleRemoteBusyL( ) ");
 TPEErrorInfo info;
 info.iCallId = aCallId;
 info.iErrorCode = ECCPErrorBusy;
 info.iErrorType = EPECcp;
 CPhoneMainErrorMessagesHandler::Instance()->ShowErrorSpecificNoteL( info );
-const TPECallType callType =
-iStateMachine->PhoneEngineInfo()->CallTypeCommand();
-if( callType == EPECallTypeVideo )
-{
-// Launch reconnect query including video call menu item
-__PHONELOG1( EBasic, EPhoneControl,
-"PhoneUIControl: CPhoneState::HandleRemoteBusyL - ShowReconnectQueryL vid 5, callid%d ",
-aCallId );
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );
-}
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleDisconnectingL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleDisconnectingL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleDisconnectingL( ) ");
 TPhoneCmdParamCallHeaderData callHeaderParam;
 callHeaderParam.SetCallState( EPEStateDisconnecting );
 TBuf<KPhoneCallHeaderLabelMaxLength> labelText( KNullDesC );
 LoadResource( labelText, EPhoneInCallDisconnected );
 callHeaderParam.SetLabelText( labelText );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );
+iViewCommandHandle->ExecuteCommandL(
-iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId,
+EPhoneViewUpdateBubble,
-&callHeaderParam );
+aCallId,
+&callHeaderParam );
 CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();
 }
 // -----------------------------------------------------------
 return iViewCommandHandle->HandleCommandL(
 EPhoneIsCustomizedDialerVisible ) == EPhoneViewResponseSuccess;
 }
 // <------------------------------- KEY EVENTS ------------------------------->
 // -----------------------------------------------------------
 // CPhoneState::HandleKeyMessageL( aMessage, aKeyCode )
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleKeyMessageL(
 EXPORT_C void CPhoneState::HandleKeyEventL(
 const TKeyEvent& aKeyEvent,
 TEventCode aEventCode )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyEventL( ) ");
-if ( ( IsNumberEntryVisibleL() ) || OnlySideVolumeKeySupported() )
+if ( aKeyEvent.iScanCode == EStdKeyUpArrow &&
-{
+aEventCode == EEventKey )
-// Handle numeric keys when key events are received in single state
-HandleNumericKeyEventL( aKeyEvent, aEventCode );
-}
-else if ( aKeyEvent.iScanCode == EStdKeyUpArrow &&
-aEventCode == EEventKey )
 {
 // Increace audio volume
 IncreaseAudioVolumeL();
 }
 else if ( aKeyEvent.iScanCode == EStdKeyDownArrow &&
 aEventCode == EEventKey )
 {
 // Decreace audio volume
 DecreaseAudioVolumeL();
-}
-else
-{
-// Handle numeric keys when key events are received in single state
-HandleNumericKeyEventL( aKeyEvent, aEventCode );
 }
 }
 // -----------------------------------------------------------
 // CPhoneState::OnlySideVolumeKeySupported
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::OnlySideVolumeKeySupported( ) ");
 TBool onlySideVolumeKeySupported(EFalse);
 if ( !CPhoneCenRepProxy::Instance()->
 IsTelephonyFeatureSupported( KTelephonyLVFlagScrollVolumeKeys ) &&
 FeatureManager::FeatureSupported( KFeatureIdSideVolumeKeys ) )
 {
 onlySideVolumeKeySupported = ETrue;
 }
 __PHONELOG1( EBasic, EPhoneControl,
 "OnlySideVolumeKeySupported: %d",
 onlySideVolumeKeySupported );
 return onlySideVolumeKeySupported;
 }
-// -----------------------------------------------------------
-// CPhoneState::HandleKeyPressDurationL( aScanCode, aKeyPressDuration )
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::HandleKeyPressDurationL(
-TKeyCode aCode,
-TTimeIntervalMicroSeconds /*aKeyPressDuration*/ )
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyPressDurationL( ) ");
-if( aCode == KPhoneDtmfHashCharacter )
-{
-if( iAlsLineChangeKeyPressTimer )
-{
-if( iAlsLineChangeKeyPressTimer->IsActive() )
-{
-iAlsLineChangeKeyPressTimer->Cancel();
-}
-}
-}
-}
-// -----------------------------------------------------------
-// CPhoneState::HandleNumericKeyEventL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::HandleNumericKeyEventL(
-const TKeyEvent& /*aKeyEvent*/,
-TEventCode /*aEventCode*/ )
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleNumericKeyEventL( ) ");
-}
 // -----------------------------------------------------------------------------
 // CPhoneState::IsAnyQueryActiveL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::IsAnyQueryActiveL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsAnyQueryActiveL( ) ");
 TBool isActive( EFalse );
 // If IsNoteDismissableL returns true then shown note is dismissable by key event
 // and then there is no actual query and IsAnyQueryActiveL returns false.
 if ( !IsNoteDismissableL() )
 {
 // Check is query displayed
 TEventCode aEventCode )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendKeyEventL( ) ");
 switch( aEventCode )
 {
-// EEventKey
 case EEventKey:
 // Send the key press to the phone engine, if applicable
 SendKeyPressL( aKeyEvent, aEventCode );
 break;
-// EEventKeyUp
 case EEventKeyUp:
 // Send a key up event for the last key code sent to
 // the phone engine
 iStateMachine->SendPhoneEngineMessage(
 MPEPhoneModel::EPEMessageEndDTMF );
 CPhoneKeys::IsDtmfTone( aKeyEvent, aEventCode );
 if ( dtmfToneKeyEntered ||
 aKeyEvent.iCode == EKeyBackspace )
 {
-// Get the number entry contents, if it exists
+// Get the number entry contents and store, if it exists
 if ( IsNumberEntryUsedL() )
 {
 HBufC* phoneNumber = PhoneNumberFromEntryLC();
-// Save the phone number
 __PHONELOG1( EBasic, EPhoneControl, "SetPhoneNumber: %S ", phoneNumber );
 iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
 // Convert key code to western.
 TBuf<1> buffer; // one character
 &buffer );
 AknTextUtils::ConvertDigitsTo( buffer, EDigitTypeWestern );
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::SendKeyPressL(%S)",
 &buffer );
+// Save the key code
 TLex code( buffer );
-// Save the key code
 iStateMachine->PhoneEngineInfo()->SetKeyCode( code.Peek() );
 // Plays a DTMF tone if active call
 iStateMachine->SendPhoneEngineMessage(
 MPEPhoneModel::EPEMessagePlayDTMF );
-// remove the phone number from the cleanup stack
 CleanupStack::PopAndDestroy( phoneNumber );
 }
 }
 }
 // <------------------------------ SYSTEM EVENTS ----------------------------->
 // -----------------------------------------------------------
 // CPhoneState::HandleSystemEventL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleSystemEventL( const TWsEvent& /*aEvent*/ )
 //
 EXPORT_C void CPhoneState::HandlePhoneFocusLostEventL()
 {
 // Notify that this method is called always when Idle is brought to foreground
 // See implementation in CPhoneAppUI::HandleWsEventL
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePhoneFocusLostEventL( ) ");
 }
 // ---------------------------------------------------------
 // CPhoneState::HandleIdleForegroundEventL
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleIdleForegroundEventL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleIdleForegroundEventL( ) ");
 // Empty implementation
-}
-// -----------------------------------------------------------
-// CPhoneState::HandleEnvironmentChangeL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::HandleEnvironmentChangeL( const TInt aChanges )
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleEnvironmentChangeL( ) ");
-__PHONELOG1( EBasic, EPhoneControl, "CPhoneState::HandleEnvironmentChangeL - Changes:  %d ", aChanges );
-// Update the profile display if required
-if ( aChanges &
-( EChangesLocale | EChangesMidnightCrossover | EChangesSystemTime ) )
-{
-UpdateProfileDisplayL();
-}
 }
 // -----------------------------------------------------------
 // CPhoneState::HandlePhoneStartupL
 // -----------------------------------------------------------
 EXPORT_C void CPhoneState::HandlePropertyChangedL(
 const TUid& aCategory,
 const TUint aKey,
 const TInt aValue )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePropertyChangedL( ) ");
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::HandlePropertyChangedL - aCategory= %d", aCategory  );
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::HandlePropertyChangedL - aKey= %d", aKey  );
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::HandlePropertyChangedL - aValue= %d", aValue  );
-if ( aCategory == KPSUidTelInformation
+if ( aCategory == KPSUidTelInformation && SimState() == EPESimUsable )
-&& SimState() == EPESimUsable )
+{
-{
-// Telephony display event
 if ( aKey == KTelDisplayInfo )
 {
-__PHONELOG( EBasic, EPhoneControl, "CPhoneState::HandlePropertyChangedL - telephony display info received" );
+__PHONELOG( EBasic, EPhoneControl,
-// Update the operator and profile display
+"CPhoneState::HandlePropertyChangedL - telephony display info received" );
-UpdateProfileDisplayL();
 }
 }
 else if ( aCategory == KPSUidStartup && aKey == KStartupSimSecurityStatus )
 {
 // Show security note, SIM is not valid.
 EPhoneViewGetTopApplicationIsDisplayedStatus ) ==
 EPhoneViewResponseSuccess;
 }
 // <---------------------------- MENU AND CBA EVENTS ------------------------->
 EXPORT_C TBool CPhoneState::HandleCommandL( TInt aCommand )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleCommandL( ) ");
 TBool commandStatus = ETrue;
 switch( aCommand )
 {
 case EPhoneEmergencyCmdExit:
-{
-}
-// this should be bypasses?
 case EPhoneDialerCallHandling:
 case EPhoneCmdBack:
-// Remove number entry from screen
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
 // Do state-specific behaviour if number entry is cleared
 HandleNumberEntryClearedL();
 break;
 case EPhoneDialerCmdTouchInput:
-break;
 case EPhoneNumberAcqCmdSendMessage:
-break;
 case EPhoneNumberAcqCmdSave:
-break;
 case EPhoneNumberAcqCmdAddToName:
 break;
 case EPhoneNumberAcqCmdAddToContacts:
 {
-if ( IsOnScreenDialerSupported() )
+TPhoneCmdParamQuery queryDialogParam;
-{
+queryDialogParam.SetQueryType( EPhoneContactsListQuery );
-TPhoneCmdParamQuery queryDialogParam;
+queryDialogParam.SetQueryResourceId(
-queryDialogParam.SetQueryType( EPhoneContactsListQuery );
+CPhoneMainResourceResolver::Instance()->
-queryDialogParam.SetQueryResourceId(
+ResolveResourceID( EPhoneAddtoContactsListQuery ) );
-CPhoneMainResourceResolver::Instance()->
+iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery,
-ResolveResourceID( EPhoneAddtoContactsListQuery )  );
+&queryDialogParam );
-// Display dialog
-iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery,
-&queryDialogParam );
-}
 }
 break;
 case EPhoneCmdWaitNoteOk:
-// Remove number entry from screen
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );
-if ( !IsOnScreenDialerSupported() )
-{
-HandleNumberEntryClearedL();
-}
 break;
 case EPhoneInCallCmdEndThisOutgoingCall:
 DisconnectCallL();
 break;
 ChangeAlsLineL();
 }
 else
 {
 SendGlobalErrorNoteL( EPhoneLineBlockingNote );
-HandleNumberEntryClearedL(); // Set back CBAs
-}
-break;
-case EPhoneCmdNoAlsLineChange:
-if ( !IsOnScreenDialerSupported() )
-{
 HandleNumberEntryClearedL();
 }
 break;
 case EPhoneCmdYesBtDisconnectQuery:
 case EPhoneInCallCmdBtHandsfree:
 CPhoneState::SetBTHandsfreeModeL(
 aCommand == EPhoneInCallCmdBtHandsfree );
 break;
+case EPhoneCmdNoAlsLineChange:
 case EPhoneInCallCmdActivatEPhonebook:
-{
-}
-break;
 case EPhoneNumberAcqSecurityDialer:
-{
-}
-break;
 case EPhoneDialerCmdContacts:
-{
-}
-break;
 case EPhoneNumberAcqCmdToggleNeAlphaMode:
 case EPhoneNumberAcqCmdToggleNeNumericMode:
-{
-}
 break;
 case EPhoneCmdYesVideoFailedNoMemorySwitchToVoice:
 DialVoiceCallL();
 break;
 case EPhoneCmdNoVideoFailedNoMemorySwitchToVoice:
 if ( IsNumberEntryUsedL() )
 {
-// Show the number entry if it exists
 SetNumberEntryVisibilityL(ETrue);
 }
 else if ( NeedToSendToBackgroundL() )
 {
 // Continue displaying current app but set up the
 // idle screen in the background
 SetupIdleScreenInBackgroundL();
 }
 else
 {
-// Display idle screen
 DisplayIdleScreenL();
 }
 break;
 case EPhoneInCallCmdSetVolumeLevel:
 ShowVideoCallOutOfMemoryNoteL();
 DisconnectCallL();
 break;
 case EPhoneCallComingCmdSoftReject:
-// Open Soft reject message editor
 OpenSoftRejectMessageEditorL();
 break;
 case EPhoneInCallCmdContacts:
 iViewCommandHandle->ExecuteCommand( EPhoneViewOpenContacts );
 break;
 default:
+{
-/*if ( IsOnScreenDialerSupported() )
+commandStatus = EFalse;
-{
+}
-// Offer command to view.
+break;
-TPhoneViewResponseId resId =
+}
-iViewCommandHandle->HandleCommandL( aCommand );
-if( resId == EPhoneViewResponseFailed )
-{
-commandStatus = EFalse;
-}
-}
-else*/
-{
-commandStatus = EFalse;
-}
-break;
-}
 if( !commandStatus && iCustomization )
 {
 commandStatus = iCustomization->HandleCommandL( aCommand );
 }
 return commandStatus;
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::ProcessCommandL
 EXPORT_C TBool CPhoneState::HandleRemConCommandL(
 TRemConCoreApiOperationId aOperationId,
 TRemConCoreApiButtonAction /*aButtonAct*/ )
 {
 TBool handled = EFalse;
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::MrccatoCommand() ");
 switch ( aOperationId )
 {
 case ERemConCoreApiVolumeUp:
 __PHONELOG( EBasic, EPhoneControl, "CPhoneState::MrccatoCommand ERemConCoreApiVolumeUp" );
 default:
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::MrccatoCommand MrccatoCmd.Other(%d)", aOperationId );
 // Other commands ignored.
 break;
 }
 return handled;
 }
 // -----------------------------------------------------------
 // CPhoneState::DecreaseAudioVolume()
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::DecreaseAudioVolumeL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DecreaceAudioVolumeL( ) ");
-__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
+__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );
-Panic( EPhoneCtrlInvariant ) );
 TPEAudioOutput output( iStateMachine->PhoneEngineInfo()->AudioOutput() );
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::DecreaseAudioVolumeL - audio output =%d", output );
 if( output == EPETTY )
 {
 SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl, ETrue );
 }
 else
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::IncreaseAudioVolumeL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IncreaceAudioVolumeL( ) ");
-__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
+__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );
-Panic( EPhoneCtrlInvariant ) );
 TPEAudioOutput output( iStateMachine->PhoneEngineInfo()->AudioOutput() );
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::IncreaseAudioVolumeL - audio output =%d", output );
 if( output == EPETTY )
 {
 SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl, ETrue );
 //
 void CPhoneState::ChangeAudioVolumeL( TInt aLevel, TBool aUpdateControl )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::ChangeAudioVolumeL( ) ");
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::ChangeAudioVolumeL - set volume =%d", aLevel );
 TInt valueToControl = aLevel;
 // sets value between 1 -10
 if ( aLevel>=KPhoneVolumeMinValue && aLevel<=KPhoneVolumeMaxValue )
 {
 iStateMachine->PhoneEngineInfo()->SetAudioVolumeCommand( aLevel );
 // Syncronizes audio volume level between engine and ui
 // causes EPEMessageAudioVolumeChanged message to phoneUI
 iStateMachine->SendPhoneEngineMessage(
 MPEPhoneModel::EPEMessageSetAudioVolume );
 }
 if ( aUpdateControl )
 {
 // Update the volume display.
 // Upper max (11) and under min (-1)
 // values are also updated to volume popup.
 TPhoneCmdParamInteger volumeParam;
 &volumeParam );
 }
 }
 // <-------------------------- COMMON STATE FUNCTIONS ------------------------>
 // -----------------------------------------------------------
 // CPhoneState::DialMultimediaCallL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::DialMultimediaCallL()
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::DialVoiceCallL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DialVoiceCallL() ");
-__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
+__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );
-Panic( EPhoneCtrlInvariant ) );
-// Disable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( ETrue );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 iStateMachine->PhoneEngineInfo()->SetCallTypeCommand( EPECallTypeCSVoice );
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisconnectCallL( ) ");
 TPhoneCmdParamInteger callIdParam;
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewGetExpandedBubbleCallId, &callIdParam );
 TBool ret = EFalse;
 if( callIdParam.Integer() > KErrNotFound )
 {
-// Release the call
 iStateMachine->SetCallId( callIdParam.Integer() );
 if( IsVideoCall( callIdParam.Integer() ) )
 {
 // Video call can be released only after we get response to VT Shutdown Command
-CPhoneMediatorFactory::Instance()->Sender()->IssueCommand( KMediatorVideoTelephonyDomain,
+CPhoneMediatorFactory::Instance()->Sender()->IssueCommand(
-KCatPhoneToVideotelCommands,
+KMediatorVideoTelephonyDomain,
-EVtCmdReleaseDataport,
+KCatPhoneToVideotelCommands,
-TVersion( KPhoneToVideotelCmdVersionMajor,
+EVtCmdReleaseDataport,
-KPhoneToVideotelCmdVersionMinor,
+TVersion( KPhoneToVideotelCmdVersionMajor,
-KPhoneToVideotelCmdVersionBuild ),
+KPhoneToVideotelCmdVersionMinor,
-KNullDesC8,
+KPhoneToVideotelCmdVersionBuild ),
-CPhoneReleaseCommand::NewL( *iStateMachine ) );
+KNullDesC8,
+CPhoneReleaseCommand::NewL( *iStateMachine ) );
 }
 else
 {
-// Release the call
 iStateMachine->SendPhoneEngineMessage(
 MPEPhoneModel::EPEMessageRelease );
 }
 ret = ETrue;
 }
 else
 {
 __PHONELOG( EOnlyFatal, EPhoneControl,
 "CPhoneState::DisconnectCallL has negative call id!" );
 }
 return ret;
 }
 // -----------------------------------------------------------
 // CPhoneState::DisplayIdleScreenL
 //
 EXPORT_C void CPhoneState::DisplayIdleScreenL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisplayIdleScreenL( ) ");
-// Don't remove reconnect query if it's shown
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );
-if( !CPhoneReconnectQuery::InstanceL()->IsDisplayingQuery() )
-{
-// Remove dialogs if necessary
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );
-}
 // Set Empty CBA
 iCbaManager->SetCbaL( EPhoneEmptyCBA );
 // Bring Idle app to the foreground
 iViewCommandHandle->ExecuteCommandL( EPhoneViewBringIdleToForeground );
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetupIdleScreenInBackgroundL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetupIdleScreenInBackgroundL( ) ");
-// Don't remove reconnect query if it's shown
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );
-if( !CPhoneReconnectQuery::InstanceL()->IsDisplayingQuery() )
-{
-// Remove dialogs if necessary
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );
-}
-// Return phone to the background
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSendToBackground );
-// Set Idle app as the top app
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetIdleTopApplication );
-// Set Empty CBA
 iCbaManager->SetCbaL( EPhoneEmptyCBA );
 }
 // ---------------------------------------------------------
 // CPhoneState::CallFromNumberEntryL
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::CallFromNumberEntryL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::CallFromNumberEntryL( ) ");
-__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
+__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );
-Panic( EPhoneCtrlInvariant ) );
+if ( IsCustomizedDialerVisibleL() )
+{
-if ( IsOnScreenDialerSupported() )
+return;
-{
+}
-if ( IsCustomizedDialerVisibleL() )
+else if( IsNumberEntryUsedL() )
+{
+// IS query on top of dialer
+if ( IsAnyQueryActiveL() )
 {
 return;
 }
+// Open recent calls list when the number entry is empty
-else if( IsNumberEntryUsedL() )
+TPhoneCmdParamInteger numberEntryCountParam;
-{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewGetNumberEntryCount,
-// Query on top of dialer
+&numberEntryCountParam );
-if ( IsAnyQueryActiveL() )
+TInt neLength( numberEntryCountParam.Integer() );
-{
+TBool startLogs = neLength == 0 ? ETrue : EFalse;
-return;
-}
+if ( startLogs )
-// Open recent calls list when the number entry is empty
+{
-TPhoneCmdParamInteger numberEntryCountParam;
+iViewCommandHandle->HandleCommandL(
-iViewCommandHandle->ExecuteCommandL( EPhoneViewGetNumberEntryCount,
+EPhoneDialerCmdLog );
-&numberEntryCountParam );
+return;
-TInt neLength( numberEntryCountParam.Integer() );
+}
-TBool startLogs = neLength == 0 ? ETrue : EFalse;
+}
-if ( startLogs )
-{
-iViewCommandHandle->HandleCommandL(
-EPhoneDialerCmdLog );
-return;
-}
-}
-}
-// Get the number entry contents
 HBufC* phoneNumber = PhoneNumberFromEntryLC();
-// Call the number
 iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
 if ( phoneNumber->Des().Length() < KPhoneValidPhoneNumberLength )
 {
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
 HandleNumberEntryClearedL();
 }
 CleanupStack::PopAndDestroy( phoneNumber );
 if ( !iCustomization ||
 !iCustomization->HandleCallFromNumberEntryL() )
 {
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::UpdateSingleActiveCallL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateSingleActiveCallL( ) ");
-// Stop capturing keys
-CaptureKeysDuringCallNotificationL( EFalse );
 BeginUiUpdateLC();
-// Update call state
 TPhoneCmdParamCallHeaderData callHeaderParam;
 callHeaderParam.SetCallState( EPEStateConnected );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId,
 &callHeaderParam );
-// Update remote info data
 UpdateRemoteInfoDataL( aCallId );
 // Create call duration label if enabled
 // This key will be moved to some other area, but since key
 // is supported we can still use it.
 if ( callDuration )
 {
 HandleChangedCallDurationL( aCallId );
 }
 EndUiUpdate();
-// Go to current state implementation
 iCbaManager->UpdateInCallCbaL();
-// Go to background if necessary
-if ( NeedToSendToBackgroundL() ||  IsAutoLockOn() )
-{
-}
 // If there is no need to send back ground and number entry is used then
 // we must show number entry.
-else if ( !NeedToSendToBackgroundL() && IsNumberEntryUsedL() )
+if ( !NeedToSendToBackgroundL() && IsNumberEntryUsedL() && !IsAutoLockOn() )
 {
 SetNumberEntryVisibilityL(ETrue);
 }
-}
-// -----------------------------------------------------------
-// CPhoneState::CaptureKeysDuringCallNotificationL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::CaptureKeysDuringCallNotificationL(
-TBool /*aCaptured*/ )
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::CaptureKeysDuringCallNotificationL( ) ");
-// Determine which view command to execute based on the capture status
-/*const TInt viewCommandId = aCaptured ?
-EPhoneViewStartCapturingKey :
-EPhoneViewStopCapturingKey;
-// Capture the App key
-TPhoneCmdParamKeyCapture appKeyCaptureParam;
-appKeyCaptureParam.SetKey( EStdKeyApplication0 );
-appKeyCaptureParam.SetKeyCode( EKeyApplication0 );
-appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
-iViewCommandHandle->ExecuteCommandL( viewCommandId, &appKeyCaptureParam );
-// Capture the Camera key, if it exists
-if ( FeatureManager::FeatureSupported( KFeatureIdCamera ) )
-{
-TPhoneCmdParamKeyCapture cameraKeyCaptureParam;
-cameraKeyCaptureParam.SetKey( EStdKeyDevice7 );
-cameraKeyCaptureParam.SetKeyCode( EKeyDevice7 );
-cameraKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
-iViewCommandHandle->ExecuteCommandL( viewCommandId,
-&cameraKeyCaptureParam );
-}*/
 }
 // -----------------------------------------------------------
 // CPhoneState::IsWaitingCallL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::UpdateRemoteInfoDataL( TInt aCallId )
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::UpdateRemoteInfoDataL() ");
 TPhoneCmdParamCallHeaderData callHeaderParam = UpdateCallHeaderInfoL( aCallId );
 if( iCustomization )
 {
 TBuf<KCntMaxTextFieldLength> inCallNumberText( KNullDesC );
 // to check if we have VoIP call in question and fix
 // parameters if needed
 iCustomization->ModifyCallHeaderTexts( aCallId, &callHeaderParam,
 inCallNumberText );
 }
 // Update the remote info data in the call header
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewUpdateCallHeaderRemoteInfoData,
 aCallId,
 &callHeaderParam );
 // -----------------------------------------------------------
 //
 void CPhoneState::UpdateCbaSwivelStateChangedL()
 {
 __LOGMETHODSTARTEND(EPhoneControl,"CPhoneState::UpdateCbaSwivelStateChangedL()" );
 TPhoneCmdParamCallStateData callStateData;
 callStateData.SetCallState( EPEStateRinging );
 iViewCommandHandle->HandleCommandL(
 EPhoneViewGetCallIdByState, &callStateData );
 TInt incomingCall = callStateData.CallId();
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 TPhoneCmdParamNote noteParam;
 noteParam.SetType( EPhoneNotePermanent );
 noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );
 }
 // -----------------------------------------------------------
 // CPhoneState::ShowQueryL
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 TPhoneCmdParamQuery queryParam;
 queryParam.SetQueryType( EPhoneQueryDialog );
 queryParam.SetQueryResourceId( CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery, &queryParam );
 }
 // -----------------------------------------------------------
 // CPhoneState::ShowTextQueryL
 queryDialogParam.SetQueryResourceId( aDialogResourceId );
 queryDialogParam.SetDefaultCba( aDefaultCbaResourceId );
 queryDialogParam.SetContentCba( aContentCbaResourceId );
 queryDialogParam.SetDataText( aDataText );
 queryDialogParam.SetSendKeyEnabled( aSendKeyEnabled );
-// Display dialog
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowQuery,
 &queryDialogParam );
 }
 // -----------------------------------------------------------
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendGlobalInfoNoteL( ) ");
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 if ( CPhonePubSubProxy::Instance()->Value(
 KPSUidUikon, KUikGlobalNotesAllowed ) == 1 )
 {
-// Re-enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 EPhoneNotificationDialog : EPhoneMessageBoxInformation;
 globalNoteParam.SetType( type );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
 globalNoteParam.SetNotificationDialog( aNotificationDialog );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 if ( CPhonePubSubProxy::Instance()->Value(
 KPSUidUikon, KUikGlobalNotesAllowed ) == 1 ||
 SimState() == EPESimReadable )
 {
-// Re-enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 EPhoneNotificationDialog : EPhoneMessageBoxWarning;
 globalNoteParam.SetType( type );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
 globalNoteParam.SetNotificationDialog( aNotificationDialog );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendGlobalErrorNoteL( ) ");
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 if ( CPhonePubSubProxy::Instance()->Value(
 KPSUidUikon, KUikGlobalNotesAllowed ) == 1 )
 {
-// Re-enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 }
 CleanupStack::PopAndDestroy( bt );
 }
 // <-------------------------- INTERNAL FUNCTIONS ------------------------>
-// -----------------------------------------------------------
-// CPhoneState::UpdateProfileDisplayL
-// -----------------------------------------------------------
-//
-void CPhoneState::UpdateProfileDisplayL()
-{
-}
 // -----------------------------------------------------------
 // CPhoneState::HandleInitiatedEmergencyCallL
 // Default handling for EPEMessageInitiatedEmergencyCallL message
 // (other items were commented in a header).
 // -----------------------------------------------------------
 //
 void CPhoneState::HandleInitiatedEmergencyCallL( TInt /*aCallId*/ )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleInitiatedEmergencyCallL( ) ");
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );
-// Stop tone playing, if necessary
 iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );
 // Reset Hold flag to view
 TPhoneCmdParamBoolean holdFlag;
 holdFlag.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );
-// Go to emergency call state
-// No need update cba
 iStateMachine->ChangeState( EPhoneStateEmergency );
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleInitiatedEmergencyWhileActiveVideoL
 // -----------------------------------------------------------
 //
 void CPhoneState::HandleInitiatedEmergencyWhileActiveVideoL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleInitiatedEmergencyWhileActiveVideoL( ) ");
+// We have existing video call so need to release dataport before continuings
-// We have existing video call so need to release dataport before continuing
 // emergency call. Otherwise we will face problems with dataport use later.
-CPhoneMediatorFactory::Instance()->Sender()->IssueCommand( KMediatorVideoTelephonyDomain,
+CPhoneMediatorFactory::Instance()->Sender()->IssueCommand(
-KCatPhoneToVideotelCommands,
+KMediatorVideoTelephonyDomain,
-EVtCmdReleaseDataport,
+KCatPhoneToVideotelCommands,
-TVersion( KPhoneToVideotelCmdVersionMajor,
+EVtCmdReleaseDataport,
-KPhoneToVideotelCmdVersionMinor,
+TVersion( KPhoneToVideotelCmdVersionMajor,
-KPhoneToVideotelCmdVersionBuild ),
+KPhoneToVideotelCmdVersionMinor,
-KNullDesC8,
+KPhoneToVideotelCmdVersionBuild ),
-CPhoneContinueEmergencyCallCommand::NewL( *iStateMachine ) );
+KNullDesC8,
+CPhoneContinueEmergencyCallCommand::NewL( *iStateMachine ) );
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleCallSecureStatusChangeL
 // -----------------------------------------------------------
 //
 void CPhoneState::HandleCallSecureStatusChangeL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleCallSecureStatusChangeL( ) ");
 TBool ciphering( ETrue );
 TBool secureSpecified( ETrue );
 if ( aCallId > KErrNotFound )
 {
 ciphering = iStateMachine->PhoneEngineInfo()->IsSecureCall( aCallId );
 secureSpecified = iStateMachine->PhoneEngineInfo()->SecureSpecified();
 }
 TPhoneCmdParamCallHeaderData callHeaderParam;
 callHeaderParam.SetCiphering( ciphering );
 callHeaderParam.SetCipheringIndicatorAllowed( secureSpecified );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewCipheringInfoChange,
 aCallId,
 &callHeaderParam );
 }
 // ---------------------------------------------------------
 //
 void CPhoneState::ChangeAlsLineL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::ChangeAlsLineL( ) ");
-if ( !IsOnScreenDialerSupported() )
-{
-// Do state-specific operation when number entry is cleared
-HandleNumberEntryClearedL();
-}
 CCCECallParameters::TCCELineType currentLine;
 TSSSettingsAlsValue newLine( ESSSettingsAlsPrimary );
 currentLine = iStateMachine->PhoneEngineInfo()->ALSLine();
 if ( currentLine == CCCECallParameters::ECCELineTypePrimary )
 {
 newLine = ESSSettingsAlsAlternate;
 }
 else if ( currentLine == CCCECallParameters::ECCELineTypeAux )
 // ---------------------------------------------------------
 //
 TInt CPhoneState::GetActiveCallIdL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::GetActiveCallId()( ) ");
 // Fetch active call's id from view
 TPhoneViewResponseId response;
 TPhoneCmdParamCallStateData callStateData;
 callStateData.SetCallState( EPEStateConnected );
 response = iViewCommandHandle->HandleCommandL(
 // check for held call
 callStateData.SetCallState( EPEStateHeld );
 response = iViewCommandHandle->HandleCommandL(
 EPhoneViewGetCallIdByState, &callStateData );
 }
 return callStateData.CallId();
 }
 // ---------------------------------------------------------
 // CPhoneState::SimState()
 // ---------------------------------------------------------
 //
 EXPORT_C TPESimState CPhoneState::SimState() const
 {
 /*
 SIM states:
 EPESimStatusUninitialized = KPEStartupEnumerationFirstValue =100,
 EPESimUsable,       // The Sim card is fully usable.
 EPESimReadable,     // The SIM card is not fully usable, but the emergency number can be read.
 EPESimNotReady,     // The Sim card is present but not ready or usable.
 EPESimNotPresent,   // The Sim card is not present.
 */
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SimState()");
 __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
 Panic( EPhoneCtrlInvariant ) );
 TPESimState simState = iStateMachine->PhoneEngineInfo()->SimState();
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::SimState - value= %d", simState );
 return simState;
 }
 // CPhoneState::IsSimOk()
 // ---------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::IsSimOk()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsSimOk()");
 // Phone is interested on Sim state and sim security statuses
 // Check first Sim state status:
 TBool retVal( ETrue );
 switch ( SimState() )
 // -----------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::IsSimStateNotPresentWithSecurityModeEnabled()
 {
 TPhoneCmdParamBoolean isSecurityMode;
+TBool retValue(EFalse);
 TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode ) );
 if ( SimState() == EPESimNotPresent && isSecurityMode.Boolean() )
 {
-return ETrue;
+retValue = ETrue;
 }
-else
+return retValue;
-{
-return EFalse;
-}
 }
 // ---------------------------------------------------------
 // CPhoneState::SetDivertIndication
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetDivertIndication( const TBool aDivertIndication )
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::SetDivertIndication()");
 TRAP_IGNORE( CallheaderManagerL()->SetDivertIndication( aDivertIndication ) );
-}
-// ---------------------------------------------------------
-// CPhoneState::StartAlsLineChangeTimerL
-// ---------------------------------------------------------
-//
-EXPORT_C void CPhoneState::StartAlsLineChangeTimerL()
-{
-__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::StartAlsLineChangeTimerL()");
-TBool alsLineAvailable = iStateMachine->PhoneEngineInfo()->ALSLineSupport();
-if( alsLineAvailable )
-{
-if( !iAlsLineChangeKeyPressTimer )
-{
-iAlsLineChangeKeyPressTimer = CPhoneTimer::NewL();
-}
-iAlsLineChangeKeyPressTimer->After( KAlsLineChangeTimerValue,
-TCallBack( AlsLineChangeTimerCallbackL, this ) );
-}
-else
-{
-// Don't bother launching the timer. ALS not supported.
-__PHONELOG( EBasic, EPhoneControl,
-"CPhoneState::StartAlsLineChangeTimerL - ALS not supported " );
-}
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::StartShowSecurityNoteL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CPhoneState::StartShowSecurityNoteL()
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::StartShowSecurityNoteL ");
-// Set security mode on.
 TPhoneCmdParamBoolean securityMode;
 securityMode.SetBoolean( ETrue );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetSecurityMode, &securityMode );
-// Remove number entry from screen
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+iCbaManager->UpdateCbaL( EPhoneEmptyCBA );
-iCbaManager->UpdateCbaL( EPhoneEmptyCBA );
 TPhoneCmdParamInteger uidParam;
-// Bring Phone app in the foreground
 uidParam.SetInteger( KUidPhoneApplication.iUid );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,
 &uidParam );
-// Set Phone as the top application
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,
 &uidParam );
 TInt resourceId ( KErrNone );
 if ( SimSecurityStatus() == ESimRejected )
 {
 resourceId = CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneSimRejected );
 }
 if ( resourceId != KErrNone )
 {
 // Add it to the resource string
 HBufC* buf = StringLoader::LoadLC( resourceId );
 TPhoneCmdParamNote noteParam;
 noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneSecurityInformationNote ) );
 noteParam.SetText( *buf );
 noteParam.SetTone( CAknNoteDialog::EConfirmationTone );
 noteParam.SetType( EPhoneNoteSecurity );
 // Display note
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );
 CleanupStack::PopAndDestroy( buf );
 // Capture the App key
 TPhoneCmdParamKeyCapture appKeyCaptureParam;
 appKeyCaptureParam.SetKey( EStdKeyApplication0 );
 appKeyCaptureParam.SetKeyCode( EKeyApplication0 );
 appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
 EPhoneViewStartCapturingKey, &appKeyCaptureParam );
 }
 }
 // ---------------------------------------------------------
-// CPhoneState::AlsLineChangeTimerCallbackL
-// ---------------------------------------------------------
-//
-TInt CPhoneState::AlsLineChangeTimerCallbackL( TAny* aAny )
-{
-__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::AlsLineChangeTimerCallbackL()");
-// Send a key up event for stopping keypad tone
-reinterpret_cast<CPhoneState*>( aAny )->
-iStateMachine->SendPhoneEngineMessage(
-MPEPhoneModel::EPEMessageEndDTMF );
-if ( !( reinterpret_cast<CPhoneState*>( aAny )->
-IsOnScreenDialerSupported() ) )
-{
-// If dialer is undefined remove the number entry.
-reinterpret_cast<CPhoneState*>( aAny )->
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
-}
-else
-{
-// If on screen dialer is in use just clear entry
-// do not remove dialer.
-reinterpret_cast<CPhoneState*>( aAny )->
-NumberEntryClearL();
-}
-// Show the als line changing confirmation query
-reinterpret_cast<CPhoneState*>( aAny )->
-ShowQueryL( EPhoneAlsLineChangeConfirmationQuery );
-return KErrNone;
-}
-// ---------------------------------------------------------
 // CPhoneState::ShowWlanMacAddressL
 // ---------------------------------------------------------
 //
 void CPhoneState::ShowWlanMacAddressL()
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::ShowWlanMacAddressL()");
-if ( IsOnScreenDialerSupported() )
+NumberEntryClearL();
-{
-NumberEntryClearL();
-}
-else
-{
-// Remove number entry from screen
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
-}
 // Fetch WLAN MAC address
 TBuf8<KPhoneWlanMacAddressLength> address;
 RProperty::Get(
 KPSUidWlan,
 KPSWlanMacAddress,
 address );
 // Format fetched address
 TBuf<KPhoneWlanMacAddressLength> wlanMACAddress;
 for ( TInt i( 0 ); i < address.Length(); i++ )
 {
 // Set separator
 // Now we need the localised text
 HBufC* wlanMacAddress = StringLoader::LoadLC(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneWlanMacAddress ), wlanMACAddress );
 TPhoneCmdParamNote noteParam;
 noteParam.SetType( EPhoneNoteCustom );
 noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneInformationWaitNote ) );
 noteParam.SetText( *wlanMacAddress );
 noteParam.SetTone( CAknNoteDialog::EConfirmationTone );
-// Display note
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );
 CleanupStack::PopAndDestroy( wlanMacAddress );
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleAudioAvailableOutputChangedL
 // -----------------------------------------------------------
 //
 void CPhoneState::HandleAudioAvailableOutputChangedL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleAudioAvailableOutputChangedL() ");
-__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
+__ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(), Panic( EPhoneCtrlInvariant ) );
-Panic( EPhoneCtrlInvariant ) );
 TPhoneCmdParamAudioAvailability outputParam;
 // Output
 const TPEAudioOutput audioOutput =
 iStateMachine->PhoneEngineInfo()->AudioOutput();
 // BT availability
 TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
 EPEBTAudioAccessory );
 outputParam.SetBTAccAvailable( btAvailable );
 // Wired availability
 TBool wiredAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
 EPEWiredAudioAccessory );
 outputParam.SetWiredAccAvailable( wiredAvailable );
 // BTA disconnect handler check
 if( btAvailable )
 {
 CPhoneBtaaDisconnectHandler::InstanceL()->Cancel();
 }
+iViewCommandHandle->ExecuteCommandL(
-// view update
+EPhoneViewActivateAudioAvailabilityUIChanges,
-iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateAudioAvailabilityUIChanges,
+&outputParam );
-&outputParam );
 }
 // ---------------------------------------------------------
 // CPhoneState::IsAlsLineChangePossible
 // ---------------------------------------------------------
 //
 TBool CPhoneState::IsAlsLineChangePossible()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsAlsLineChangePossible( ) ");
 TBool isAlsLineChangePossible( ETrue );
 TSSSettingsAlsBlockingValue AlsBlockingValue( ESSSettingsAlsBlockingNotSupported );
 TInt value( 0 );
 RSSSettings ssSettings;
 TInt retValue = ssSettings.Open();
 if ( retValue == KErrNone )
 {
 ssSettings.Get( ESSSettingsAlsBlocking, value );
 ssSettings.Close();
 AlsBlockingValue = static_cast< TSSSettingsAlsBlockingValue > ( value );
 if( AlsBlockingValue == ESSSettingsAlsAlternate )
 {
 isAlsLineChangePossible = EFalse;
 }
 }
 return isAlsLineChangePossible;
 }
 // ---------------------------------------------------------
 // CPhoneState::ShowNumberBusyNoteL
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::ShowNumberBusyNoteL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::ShowNumberBusyNoteL( ) ");
-// Re-enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 TInt resource( EPhoneNumberBusy );
 if( iCustomization )
 {
 // Get customized text resource for busy note
 resource = iCustomization->CustomizeBusyNoteText();
 }
 // CPhoneState::IsAutoLockOn
 // ---------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::IsAutoLockOn() const
 {
-// Check if phone is locked
 const TBool phoneIsLocked =
 CPhonePubSubProxy::Instance()->Value(
 KPSUidCoreApplicationUIs,
 KCoreAppUIsAutolockStatus ) > EAutolockOff;
 __PHONELOG1( EBasic,
 EPhoneControl,
 "CPhoneState::IsAutoLockOn() Status: %d",
 phoneIsLocked );
 return phoneIsLocked;
 }
 // ---------------------------------------------------------
 // CPhoneState::IsKeyLockOn
 EXPORT_C TBool CPhoneState::IsKeyLockOn() const
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsKeyLockOn( ) ");
 TPhoneCmdParamBoolean keyLockStatus;
 keyLockStatus.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommand(
 EPhoneViewGetKeyLockStatus,
 &keyLockStatus );
 __PHONELOG1( EBasic,
 EPhoneControl,
 "CPhoneState::IsKeyLockOn() Lock Status: %d",
 keyLockStatus.Boolean() );
 return keyLockStatus.Boolean();
 // CPhoneState::SetTouchPaneButtons
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetTouchPaneButtons( TInt /*aResourceId*/ )
 {
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+TPhoneCmdParamBoolean muteParam;
-{
+muteParam.SetBoolean( iStateMachine->PhoneEngineInfo()->AudioMute() );
-TPhoneCmdParamBoolean muteParam;
+iViewCommandHandle->ExecuteCommand(EPhoneViewSetMuteFlag,&muteParam);
-muteParam.SetBoolean( iStateMachine->PhoneEngineInfo()->AudioMute() );
-iViewCommandHandle->ExecuteCommand(EPhoneViewSetMuteFlag,&muteParam);
+const TPEAudioOutput audioOutput =
+iStateMachine->PhoneEngineInfo()->AudioOutput();
-const TPEAudioOutput audioOutput =
-iStateMachine->PhoneEngineInfo()->AudioOutput();
+TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
+EPEBTAudioAccessory );
-TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
-EPEBTAudioAccessory );
+TPhoneCmdParamBoolean btParam;
+btParam.SetBoolean( audioOutput == EPEBTAudioAccessory );
-TPhoneCmdParamBoolean btParam;
+iViewCommandHandle->ExecuteCommand(EPhoneViewSetBlueToothFlag,&btParam);
-btParam.SetBoolean( audioOutput == EPEBTAudioAccessory );
-iViewCommandHandle->ExecuteCommand(EPhoneViewSetBlueToothFlag,&btParam);
+TPhoneCmdParamBoolean btAvailableParam;
+btAvailableParam.SetBoolean( btAvailable );
-TPhoneCmdParamBoolean btAvailableParam;
+iViewCommandHandle->ExecuteCommand(
-btAvailableParam.SetBoolean( btAvailable );
+EPhoneViewSetBluetoothAvailableFlag,&btAvailableParam);
-iViewCommandHandle->ExecuteCommand(
-EPhoneViewSetBluetoothAvailableFlag,&btAvailableParam);
+TBool emergency( EPEStateIdle !=
+iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) );
-TBool emergency( EPEStateIdle !=
+TPhoneCmdParamBoolean booleanParam;
-iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) );
+booleanParam.SetBoolean( emergency );
-TPhoneCmdParamBoolean booleanParam;
-booleanParam.SetBoolean( emergency );
+TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetTouchPaneButtons,
-TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
+&booleanParam ) );
-EPhoneViewSetTouchPaneButtons,
-&booleanParam ) );
-}
 }
 // ---------------------------------------------------------
 // CPhoneState::DeleteTouchPaneButtons
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::DeleteTouchPaneButtons()
 {
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+TPhoneCmdParamBoolean boolParam;
-{
+TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
-TPhoneCmdParamBoolean boolParam;
+EPhoneViewSetTouchPaneButtons,
-TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
+&boolParam ) );
-EPhoneViewSetTouchPaneButtons,
-&boolParam ) );
-}
-}
-// ---------------------------------------------------------
-// CPhoneState::HandleLongHashL
-// ---------------------------------------------------------
-//
-EXPORT_C void CPhoneState::HandleLongHashL()
-{
-__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::HandleLongHashL() ");
 }
 // -----------------------------------------------------------
 // CPhoneState::BeginUiUpdateLC
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::BeginUiUpdateLC()
 {
 iViewCommandHandle->ExecuteCommand( EPhoneViewBeginUpdate );
 TCleanupItem operation( UiUpdateCleanup, this );
 CleanupStack::PushL( operation );
 }
 // -----------------------------------------------------------
 TInt callSummaryActivated = 0;
 const TInt err = CPhoneCenRepProxy::Instance()->GetInt(
 KCRUidCommonTelephonySettings,
 KSettingsSummaryAfterCall,
 callSummaryActivated );
 if ( err == KErrNone && callSummaryActivated )
 {
 show = ETrue;
 }
 return show;
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::HandleDtmfKeyTone
 // Called from KeyEventForwarder
 // Allow only special characters to pass from
 // keyEventForwarder to phoneEngine
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleDtmfKeyToneL( const TKeyEvent& aKeyEvent,
 TEventCode aEventCode )
 {
 SendDtmfKeyEventL( aKeyEvent, aEventCode );
 }
 //
 EXPORT_C void CPhoneState::SetDefaultFlagsL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetDefaultFlagsL()");
 iViewCommandHandle->ExecuteCommandL( EPhoneViewHideNaviPaneAudioVolume );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateFSW );
 // Reset Hold flag to view
 TPhoneCmdParamBoolean holdFlag;
 holdFlag.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );
-// Update FSW
-iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateFSW );
-// Re-enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetEikonNotifiersDisabled,
 &globalNotifierParam );
-// uncapture App and Camera keys if not security mode
-TPhoneCmdParamBoolean isSecurityMode;
-iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode );
-if ( !isSecurityMode.Boolean() )
-{
-CaptureKeysDuringCallNotificationL( EFalse );
-}
 // Restore keylock if phone has been locked before call.
 if ( iStateMachine->PhoneStorage()->NeedToEnableKeylock() )
 {
 iViewCommandHandle->ExecuteCommandL( EPhoneViewEnableKeyLock );
 iStateMachine->PhoneStorage()->SetNeedToEnableKeylock( EFalse );
 // -----------------------------------------------------------
 //
 TInt CPhoneState::GetVolumeLevel()
 {
 TPhoneCmdParamInteger integerParam;
 iViewCommandHandle->ExecuteCommand( EPhoneViewGetAudioVolumeLevel,
 &integerParam );
 return integerParam.Integer();
 }
 //
 void CPhoneState::ShowVideoCallOutOfMemoryNoteL()
 {
 __LOGMETHODSTARTEND(EPhoneControl,
 "CPhoneState::ShowVideoCallOutOfMemoryNoteL()" );
-// Re-enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
-// Bring Phone app in the foreground
 TPhoneCmdParamInteger uidParam;
 uidParam.SetInteger( KUidPhoneApplication.iUid );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,
 &uidParam );
-// Set Phone as the top application
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,
 &uidParam );
 // Display error note
 SExtendedError ext;
 //
 TInt CPhoneState::SimSecurityStatus() const
 {
 /*
 Sim security statuses:
 ESimSecurityStatusUninitialized = KStartupEnumerationFirstValue,
 ESimRejected,   // The PUK code has been entered incorrectly, so the card is rejected.
 ESimUnaccepted  // The SIM lock is on, so the card is unaccepted.
 */
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SimSecurityStatus()" );
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CPhoneState::CallWaitingNoteL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::CallWaitingNoteL()" );
 TBuf< KPhoneContactNameMaxLength > callText( KNullDesC );
 // Set CLI text for the call header
 const TBool contactInfoAvailable =
 iStateMachine->PhoneEngineInfo()->RemoteName( aCallId ).Length() ||
 iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId ).Length();
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::CallWaitingNoteL - contactInfoAvailable(%d)", contactInfoAvailable );
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::CallWaitingNoteL - remote name(%S)",
 &iStateMachine->PhoneEngineInfo()->RemoteName( aCallId ) );
 __PHONELOG1( EBasic, EPhoneControl,
 "CPhoneState::CallWaitingNoteL - company name(%S)",
 &iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId ) );
 if ( contactInfoAvailable )
 {
 // Set Call Text flag to waiting note
 callText = iStateMachine->PhoneEngineInfo()->RemoteName( aCallId );
 }
 TPhoneCmdParamGlobalNote globalNoteParam;
 globalNoteParam.SetText( callText );
 globalNoteParam.SetType( EPhoneNotificationDialog );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneCallWaitingWithLabel ) );
 globalNoteParam.SetNotificationDialog( ETrue );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 else
 {
 // CPhoneState::SetRingingTonePlaybackL()
 // ----------------------------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetRingingTonePlaybackL( TInt aCallId )
 {
-__LOGMETHODSTARTEND(EPhoneControl,
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetRingingTonePlaybackL()" );
-"CPhoneState::SetRingingTonePlaybackL()" );
 TPhoneCmdParamRingTone ringToneParam;
 ringToneParam.SetVolume(
 iStateMachine->PhoneEngineInfo()->RingingVolume() );
 TArray< TContactItemId > alertGroups =
 iStateMachine->PhoneEngineInfo()->AlertForGroup();
 TInt alertGroupCount = alertGroups.Count();
 TInt contactGroupCount =
 iStateMachine->PhoneEngineInfo()->ContactGroups( aCallId ).Count();
 TBool alertingGroupFound( EFalse );
 }
 if ( iStateMachine->PhoneEngineInfo()->CallerText( aCallId ).Length() > 0 )
 {
 ringToneParam.SetCallerTextStatus( ETrue );
 }
-// Play the ring tone
 iViewCommandHandle->ExecuteCommandL( EPhoneViewPlayRingTone, &ringToneParam );
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleCugNoteL
 // -----------------------------------------------------------
 //
 void CPhoneState::HandleCugInUseNoteL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleCugInUseNoteL() ");
 TInt cugIndex( 0 );
 RSSSettings ssSettings;
 TInt retValue = ssSettings.Open();
 if ( retValue == KErrNone )
 {
 ssSettings.Get( ESSSettingsCug, cugIndex  );
 }
 ssSettings.Close();
 if ( cugIndex )
 {
 // Add it to the resource string
 HBufC* buf = StringLoader::LoadLC(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID(
 EPhoneInfoCugInUse ), cugIndex );
 TPhoneCmdParamGlobalNote globalNoteParam;
 globalNoteParam.SetText( *buf );
 globalNoteParam.SetType( EPhoneMessageBoxInformation );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 CleanupStack::PopAndDestroy( buf );
 }
 }
 // -----------------------------------------------------------
 *iViewCommandHandle,
 *iStateMachine,
 iCustomization );
 }
 return iCallHeaderManager;
-}
-// -----------------------------------------------------------
-// CPhoneState::CheckIfRestoreNEContentAfterDtmfDialer
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::CheckIfRestoreNEContentAfterDtmfDialer()
-{
-}
-// -----------------------------------------------------------
-// CPhoneState::IsOnScreenDialerSupported
-// -----------------------------------------------------------
-//
-EXPORT_C TBool CPhoneState::IsOnScreenDialerSupported() const
-{
-return iOnScreenDialer;
 }
 // ---------------------------------------------------------------------------
 // CPhoneState::LoadResource
 // ---------------------------------------------------------------------------
 TBool alphaNumericSupport(EFalse);
 TRAP_IGNORE( alphaNumericSupport = NumberEntryManagerL()->IsAlphanumericSupportedAndCharInput( aKeyEvent ) );
 return alphaNumericSupport;
 }
-// ---------------------------------------------------------
-// CPhoneState::OnlyHashInNumberEntryL
-// ---------------------------------------------------------
-//
-EXPORT_C void CPhoneState::OnlyHashInNumberEntryL()
-{
-__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::OnlyHashInNumberEntryL( ) ");
-// 0.8 seconds has passed, start ALS line change timer
-StartAlsLineChangeTimerL();
-}
 // -----------------------------------------------------------
 // CPhoneState::NumberEntryClearL
 // -----------------------------------------------------------
 //
 void CPhoneState::NumberEntryClearL()
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisableHWKeysL( ) ");
 if( iStateMachine->PhoneStorage()->IsBlockedKeysListEmpty() )
 {
 __PHONELOG( EBasic, EPhoneControl, " CPhoneState::DisableHWKeysL HW Keys Disabled " );
 iStateMachine->PhoneStorage()->AppendBlockedKeysListL( EStdKeyNo );
 iStateMachine->PhoneStorage()->AppendBlockedKeysListL( EStdKeyYes );
 }
 }
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::DisableCallUIL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisableCallUIL( ) ");
 // Set Call UI state to storage
 if( !iStateMachine->PhoneStorage()->IsScreenLocked() )
 {
 __PHONELOG( EBasic, EPhoneControl, " CPhoneState::DisableCallUIL CallUI Disabled " );
 // Show keys locked note
 TPhoneCmdParamNote noteParam;
 noteParam.SetType( EPhoneNoteUIDisabled );
 noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneInformationNote ) );
 TPhoneCmdParamKeyCapture appKeyCaptureParam;
 appKeyCaptureParam.SetKey( EStdKeyDevice7 );
 appKeyCaptureParam.SetKeyCode( EKeyDeviceF );
 appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewStartCapturingKey, &appKeyCaptureParam );
 // Set Call UI state to storage
 iStateMachine->PhoneStorage()->SetScreenLocked( ETrue );
 }
 }
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::EnableCallUIL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::EnableCallUIL( ) ");
 if( iStateMachine->PhoneStorage()->IsScreenLocked() )
 {
 __PHONELOG( EBasic, EPhoneControl, " CPhoneState::EnableCallUIL CallUI Enabled " );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewDisableKeyLockWithoutNote );
 // Stop capturing the key guard key
 TPhoneCmdParamKeyCapture appKeyCaptureParam;
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::CheckDisableHWKeysAndCallUIL()
 {
 __LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneState::CheckDisableHWKeysAndCallUIL( ) ");
 if( IsKeyLockOn() || IsAutoLockOn() )
 {
 // Disable HW keys if needed
 if( CPhoneCenRepProxy::Instance()->
 IsTelephonyFeatureSupported( KTelephonyLVFlagDisableCallControlHardKeysWhileLocked ) )
 if( CPhoneCenRepProxy::Instance()->
 IsTelephonyFeatureSupported( KTelephonyLVFlagDisableCallControlHardKeysWhileLocked ) )
 {
 if( iStateMachine->PhoneStorage()->IsBlockedKeysListEmpty() )
 {
-// Disable HW Keys if needed
 DisableHWKeysL();
 }
 else
 {
-// Reset blocked keys list
 iStateMachine->PhoneStorage()->ResetBlockedKeysList();
 }
 }
 if( FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke )
 && !CPhoneCenRepProxy::Instance()->
 IsTelephonyFeatureSupported( KTelephonyLVFlagAllowUnlockOnIncoming ) )
 {
 if( iStateMachine->PhoneStorage()->IsScreenLocked() )
 {
-// Enable Call
 EnableCallUIL();
 }
 else
 {
-// Set keylock enabled
 iViewCommandHandle->ExecuteCommandL( EPhoneViewEnableKeyLockWithoutNote );
-// Disable Call
 DisableCallUIL();
 }
 }
+iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );
-// Stop ringingtone
-iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );
 }
 // -----------------------------------------------------------
 // CPhoneState::RetainPreviousKeylockStateL
 // -----------------------------------------------------------
 && CPhoneCenRepProxy::Instance()->
 IsTelephonyFeatureSupported( KTelephonyLVFlagDisableCallControlHardKeysWhileLocked ) )
 {
 if( !aKeylockEnabled )
 {
-// Keylock disabled
 // Reset blocked keys list
 iStateMachine->PhoneStorage()->ResetBlockedKeysList();
 }
 }
 }
 // CPhoneState::SetToolbarButtonLoudspeakerEnabled
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetToolbarButtonLoudspeakerEnabled()
 {
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+TPhoneCmdParamInteger integerParam;
-{
+integerParam.SetInteger( EPhoneInCallCmdActivateIhf );
-TPhoneCmdParamInteger integerParam;
+TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
-integerParam.SetInteger( EPhoneInCallCmdActivateIhf );
+EPhoneViewEnableToolbarButton, &integerParam ));
-TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
-EPhoneViewEnableToolbarButton, &integerParam ));
-}
 }
 // ---------------------------------------------------------
 // CPhoneState::SetBackButtonActive
 // ---------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetBackButtonActive( TBool aActive )
 {
-if(IsAutoLockOn() && aActive) {
+if( IsAutoLockOn() && aActive )
+{
 // keep back button dimmed device lock case
 return;
 }
+TPhoneCmdParamBoolean booleanParam;
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+booleanParam.SetBoolean( aActive );
-{
+iViewCommandHandle->ExecuteCommand(
-TPhoneCmdParamBoolean booleanParam;
+EPhoneViewBackButtonActive, &booleanParam );
-booleanParam.SetBoolean( aActive );
-iViewCommandHandle->ExecuteCommand(
-EPhoneViewBackButtonActive, &booleanParam );
-}
 }
 // -----------------------------------------------------------
 // CPhoneState::OpenSoftRejectMessageEditorL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::OpenSoftRejectMessageEditorL()
 {
 __LOGMETHODSTARTEND(EPhoneControl,
 "CPhoneState::OpenSoftRejectMessageEditorL ()" );
+iCbaManager->SetSoftRejectStatus( EFalse );
-// Fetch incoming call's id from view
 TPhoneCmdParamCallStateData callStateData;
 callStateData.SetCallState( EPEStateRinging );
 iViewCommandHandle->HandleCommandL(
 EPhoneViewGetCallIdByState, &callStateData );
 TInt ringingCallId( KErrNotFound );
 // Do nothing if negative incoming call id
 if( callStateData.CallId() > KErrNotFound  )
 {
 iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveQuery );
 ringingCallId = callStateData.CallId();
 }
 TPhoneCmdParamSfiData sfiDataParam;
 if (KErrNotFound != ringingCallId)
 {
-if ( iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ).Length() )
+if ( iStateMachine->PhoneEngineInfo()->
+RemoteName( ringingCallId ).Length() )
 {
 // store both the name and the number
-sfiDataParam.SetNumber( iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
+sfiDataParam.SetNumber(
-sfiDataParam.SetName( iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ) );
+iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
+sfiDataParam.SetName(
+iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ) );
 }
 else
 {
 // store the number
-sfiDataParam.SetNumber( iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
+sfiDataParam.SetNumber(
-}
+iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
 }
+}
+TPhoneCmdParamInteger activeCallCount;
 iViewCommandHandle->ExecuteCommandL(
-EPhoneViewOpenSoftRejectEditor, &sfiDataParam );
+EPhoneViewGetCountOfActiveCalls, &activeCallCount );
+switch( activeCallCount.Integer() )
+{
+case EOneActiveCall:
+iCbaManager->UpdateCbaL( EPhoneCallHandlingCallWaitingCBA );
+break;
+default:
+iCbaManager->UpdateCbaL( EPhoneCallHandlingIncomingRejectCBA );
+break;
+}
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewOpenSoftRejectEditor, &sfiDataParam );
 }
 //  End of File

changeset 65	2a5d4ab426d3
parent 53	22cc52eade9b
child 74	d1c62c765e48