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

equal deleted inserted replaced

-:41a7f70b3818
+:5266b1f337bd
 /*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include <Profile.hrh>
 #include <PUAcodes.hrh>
 #include <AknUtils.h>
 #include <telephonyvariant.hrh>
 #include <aknsoundsystem.h>
+#include <cphcntprofileengine.h>
 #include <wlaninternalpskeys.h>
 #include <btengdomainpskeys.h>
 #include <btengdomaincrkeys.h>
 #include <settingsinternalcrkeys.h>
 #include <starterclient.h>
-#include <rsssettings.h>
+#include <RSSSettings.h>
 #include <UikonInternalPSKeys.h>
 #include <telephonydomainpstypes.h>
 #include <telinformationpskeys.h>
+#include <activeidle2domainpskeys.h>
 #include <coreapplicationuisdomainpskeys.h>
 #include <mccecall.h>
 #include <ccpdefs.h>
 #include <LogsDomainCRKeys.h>
 #include <spsettings.h>
+#include <ScreensaverInternalPSKeys.h>
 #include <startupdomainpskeys.h>
 #include <MediatorDomainUIDs.h>
 #include <videotelcontrolmediatorapi.h>
 #include <textresolver.h>
 #include <phoneappvoipcommands.hrh>
 #include "tphonecmdparamkeyevent.h"
 #include "tphonecmdparamdynmenu.h"
 #include "tphonecmdparamcallheaderdata.h"
 #include "tphonecmdparamincallindicatordata.h"
 #include "tphonecmdparamnote.h"
-#include "tphonecmdparamkeycapture.h"
+#include "tphonecmdparamKeycapture.h"
 #include "tphonecmdparamglobalnote.h"
 #include "tphonecmdparamquery.h"
 #include "tphonecmdparamstring.h"
+#include "tphonecmdparammessageeditor.h"
 #include "tphonecmdparamcallstatedata.h"
 #include "tphonecmdparambitmap.h"
 #include "tphonecmdparamaudiooutput.h"
 #include "tphonecmdparamaudioavailability.h"
 #include "tphonecmdparamappinfo.h"
 #include "cphonemediatorsender.h"
 #include "cphonereleasecommand.h"
 #include "cphonecontinueemergencycallcommand.h"
 #include "cphonecallheadermanager.h"
 #include "cphonenumberentrymanager.h"
-#include "tphonecmdparamsfidata.h"
+#include "mphonesecuritymodeobserver.h"
-#include "mphonestorage.h"
+#include "easydialingcommands.hrh"
-#include "phoneconstants.h"
-#include "cphoneclearblacklist.h"
 // ================= MEMBER FUNCTIONS =======================
 EXPORT_C CPhoneState::CPhoneState(
 MPhoneStateMachine* aStateMachine,
 MPhoneViewCommandHandle* aViewCommandHandle,
 MPhoneCustomization* aCustomization) :
 iStateMachine( aStateMachine ),
 iViewCommandHandle( aViewCommandHandle ),
-iCustomization( aCustomization ),
+iCustomization( aCustomization )
-iEnv( *CEikonEnv::Static() )
 {
 // Need to get current SimState for inherited classis
 iPreviousSimState = SimState();
 __ASSERT_ALWAYS(
 aStateMachine && aViewCommandHandle,
 case MEngineMonitor::EPEMessageAudioOutputChanged:
 HandleAudioOutputChangedL();
 // Go to current state implementation
 iCbaManager->UpdateInCallCbaL();
-SetTouchPaneButtons(0);
 break;
 case MEngineMonitor::EPEMessageAvailableAudioOutputsChanged:
 HandleAudioAvailableOutputChangedL();
 if ( iStateMachine->PhoneEngineInfo()->AudioOutput() != EPENotActive )
 {
 // Go to current state implementation
 iCbaManager->UpdateInCallCbaL();
-SetTouchPaneButtons(0);
 }
 break;
 case MEngineMonitor::EPEMessageChangedCallDuration:
 HandleChangedCallDurationL( aCallId );
 case MEngineMonitor::EPEMessageRemoteBusy:
 HandleRemoteBusyL( aCallId );
 break;
 case MEngineMonitor::EPEMessageCallWaiting:
-// No need to send waiting notification for user.
+SendGlobalInfoNoteL( EPhoneWaitingText );
-//SendGlobalInfoNoteL( EPhoneWaitingText, ETrue );
 break;
 case MEngineMonitor::EPEMessageProfileChanged:
 {
+TPhoneCmdParamBoolean keypadVolumeParam;
+if ( iStateMachine->PhoneEngineInfo()->KeypadVolume() == 0 )
+{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewKeypadAudioDisabled );
+}
+else
+{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewKeypadAudioEnabled );
+}
+UpdateProfileDisplayL();
 }
 break;
 case MEngineMonitor::EPEMessageRemoteTerminated:
+// Close menu bar, if it is displayed, for call ending note
+iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );
 /* Flow through */
 case MEngineMonitor::EPEMessageDisconnecting:
 HandleDisconnectingL( aCallId );
 break;
 case MEngineMonitor::EPEMessageTransferDone:
-SendGlobalInfoNoteL( EPhoneInCallTransferred, ETrue );
+SendGlobalInfoNoteL( EPhoneInCallTransferred );
 break;
 case MEngineMonitor::EPEMessageInitiatedEmergencyCall:
 HandleInitiatedEmergencyCallL( aCallId );
 break;
 case MEngineMonitor::EPEMessageInitiatedEmergencyWhileActiveVideo:
 HandleInitiatedEmergencyWhileActiveVideoL();
 break;
-case MEngineMonitor::EPEMessageCallSecureStatusChanged:
+case MEngineMonitor::EPEMessageShowIMEI:
-HandleCallSecureStatusChangeL( aCallId );
+// Stop playing DTMF tone
+iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
-if ( iCustomization )
+HandleShowImeiL();
-{
+break;
-iCustomization->HandlePhoneEngineMessageL( aMessage,
-aCallId );
+case MEngineMonitor::EPEMessageCallSecureStatusChanged:
-}
+HandleCallSecureStatusChangeL( aCallId );
-break;
+ForwardPEMessageToPhoneCustomizationL( aMessage, aCallId );
+break;
+case MEngineMonitor::EPEMessageActivateWarrantyMode:
+// Stop playing DTMF tone
+iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
+HandleShowLifeTimerL();
+break;
 case MEngineMonitor::EPEMessageIssuingUSSDRequest:
 {
 // Enable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 case MEngineMonitor::EPEMessageShowIncCallGroupIndex:
 HandleCugInUseNoteL();
 break;
+// *#2873#
+case MEngineMonitor::EPEMessageBTDebugMode:
+accessoryBtHandler = CPhoneAccessoryBTHandler::NewLC(
+iViewCommandHandle, iStateMachine, this );
+accessoryBtHandler->SetBTDebugModeL();
+CleanupStack::PopAndDestroy( accessoryBtHandler );
+break;
+case MEngineMonitor::EPEMessageInitiatedMoCall:
+// Message should be only handled by CPhoneStateIdle,
+// if state is something else than idle then do nothing.
+break;
 default:
 TBool handled( EFalse );
+handled = ForwardPEMessageToPhoneCustomizationL( aMessage, aCallId );
-if ( iCustomization )
-{
-handled = iCustomization->HandlePhoneEngineMessageL(
-aMessage, aCallId );
-}
 if ( EFalse == handled )
 {
 MPhoneMediatorMessage* mediatorMessage = CPhoneMediatorFactory::Instance()->MediatorMessage( aMessage, aCallId );
 if( mediatorMessage )
 {
 TPhoneCmdParamBoolean booleanParam;
 const TBool audioMute = iStateMachine->PhoneEngineInfo()->AudioMute();
 booleanParam.SetBoolean( audioMute );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewActivateMuteUIChanges,
 &booleanParam );
-SetTouchPaneButtons(0);
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleAudioOutputChangedL
 // Default handling for EPEMessageAudioOutputChanged message
 !btAvailable )
 {
 CPhoneBtaaDisconnectHandler::InstanceL()->HandleConnectionLostL();
 }
 else if ( audioOutput == EPEBTAudioAccessory &&
-previousOutput != EPEBTAudioAccessory &&
+		previousOutput > EPENotActive &&
+		previousOutput != EPEBTAudioAccessory &&
 btAvailable )
 {
 CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 bt->ShowBTActivatedL();
 CPhoneBtaaDisconnectHandler::InstanceL()->Cancel();
 }
 else if ( RouteParameters.iShowNote && audioOutput == EPELoudspeaker )
 {
 CAknKeySoundSystem* keySounds =
-static_cast<CAknAppUi*>( iEnv.EikAppUi() )->KeySounds();
+static_cast<CAknAppUi*>( EikonEnv()->EikAppUi() )->KeySounds();
 keySounds->PlaySound( EAvkonSIDIHFActive );
 }
 }
 // -----------------------------------------------------------
 iPreviousSimState == EPESimNotReady )
 {
 __PHONELOG( EBasic, EPhoneControl, "SIM card was removed" );
 TPhoneCmdParamGlobalNote globalNoteParam;
-globalNoteParam.SetType( EPhoneMessageBoxInformation );
+globalNoteParam.SetType( EAknGlobalInformationNote );
+globalNoteParam.SetTone( EAvkonSIDNoSound );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneSimRemoved ) );
 // -----------------------------------------------------------------------------
 //
 TBool CPhoneState::IsTouchDTmfDialerOn() const
 {
 TBool status( EFalse );
+if ( IsOnScreenDialerSupported() )
+{
+TBool isDialerVisible( EFalse );
+TRAP_IGNORE( isDialerVisible = IsDTMFEditorVisibleL() );
+if ( isDialerVisible )
+{
+status = ETrue;
+}
+}
 return status;
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::SendDtmfKeyEventL
 // send dtmf event when,
 void CPhoneState::SendDtmfKeyEventL( const TKeyEvent& aKeyEvent,
 TEventCode aEventCode  )
 {
 if ( !IsTouchDTmfDialerOn()
-&& !IsAnyQueryActiveL() )
+&& !IsAnyQueryActiveL()
-{
+&& !IsMenuBarVisibleL() )
-// Send the key event to the phone engine.
+{
-SendKeyEventL( aKeyEvent, aEventCode );
+if( IsKeyEventFurtherProcessedL( aKeyEvent ))
-}
+{
+// Send the key event to the phone engine.
+SendKeyEventL( aKeyEvent, aEventCode );
+}
+}
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::IsKeyEventFurtherProcessed
 // -----------------------------------------------------------------------------
 //
-TBool CPhoneState::IsKeyEventFurtherProcessedL( const TKeyEvent& /*aKeyEvent*/ ) const
+TBool CPhoneState::IsKeyEventFurtherProcessedL( const TKeyEvent& aKeyEvent ) const
 {
+// While being in some special keyboard mode (Full Screen&mini QWERTY,
+// handwriting mode) FEP sends only EEventKey -event and thus manual
+// DTMFs can not be played with the user specified tone lengths. Also,
+// in general, DTMFs are tried to play only in numeric mode.
+TBool numericMode = iViewCommandHandle->HandleCommandL(
+EPhoneViewIsNumberEntryNumericMode ) == EPhoneViewResponseSuccess;
+// Key presses simulated by dialer are played even if in alphanumeric mode.
+const TBool simulatedByDialer =
+( ( aKeyEvent.iModifiers & ( EModifierNumLock | EModifierKeypad ) )
+== ( EModifierNumLock | EModifierKeypad ) );
+if ( ( ( aKeyEvent.iModifiers & EModifierSpecial ) != 0 || !numericMode ) && !simulatedByDialer )
+{
+return EFalse;
+}
 return ETrue;
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleErrorL
 __PHONELOG1( EBasic, EPhoneControl,
 "PhoneUIControl: CPhoneState::HandleErrorL - aErrorInfo.iCallId =%d ",
 aErrorInfo.iCallId );
+// Sets touch buttons to correct status if error has occured.
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+{
+iViewCommandHandle->ExecuteCommand( EPhoneResetTouchButtons );
+}
 // Do the common error handling (display proper notes etc)
 CPhoneMainErrorMessagesHandler::Instance()->ShowErrorSpecificNoteL( aErrorInfo );
 switch( aErrorInfo.iErrorCode )
 }
 }
 }
 break;
 case ECCPErrorCCServiceNotAvailable:
+{
+if( IsVideoCall( aErrorInfo.iCallId ) )
 {
-if( IsVideoCall( aErrorInfo.iCallId ) )
+CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( EFalse );
-{
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( EFalse );
-}
 }
-break;
+}
+break;
-case ECCPErrorBadRequest:
+case ECCPErrorBadRequest:
+{
+TPECallType callType =
+iStateMachine->PhoneEngineInfo()->CallTypeCommand();
+if( callType == EPECallTypeVideo )
 {
-TPECallType callType =
+// Dialling MO video call cannot reach 3G network.
-iStateMachine->PhoneEngineInfo()->CallTypeCommand();
+__PHONELOG1( EBasic, EPhoneControl,
+"PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 2, callid%d ",
-if( callType == EPECallTypeVideo )
+aErrorInfo.iCallId );
-{
+CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );
-// 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;
+}
+break;
-case ECCPErrorVideoCallNotSupportedByNetwork:
+case ECCPErrorVideoCallNotSupportedByNetwork: // Flow trough
 case ECCPErrorVideoCallSetupFailed:
 case ECCPErrorNotReached:
-// If call id found and seems to be Video Call
+case ECCPErrorCCBearerCapabilityNotCurrentlyAvailable:
+case ECCPErrorCCBearerCapabilityNotAuthorised:
+case ECCPErrorServiceSettingError:
+case ECCPErrorNoAnswerForVideo:
+{
+// If call id found and seems to be Video Call
 if ( IsVideoCall( aErrorInfo.iCallId ) )
 {
 // Get active call count
 TPhoneCmdParamInteger activeCallCount;
 iViewCommandHandle->ExecuteCommandL(
 aErrorInfo.iCallId );
 CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL(
 ECCPErrorNotReached == aErrorInfo.iErrorCode );
 }
 }
+}
 break;
 case ECCPErrorNoService:
 // No network -> hide volume popup
 iViewCommandHandle->ExecuteCommandL( EPhoneViewHideNaviPaneAudioVolume );
 case ECCPErrorSatControl:
 {
 // check, that there really was a call established before completing SAT request
 if( aErrorInfo.iCallId != KPECallIdNotUsed )
 {
+// Complete sat request
+if ( iStateMachine->PhoneEngineInfo()->CallOrigin( aErrorInfo.iCallId ) == EPECallOriginSAT )
+{
+CompleteSatRequestL( aErrorInfo.iCallId );
+}
 }
 // remove number entry
 if ( !IsOnScreenDialerSupported() && IsNumberEntryUsedL() )
 {
 break;
 default:
 break;
 }
 // clear call blacklist if call failure occurs
 CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();
 }
 // -----------------------------------------------------------
 // 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 =
+TTime time( 0 );
+TTimeIntervalSeconds timeInterval =
 iStateMachine->PhoneEngineInfo()->CallDuration( aCallId );
+time += timeInterval;
-TPhoneCmdParamInteger time;
-time.SetInteger(seconds.Int());
+// Read format string from AVKON resource
-iViewCommandHandle->ExecuteCommandL(EPhoneViewUpdateCallHeaderCallDuration, aCallId, &time);
+TBuf<KPhoneMaxCharsInNote> timeDurationFormatString( KNullDesC );
-}
+LoadResource( timeDurationFormatString, EPhoneCallDurationFormatString );
-}
+// Format the time
+TBuf<KPhoneMaxTimeDisplayTextLength> timeString( KNullDesC );
+time.FormatL( timeString, timeDurationFormatString );
+// Localize time format
+AknTextUtils::LanguageSpecificNumberConversion( timeString );
+// update the call header call duration
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewUpdateCallHeaderCallDuration,
+aCallId,
+timeString );
+}
+}
 // -----------------------------------------------------------------------------
 // CPhoneState::HandleRemoteBusyL
 // -----------------------------------------------------------------------------
 //
 void CPhoneState::HandleRemoteBusyL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleRemoteBusyL( ) ");
+ShowNumberBusyNoteL();
-TPEErrorInfo info;
-info.iCallId = aCallId;
-info.iErrorCode = ECCPErrorBusy;
-info.iErrorType = EPECcp;
-CPhoneMainErrorMessagesHandler::Instance()->ShowErrorSpecificNoteL( info );
 const TPECallType callType =
 iStateMachine->PhoneEngineInfo()->CallTypeCommand();
 if( callType == EPECallTypeVideo )
 {
 __PHONELOG1( EBasic, EPhoneControl,
 "PhoneUIControl: CPhoneState::HandleRemoteBusyL - ShowReconnectQueryL vid 5, callid%d ",
 aCallId );
 CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( ETrue );
 }
+else
+{
+// Complete sat request
+if ( iStateMachine->PhoneEngineInfo()->CallOrigin( aCallId ) == EPECallOriginSAT )
+{
+CompleteSatRequestL( aCallId );
+}
+}
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleDisconnectingL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleDisconnectingL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleDisconnectingL( ) ");
+// If there is no call in connected state then EPhoneDtmfTextQuery and EPhoneDtmfListQueryDialog
+// must be dismmissed from UI, therefore we must set EPhoneViewSetNoConnectedCalls to ETrue this
+// way we can ensure that CPhoneQueryController doesnt relaunch EPhoneDtmfListQueryDialog.
+if ( !IsAnyConnectedCalls() )
+{
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean(ETrue);
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetNoConnectedCalls, &booleanParam );
+}
 TPhoneCmdParamCallHeaderData callHeaderParam;
 callHeaderParam.SetCallState( EPEStateDisconnecting );
 TBuf<KPhoneCallHeaderLabelMaxLength> labelText( KNullDesC );
 callHeaderParam.SetLabelText( labelText );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId,
 &callHeaderParam );
 CPhoneClearBlacklist::Instance()->ClearBlackListOnNextKey();
 }
 // -----------------------------------------------------------
 }
 }
 }
 // -----------------------------------------------------------
+// CPhoneState::IsNoteVisibleL
+// -----------------------------------------------------------
+//
+EXPORT_C TBool CPhoneState::IsNoteVisibleL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsNoteVisibleL( ) ");
+TPhoneCmdParamBoolean booleanParam;
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewGetIsNoteVisible, &booleanParam );
+return booleanParam.Boolean();
+}
+// -----------------------------------------------------------
+// CPhoneState::IsMenuBarVisibleL
+// -----------------------------------------------------------
+//
+EXPORT_C TBool CPhoneState::IsMenuBarVisibleL() const
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsMenuBarVisibleL( ) ");
+return iViewCommandHandle->HandleCommandL(
+EPhoneViewIsMenuBarVisible ) ==
+EPhoneViewResponseSuccess;
+}
+// -----------------------------------------------------------
 // CPhoneState::HandleNumericKeyEventL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleNumericKeyEventL(
-const TKeyEvent& /*aKeyEvent*/,
+const TKeyEvent& aKeyEvent,
-TEventCode /*aEventCode*/ )
+TEventCode aEventCode )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleNumericKeyEventL( ) ");
+TBool numberEntryUsed = IsNumberEntryUsedL();
+if ( numberEntryUsed && ( aKeyEvent.iRepeats == 0 ||
+aKeyEvent.iScanCode == EStdKeyBackspace ||
+aKeyEvent.iScanCode == EStdKeyLeftArrow ||
+aKeyEvent.iScanCode == EStdKeyUpArrow   ||
+aKeyEvent.iScanCode == EStdKeyDownArrow ||
+aKeyEvent.iScanCode == EStdKeyRightArrow ))
+{
+// Number entry exists but may be hidden
+KeyEventForExistingNumberEntryL( aKeyEvent, aEventCode );
+}
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::IsAnyQueryActiveL
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::IsNoteDismissableL: %d ", dismiss );
 return dismiss;
 }
 // -----------------------------------------------------------
+// CPhoneState::IsDialingExtensionInFocusL
+// -----------------------------------------------------------
+//
+EXPORT_C TBool CPhoneState::IsDialingExtensionInFocusL() const
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsDialingExtensionInFocusL( ) ");
+return iViewCommandHandle->HandleCommandL(
+EPhoneViewGetEasyDialingInFocusStatus ) ==
+EPhoneViewResponseSuccess;
+}
+// -----------------------------------------------------------
+// CPhoneState::EikonEnv
+// -----------------------------------------------------------
+//
+EXPORT_C CEikonEnv* CPhoneState::EikonEnv() const
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::EikonEnv( ) ");
+return iEnv;
+}
+// -----------------------------------------------------------
+// CPhoneState::SetEikonEnv
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetEikonEnv( CEikonEnv* aEnv )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetEikonEnv( ) ");
+iEnv = aEnv;
+}
+// -----------------------------------------------------------
 // CPhoneState::SendKeyEventL
 // -----------------------------------------------------------
 //
 void CPhoneState::SendKeyEventL(
 const TKeyEvent& aKeyEvent,
 // Get the number entry contents, if it exists
 if ( IsNumberEntryUsedL() )
 {
 HBufC* phoneNumber = PhoneNumberFromEntryLC();
 // Save the phone number
-__PHONELOG1( EBasic, EPhoneControl, "SetPhoneNumber: %S ", phoneNumber );
+__PHONELOG1( EBasic, EPhoneControl, "SetPhoneNumber: %S ", &phoneNumber->Des() );
 iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
 // Convert key code to western.
 TBuf<1> buffer; // one character
 buffer.Append( aKeyEvent.iCode );
 }
 }
 // <------------------------------ SYSTEM EVENTS ----------------------------->
+// -----------------------------------------------------------
+// CPhoneState::DynInitMenuPaneL
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::DynInitMenuPaneL(
+TInt aResourceId,
+CEikMenuPane* aMenuPane )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DynInitMenuPaneL( ) ");
+__ASSERT_DEBUG( aMenuPane && aResourceId,
+Panic( EPhoneCtrlParameterNotInitialized ) );
+// Save the number of digits in the number entry before processing
+// the menu pane
+if ( IsNumberEntryUsedL() )
+{
+TPhoneCmdParamBoolean serviceCodeParam;
+serviceCodeParam.SetBoolean(
+iStateMachine->PhoneEngineInfo()->PhoneNumberIsServiceCode() );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetServiceCodeFlag,
+&serviceCodeParam );
+}
+// Process the menu pane
+TPhoneCmdParamDynMenu dynMenuPane;
+dynMenuPane.SetResourceId( aResourceId );
+dynMenuPane.SetDynMenu( aMenuPane );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuPane, &dynMenuPane );
+if ( iCustomization )
+{
+// Menu pane is customized after default items are decided
+iCustomization->CustomizeMenuPaneL(aResourceId, aMenuPane);
+}
+}
+// -----------------------------------------------------------
+// CPhoneState::DynInitMenuBarL
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::DynInitMenuBarL(
+TInt aResourceId,
+CEikMenuBar* aMenuBar )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DynInitMenuBarL( ) ");
+__ASSERT_DEBUG( aMenuBar && aResourceId,
+Panic( EPhoneCtrlParameterNotInitialized ) );
+TPhoneCmdParamDynMenu dynMenuBar;
+dynMenuBar.SetResourceId( aResourceId );
+dynMenuBar.SetDynMenu( aMenuBar );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBar, &dynMenuBar );
+if ( iCustomization )
+{
+// Menu bar is customized after default items are decided
+iCustomization->CustomizeMenuBarL(aResourceId, aMenuBar);
+}
+}
 // -----------------------------------------------------------
 // CPhoneState::HandleSystemEventL
 // -----------------------------------------------------------
 //
 // CPhoneState::HandlePhoneForegroundEventL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandlePhoneForegroundEventL()
 {
-}
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePhoneForegroundEventL( ) ");
+// Force Idle to the foreground if a foreground event is received,
+// but Idle is the top application
+const TBool idleIsTopApp = iViewCommandHandle->HandleCommandL(
+EPhoneViewIsIdleTopApp ) ==
+EPhoneViewResponseSuccess ;
+if ( !IsOnScreenDialerSupported() && idleIsTopApp )
+{
+TBool activatePhone = CPhonePubSubProxy::Instance()->Value(
+KPSUidAiInformation, KActiveIdleState ) == EPSAiNumberEntry;
+if ( activatePhone )
+{
+// Set Phone as the top application
+TPhoneCmdParamInteger uidParam;
+uidParam.SetInteger( KUidPhoneApplication.iUid );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,
+&uidParam );
+NumberEntryManagerL()->CreateNumberEntryL();
+SetNumberEntryVisibilityL(ETrue);
+}
+else
+{
+if ( !iStateMachine->SecurityMode()->IsSecurityMode() )
+{
+__PHONELOG( EBasic, EPhoneControl,
+"CPhoneState::HandlePhoneForegroundEventL - Force Idle to the foreground" );
+// Bring Idle app to the foreground
+iViewCommandHandle->ExecuteCommandL( EPhoneViewBringIdleToForeground );
+}
+}
+}
+if( NumberEntryManagerL()->IsNumberEntryUsedL() )
+{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetIncallBubbleTrue );
+}
+else
+{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetIncallBubbleFalse );
+}
+}
 // -----------------------------------------------------------
 // CPhoneState::HandlePhoneFocusLostEventL
 // -----------------------------------------------------------
 //
 {
 // Notify that this method is called always when Idle is brought to foreground
 // See implementation in CPhoneAppUI::HandleWsEventL
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandlePhoneFocusLostEventL( ) ");
+// Phone app focus lost -> close Dtmf dialer when visible
+if ( IsOnScreenDialerSupported() && IsDTMFEditorVisibleL() )
+{
+CloseDTMFEditorL();
+}
+else if ( IsOnScreenDialerSupported() && IsCustomizedDialerVisibleL() )
+{
+CloseCustomizedDialerL();
+}
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetIncallBubbleTrue );
 }
 // ---------------------------------------------------------
 // CPhoneState::HandleIdleForegroundEventL
 // ---------------------------------------------------------
 //
 "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 == KPSUidCtsyCallInformation )
+{
+// Call state event
+if ( aKey == KCTsyCallState )
+{
+// Update the incall indicator
+UpdateIncallIndicatorL( aValue );
+}
+}
+// Telephony information category
+else if ( aCategory == KPSUidTelInformation
 && SimState() == EPESimUsable )
 {
 // Telephony display event
 if ( aKey == KTelDisplayInfo )
 {
 }
 }
 else if ( aCategory == KPSUidStartup && aKey == KStartupSimSecurityStatus )
 {
 // Show security note, SIM is not valid.
-if ( aValue == ESimRejected ||  aValue == ESimUnaccepted )
+if ( aValue == ESimRejected
+|| aValue == ESimUnaccepted
+|| aValue == ESimInvalid )
 {
 __PHONELOG( EBasic, EPhoneControl, "CPhoneStateStartup::HandlePropertyChangedL - SimSecurity status received" );
 StartShowSecurityNoteL();
 }
 }
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleCenRepChangeL( ) ");
 }
 // -----------------------------------------------------------
-// CPhoneState::NeedToSendToBackgroundL
+// CPhoneState::NeedToReturnToForegroundAppL
 // -----------------------------------------------------------
 //
-EXPORT_C TBool CPhoneState::NeedToSendToBackgroundL() const
+EXPORT_C TBool CPhoneState::NeedToReturnToForegroundAppL() const
 {
 return iViewCommandHandle->HandleCommandL(
-EPhoneViewGetNeedToSendToBackgroundStatus ) ==
+EPhoneViewGetNeedToReturnToForegroundAppStatus ) ==
 EPhoneViewResponseSuccess;
 }
 // -----------------------------------------------------------
 // CPhoneState::TopAppIsDisplayedL
 return iViewCommandHandle->HandleCommandL(
 EPhoneViewGetTopApplicationIsDisplayedStatus ) ==
 EPhoneViewResponseSuccess;
 }
+// -----------------------------------------------------------
+// CPhoneState::TitlePaneIsVisibleL
+// -----------------------------------------------------------
+//
+TBool CPhoneState::TitlePaneIsVisibleL() const
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::TitlePaneIsVisibleL( ) ");
+return iViewCommandHandle->HandleCommandL(
+EPhoneViewGetTitlePaneIsVisibleStatus ) ==
+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
+CloseClearNumberEntryAndLoadEffectL( ECallUiAppear );
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
-// Do state-specific behaviour if number entry is cleared
-HandleNumberEntryClearedL();
 break;
 case EPhoneDialerCmdTouchInput:
+OpenVkbL();
 break;
 case EPhoneNumberAcqCmdSendMessage:
+// Open the mms editor
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSendMessage );
+if ( !IsOnScreenDialerSupported() )
+{
+// Remove number entry from screen
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+// Do state-specific behaviour if number entry is cleared
+HandleNumberEntryClearedL();
+}
 break;
 case EPhoneNumberAcqCmdSave:
+// Open Create contact
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewAddContact );
 break;
 case EPhoneNumberAcqCmdAddToName:
+// Open the message editor
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewUpdateContact );
 break;
 case EPhoneNumberAcqCmdAddToContacts:
 {
 if ( IsOnScreenDialerSupported() )
 aCommand == EPhoneInCallCmdBtHandsfree );
 break;
 case EPhoneInCallCmdActivatEPhonebook:
 {
-}
+// Launch Phonebook application
-break;
+TPhoneCmdParamAppInfo appInfoParam;
+appInfoParam.SetAppUid( KPhoneUidAppPhonebook );
-case EPhoneNumberAcqSecurityDialer:
+iViewCommandHandle->ExecuteCommandL(
-{
+EPhoneViewActivateApp, &appInfoParam );
+}
-}
+break;
-break;
+case EPhoneViewYesSingleItemFetch:
-case EPhoneDialerCmdContacts:
+{
-{
+if ( IsOnScreenDialerSupported() )
-}
+{
-break;
+TBuf<KPhoneNumberEntryBufferSize> fetchContent;
+fetchContent = iViewCommandHandle->FetchContent();
+if ( fetchContent.Length() )
+{
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetNumberEntryContent,
+0,
+fetchContent );
+CallFromNumberEntryL();
+}
+}
+}
+break;
 case EPhoneNumberAcqCmdToggleNeAlphaMode:
 case EPhoneNumberAcqCmdToggleNeNumericMode:
 {
+// Toggle mode
+NumberEntryManagerL()->NumberEntryToggleAlphaNumericModeL();
 }
 break;
 case EPhoneCmdYesVideoFailedNoMemorySwitchToVoice:
 DialVoiceCallL();
 if ( IsNumberEntryUsedL() )
 {
 // Show the number entry if it exists
 SetNumberEntryVisibilityL(ETrue);
 }
-else if ( NeedToSendToBackgroundL() )
+else if ( NeedToReturnToForegroundAppL() )
 {
 // Continue displaying current app but set up the
 // idle screen in the background
 SetupIdleScreenInBackgroundL();
 }
 // value to control (second parameter set false).
 ChangeAudioVolumeL( GetVolumeLevel(), EFalse );
 }
 break;
+case EPhoneDialerCmdHelp:
+if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )
+{
+TPtrC contextName;
+contextName.Set( KDATA_DIALER_HLP_MAIN() );
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewLaunchHelpApplication, 0, contextName );
+}
+break;
 case EPhoneCmdVideoCallOutOfMemory:
 ShowVideoCallOutOfMemoryNoteL();
 DisconnectCallL();
 break;
-case EPhoneCallComingCmdSoftReject:
+case EPhoneCmdUpdateCba:
-// Open Soft reject message editor
+case EPhoneDialerValidNumber:
-OpenSoftRejectMessageEditorL();
+case EPhoneDialerInvalidNumber:
-break;
+case EPhoneCmdBlockingDialogLaunched:
+case EPhoneCmdBlockingDialogClosed:
-case EPhoneInCallCmdContacts:
+{
-iViewCommandHandle->ExecuteCommand( EPhoneViewOpenContacts );
+// these command ids are sent by easydialing to communicate to phone app
-break;
+HandleEasyDialingCommandsL( aCommand );
+}
+break;
 default:
+if ( IsOnScreenDialerSupported() )
-/*if ( IsOnScreenDialerSupported() )
 {
 // Offer command to view.
+// Easydialing commands are handled in view, too.
 TPhoneViewResponseId resId =
 iViewCommandHandle->HandleCommandL( aCommand );
 if( resId == EPhoneViewResponseFailed )
 {
 commandStatus = EFalse;
 }
 }
-else*/
+else
 {
 commandStatus = EFalse;
 }
 break;
 }
 // CPhoneState::ProcessCommandL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::ProcessCommandL( TInt /*aCommand*/ )
 {
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::ProcessCommandL() ");
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::ProcessCommandL() ");
 // no implementation.
 return EFalse;
 }
 // <-------------------------- REMOTE CONTROL EVENTS ------------------------->
 TPEAudioOutput output( iStateMachine->PhoneEngineInfo()->AudioOutput() );
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::DecreaseAudioVolumeL - audio output =%d", output );
 if( output == EPETTY )
 {
-SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl, ETrue );
+SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl );
 }
 else
 {
 TInt audioVolume( iStateMachine->PhoneEngineInfo()->AudioVolume() );
 audioVolume--;
 TPEAudioOutput output( iStateMachine->PhoneEngineInfo()->AudioOutput() );
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::IncreaseAudioVolumeL - audio output =%d", output );
 if( output == EPETTY )
 {
-SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl, ETrue );
+SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl );
 }
 else
 {
 TInt audioVolume( iStateMachine->PhoneEngineInfo()->AudioVolume() );
 audioVolume++;
 // Syncronizes audio volume level between engine and ui
 // causes EPEMessageAudioVolumeChanged message to phoneUI
 iStateMachine->SendPhoneEngineMessage(
 MPEPhoneModel::EPEMessageSetAudioVolume );
 }
+else
-if ( aUpdateControl )
+{
+CAknKeySoundSystem* keySounds =
+static_cast<CAknAppUi*>( EikonEnv()->EikAppUi() )
+->KeySounds();
+if ( aLevel < KPhoneVolumeMinValue )
+{
+// Set the volume value to volume control
+valueToControl = KPhoneVolumeMinValue;
+keySounds->PlaySound( EAvkonSIDVolumeMinTone );
+}
+else // aLevel > KPhoneVolumeMaxValue
+{
+// Set the volume value to volume control
+valueToControl = KPhoneVolumeMaxValue;
+keySounds->PlaySound( EAvkonSIDVolumeMaxTone );
+}
+}
+if ( aUpdateControl )
 {
 // Update the volume display.
 // Upper max (11) and under min (-1)
 // values are also updated to volume popup.
 TPhoneCmdParamInteger volumeParam;
 EXPORT_C void CPhoneState::DialVoiceCallL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DialVoiceCallL() ");
 __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
 Panic( EPhoneCtrlInvariant ) );
 // Disable global notes
 TPhoneCmdParamBoolean globalNotifierParam;
 globalNotifierParam.SetBoolean( ETrue );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 iStateMachine->PhoneEngineInfo()->SetCallTypeCommand( EPECallTypeCSVoice );
 iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageDial );
 }
 // -----------------------------------------------------------
 // CPhoneState::DisconnectCallL
 // -----------------------------------------------------------
 //
-EXPORT_C TBool CPhoneState::DisconnectCallL()
+EXPORT_C void CPhoneState::DisconnectCallL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisconnectCallL( ) ");
-TPhoneCmdParamInteger callIdParam;
+// Fetch active call's id from view
-iViewCommandHandle->ExecuteCommandL(
+TPhoneCmdParamCallStateData callStateData;
-EPhoneViewGetExpandedBubbleCallId, &callIdParam );
+callStateData.SetCallState( EPEStateConnected );
+iViewCommandHandle->HandleCommandL(
-TBool ret = EFalse;
+EPhoneViewGetCallIdByState, &callStateData );
-if( callIdParam.Integer() > KErrNotFound )
+if( callStateData.CallId() == KErrNotFound )
+{
+// No connected call, find the hold call
+callStateData.SetCallState( EPEStateHeld );
+iViewCommandHandle->HandleCommandL(
+EPhoneViewGetCallIdByState, &callStateData );
+if( callStateData.CallId() == KErrNotFound )
+{
+// No hold call, find the dialing call
+callStateData.SetCallState( EPEStateDialing );
+iViewCommandHandle->HandleCommandL(
+EPhoneViewGetCallIdByState, &callStateData );
+}
+if( callStateData.CallId() == KErrNotFound )
+{
+// No dialing call, find the outgoing call
+callStateData.SetCallState( EPEStateConnecting );
+iViewCommandHandle->HandleCommandL(
+EPhoneViewGetCallIdByState, &callStateData );
+}
+if( callStateData.CallId() == KErrNotFound )
+{
+// No active call, find the disconnectinging call
+callStateData.SetCallState( EPEStateDisconnecting );
+iViewCommandHandle->HandleCommandL(
+EPhoneViewGetCallIdByState, &callStateData );
+}
+}
+if( callStateData.CallId() > KErrNotFound )
 {
 // Release the call
-iStateMachine->SetCallId( callIdParam.Integer() );
+iStateMachine->SetCallId( callStateData.CallId() );
+if( IsVideoCall( callStateData.CallId() ) )
-if( IsVideoCall( callIdParam.Integer() ) )
 {
 // Video call can be released only after we get response to VT Shutdown Command
 CPhoneMediatorFactory::Instance()->Sender()->IssueCommand( KMediatorVideoTelephonyDomain,
-KCatPhoneToVideotelCommands,
+			                                                           			 KCatPhoneToVideotelCommands,
-EVtCmdReleaseDataport,
+			                                                           			 EVtCmdReleaseDataport,
 TVersion( KPhoneToVideotelCmdVersionMajor,
-KPhoneToVideotelCmdVersionMinor,
+	                                                 KPhoneToVideotelCmdVersionMinor,
-KPhoneToVideotelCmdVersionBuild ),
+	                                                 KPhoneToVideotelCmdVersionBuild ),
 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
 // -----------------------------------------------------------
 //
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetupIdleScreenInBackgroundL( ) ");
 // Don't remove reconnect query if it's shown
 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 to PS key this way we know if need to
-// Set Idle app as the top app
+// bring idle to fore in next phone acitvation event.
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetIdleTopApplication );
-// Set Empty CBA
 iCbaManager->SetCbaL( EPhoneEmptyCBA );
 }
 // ---------------------------------------------------------
 // CPhoneState::CallFromNumberEntryL
 __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
 Panic( EPhoneCtrlInvariant ) );
 if ( IsOnScreenDialerSupported() )
 {
-if ( IsCustomizedDialerVisibleL() )
+if ( IsDTMFEditorVisibleL() ||
+IsCustomizedDialerVisibleL() )
 {
 return;
 }
 else if( IsNumberEntryUsedL() )
 {
 // Query on top of dialer
 if ( IsAnyQueryActiveL() )
 {
+return;
+}
+else if ( IsMenuBarVisibleL() )
+{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );
 return;
 }
 // Open recent calls list when the number entry is empty
 TPhoneCmdParamInteger numberEntryCountParam;
 iViewCommandHandle->ExecuteCommandL( EPhoneViewGetNumberEntryCount,
 EPhoneDialerCmdLog );
 return;
 }
 }
 }
-// Get the number entry contents
+// If easydialing has focus, call should be initiated to focused contact.
-HBufC* phoneNumber = PhoneNumberFromEntryLC();
+if ( IsDialingExtensionInFocusL() )
+{
-// Call the number
+iViewCommandHandle->HandleCommandL( EEasyDialingVoiceCall );
-iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
+}
+else
-if ( phoneNumber->Des().Length() < KPhoneValidPhoneNumberLength )
+{
-{
+// Get the number entry contents
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+HBufC* phoneNumber = PhoneNumberFromEntryLC();
-HandleNumberEntryClearedL();
+// Call the number
-}
+iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
-CleanupStack::PopAndDestroy( phoneNumber );
+if ( phoneNumber->Des().Length() < KPhoneValidPhoneNumberLength )
+{
-if ( !iCustomization ||
+CloseClearNumberEntryAndLoadEffectL( ECallUiAppear );
-!iCustomization->HandleCallFromNumberEntryL() )
+}
-{
-// Customization didn't handle call. Dial voice call
+CleanupStack::PopAndDestroy( phoneNumber );
-// as normally
-DialVoiceCallL();
+if ( !iCustomization ||
-}
+!iCustomization->HandleCallFromNumberEntryL() )
+{
+// Customization didn't handle call. Dial voice call
+// as normally
+DialVoiceCallL();
+}
+}
 }
 // -----------------------------------------------------------
 // CPhoneState::DisplayHeaderForCallComingInL
 // -----------------------------------------------------------
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::UpdateSingleActiveCallL( TInt aCallId )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateSingleActiveCallL( ) ");
 // Stop capturing keys
 CaptureKeysDuringCallNotificationL( EFalse );
 BeginUiUpdateLC();
+SetTouchPaneButtonEnabled( EPhoneInCallCmdHold );
 // Update call state
 TPhoneCmdParamCallHeaderData callHeaderParam;
 callHeaderParam.SetCallState( EPEStateConnected );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId,
 // 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.
 TBool callDuration( EFalse );
 CPhoneCenRepProxy::Instance()->GetInt(
 KCRUidLogs, KLogsShowCallDuration, callDuration );
 if ( callDuration )
 EndUiUpdate();
 // Go to current state implementation
 iCbaManager->UpdateInCallCbaL();
-// Go to background if necessary
+//Update state of switch to video or voice call touch button.
-if ( NeedToSendToBackgroundL() ||  IsAutoLockOn() )
+TPECallType type = iStateMachine->PhoneEngineInfo()->CallType( aCallId );
-{
-}
+if( type == EPECallTypeVideo )
-// If there is no need to send back ground and number entry is used then
+{
-// we must show number entry.
+TPhoneCmdParamBoolean booleanParam;
-else if ( !NeedToSendToBackgroundL() && IsNumberEntryUsedL() )
+booleanParam.SetBoolean( ETrue );
-{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetVideoCallFlag, &booleanParam );
-SetNumberEntryVisibilityL(ETrue);
+}
+else
+{
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( EFalse );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetVideoCallFlag, &booleanParam );
+}
+// Check if application and number entry was open before incoming call. If so give control to number entry
+	// to prevent flickering
+if ( NeedToReturnToForegroundAppL() ||  IsAutoLockOn() )
+{
+// If number entry is used set control and visibility.
+if ( IsNumberEntryUsedL() )
+{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetControlAndVisibility );
+}
 }
 }
 // -----------------------------------------------------------
 // CPhoneState::CaptureKeysDuringCallNotificationL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::CaptureKeysDuringCallNotificationL(
-TBool /*aCaptured*/ )
+TBool aCaptured )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::CaptureKeysDuringCallNotificationL( ) ");
+if ( AknLayoutUtils::PenEnabled() )
+{
+//Capture pointer events
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( aCaptured );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetPointerCapture, &booleanParam );
+}
 // Determine which view command to execute based on the capture status
-/*const TInt viewCommandId = aCaptured ?
+const TInt viewCommandId = aCaptured ?
 EPhoneViewStartCapturingKey :
 EPhoneViewStopCapturingKey;
 // Capture the App key
 TPhoneCmdParamKeyCapture appKeyCaptureParam;
 cameraKeyCaptureParam.SetKey( EStdKeyDevice7 );
 cameraKeyCaptureParam.SetKeyCode( EKeyDevice7 );
 cameraKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
 iViewCommandHandle->ExecuteCommandL( viewCommandId,
 &cameraKeyCaptureParam );
-}*/
+}
 }
 // -----------------------------------------------------------
 // CPhoneState::IsWaitingCallL
 // -----------------------------------------------------------
 TPhoneCmdParamCallHeaderData callHeaderParam = UpdateCallHeaderInfoL( aCallId );
 if( iCustomization )
 {
 TBuf<KCntMaxTextFieldLength> inCallNumberText( KNullDesC );
+// incall number text could be 'Call 1', 'Call 2', ...
+CallheaderManagerL()->GetInCallNumberTextL( aCallId, inCallNumberText );
 // to check if we have VoIP call in question and fix
 // parameters if needed
 iCustomization->ModifyCallHeaderTexts( aCallId, &callHeaderParam,
 inCallNumberText );
 }
 // -----------------------------------------------------------
 // CPhoneState::SetCallHeaderType
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::SetCallHeaderType(
-TInt aCallHeaderType )
+const CBubbleManager::TPhoneCallTypeFlags aCallHeaderType )
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::SetCallHeaderType() ");
 TRAP_IGNORE( CallheaderManagerL()->SetCallHeaderType( aCallHeaderType ) );
 }
 if ( incomingCall > KErrNotFound )
 {
 if( activeCallCount.Integer() == ENoActiveCalls )
 {
 iCbaManager->UpdateIncomingCbaL( incomingCall );
+UpdateSilenceButtonDimming();
 }
 else
 {
 iCbaManager->UpdateCbaL( EPhoneCallHandlingCallWaitingCBA );
 }
 return EFalse;
 }
 }
 // <-------------------------- CONTEXT MENU ------------------------->
+// -----------------------------------------------------------------------------
+// CPhoneState::SetContextMenu
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetContextMenuL( TInt aResourceId )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetContextMenuL() ");
+TPhoneCmdParamInteger integerParam;
+TInt resId( CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( aResourceId ) );
+integerParam.SetInteger( resId );
+__PHONELOG1( EBasic, EPhoneControl,
+"CPhoneState::SetContextMenuL : resId =%d",resId );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateContextMenu,
+&integerParam );
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::UpdateInCallContextMenuL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::UpdateInCallContextMenuL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateInCallContextMenuL() ");
+SetContextMenuL( EPhoneNumberAcqMenubar );
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::UpdateIncomingContextMenuL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::UpdateIncomingContextMenuL( TInt aCallId )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateIncomingContextMenuL() ");
+if( CPhoneState::IsVideoCall ( aCallId ) )
+{
+SetContextMenuL( EPhoneIncomingVideoCallMenubar );
+}
+else
+{
+SetContextMenuL( EPhoneIncomingCallMenubar );
+}
+}
 // -----------------------------------------------------------
 // CPhoneState::ShowNoteL
 // -----------------------------------------------------------
 //
 AknTextUtils::DisplayTextLanguageSpecificNumberConversion( timeString );
 noteText.Append( timeString );
 TPhoneCmdParamGlobalNote globalNoteParam;
-globalNoteParam.SetType( EPhoneMessageBoxInformation );
+globalNoteParam.SetType( EAknGlobalInformationNote );
 globalNoteParam.SetText( noteText );
+globalNoteParam.SetTone( CAknNoteDialog::ENoTone );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 }
 // ---------------------------------------------------------
 // CPhoneState::SendGlobalInfoNoteL
 // ---------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SendGlobalInfoNoteL(
+EXPORT_C void CPhoneState::SendGlobalInfoNoteL( TInt aResourceId )
-TInt aResourceId, TBool aNotificationDialog )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendGlobalInfoNoteL( ) ");
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 if ( CPhonePubSubProxy::Instance()->Value(
 KPSUidUikon, KUikGlobalNotesAllowed ) == 1 )
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 TPhoneCmdParamGlobalNote globalNoteParam;
-PhoneNotificationType type = aNotificationDialog ?
-EPhoneNotificationDialog : EPhoneMessageBoxInformation;
+globalNoteParam.SetType( EAknGlobalInformationNote );
-globalNoteParam.SetType( type );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
+globalNoteParam.SetTone( EAvkonSIDInformationTone );
-globalNoteParam.SetNotificationDialog( aNotificationDialog );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 }
 // ---------------------------------------------------------
 //  CPhoneUIController::SendGlobalWarningNoteL
 // ---------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SendGlobalWarningNoteL(
+EXPORT_C void CPhoneState::SendGlobalWarningNoteL( TInt aResourceId )
-TInt aResourceId, TBool aNotificationDialog )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendGlobalWarningNoteL( ) ");
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 if ( CPhonePubSubProxy::Instance()->Value(
 KPSUidUikon, KUikGlobalNotesAllowed ) == 1 ||
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 TPhoneCmdParamGlobalNote globalNoteParam;
-PhoneNotificationType type = aNotificationDialog ?
+globalNoteParam.SetType( EAknGlobalWarningNote );
-EPhoneNotificationDialog : EPhoneMessageBoxWarning;
-globalNoteParam.SetType( type );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
+globalNoteParam.SetTone( EAvkonSIDWarningTone );
-globalNoteParam.SetNotificationDialog( aNotificationDialog );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 }
 // ---------------------------------------------------------
 //  CPhoneUIController::SendGlobalErrorNoteL
 // ---------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SendGlobalErrorNoteL(
+EXPORT_C void CPhoneState::SendGlobalErrorNoteL( TInt aResourceId )
-TInt aResourceId, TBool aNotificationDialog )
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SendGlobalErrorNoteL( ) ");
 __ASSERT_DEBUG( aResourceId, Panic( EPhoneCtrlParameterNotInitialized ) );
 if ( CPhonePubSubProxy::Instance()->Value(
 KPSUidUikon, KUikGlobalNotesAllowed ) == 1 )
 globalNotifierParam.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,
 &globalNotifierParam );
 TPhoneCmdParamGlobalNote globalNoteParam;
-PhoneNotificationType type = aNotificationDialog ?
+globalNoteParam.SetType( EAknGlobalErrorNote );
-EPhoneNotificationDialog : EPhoneMessageBoxInformation;
-globalNoteParam.SetType( type );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
-globalNoteParam.SetNotificationDialog( aNotificationDialog );
+globalNoteParam.SetTone( CAknNoteDialog::EErrorTone );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 }
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetHandsfreeModeL( ) ");
 CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 if ( !bt->SetHandsfreeModeL( aHandsfreeMode ))
 {
-SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );
+SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed );
 }
 CleanupStack::PopAndDestroy( bt );
 }
 // ---------------------------------------------------------
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetBTHandsfreeModeL( ) ");
 CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 if ( !bt->SetBTHandsfreeModeL( aHandsfreeMode ))
 {
-SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );
+SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed );
 }
 CleanupStack::PopAndDestroy( bt );
 }
 // <-------------------------- INTERNAL FUNCTIONS ------------------------>
 // -----------------------------------------------------------
+// CPhoneState::UpdateIncallIndicatorL
+// -----------------------------------------------------------
+//
+void CPhoneState::UpdateIncallIndicatorL( TInt aCallState )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateIncallIndicatorL( ) ");
+TPhoneCmdParamIncallIndicatorData incallIndicatorParam;
+// Set the state.
+incallIndicatorParam.SetCallState( aCallState );
+if((aCallState == EPSCTsyCallStateUninitialized) ||
+(aCallState == EPSCTsyCallStateNone))
+{
+incallIndicatorParam.SetLittleBubbleVisible( EFalse );
+}
+else
+{
+SetLittleBubbleVisibilityL(&incallIndicatorParam);
+}
+// Set mode
+incallIndicatorParam.SetMode(
+CPhonePubSubProxy::Instance()->Value(
+KPSUidCtsyCallInformation,
+KCTsyCallType ) );
+TInt activeCallId = GetActiveCallIdL();
+if ( activeCallId > KErrNone )
+{
+if ( iStateMachine->PhoneEngineInfo()->CallALSLine( activeCallId )
+== CCCECallParameters::ECCELineTypeAux )
+{
+incallIndicatorParam.SetLine2( ETrue );
+}
+}
+// Set the mute status
+const TBool audioMute = iStateMachine->PhoneEngineInfo()->AudioMute();
+incallIndicatorParam.SetMute( audioMute );
+// Set the voice privacy status
+if ( activeCallId > KErrNotFound && activeCallId != KConferenceCallId  )
+{
+incallIndicatorParam.SetCiphering(
+iStateMachine->PhoneEngineInfo()->IsSecureCall( activeCallId ) );
+}
+else
+{
+incallIndicatorParam.SetCiphering( ETrue );
+}
+incallIndicatorParam.SetCipheringIndicatorAllowed(
+iStateMachine->PhoneEngineInfo()->SecureSpecified() );
+// Set the emergency status
+if( EPEStateIdle != iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) )
+{
+incallIndicatorParam.SetEmergency( ETrue );
+}
+// Update the in-call indicator
+iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateIncallIndicator,
+&incallIndicatorParam );
+}
+// -----------------------------------------------------------
 // CPhoneState::UpdateProfileDisplayL
 // -----------------------------------------------------------
 //
 void CPhoneState::UpdateProfileDisplayL()
 {
-}
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateProfileDisplayL( ) ");
+// Get the profile information
+const TInt profileId =
+iStateMachine->PhoneEngineInfo()->ProfileId();
+TPEProfileName profileName =
+iStateMachine->PhoneEngineInfo()->ProfileName();
+HBufC* profileString = HBufC::NewLC( profileName.Length() +
+KPhoneMaxDateDisplayTextLength );
+TPtr profileNameBuf = profileString->Des();
+profileNameBuf.Zero();
+profileNameBuf.Append( profileName );
+if ( ( profileId == EProfileGeneralId ) ||
+( profileId == EProfileOffLineId ) )
+{
+// Show date instead of profile name on navi pane
+HBufC* buffer = HBufC::NewLC( KPhoneMaxDateDisplayTextLength );
+TPtr dateString( buffer->Des() );
+TTime time;
+time.HomeTime();
+// Get date string
+CCoeEnv* coeEnv = CCoeEnv::Static();
+HBufC* dateFormatString =
+StringLoader::LoadLC( R_QTN_DATE_USUAL_WITH_ZERO, coeEnv );
+time.FormatL( dateString, *dateFormatString );
+CleanupStack::PopAndDestroy( dateFormatString );
+// To arabic
+AknTextUtils::DisplayTextLanguageSpecificNumberConversion(
+dateString );
+//Get week day abbreviation
+TDayNameAbb wkDayAbb = TDayNameAbb();
+wkDayAbb.Set(time.DayNoInWeek());
+//Get time format string
+HBufC* timeFormat = StringLoader::LoadLC(
+CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( EPhoneIdleTimeFormat ),
+coeEnv );
+//Set date and weekdays to time format
+profileNameBuf.Zero();
+StringLoader::Format(
+profileNameBuf,
+*timeFormat,
+1, // date
+dateString );
+dateString.Copy( profileNameBuf );
+StringLoader::Format(
+profileNameBuf,
+dateString,
+0, // weekday
+wkDayAbb );
+CleanupStack::PopAndDestroy( timeFormat );
+CleanupStack::PopAndDestroy( buffer );
+}
+// Set silence indicator based on the ringing profile
+const TProfileRingingType ringingType =
+iStateMachine->PhoneEngineInfo()->RingingType();
+if ( ringingType == EProfileRingingTypeSilent )
+{
+TBuf< 1 > silent;
+silent.Append( KPuaCodeSilentSymbol );
+profileNameBuf.Insert( 0, silent );
+}
+// Update the profile display on the navi pane
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetNaviPaneContent, 0,
+profileNameBuf );
+if ( profileId == EProfileOffLineId )
+{
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetTitlePaneContent,
+0,
+profileName );
+}
+else
+{
+UpdateOperatorDisplayL();
+}
+CleanupStack::PopAndDestroy( profileString );
+}
+// -----------------------------------------------------------
+// CPhoneState::UpdateOperatorDisplayL
+// -----------------------------------------------------------
+//
+void CPhoneState::UpdateOperatorDisplayL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::UpdateOperatorDisplayL( ) ");
+__PHONELOG( EBasic, EPhoneControl, "CPhoneState::UpdateOperatorDisplayL" );
+// Get current title pane content.
+TTelTitleDisplay titleContent;
+titleContent.iDisplayTag.Zero();
+titleContent.iLogoHandle = 0;
+TPckg<TTelTitleDisplay> titlePckg( titleContent );
+RProperty::Get(
+KPSUidTelInformation,
+KTelDisplayInfo,
+titlePckg );
+if ( TitlePaneIsVisibleL() )
+{
+// There is a title pane icon.
+if ( titleContent.iLogoHandle != 0 )
+{
+// Set new logo.
+__PHONELOG( EBasic, EPhoneControl,
+"CPhoneState::UpdateOperatorDisplayL - logo found" );
+if( iLogoHandle != titleContent.iLogoHandle )
+{
+__PHONELOG( EBasic, EPhoneControl,
+"CPhoneState::UpdateOperatorDisplayL - set new logo" );
+TPhoneCmdParamBitmap bitmapParam;
+// Duplicate bitmap from handle.
+CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+CleanupStack::PushL( bitmap );
+User::LeaveIfError(
+bitmap->Duplicate( titleContent.iLogoHandle ) );
+bitmapParam.SetBitmap( bitmap );
+// Duplicate and set bitmap mask if needed
+CFbsBitmap* maskBitmap = NULL;
+if( titleContent.iLogoMaskHandle != 0 )
+{
+maskBitmap = new( ELeave )CFbsBitmap;
+CleanupStack::PushL( maskBitmap );
+User::LeaveIfError( maskBitmap->Duplicate(
+titleContent.iLogoMaskHandle ) );
+bitmapParam.SetMaskBitmap( maskBitmap );
+}
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetTitlePanePicture,
+&bitmapParam );
+// The title pane takes ownership of the bitmaps so no need
+// to destroy it here.
+if( maskBitmap )
+{
+// Pop maskBitmap only, if it has been created
+CleanupStack::Pop( maskBitmap );
+}
+CleanupStack::Pop( bitmap );
+}
+}
+else
+{
+__PHONELOG1( EBasic, EPhoneControl,
+"CPhoneState::UpdateOperatorDisplayL - set text=%S", &titleContent.iDisplayTag );
+iLogoHandle = titleContent.iLogoHandle;
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetTitlePaneContent,
+0,
+titleContent.iDisplayTag );
+}
+}
+// Check background image.
+TPhoneCmdParamBitmap savedBitmapParam;
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewGetBackgroundImageBitmap,
+&savedBitmapParam );
+if ( titleContent.iBackgroundImageHandle !=
+savedBitmapParam.Bitmap()->Handle() )
+{
+__PHONELOG2( EBasic, EPhoneControl,
+"CPhoneState::UpdateOperatorDisplayL - update background image since different titleContent(%d), saved(%d)",
+titleContent.iBackgroundImageHandle, savedBitmapParam.Bitmap()->Handle() );
+// Background image has changed. Duplicate bitmap from handle if
+// available; otherwise reset the background image
+CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+CleanupStack::PushL( bitmap );
+TInt err = KErrNone;
+if ( titleContent.iBackgroundImageHandle != 0 )
+{
+err = bitmap->Duplicate( titleContent.iBackgroundImageHandle );
+}
+else
+{
+bitmap->Reset();
+}
+if ( err == KErrNone )
+{
+iBitmapRedrawCounter = titleContent.iBackgroundImageRedrawCounter;
+TPhoneCmdParamBitmap bitmapParam;
+bitmapParam.SetBitmap( bitmap );
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetBackgroundImageBitmap,
+&bitmapParam );
+}
+CleanupStack::PopAndDestroy( bitmap );
+}
+else if ( titleContent.iBackgroundImageRedrawCounter !=
+iBitmapRedrawCounter  )
+{
+iBitmapRedrawCounter = titleContent.iBackgroundImageRedrawCounter;
+iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateView );
+}
+}
 // -----------------------------------------------------------
 // CPhoneState::HandleInitiatedEmergencyCallL
 // Default handling for EPEMessageInitiatedEmergencyCallL message
 // (other items were commented in a header).
 // Reset Hold flag to view
 TPhoneCmdParamBoolean holdFlag;
 holdFlag.SetBoolean( EFalse );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );
+// Undim Answer button for sure.
+SetTouchPaneButtonEnabled( EPhoneCallComingCmdAnswer );
 // Go to emergency call state
 // No need update cba
 iStateMachine->ChangeState( EPhoneStateEmergency );
 }
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleInitiatedEmergencyWhileActiveVideoL( ) ");
 // 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::HandleShowImeiL
+// -----------------------------------------------------------
+//
+void CPhoneState::HandleShowImeiL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleShowImeiL( ) ");
+if ( IsOnScreenDialerSupported() )
+{
+NumberEntryClearL();
+}
+else
+{
+// Remove number entry from screen
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+}
+// Fetch IMEI
+TBuf<RMobilePhone::KPhoneSerialNumberSize> serialNumber;
+TPEPhoneIdentityParameters phoneIdentityParameters = iStateMachine->
+PhoneEngineInfo()->PhoneIdentityParameters();
+serialNumber = phoneIdentityParameters.iSerialNumber;
+// Add it to the resource string
+HBufC* buf = StringLoader::LoadLC(
+CPhoneMainResourceResolver::Instance()->
+ResolveResourceID(
+EPhonePhoneImeiString ), serialNumber );
+TPhoneCmdParamNote noteParam;
+noteParam.SetType( EPhoneNoteCustom );
+noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( EPhoneInformationWaitNote ) );
+noteParam.SetText( *buf );
+// Display note
+iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );
+CleanupStack::PopAndDestroy( buf );
 }
 // -----------------------------------------------------------
 // CPhoneState::HandleCallSecureStatusChangeL
 // -----------------------------------------------------------
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewCipheringInfoChange,
 aCallId,
 &callHeaderParam );
+}
+// -----------------------------------------------------------
+// CPhoneState::HandleShowLifeTimerL
+// -----------------------------------------------------------
+//
+void CPhoneState::HandleShowLifeTimerL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleShowLifeTimerL( ) ");
+if ( IsOnScreenDialerSupported() )
+{
+NumberEntryClearL();
+}
+else
+{
+// Remove number entry from screen
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+}
+// Fetch LifeTime
+TPELifeTimeData lifeTimeData = iStateMachine->
+PhoneEngineInfo()->LifeTimerData();
+TLocale locale;
+TBuf<KTimerTextLength> lifetimerText;
+lifetimerText.NumFixedWidth(
+lifeTimeData.iHours,
+EDecimal,
+KPhoneLifeTimerHoursLength );
+lifetimerText.Append(locale.TimeSeparator( KTimerMinuteSeparator ) );   // minute seperator
+TBuf<KPhoneLifeTimerMinutesLength> mins;
+mins.NumFixedWidth(
+lifeTimeData.iMinutes,
+EDecimal,
+KPhoneLifeTimerMinutesLength );
+lifetimerText.Append(mins);
+// Add it to the resource string
+HBufC* buf = StringLoader::LoadLC(
+CPhoneMainResourceResolver::Instance()->
+ResolveResourceID(
+EPhoneLifeTimeFormat ), lifetimerText );
+TPhoneCmdParamNote noteParam;
+noteParam.SetType( EPhoneNoteCustom );
+noteParam.SetResourceId( CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( EPhoneInformationWaitNote ) );
+noteParam.SetText( *buf );
+// Display note
+iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );
+CleanupStack::PopAndDestroy( buf );
 }
 // ---------------------------------------------------------
 // CPhoneState::IsVideoCall
 // ---------------------------------------------------------
 // Sim state is valid, check also Sim security status
 switch ( SimSecurityStatus() )
 {
 case ESimRejected:
 case ESimUnaccepted:
+case ESimInvalid:
 retVal = EFalse;
 break;
 default:
 break;
 // CPhoneState::IsSimStateNotPresentWithSecurityModeEnabled
 // -----------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::IsSimStateNotPresentWithSecurityModeEnabled()
 {
-TPhoneCmdParamBoolean isSecurityMode;
+if ( SimState() == EPESimNotPresent && iStateMachine->SecurityMode()->IsSecurityMode() )
-TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode ) );
-if ( SimState() == EPESimNotPresent && isSecurityMode.Boolean() )
 {
 return ETrue;
 }
 else
 {
 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::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 );
+TPhoneCmdParamBoolean visibleMode;
+visibleMode.SetBoolean( EFalse );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetStatusPaneVisible, &visibleMode );
 iCbaManager->UpdateCbaL( EPhoneEmptyCBA );
 TPhoneCmdParamInteger uidParam;
 // Bring Phone app in the foreground
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,
 &uidParam );
 TInt resourceId ( KErrNone );
-if ( SimSecurityStatus() == ESimRejected )
-{
+switch( SimSecurityStatus() )
-resourceId = CPhoneMainResourceResolver::Instance()->
+{
-ResolveResourceID( EPhoneSimRejected );
+			  case ESimRejected:
-}
+			      {
-else if ( SimState() == EPESimNotPresent )
+			      resourceId = CPhoneMainResourceResolver::Instance()->
-{
+ResolveResourceID( EPhoneSimRejected );
-// insert sim card -note
+break;
-resourceId = CPhoneMainResourceResolver::Instance()->
+			      }
-ResolveResourceID( EPhoneSimRemoved );
+			  case ESimUnaccepted:
-}
+			      {
-else if ( SimSecurityStatus() == ESimUnaccepted )
+			      // insert sim card -note
-{
+resourceId = CPhoneMainResourceResolver::Instance()->
-resourceId = CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( EPhoneSimUnaccepted );
-ResolveResourceID( EPhoneSimUnaccepted );
+			      break;
+			      }
+			  case ESimInvalid:
+			      {
+			      resourceId = CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( EPhoneSIMInvalidUICC );
+			      break;
+			      }
+default:
+	          {
+	          if ( SimState() == EPESimNotPresent )
+{
+// insert sim card -note
+resourceId = CPhoneMainResourceResolver::Instance()->
+ResolveResourceID( EPhoneSimRemoved );
+}
+	          break;
+	          }
 }
 if ( resourceId != KErrNone )
 {
 // Add it to the resource string
 {
 // Get customized text resource for busy note
 resource = iCustomization->CustomizeBusyNoteText();
 }
-// Show number busy notification
+// Show number busy note
 TPhoneCmdParamGlobalNote globalNoteParam;
-globalNoteParam.SetType( EPhoneNotificationDialog );
+globalNoteParam.SetType( EAknGlobalInformationNote );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( resource ) );
+globalNoteParam.SetTone( EAvkonSIDInformationTone );
-globalNoteParam.SetNotificationDialog( ETrue );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewShowGlobalNote,
 &globalNoteParam );
 }
 // ---------------------------------------------------------
 const TBool phoneIsLocked =
 CPhonePubSubProxy::Instance()->Value(
 KPSUidCoreApplicationUIs,
 KCoreAppUIsAutolockStatus ) > EAutolockOff;
-__PHONELOG1( EBasic,
-EPhoneControl,
-"CPhoneState::IsAutoLockOn() Status: %d",
-phoneIsLocked );
 return phoneIsLocked;
 }
 // ---------------------------------------------------------
 // CPhoneState::IsKeyLockOn
 // ---------------------------------------------------------
 // CPhoneState::SetTouchPaneButtons
 // ---------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SetTouchPaneButtons( TInt /*aResourceId*/ )
+EXPORT_C void CPhoneState::SetTouchPaneButtons( TInt aResourceId )
 {
 if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
 {
-TPhoneCmdParamBoolean muteParam;
+// Display Video Share button instead of Hold Button if
-muteParam.SetBoolean( iStateMachine->PhoneEngineInfo()->AudioMute() );
+// the feature is enabled and video sharing is currently available.
-iViewCommandHandle->ExecuteCommand(EPhoneViewSetMuteFlag,&muteParam);
+if ( aResourceId == EPhoneIncallButtons &&
+FeatureManager::FeatureSupported( KFeatureIdFfEntryPointForVideoShare ) &&
-const TPEAudioOutput audioOutput =
+CPhonePubSubProxy::Instance()->Value
-iStateMachine->PhoneEngineInfo()->AudioOutput();
+( KPSUidCoreApplicationUIs, KCoreAppUIsVideoSharingIndicator )
+== ECoreAppUIsVideoSharingIndicatorOn )
-TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
+{
-EPEBTAudioAccessory );
+aResourceId = EPhoneIncallVideoShareButtons;
+}
-TPhoneCmdParamBoolean btParam;
+TPhoneCmdParamInteger integerParam;
-btParam.SetBoolean( audioOutput == EPEBTAudioAccessory );
+integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
-iViewCommandHandle->ExecuteCommand(EPhoneViewSetBlueToothFlag,&btParam);
+ResolveResourceID( aResourceId ) );
-TPhoneCmdParamBoolean btAvailableParam;
-btAvailableParam.SetBoolean( btAvailable );
-iViewCommandHandle->ExecuteCommand(
-EPhoneViewSetBluetoothAvailableFlag,&btAvailableParam);
-TBool emergency( EPEStateIdle !=
-iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) );
-TPhoneCmdParamBoolean booleanParam;
-booleanParam.SetBoolean( emergency );
 TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
 EPhoneViewSetTouchPaneButtons,
-&booleanParam ) );
+&integerParam ) );
+SetTouchPaneVisible( ETrue );
 }
 }
 // ---------------------------------------------------------
 // CPhoneState::DeleteTouchPaneButtons
 //
 EXPORT_C void CPhoneState::DeleteTouchPaneButtons()
 {
 if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
 {
-TPhoneCmdParamBoolean boolParam;
+TPhoneCmdParamInteger integerParam;
+integerParam.SetInteger( 0 );
 TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
 EPhoneViewSetTouchPaneButtons,
-&boolParam ) );
+&integerParam ) );
+SetTouchPaneVisible( EFalse );
+}
+}
+// ---------------------------------------------------------
+// CPhoneState::SetTouchPaneVisible
+// ---------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetTouchPaneVisible( TBool aVisible )
+{
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+{
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( aVisible );
+TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetTouchPaneVisible,
+&booleanParam ) );
+}
+}
+// ----------------------------------------------------------------------------
+// CPhoneState::SetTouchButtonEnabled
+// ----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetTouchPaneButtonEnabled( TInt aCommandId )
+{
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+{
+TPhoneCmdParamInteger commandParam;
+commandParam.SetInteger( aCommandId );
+iViewCommandHandle->ExecuteCommand( EPhoneViewEnableTouchButton,
+&commandParam );
+}
+}
+// ----------------------------------------------------------------------------
+// CPhoneState::SetTouchButtonDisabled
+// ----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetTouchPaneButtonDisabled( TInt aCommandId )
+{
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+{
+TPhoneCmdParamInteger commandParam;
+commandParam.SetInteger( aCommandId );
+iViewCommandHandle->ExecuteCommand( EPhoneViewDisableTouchButton,
+&commandParam );
 }
 }
 // ---------------------------------------------------------
 // CPhoneState::HandleLongHashL
 //
 EXPORT_C void CPhoneState::HandleLongHashL()
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::HandleLongHashL() ");
+TPhoneCmdParamInteger numberEntryCountParam;
+iViewCommandHandle->ExecuteCommandL( EPhoneViewGetNumberEntryCount,
+&numberEntryCountParam );
+TInt neLength( numberEntryCountParam.Integer() );
+if( neLength == 1 )
+{
+if ( !iStateMachine->SecurityMode()->IsSecurityMode() )
+{
+OnlyHashInNumberEntryL();
+}
+}
+}
+// -----------------------------------------------------------
+// CPhoneState::OpenVKBL
+// -----------------------------------------------------------
+//
+void CPhoneState::OpenVkbL()
+{
+__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::OpenVKB() ");
+iViewCommandHandle->ExecuteCommandL( EPhoneViewOpenVirtualKeyBoard );
 }
 // -----------------------------------------------------------
 // CPhoneState::BeginUiUpdateLC
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::BeginUiUpdateLC()
 {
 iViewCommandHandle->ExecuteCommand( EPhoneViewBeginUpdate );
 TCleanupItem operation( UiUpdateCleanup, this );
 CleanupStack::PushL( operation );
 }
 // -----------------------------------------------------------
 // CPhoneState::EndUiUpdate
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::EndUiUpdate()
 {
 CleanupStack::PopAndDestroy(); // Call UiUpdateCleanup
+}
+// -----------------------------------------------------------
+// CPhoneState::BeginTransEffectLC
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::BeginTransEffectLC( TStateTransEffectType aType )
+{
+__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::BeginTransEffectLC( ) ");
+TPhoneCmdParamTransEffect effectParam;
+switch ( aType )
+{
+case ENumberEntryOpen:
+effectParam.SetType( EPhoneTransEffectDialerOpen );
+break;
+case ENumberEntryClose:
+effectParam.SetType( EPhoneTransEffectDialerClose );
+break;
+case ENumberEntryCreate:
+effectParam.SetType( EPhoneTransEffectDialerCreate );
+break;
+case ECallUiAppear:
+effectParam.SetType( EPhoneTransEffectCallUiAppear );
+break;
+case ECallUiDisappear:
+effectParam.SetType( EPhoneTransEffectCallUiDisappear );
+break;
+default:
+effectParam.SetType( EPhoneTransEffectNone );
+}
+effectParam.SetAppUid( KUidPhoneApplication );
+iViewCommandHandle->ExecuteCommand(
+EPhoneViewBeginTransEffect,
+&effectParam );
+// Always put the cleanup item into stack as expected by the caller.
+TCleanupItem operation( EffectCleanup, this );
+CleanupStack::PushL( operation );
+}
+// -----------------------------------------------------------
+// CPhoneState::EndTransEffect
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::EndTransEffect()
+{
+CleanupStack::PopAndDestroy(); // Call EffectCleanup
 }
 // -----------------------------------------------------------
 // CPhoneState::CheckIfShowTerminationNote
 // This method is intended to be overridden in states
 //
 void CPhoneState::UiUpdateCleanup(TAny* aThis )
 {
 static_cast<CPhoneState*>( aThis )->iViewCommandHandle->ExecuteCommand(
 EPhoneViewEndUpdate );
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::EffectCleanup
+// -----------------------------------------------------------------------------
+//
+void CPhoneState::EffectCleanup(TAny* aThis )
+{
+TPhoneCmdParamTransEffect effectParam;
+effectParam.SetType( EPhoneTransEffectStop );
+// won't do anything if effect wasn't started
+static_cast<CPhoneState*>( aThis )->iViewCommandHandle->ExecuteCommand(
+EPhoneViewEndTransEffect, &effectParam );
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::IsDTMFEditorVisibleL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CPhoneState::IsDTMFEditorVisibleL() const
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsDTMFEditorVisibleL( ) ");
+return iViewCommandHandle->HandleCommandL(
+EPhoneViewIsDTMFEditorVisible ) ==
+EPhoneViewResponseSuccess;
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::CloseDTMFEditorL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::CloseDTMFEditorL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::CloseDTMFEditorL()");
+if ( iOnScreenDialer ) // Touch
+{
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( EFalse );
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetDtmfDialerViewVisible,
+&booleanParam );
+CloseClearNumberEntryAndLoadEffectL( ECallUiAppear );
+}
+else // Non-Touch
+{
+// If dtmf query is visible then remove number entry
+// because it should not be shown if user has pressed end key.
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveQuery );
+// Do state-specific behaviour if number entry is cleared
+HandleNumberEntryClearedL();
+}
 }
 // -----------------------------------------------------------
 // CPhoneState::SetDefaultFlagsL()
 // -----------------------------------------------------------
 &globalNotifierParam );
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetEikonNotifiersDisabled,
 &globalNotifierParam );
 // uncapture App and Camera keys if not security mode
-TPhoneCmdParamBoolean isSecurityMode;
+if ( !iStateMachine->SecurityMode()->IsSecurityMode() )
-iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode );
-if ( !isSecurityMode.Boolean() )
 {
 CaptureKeysDuringCallNotificationL( EFalse );
 }
-// Restore keylock if phone has been locked before call.
+CPhonePubSubProxy::Instance()->ChangePropertyValue(
-if ( iStateMachine->PhoneStorage()->NeedToEnableKeylock() )
+KPSUidScreenSaver,
-{
+KScreenSaverAllowScreenSaver,
-iViewCommandHandle->ExecuteCommandL( EPhoneViewEnableKeyLock );
+EPhoneScreensaverAllowed );
-iStateMachine->PhoneStorage()->SetNeedToEnableKeylock( EFalse );
-}
 }
 // -----------------------------------------------------------
 // CPhoneState::GetVolumeLevel
 // -----------------------------------------------------------
 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.
+ESimInvalid     // The Sim inserted is not same as the one provided by the
+// operator, so card is invalid.
 */
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SimSecurityStatus()" );
 return CPhonePubSubProxy::Instance()->Value(
 KPSUidStartup, KStartupSimSecurityStatus );
 }
 callText = iStateMachine->PhoneEngineInfo()->RemoteCompanyName( aCallId );
 }
 TPhoneCmdParamGlobalNote globalNoteParam;
 globalNoteParam.SetText( callText );
-globalNoteParam.SetType( EPhoneNotificationDialog );
+globalNoteParam.SetType( EAknGlobalInformationNote );
+globalNoteParam.SetTone( EAvkonSIDInformationTone );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneCallWaitingWithLabel ) );
-globalNoteParam.SetNotificationDialog( ETrue );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 else
 {
-SendGlobalInfoNoteL( EPhoneCallWaitingWithoutLabel, ETrue );
+SendGlobalInfoNoteL( EPhoneCallWaitingWithoutLabel );
 }
 }
 // ----------------------------------------------------------------------------
 // CPhoneState::SetRingingTonePlaybackL()
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID(
 EPhoneInfoCugInUse ), cugIndex );
 TPhoneCmdParamGlobalNote globalNoteParam;
-globalNoteParam.SetText( *buf );
+	    globalNoteParam.SetText( *buf );
-globalNoteParam.SetType( EPhoneMessageBoxInformation );
+	    globalNoteParam.SetType( EAknGlobalInformationNote );
+	    globalNoteParam.SetTone( EAvkonSIDInformationTone );
-iViewCommandHandle->ExecuteCommandL(
-EPhoneViewShowGlobalNote, &globalNoteParam );
+	    iViewCommandHandle->ExecuteCommandL(
+	            EPhoneViewShowGlobalNote, &globalNoteParam );
-CleanupStack::PopAndDestroy( buf );
+	    CleanupStack::PopAndDestroy( buf );
 }
 }
 // -----------------------------------------------------------
 // CPhoneState::CallheaderManagerL
 iCustomization );
 }
 return iCallHeaderManager;
 }
+// -----------------------------------------------------------------------------
+// CPhoneState::CloseCustomizedDialerL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneState::CloseCustomizedDialerL()
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::CloseCustomizedDialerL( ) ");
+// Set dialer back to default mode.
+iViewCommandHandle->HandleCommandL( EPhoneViewHideCustomizedDialer );
+CloseClearNumberEntryAndLoadEffectL( ENumberEntryClose );
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::CustomizedDialerMenuResourceId
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPhoneState::CustomizedDialerMenuResourceIdL()
+{
+__LOGMETHODSTARTEND(EPhoneControl,
+"CPhoneState::CustomizedDialerMenuResourceId( ) ");
+// Get and return customized dialer menu resource id
+TPhoneCmdParamInteger integerParam;
+iViewCommandHandle->HandleCommandL(
+EPhoneViewGetCustomizedDialerMenuResourceId,
+&integerParam );
+return integerParam.Integer();
+}
+// -----------------------------------------------------------------------------
+// CPhoneState::CustomizedDialerCbaResourceId
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CPhoneState::CustomizedDialerCbaResourceIdL()
+{
+__LOGMETHODSTARTEND(EPhoneControl,
+"CPhoneState::CustomizedDialerCbaResourceId( ) ");
+// Get and return customized dialer CBA resource id
+TPhoneCmdParamInteger integerParam;
+iViewCommandHandle->HandleCommandL(
+EPhoneViewGetCustomizedDialerCbaResourceId,
+&integerParam );
+return integerParam.Integer();
+}
+// -----------------------------------------------------------
+// CPhoneState::ShowDtmfDialerL
+// -----------------------------------------------------------
+//
+void CPhoneState::ShowDtmfDialerL()
+{
+__LOGMETHODSTARTEND(EPhoneControl,
+"CPhoneState::ShowDtmfDialerL()" );
+// Set dialer to DTMF mode.
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( ETrue );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetDtmfDialerViewVisible,
+&booleanParam );
+BeginTransEffectLC( ECallUiDisappear );
+if ( IsNumberEntryUsedL() )
+{
+// Store the number entry content to cache
+if ( !IsNumberEntryContentStored() )
+{
+StoreNumberEntryContentL();
+}
+// Clear and display DTMF dialer
+NumberEntryClearL();
+SetNumberEntryVisibilityL(ETrue);
+}
+else
+{
+// Create and display DTMF dialer
+NumberEntryManagerL()->CreateNumberEntryL();
+}
+EndTransEffect();
+// Update CBA
+iCbaManager->UpdateInCallCbaL();
+if( EPSCTsyCallStateDialling ==
+CPhonePubSubProxy::Instance()->Value(KPSUidCtsyCallInformation, KCTsyCallState ) )
+{
+// Call indicator update to ensure that small call
+// bubble is shown in dtmf dialer during dialing
+// call this needs to be done because when call is
+// initialized small call bubble visibility is set to false.
+UpdateIncallIndicatorL(EPSCTsyCallStateDialling);
+}
+}
 // -----------------------------------------------------------
 // CPhoneState::CheckIfRestoreNEContentAfterDtmfDialer
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::CheckIfRestoreNEContentAfterDtmfDialer()
 {
+if ( IsOnScreenDialerSupported() )
+{
+TBool isDialerVisible( EFalse );
+TRAP_IGNORE( isDialerVisible = IsDTMFEditorVisibleL() );
+if ( isDialerVisible )
+{
+TRAP_IGNORE( CloseDTMFEditorL() );
+}
+// if the DTMF dialer is used before the idle message, we have to
+// restore the original content of the number entry
+if ( IsNumberEntryContentStored() )
+{
+TBool isNumberEntryUsed( EFalse );
+TRAP_IGNORE( isNumberEntryUsed = IsNumberEntryUsedL() );
+if ( !isNumberEntryUsed )
+{
+TRAP_IGNORE( NumberEntryManagerL()->CreateNumberEntryL() );
+}
+// Restore the number entry content from cache
+TRAP_IGNORE( RestoreNumberEntryContentL() );
+}
+}
 }
 // -----------------------------------------------------------
 // CPhoneState::IsOnScreenDialerSupported
 // -----------------------------------------------------------
 {
 __LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::LoadResource() ");
 __PHONELOG1( EBasic, EPhoneControl, "CPhoneState::LoadResource - aResource: %d", aResource );
 StringLoader::Load(  aData,
 CPhoneMainResourceResolver::Instance()->ResolveResourceID( aResource ),
-&iEnv  );
+EikonEnv() );
 }
 // -----------------------------------------------------------
 // CPhoneState::IsAnyConnectedCalls
 // -----------------------------------------------------------
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::IsNumberEntryVisibleL( ) ");
 return NumberEntryManagerL()->IsNumberEntryVisibleL();
 }
 // -----------------------------------------------------------
+// CPhoneState::KeyEventForExistingNumberEntryL
+// -----------------------------------------------------------
+//
+void CPhoneState::KeyEventForExistingNumberEntryL( const TKeyEvent& aKeyEvent,
+TEventCode aEventCode )
+{
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::KeyEventForExistingNumberEntryL( ) ");
+NumberEntryManagerL()->KeyEventForExistingNumberEntryL( aKeyEvent, aEventCode );
+}
+// -----------------------------------------------------------
 // CPhoneState::HandleNumberEntryClearedL
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::HandleNumberEntryClearedL()
 {
 booleanParam.SetBoolean( EFalse );
 }
 NumberEntryManagerL()->SetNumberEntryVisibilityL( booleanParam );
 }
+// ---------------------------------------------------------
+// CPhoneState::HandleCreateNumberEntryL
+// ---------------------------------------------------------
+//
+EXPORT_C void CPhoneState::HandleCreateNumberEntryL(
+const TKeyEvent& /*aKeyEvent*/,
+TEventCode /*aEventCode*/ )
+{
+NumberEntryManagerL()->HandleCreateNumberEntryL();
+}
 // -----------------------------------------------------------
 // CPhoneState::IsNumberEntryContentStored
 // -----------------------------------------------------------
 //
 EXPORT_C TBool CPhoneState::IsNumberEntryContentStored()
 {
 NumberEntryManagerL()->StoreNumberEntryContentL();
 }
 // -----------------------------------------------------------
+// CPhoneState::RestoreNumberEntryContentL
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::RestoreNumberEntryContentL()
+{
+NumberEntryManagerL()->RestoreNumberEntryContentL();
+}
+// -----------------------------------------------------------
 // CPhoneState::ClearNumberEntryContentCache
 // -----------------------------------------------------------
 //
 EXPORT_C void CPhoneState::ClearNumberEntryContentCache()
 {
 TRAP_IGNORE( NumberEntryManagerL()->ClearNumberEntryContentCache() );
+}
+// -----------------------------------------------------------
+// CPhoneState::HandleNumberEntryEdited
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::HandleNumberEntryEdited()
+{
+__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::HandleNumberEntryEdited() ");
+TRAP_IGNORE( NumberEntryManagerL()->HandleNumberEntryEdited() );
 }
 // -----------------------------------------------------------------------------
 // CPhoneState::IsAlphanumericSupportedAndCharInput
 // -----------------------------------------------------------------------------
 //
 void CPhoneState::NumberEntryClearL()
 {
 NumberEntryManagerL()->NumberEntryClearL();
 }
 // -----------------------------------------------------------
-// CPhoneState::GetBlockedKeyList
+// CPhoneState::UpdateSilenceButtonDimming
 // -----------------------------------------------------------
 //
-EXPORT_C const RArray<TInt>& CPhoneState::GetBlockedKeyList() const
+EXPORT_C void CPhoneState::UpdateSilenceButtonDimming()
 {
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::GetBlockedKeyList( ) ");
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
-return iStateMachine->PhoneStorage()->GetBlockedKeyList();
+{
-}
+const TProfileRingingType ringingType =
+iStateMachine->PhoneEngineInfo()->RingingType();
-// -----------------------------------------------------------
-// CPhoneState::DisableHWKeysL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::DisableHWKeysL()
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisableHWKeysL( ) ");
-if( iStateMachine->PhoneStorage()->IsBlockedKeysListEmpty() )
-{
-__PHONELOG( EBasic, EPhoneControl, " CPhoneState::DisableHWKeysL HW Keys Disabled " );
-iStateMachine->PhoneStorage()->AppendBlockedKeysListL( EStdKeyNo );
-iStateMachine->PhoneStorage()->AppendBlockedKeysListL( EStdKeyYes );
-}
-}
-// -----------------------------------------------------------
-// CPhoneState::DisableCallUIL
-// -----------------------------------------------------------
-//
-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 ) );
-HBufC* noteText = StringLoader::LoadLC(
-CPhoneMainResourceResolver::Instance()->
-ResolveResourceID( EPhoneIncomingCallKeysLocked ) );
-noteParam.SetText( *noteText );
-iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNote, &noteParam );
-CleanupStack::PopAndDestroy( noteText );
-// Start capturing the key guard key
-TPhoneCmdParamKeyCapture appKeyCaptureParam;
-appKeyCaptureParam.SetKey( EStdKeyDevice7 );
-appKeyCaptureParam.SetKeyCode( EKeyDeviceF );
-appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
-iViewCommandHandle->ExecuteCommandL( EPhoneViewStartCapturingKey, &appKeyCaptureParam );
-// Set Call UI state to storage
+TBool callIsAlerting =
-iStateMachine->PhoneStorage()->SetScreenLocked( ETrue );
+!(( ringingType == EProfileRingingTypeSilent ) ||
-}
+( ringingType == EProfileRingingTypeBeepOnce ));
-}
+if ( !callIsAlerting )
-// -----------------------------------------------------------
+{
-// CPhoneState::EnableCallUIL
+SetTouchPaneButtonDisabled( EPhoneCallComingCmdSilent );
-// -----------------------------------------------------------
+}
-//
+}
-EXPORT_C void CPhoneState::EnableCallUIL()
+}
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::EnableCallUIL( ) ");
+// ---------------------------------------------------------
+// CPhoneState::SetToolbarDimming
-if( iStateMachine->PhoneStorage()->IsScreenLocked() )
+// ---------------------------------------------------------
-{
+//
-__PHONELOG( EBasic, EPhoneControl, " CPhoneState::EnableCallUIL CallUI Enabled " );
+EXPORT_C void CPhoneState::SetToolbarDimming( TBool aDimmed )
+{
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );
+	if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
-iViewCommandHandle->ExecuteCommandL( EPhoneViewDisableKeyLockWithoutNote );
+{
+		// Check that we are not undimming toolbar in security mode
-// Stop capturing the key guard key
+		if ( !( !aDimmed && iStateMachine->SecurityMode()->IsSecurityMode() ) )
-TPhoneCmdParamKeyCapture appKeyCaptureParam;
+			{
-appKeyCaptureParam.SetKey( EStdKeyDevice7 );
+			TPhoneCmdParamBoolean booleanParam;
-appKeyCaptureParam.SetKeyCode( EKeyDeviceF );
+			booleanParam.SetBoolean( aDimmed );
-appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
+			TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
-iViewCommandHandle->ExecuteCommandL( EPhoneViewStopCapturingKey, &appKeyCaptureParam );
+				EPhoneViewSetToolbarDimming, &booleanParam ));
+			}
-iStateMachine->PhoneStorage()->SetScreenLocked( EFalse );
-}
-}
-// -----------------------------------------------------------
-// CPhoneState::CheckDisableHWKeysAndCallUIL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::CheckDisableHWKeysAndCallUIL()
-{
-__LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneState::CheckDisableHWKeysAndCallUIL( ) ");
-if( IsKeyLockOn() || IsAutoLockOn() )
-{
-// Disable HW keys if needed
-if( CPhoneCenRepProxy::Instance()->
-IsTelephonyFeatureSupported( KTelephonyLVFlagDisableCallControlHardKeysWhileLocked ) )
-{
-DisableHWKeysL();
-}
-// Disable Call UI if needed
-if( FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke )
-&& !CPhoneCenRepProxy::Instance()->
-IsTelephonyFeatureSupported( KTelephonyLVFlagAllowUnlockOnIncoming ) )
-{
-DisableCallUIL();
-iStateMachine->PhoneStorage()->SetNeedToEnableKeylock( ETrue );
-}
-}
-}
-// -----------------------------------------------------------
-// CPhoneState::HandleHoldSwitchL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::HandleHoldSwitchL()
-{
-__LOGMETHODSTARTEND( EPhoneUIStates, "CPhoneState::HandleHoldSwitchL( ) ");
-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();
-}
-}
-// Stop ringingtone
-iViewCommandHandle->ExecuteCommandL( EPhoneViewStopRingTone );
-}
-// -----------------------------------------------------------
-// CPhoneState::RetainPreviousKeylockStateL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::RetainPreviousKeylockStateL()
-{
-// Lock keypad, if keylock was enabled before incoming call.
-// Also reset PhoneStorage keylock status.
-if ( FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke ) &&
-iStateMachine->PhoneStorage()->NeedToEnableKeylock() )
-{
-iStateMachine->PhoneStorage()->SetNeedToEnableKeylock( EFalse );
-iViewCommandHandle->ExecuteCommandL( EPhoneViewEnableKeyLockWithoutNote );
-}
-}
-// ---------------------------------------------------------
-// CPhoneState::HandleKeyLockEnabledL
-// ---------------------------------------------------------
-//
-EXPORT_C void CPhoneState::HandleKeyLockEnabled( TBool aKeylockEnabled )
-{
-__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleKeyLockEnabledL( ) ");
-if( !FeatureManager::FeatureSupported( KFeatureIdFfTouchUnlockStroke )
-&& CPhoneCenRepProxy::Instance()->
-IsTelephonyFeatureSupported( KTelephonyLVFlagDisableCallControlHardKeysWhileLocked ) )
-{
-if( !aKeylockEnabled )
-{
-// Keylock disabled
-// Reset blocked keys list
-iStateMachine->PhoneStorage()->ResetBlockedKeysList();
-}
 }
 }
 // ---------------------------------------------------------
 // CPhoneState::SetToolbarButtonLoudspeakerEnabled
 {
 if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
 {
 TPhoneCmdParamInteger integerParam;
 integerParam.SetInteger( EPhoneInCallCmdActivateIhf );
-TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
+iViewCommandHandle->ExecuteCommand(
-EPhoneViewEnableToolbarButton, &integerParam ));
+EPhoneViewEnableToolbarButton, &integerParam );
 }
 }
 // ---------------------------------------------------------
-// CPhoneState::SetBackButtonActive
+// CPhoneState::SetToolbarButtonHandsetEnabled
 // ---------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SetBackButtonActive( TBool aActive )
+EXPORT_C void CPhoneState::SetToolbarButtonHandsetEnabled()
 {
-if(IsAutoLockOn() && aActive) {
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
-// keep back button dimmed device lock case
+{
-return;
+TPhoneCmdParamInteger integerParam;
-}
+integerParam.SetInteger( EPhoneInCallCmdHandset );
+iViewCommandHandle->ExecuteCommand(
+EPhoneViewEnableToolbarButton, &integerParam );
+}
+}
+// ---------------------------------------------------------
+// CPhoneState::SetToolbarButtonBTHFEnabled
+// ---------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetToolbarButtonBTHFEnabled()
+{
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+{
+TPhoneCmdParamInteger integerParam;
+integerParam.SetInteger( EPhoneInCallCmdBtHandsfree );
+iViewCommandHandle->ExecuteCommand(
+EPhoneViewEnableToolbarButton, &integerParam );
+}
+}
+// ---------------------------------------------------------
+// CPhoneState::HandleEasyDialingCommandsL
+// ---------------------------------------------------------
+//
+void CPhoneState::HandleEasyDialingCommandsL( TInt aCommandId )
+{
+switch ( aCommandId )
+{
+case EPhoneCmdUpdateCba:
+iCbaManager->UpdateInCallCbaL();
+break;
+case EPhoneDialerValidNumber:
+{
+TPhoneCmdParamBoolean command;
+command.SetBoolean( EFalse );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetInvalidCsPhoneNumberFlag, &command );
+}
+break;
+case EPhoneDialerInvalidNumber:
+{
+TPhoneCmdParamBoolean command;
+command.SetBoolean( ETrue );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetInvalidCsPhoneNumberFlag, &command );
+}
+break;
+case EPhoneCmdBlockingDialogLaunched:
+{
+TPhoneCmdParamBoolean param;
+param.SetBoolean( ETrue );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetBlockingDialogStatus, &param );
+}
+break;
+case EPhoneCmdBlockingDialogClosed:
+{
+TPhoneCmdParamBoolean param;
+param.SetBoolean( EFalse );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewSetBlockingDialogStatus, &param );
+}
+break;
+default:
+break;
+}
+}
+// -----------------------------------------------------------
+// CPhoneState::ForwardPEMessageToPhoneCustomizationL
+// Forward Phone Engine messages to Phone customization
+// (other items were commented in a header).
+// -----------------------------------------------------------
+//
+EXPORT_C TBool CPhoneState::ForwardPEMessageToPhoneCustomizationL(
+const TInt aMessage,
+TInt aCallId )
+{
+__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::ForwardPEMessageToPhoneCustomizationL() " );
+TBool handled = EFalse;
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+if ( iCustomization )
 {
-TPhoneCmdParamBoolean booleanParam;
+handled = iCustomization->HandlePhoneEngineMessageL( aMessage, aCallId );
-booleanParam.SetBoolean( aActive );
+}
-iViewCommandHandle->ExecuteCommand(
+return handled;
-EPhoneViewBackButtonActive, &booleanParam );
+}
-}
-}
+// -----------------------------------------------------------
+// CPhoneState::SetLittleBubbleVisibilityL
 // -----------------------------------------------------------
-// CPhoneState::OpenSoftRejectMessageEditorL
+//
-// -----------------------------------------------------------
+void CPhoneState::SetLittleBubbleVisibilityL(
-//
+TPhoneCommandParam* aCommandParam)
-EXPORT_C void CPhoneState::OpenSoftRejectMessageEditorL()
+{
-{
+__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::SetLittleBubbleVisibilityL() " );
-__LOGMETHODSTARTEND(EPhoneControl,
+// If user has opened dtmfeditor(dtmfdialer) then do not make any changes
-"CPhoneState::OpenSoftRejectMessageEditorL ()" );
+// to SetLittleBubbleVisible value. SetLittleBubbleVisible value is true by default.
+if( !IsDTMFEditorVisibleL() )
-// Fetch incoming call's id from view
+{
-TPhoneCmdParamCallStateData callStateData;
+TPhoneCmdParamIncallIndicatorData* incallIndicatorParam =
-callStateData.SetCallState( EPEStateRinging );
+static_cast<TPhoneCmdParamIncallIndicatorData*>( aCommandParam );
-iViewCommandHandle->HandleCommandL(
+TInt activeCallId = GetActiveCallIdL();
-EPhoneViewGetCallIdByState, &callStateData );
+switch( incallIndicatorParam->CallState() )
+{
-TInt ringingCallId( KErrNotFound );
+case EPSCTsyCallStateRinging:
-// Do nothing if negative incoming call id
+case EPSCTsyCallStateDialling:
-if( callStateData.CallId() > KErrNotFound  )
+{
-{
+// If we have single ringing or dialling call then it is ok
-iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveQuery );
+// to set visibility to false.
+if ( activeCallId < KErrNone )
-ringingCallId = callStateData.CallId();
+{
-}
+incallIndicatorParam->SetLittleBubbleVisible( EFalse );
+}
+}
-TPhoneCmdParamSfiData sfiDataParam;
+break;
+default:
-if (KErrNotFound != ringingCallId)
+incallIndicatorParam->SetLittleBubbleVisible( ETrue );
-{
+break;
-if ( iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ).Length() )
+}
-{
+}
-// store both the name and the number
+}
-sfiDataParam.SetNumber( iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
-sfiDataParam.SetName( iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ) );
+// -----------------------------------------------------------
-}
+// CPhoneState::DisplayCallSetupL
-else
+// -----------------------------------------------------------
-{
+//
-// store the number
+EXPORT_C void CPhoneState::DisplayCallSetupL( TInt aCallId )
-sfiDataParam.SetNumber( iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
+{
-}
+__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::DisplayCallSetupL() ");
-}
+BeginTransEffectLC( ECallUiAppear );
+BeginUiUpdateLC();
-iViewCommandHandle->ExecuteCommandL(
+SetNumberEntryVisibilityL( EFalse );
-EPhoneViewOpenSoftRejectEditor, &sfiDataParam );
+CaptureKeysDuringCallNotificationL( ETrue );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );
+TPhoneCmdParamInteger uidParam;
+uidParam.SetInteger( KUidPhoneApplication.iUid );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,
+&uidParam );
+// Do state-specific operations.
+DoStateSpecificCallSetUpDefinitionsL();
+DisplayHeaderForOutgoingCallL(aCallId);
+EndUiUpdate();
+EndTransEffect();
+iCbaManager->UpdateCbaL(EPhoneCallHandlingCallSetupCBA);
+}
+// -----------------------------------------------------------
+// Sends command to viewcontroller to store the flag
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetNeedToReturnToForegroundAppStatusL(
+TBool aNeedToReturn )
+{
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( aNeedToReturn );
+iViewCommandHandle->ExecuteCommandL(
+EPhoneViewSetNeedToReturnToForegroundAppStatus,
+&booleanParam );
+}
+// -----------------------------------------------------------
+// CPhoneState::DoStateSpecificCallSetUpDefinitionsL
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::DoStateSpecificCallSetUpDefinitionsL()
+{
+// do nothing
+}
+// -----------------------------------------------------------
+// CPhoneState::CloseClearNumberEntryAndLoadEffect
+// -----------------------------------------------------------
+//
+EXPORT_C void CPhoneState::CloseClearNumberEntryAndLoadEffectL(
+TStateTransEffectType aType )
+{
+__LOGMETHODSTARTEND( EPhoneControl,
+"CPhoneState::CloseClearNumberEntryAndLoadEffectL() ");
+BeginTransEffectLC( aType );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+EndTransEffect();
+// Do state-specific operation when number entry is cleared
+HandleNumberEntryClearedL();
 }
 //  End of File

branch	RCL_3
changeset 25	5266b1f337bd
parent 24	41a7f70b3818
child 26	8baf28733c3d