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

equal deleted inserted replaced

-:40a3f856b14d
+:41a7f70b3818
 /*
-* Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2009 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 "mphonesecuritymodeobserver.h"
+#include "tphonecmdparamsfidata.h"
-#include "easydialingcommands.hrh"
+#include "mphonestorage.h"
+#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:
-SendGlobalInfoNoteL( EPhoneWaitingText );
+// No need to send waiting notification for user.
+//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 );
+SendGlobalInfoNoteL( EPhoneInCallTransferred, ETrue );
 break;
 case MEngineMonitor::EPEMessageInitiatedEmergencyCall:
 HandleInitiatedEmergencyCallL( aCallId );
 break;
 case MEngineMonitor::EPEMessageInitiatedEmergencyWhileActiveVideo:
 HandleInitiatedEmergencyWhileActiveVideoL();
 break;
-case MEngineMonitor::EPEMessageShowIMEI:
+case MEngineMonitor::EPEMessageCallSecureStatusChanged:
-// Stop playing DTMF tone
+HandleCallSecureStatusChangeL( aCallId );
-iStateMachine->SendPhoneEngineMessage( MPEPhoneModel::EPEMessageEndDTMF );
-HandleShowImeiL();
+if ( iCustomization )
-break;
+{
+iCustomization->HandlePhoneEngineMessageL( aMessage,
-case MEngineMonitor::EPEMessageCallSecureStatusChanged:
+aCallId );
-HandleCallSecureStatusChangeL( aCallId );
+}
-ForwardPEMessageToPhoneCustomizationL( aMessage, aCallId );
+break;
-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 > EPENotActive &&
+previousOutput != EPEBTAudioAccessory &&
-		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*>( EikonEnv()->EikAppUi() )->KeySounds();
+static_cast<CAknAppUi*>( iEnv.EikAppUi() )->KeySounds();
 keySounds->PlaySound( EAvkonSIDIHFActive );
 }
 }
 // -----------------------------------------------------------
 iPreviousSimState == EPESimNotReady )
 {
 __PHONELOG( EBasic, EPhoneControl, "SIM card was removed" );
 TPhoneCmdParamGlobalNote globalNoteParam;
-globalNoteParam.SetType( EAknGlobalInformationNote );
+globalNoteParam.SetType( EPhoneMessageBoxInformation );
-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.
-if( IsKeyEventFurtherProcessedL( aKeyEvent ))
+SendKeyEventL( aKeyEvent, aEventCode );
-{
+}
-// 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 ) )
 {
-CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( EFalse );
+if( IsVideoCall( aErrorInfo.iCallId ) )
+{
+CPhoneReconnectQuery::InstanceL()->ShowReconnectQueryL( EFalse );
+}
 }
-}
+break;
-break;
+case ECCPErrorBadRequest:
-case ECCPErrorBadRequest:
-{
-TPECallType callType =
-iStateMachine->PhoneEngineInfo()->CallTypeCommand();
-if( callType == EPECallTypeVideo )
 {
-// Dialling MO video call cannot reach 3G network.
+TPECallType callType =
-__PHONELOG1( EBasic, EPhoneControl,
+iStateMachine->PhoneEngineInfo()->CallTypeCommand();
-"PhoneUIControl: CPhoneState::HandleErrorL - ShowReconnectQueryL vid 2, callid%d ",
-aErrorInfo.iCallId );
+if( callType == EPECallTypeVideo )
-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:
-case ECCPErrorCCBearerCapabilityNotCurrentlyAvailable:
+// If call id found and seems to be Video Call
-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
-TTime time( 0 );
+TTimeIntervalSeconds seconds =
-TTimeIntervalSeconds timeInterval =
 iStateMachine->PhoneEngineInfo()->CallDuration( aCallId );
-time += timeInterval;
+TPhoneCmdParamInteger time;
-// Read format string from AVKON resource
+time.SetInteger(seconds.Int());
-TBuf<KPhoneMaxCharsInNote> timeDurationFormatString( KNullDesC );
+iViewCommandHandle->ExecuteCommandL(EPhoneViewUpdateCallHeaderCallDuration, aCallId, &time);
-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->Des() );
+__PHONELOG1( EBasic, EPhoneControl, "SetPhoneNumber: %S ", phoneNumber );
 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 == KPSUidCtsyCallInformation )
+if ( aCategory == KPSUidTelInformation
-{
-// 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
+if ( aValue == ESimRejected ||  aValue == ESimUnaccepted )
-|| aValue == ESimUnaccepted
-|| aValue == ESimInvalid )
 {
 __PHONELOG( EBasic, EPhoneControl, "CPhoneStateStartup::HandlePropertyChangedL - SimSecurity status received" );
 StartShowSecurityNoteL();
 }
 }
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::HandleCenRepChangeL( ) ");
 }
 // -----------------------------------------------------------
-// CPhoneState::NeedToReturnToForegroundAppL
+// CPhoneState::NeedToSendToBackgroundL
 // -----------------------------------------------------------
 //
-EXPORT_C TBool CPhoneState::NeedToReturnToForegroundAppL() const
+EXPORT_C TBool CPhoneState::NeedToSendToBackgroundL() const
 {
 return iViewCommandHandle->HandleCommandL(
-EPhoneViewGetNeedToReturnToForegroundAppStatus ) ==
+EPhoneViewGetNeedToSendToBackgroundStatus ) ==
 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:
-CloseClearNumberEntryAndLoadEffectL( ECallUiAppear );
+// Remove number entry from screen
+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
+}
-TPhoneCmdParamAppInfo appInfoParam;
+break;
-appInfoParam.SetAppUid( KPhoneUidAppPhonebook );
-iViewCommandHandle->ExecuteCommandL(
+case EPhoneNumberAcqSecurityDialer:
-EPhoneViewActivateApp, &appInfoParam );
+{
-}
-break;
+}
+break;
-case EPhoneViewYesSingleItemFetch:
-{
+case EPhoneDialerCmdContacts:
-if ( IsOnScreenDialerSupported() )
+{
-{
+}
-TBuf<KPhoneNumberEntryBufferSize> fetchContent;
+break;
-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 ( NeedToReturnToForegroundAppL() )
+else if ( NeedToSendToBackgroundL() )
 {
 // 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 EPhoneCmdUpdateCba:
+case EPhoneCallComingCmdSoftReject:
-case EPhoneDialerValidNumber:
+// Open Soft reject message editor
-case EPhoneDialerInvalidNumber:
+OpenSoftRejectMessageEditorL();
-case EPhoneCmdBlockingDialogLaunched:
+break;
-case EPhoneCmdBlockingDialogClosed:
-{
+case EPhoneInCallCmdContacts:
-// these command ids are sent by easydialing to communicate to phone app
+iViewCommandHandle->ExecuteCommand( EPhoneViewOpenContacts );
-HandleEasyDialingCommandsL( aCommand );
+break;
-}
-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, "CPhoneState::ProcessCommandL() ");
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::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 );
+SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl, ETrue );
 }
 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 );
+SendGlobalInfoNoteL( EPhoneNoteTTYNoAudioControl, ETrue );
 }
 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 void CPhoneState::DisconnectCallL()
+EXPORT_C TBool CPhoneState::DisconnectCallL()
 {
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::DisconnectCallL( ) ");
-// Fetch active call's id from view
+TPhoneCmdParamInteger callIdParam;
-TPhoneCmdParamCallStateData callStateData;
+iViewCommandHandle->ExecuteCommandL(
-callStateData.SetCallState( EPEStateConnected );
+EPhoneViewGetExpandedBubbleCallId, &callIdParam );
-iViewCommandHandle->HandleCommandL(
-EPhoneViewGetCallIdByState, &callStateData );
+TBool ret = EFalse;
+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( callStateData.CallId() );
+iStateMachine->SetCallId( callIdParam.Integer() );
-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
-// bring idle to fore in next phone acitvation event.
+// Set Idle app as the top app
 iViewCommandHandle->ExecuteCommandL( EPhoneViewSetIdleTopApplication );
+// Set Empty CBA
 iCbaManager->SetCbaL( EPhoneEmptyCBA );
 }
 // ---------------------------------------------------------
 // CPhoneState::CallFromNumberEntryL
 __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo(),
 Panic( EPhoneCtrlInvariant ) );
 if ( IsOnScreenDialerSupported() )
 {
-if ( IsDTMFEditorVisibleL() ||
+if ( IsCustomizedDialerVisibleL() )
-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;
 }
 }
 }
-// If easydialing has focus, call should be initiated to focused contact.
+// Get the number entry contents
-if ( IsDialingExtensionInFocusL() )
+HBufC* phoneNumber = PhoneNumberFromEntryLC();
-{
-iViewCommandHandle->HandleCommandL( EEasyDialingVoiceCall );
+// Call the number
-}
+iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
-else
-{
+if ( phoneNumber->Des().Length() < KPhoneValidPhoneNumberLength )
-// Get the number entry contents
+{
-HBufC* phoneNumber = PhoneNumberFromEntryLC();
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );
-// Call the number
+HandleNumberEntryClearedL();
-iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );
+}
-if ( phoneNumber->Des().Length() < KPhoneValidPhoneNumberLength )
+CleanupStack::PopAndDestroy( phoneNumber );
-{
-CloseClearNumberEntryAndLoadEffectL( ECallUiAppear );
+if ( !iCustomization ||
-}
+!iCustomization->HandleCallFromNumberEntryL() )
+{
-CleanupStack::PopAndDestroy( phoneNumber );
+// Customization didn't handle call. Dial voice call
+// as normally
-if ( !iCustomization ||
+DialVoiceCallL();
-!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();
-//Update state of switch to video or voice call touch button.
+// Go to background if necessary
-TPECallType type = iStateMachine->PhoneEngineInfo()->CallType( aCallId );
+if ( NeedToSendToBackgroundL() ||  IsAutoLockOn() )
+{
-if( type == EPECallTypeVideo )
+}
-{
+// If there is no need to send back ground and number entry is used then
-TPhoneCmdParamBoolean booleanParam;
+// we must show number entry.
-booleanParam.SetBoolean( ETrue );
+else if ( !NeedToSendToBackgroundL() && IsNumberEntryUsedL() )
-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(
-const CBubbleManager::TPhoneCallTypeFlags aCallHeaderType )
+TInt 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( EAknGlobalInformationNote );
+globalNoteParam.SetType( EPhoneMessageBoxInformation );
 globalNoteParam.SetText( noteText );
-globalNoteParam.SetTone( CAknNoteDialog::ENoTone );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 }
 // ---------------------------------------------------------
 // CPhoneState::SendGlobalInfoNoteL
 // ---------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SendGlobalInfoNoteL( TInt aResourceId )
+EXPORT_C void CPhoneState::SendGlobalInfoNoteL(
+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 ?
-globalNoteParam.SetType( EAknGlobalInformationNote );
+EPhoneNotificationDialog : EPhoneMessageBoxInformation;
+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( TInt aResourceId )
+EXPORT_C void CPhoneState::SendGlobalWarningNoteL(
+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;
-globalNoteParam.SetType( EAknGlobalWarningNote );
+PhoneNotificationType type = aNotificationDialog ?
+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( TInt aResourceId )
+EXPORT_C void CPhoneState::SendGlobalErrorNoteL(
+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;
-globalNoteParam.SetType( EAknGlobalErrorNote );
+PhoneNotificationType type = aNotificationDialog ?
+EPhoneNotificationDialog : EPhoneMessageBoxInformation;
+globalNoteParam.SetType( type );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( aResourceId ) );
-globalNoteParam.SetTone( CAknNoteDialog::EErrorTone );
+globalNoteParam.SetNotificationDialog( aNotificationDialog );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 }
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetHandsfreeModeL( ) ");
 CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 if ( !bt->SetHandsfreeModeL( aHandsfreeMode ))
 {
-SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed );
+SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );
 }
 CleanupStack::PopAndDestroy( bt );
 }
 // ---------------------------------------------------------
 __LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::SetBTHandsfreeModeL( ) ");
 CPhoneAccessoryBTHandler* bt = CPhoneAccessoryBTHandler::NewLC(
 iViewCommandHandle, iStateMachine, this );
 if ( !bt->SetBTHandsfreeModeL( aHandsfreeMode ))
 {
-SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed );
+SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );
 }
 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(
+CPhoneMediatorFactory::Instance()->Sender()->IssueCommand( KMediatorVideoTelephonyDomain,
-KMediatorVideoTelephonyDomain,
+KCatPhoneToVideotelCommands,
-KCatPhoneToVideotelCommands,
+EVtCmdReleaseDataport,
-EVtCmdReleaseDataport,
+TVersion( KPhoneToVideotelCmdVersionMajor,
-TVersion( KPhoneToVideotelCmdVersionMajor,
+KPhoneToVideotelCmdVersionMinor,
-KPhoneToVideotelCmdVersionMinor,
+KPhoneToVideotelCmdVersionBuild ),
-KPhoneToVideotelCmdVersionBuild ),
+KNullDesC8,
-KNullDesC8,
+CPhoneContinueEmergencyCallCommand::NewL( *iStateMachine ) );
-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()
 {
-if ( SimState() == EPESimNotPresent && iStateMachine->SecurityMode()->IsSecurityMode() )
+TPhoneCmdParamBoolean 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()->
-			  case ESimRejected:
+ResolveResourceID( EPhoneSimRejected );
-			      {
+}
-			      resourceId = CPhoneMainResourceResolver::Instance()->
+else if ( SimState() == EPESimNotPresent )
-ResolveResourceID( EPhoneSimRejected );
+{
-break;
+// insert sim card -note
-			      }
+resourceId = CPhoneMainResourceResolver::Instance()->
-			  case ESimUnaccepted:
+ResolveResourceID( EPhoneSimRemoved );
-			      {
+}
-			      // insert sim card -note
+else if ( SimSecurityStatus() == ESimUnaccepted )
-resourceId = CPhoneMainResourceResolver::Instance()->
+{
-ResolveResourceID( EPhoneSimUnaccepted );
+resourceId = CPhoneMainResourceResolver::Instance()->
-			      break;
+ResolveResourceID( EPhoneSimUnaccepted );
-			      }
-			  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 note
+// Show number busy notification
 TPhoneCmdParamGlobalNote globalNoteParam;
-globalNoteParam.SetType( EAknGlobalInformationNote );
+globalNoteParam.SetType( EPhoneNotificationDialog );
 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 ) )
 {
-// Display Video Share button instead of Hold Button if
+TPhoneCmdParamBoolean muteParam;
-// the feature is enabled and video sharing is currently available.
+muteParam.SetBoolean( iStateMachine->PhoneEngineInfo()->AudioMute() );
-if ( aResourceId == EPhoneIncallButtons &&
+iViewCommandHandle->ExecuteCommand(EPhoneViewSetMuteFlag,&muteParam);
-FeatureManager::FeatureSupported( KFeatureIdFfEntryPointForVideoShare ) &&
-CPhonePubSubProxy::Instance()->Value
+const TPEAudioOutput audioOutput =
-( KPSUidCoreApplicationUIs, KCoreAppUIsVideoSharingIndicator )
+iStateMachine->PhoneEngineInfo()->AudioOutput();
-== ECoreAppUIsVideoSharingIndicatorOn )
-{
+TBool btAvailable = iStateMachine->PhoneEngineInfo()->AudioOutputAvailable(
-aResourceId = EPhoneIncallVideoShareButtons;
+EPEBTAudioAccessory );
-}
-TPhoneCmdParamInteger integerParam;
+TPhoneCmdParamBoolean btParam;
-integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
+btParam.SetBoolean( audioOutput == EPEBTAudioAccessory );
-ResolveResourceID( aResourceId ) );
+iViewCommandHandle->ExecuteCommand(EPhoneViewSetBlueToothFlag,&btParam);
+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,
-&integerParam ) );
+&booleanParam ) );
-SetTouchPaneVisible( ETrue );
 }
 }
 // ---------------------------------------------------------
 // CPhoneState::DeleteTouchPaneButtons
 //
 EXPORT_C void CPhoneState::DeleteTouchPaneButtons()
 {
 if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
 {
-TPhoneCmdParamInteger integerParam;
+TPhoneCmdParamBoolean boolParam;
-integerParam.SetInteger( 0 );
 TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
 EPhoneViewSetTouchPaneButtons,
-&integerParam ) );
+&boolParam ) );
-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
-if ( !iStateMachine->SecurityMode()->IsSecurityMode() )
+TPhoneCmdParamBoolean isSecurityMode;
+iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode );
+if ( !isSecurityMode.Boolean() )
 {
 CaptureKeysDuringCallNotificationL( EFalse );
 }
-CPhonePubSubProxy::Instance()->ChangePropertyValue(
+// Restore keylock if phone has been locked before call.
-KPSUidScreenSaver,
+if ( iStateMachine->PhoneStorage()->NeedToEnableKeylock() )
-KScreenSaverAllowScreenSaver,
+{
-EPhoneScreensaverAllowed );
+iViewCommandHandle->ExecuteCommandL( EPhoneViewEnableKeyLock );
+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( EAknGlobalInformationNote );
+globalNoteParam.SetType( EPhoneNotificationDialog );
-globalNoteParam.SetTone( EAvkonSIDInformationTone );
 globalNoteParam.SetTextResourceId(
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID( EPhoneCallWaitingWithLabel ) );
+globalNoteParam.SetNotificationDialog( ETrue );
 iViewCommandHandle->ExecuteCommandL(
 EPhoneViewShowGlobalNote, &globalNoteParam );
 }
 else
 {
-SendGlobalInfoNoteL( EPhoneCallWaitingWithoutLabel );
+SendGlobalInfoNoteL( EPhoneCallWaitingWithoutLabel, ETrue );
 }
 }
 // ----------------------------------------------------------------------------
 // CPhoneState::SetRingingTonePlaybackL()
 CPhoneMainResourceResolver::Instance()->
 ResolveResourceID(
 EPhoneInfoCugInUse ), cugIndex );
 TPhoneCmdParamGlobalNote globalNoteParam;
-	    globalNoteParam.SetText( *buf );
+globalNoteParam.SetText( *buf );
-	    globalNoteParam.SetType( EAknGlobalInformationNote );
+globalNoteParam.SetType( EPhoneMessageBoxInformation );
-	    globalNoteParam.SetTone( EAvkonSIDInformationTone );
+iViewCommandHandle->ExecuteCommandL(
-	    iViewCommandHandle->ExecuteCommandL(
+EPhoneViewShowGlobalNote, &globalNoteParam );
-	            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 ),
-EikonEnv() );
+&iEnv  );
 }
 // -----------------------------------------------------------
 // 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::UpdateSilenceButtonDimming
+// CPhoneState::GetBlockedKeyList
 // -----------------------------------------------------------
 //
-EXPORT_C void CPhoneState::UpdateSilenceButtonDimming()
+EXPORT_C const RArray<TInt>& CPhoneState::GetBlockedKeyList() const
 {
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::GetBlockedKeyList( ) ");
-{
+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 );
-TBool callIsAlerting =
+// Set Call UI state to storage
-!(( ringingType == EProfileRingingTypeSilent ) ||
+iStateMachine->PhoneStorage()->SetScreenLocked( ETrue );
-( ringingType == EProfileRingingTypeBeepOnce ));
+}
+}
-if ( !callIsAlerting )
-{
+// -----------------------------------------------------------
-SetTouchPaneButtonDisabled( EPhoneCallComingCmdSilent );
+// CPhoneState::EnableCallUIL
-}
+// -----------------------------------------------------------
-}
+//
-}
+EXPORT_C void CPhoneState::EnableCallUIL()
+{
-// ---------------------------------------------------------
+__LOGMETHODSTARTEND(EPhoneControl, "CPhoneState::EnableCallUIL( ) ");
-// CPhoneState::SetToolbarDimming
-// ---------------------------------------------------------
+if( iStateMachine->PhoneStorage()->IsScreenLocked() )
-//
+{
-EXPORT_C void CPhoneState::SetToolbarDimming( TBool aDimmed )
+__PHONELOG( EBasic, EPhoneControl, " CPhoneState::EnableCallUIL CallUI Enabled " );
-{
-	if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );
-{
+iViewCommandHandle->ExecuteCommandL( EPhoneViewDisableKeyLockWithoutNote );
-		// Check that we are not undimming toolbar in security mode
-		if ( !( !aDimmed && iStateMachine->SecurityMode()->IsSecurityMode() ) )
+// Stop capturing the key guard key
-			{
+TPhoneCmdParamKeyCapture appKeyCaptureParam;
-			TPhoneCmdParamBoolean booleanParam;
+appKeyCaptureParam.SetKey( EStdKeyDevice7 );
-			booleanParam.SetBoolean( aDimmed );
+appKeyCaptureParam.SetKeyCode( EKeyDeviceF );
-			TRAP_IGNORE( iViewCommandHandle->ExecuteCommandL(
+appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
-				EPhoneViewSetToolbarDimming, &booleanParam ));
+iViewCommandHandle->ExecuteCommandL( EPhoneViewStopCapturingKey, &appKeyCaptureParam );
-			}
+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(
+EPhoneViewEnableToolbarButton, &integerParam ));
+}
+}
+// ---------------------------------------------------------
+// CPhoneState::SetBackButtonActive
+// ---------------------------------------------------------
+//
+EXPORT_C void CPhoneState::SetBackButtonActive( TBool aActive )
+{
+if(IsAutoLockOn() && aActive) {
+// keep back button dimmed device lock case
+return;
+}
+if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+{
+TPhoneCmdParamBoolean booleanParam;
+booleanParam.SetBoolean( aActive );
 iViewCommandHandle->ExecuteCommand(
-EPhoneViewEnableToolbarButton, &integerParam );
+EPhoneViewBackButtonActive, &booleanParam );
 }
 }
-// ---------------------------------------------------------
+// -----------------------------------------------------------
-// CPhoneState::SetToolbarButtonHandsetEnabled
+// CPhoneState::OpenSoftRejectMessageEditorL
-// ---------------------------------------------------------
+// -----------------------------------------------------------
 //
-EXPORT_C void CPhoneState::SetToolbarButtonHandsetEnabled()
+EXPORT_C void CPhoneState::OpenSoftRejectMessageEditorL()
 {
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+__LOGMETHODSTARTEND(EPhoneControl,
-{
+"CPhoneState::OpenSoftRejectMessageEditorL ()" );
-TPhoneCmdParamInteger integerParam;
-integerParam.SetInteger( EPhoneInCallCmdHandset );
+// Fetch incoming call's id from view
-iViewCommandHandle->ExecuteCommand(
+TPhoneCmdParamCallStateData callStateData;
-EPhoneViewEnableToolbarButton, &integerParam );
+callStateData.SetCallState( EPEStateRinging );
-}
+iViewCommandHandle->HandleCommandL(
-}
+EPhoneViewGetCallIdByState, &callStateData );
-// ---------------------------------------------------------
+TInt ringingCallId( KErrNotFound );
-// CPhoneState::SetToolbarButtonBTHFEnabled
+// Do nothing if negative incoming call id
-// ---------------------------------------------------------
+if( callStateData.CallId() > KErrNotFound  )
-//
+{
-EXPORT_C void CPhoneState::SetToolbarButtonBTHFEnabled()
+iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveQuery );
-{
-if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+ringingCallId = callStateData.CallId();
-{
+}
-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 ( iCustomization )
-{
+TPhoneCmdParamSfiData sfiDataParam;
-handled = iCustomization->HandlePhoneEngineMessageL( aMessage, aCallId );
-}
+if (KErrNotFound != ringingCallId)
-return handled;
+{
-}
+if ( iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ).Length() )
+{
-// -----------------------------------------------------------
+// store both the name and the number
-// CPhoneState::SetLittleBubbleVisibilityL
+sfiDataParam.SetNumber( iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
-// -----------------------------------------------------------
+sfiDataParam.SetName( iStateMachine->PhoneEngineInfo()->RemoteName( ringingCallId ) );
-//
+}
-void CPhoneState::SetLittleBubbleVisibilityL(
+else
-TPhoneCommandParam* aCommandParam)
+{
-{
+// store the number
-__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::SetLittleBubbleVisibilityL() " );
+sfiDataParam.SetNumber( iStateMachine->PhoneEngineInfo()->RemotePhoneNumber( ringingCallId ) );
-// If user has opened dtmfeditor(dtmfdialer) then do not make any changes
+}
-// to SetLittleBubbleVisible value. SetLittleBubbleVisible value is true by default.
+}
-if( !IsDTMFEditorVisibleL() )
-{
+iViewCommandHandle->ExecuteCommandL(
-TPhoneCmdParamIncallIndicatorData* incallIndicatorParam =
+EPhoneViewOpenSoftRejectEditor, &sfiDataParam );
-static_cast<TPhoneCmdParamIncallIndicatorData*>( aCommandParam );
-TInt activeCallId = GetActiveCallIdL();
-switch( incallIndicatorParam->CallState() )
-{
-case EPSCTsyCallStateRinging:
-case EPSCTsyCallStateDialling:
-{
-// If we have single ringing or dialling call then it is ok
-// to set visibility to false.
-if ( activeCallId < KErrNone )
-{
-incallIndicatorParam->SetLittleBubbleVisible( EFalse );
-}
-}
-break;
-default:
-incallIndicatorParam->SetLittleBubbleVisible( ETrue );
-break;
-}
-}
-}
-// -----------------------------------------------------------
-// CPhoneState::DisplayCallSetupL
-// -----------------------------------------------------------
-//
-EXPORT_C void CPhoneState::DisplayCallSetupL( TInt aCallId )
-{
-__LOGMETHODSTARTEND( EPhoneControl, "CPhoneState::DisplayCallSetupL() ");
-BeginTransEffectLC( ECallUiAppear );
-BeginUiUpdateLC();
-SetNumberEntryVisibilityL( EFalse );
-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 24	41a7f70b3818
parent 23	40a3f856b14d
child 25	5266b1f337bd