/*

* 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".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Implementation of CPhoneStateIdle class.

*

*/

// INCLUDES

#include <eikenv.h>

#include <e32property.h>

#include <connect/sbdefs.h>

#include <w32std.h>

#include <StringLoader.h>

#include <aknnotedialog.h> // For CAknNoteDialog::EErrorTone

#include <apgcli.h>

#include <telephonyvariant.hrh>

#include <featmgr.h>

#include <settingsinternalcrkeys.h>

#include <ScreensaverInternalPSKeys.h>

#include <mpeengineinfo.h>

#include <activeidle2domainpskeys.h>

#include <mpeclientinformation.h>

#include <bldvariant.hrh>

#include "cphonepubsubproxy.h"

#include "cphonecenrepproxy.h"

#include "cphonestateidle.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparamglobalnote.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparamspeeddial.h"

#include "tphonecmdparamboolean.h"

#include "mphonestatemachine.h"

#include "phonestatedefinitions.h"

#include "tphonecmdparamappinfo.h"

#include "cphonekeys.h"

#include "tphonecmdparamcallstatedata.h"

#include "phoneviewcommanddefinitions.h"

#include "phoneui.hrh"

#include "phonerssbase.h"

#include "cphonemainresourceresolver.h"

#include "cphonecenrepproxy.h"

#include "cphonepubsubproxy.h"

#include "phonelogger.h"

#include "phoneui.pan"

#include "phoneconstants.h"

#include "mphonecustomization.h"

#include <easydialingcommands.hrh>

#include "mphonesecuritymodeobserver.h"

//CONSTANTS

const TInt  KMaxParamLength = 1024;

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

EXPORT_C CPhoneStateIdle::CPhoneStateIdle( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aCustomization ) : 

    CPhoneState( aStateMachine, aViewCommandHandle, aCustomization )

    {

    }

// Destructor

EXPORT_C CPhoneStateIdle::~CPhoneStateIdle()

    {

    }

// -----------------------------------------------------------

// CPhoneStateIdle::ConstructL()

// -----------------------------------------------------------

//

EXPORT_C void CPhoneStateIdle::ConstructL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::ConstructL() ");

    CPhoneState::BaseConstructL();

    // Set send key activation on.

    TPhoneCmdParamBoolean boolean;

    boolean.SetBoolean( ETrue );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetSendKeyDialerActivationFlag, 

                &boolean );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewCreatePhoneBookServices ); 

    }

// -----------------------------------------------------------

// CPhoneStateIdle::NewL()

// -----------------------------------------------------------

//

CPhoneStateIdle* CPhoneStateIdle::NewL( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization )

    {

    CPhoneStateIdle* self = new (ELeave) CPhoneStateIdle( 

        aStateMachine, aViewCommandHandle, aPhoneCustomization );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleKeyEventL

// -----------------------------------------------------------

//

EXPORT_C void CPhoneStateIdle::HandleKeyEventL( 

    const TKeyEvent& aKeyEvent, 

    TEventCode aEventCode )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleKeyEventL( ) ");

    // Number entry is blocked, if active Query

    if ( !IsAnyQueryActiveL() )

        {

        // Handle numeric keys when key events are received in idle state

        HandleNumericKeyEventL( aKeyEvent, aEventCode );  

        }

    else if ( iStateMachine->SecurityMode()->IsSecurityMode()

    	&& CPhoneKeys::IsNumericKey( aKeyEvent, aEventCode ) )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

        // Handle numeric keys when key events are received in single state

        HandleNumericKeyEventL( aKeyEvent, aEventCode );  

        }

    else if ( aEventCode == EEventKeyUp )

        {

        // Provide up event to engine. 

        // Otherwise DTMF tone keeps playing.    

           iStateMachine->SendPhoneEngineMessage( 

                MPEPhoneModel::EPEMessageEndDTMF );

         __PHONELOG( EBasic, EPhoneControl,

                "PhoneUIControl: CPhoneStateIdle::HandleKeyEventL" );

        }

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleNumberEntryClearedL()

// -----------------------------------------------------------

//

EXPORT_C void CPhoneStateIdle::HandleNumberEntryClearedL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleNumberEntryClearedL( ) ");

    if ( IsSimOk() && !IsSimStateNotPresentWithSecurityModeEnabled() )

        {

        //  if still idle ( f.e not incoming call arrived when rfs )

        if ( iStateMachine->State() == this )

            {

            DisplayIdleScreenL();

            }

        }

   else

        {

        StartShowSecurityNoteL(); 

        }

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleKeyMessageL

// -----------------------------------------------------------

//

EXPORT_C void CPhoneStateIdle::HandleKeyMessageL( 

    TPhoneKeyEventMessages aMessage,

    TKeyCode aCode )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleKeyMessageL( ) ");

    if( aMessage == EPhoneKeyLongPress && CheckAppLaunchingL( aCode ) )

    	{

        return;

    	}

    switch ( aCode )

        {

        case EKeyEnd:

            // This key even occur only in idle state, behaviour for this should

            // be same as long end-key press. (Bug in window server)

            HandleEndKeyPressL( EPhoneKeyLongPress );

            break;

        // end-key

        case EKeyNo:

            HandleEndKeyPressL( aMessage );            

            break;

        // send-key

        case EKeyYes:

            if ( iOnScreenDialer )

                {

                if ( IsNumberEntryUsedL() )

                    {

                    TPhoneCmdParamInteger numberEntryCountParam;

                    iViewCommandHandle->ExecuteCommandL( EPhoneViewGetNumberEntryCount,

                    &numberEntryCountParam );

                    TInt neLength( numberEntryCountParam.Integer() );

                    // Query on top of dialer

                    if ( IsAnyQueryActiveL() )

                        {

                        return;

                        }

                    else if ( IsMenuBarVisibleL() )

                        {

                        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

                        return;

                        }

                    else if ( neLength == 0 && !iStateMachine->SecurityMode()->IsSecurityMode() )

                        {

                        // start logs

                        iViewCommandHandle->HandleCommandL( 

                        EPhoneDialerCmdLog );

                        return;

                        }

                    HandleSendCommandL();

                    }

                // If dialer is not open but phone is in foreground and phone receives

                // send-key event we have to check if security mode is true and if it

                // is then open emergency dialer.

                else if ( !IsNumberEntryUsedL() ) 

                    {

                   if ( iStateMachine->SecurityMode()->IsSecurityMode() )

						{

						iViewCommandHandle->HandleCommandL( EPhoneViewOpenNumberEntry );

						}

                    }           

                }

            else // iOnScreenDialer false, non-touch.

                {

                HandleSendCommandL();

                }

            break;

        case EKeyApplication0:

            {

            // If dialer is not open but phone is in foreground and phone receives

            // applicaion-key event we have to open emergency dialer. 

            // Securitymode check because Applicationkey only open dialer in securitymode.

            if ( iStateMachine->SecurityMode()->IsSecurityMode() && !IsNumberEntryUsedL() )

                {

                iViewCommandHandle->HandleCommandL( EPhoneViewOpenNumberEntry );

                }           

            }

            break;

        // "O" key

        case KPhoneDtmf0Character:

            if ( aMessage == EPhoneKeyLongPress && IsSimOk() )

                {

                LaunchApplicationL();

                }

            break;

        // number key

        case KPhoneDtmf1Character:

        case KPhoneDtmf2Character:

        case KPhoneDtmf3Character:

        case KPhoneDtmf4Character:

        case KPhoneDtmf5Character:

        case KPhoneDtmf6Character:

        case KPhoneDtmf7Character:

        case KPhoneDtmf8Character:

        case KPhoneDtmf9Character:

            if ( aMessage == EPhoneKeyLongPress && IsSimOk() )

                {

                HandleNumberLongKeyPressL();

                }

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT   

        case EKeyEnter:

            if ( IsNumberEntryVisibleL() )

                {

                if ( IsDialingExtensionInFocusL() )

                    {

                    HandleCommandL( EEasyDialingEnterKeyAction );

                    }

                else

                    {

                    HandleCommandL( EPhoneCmdOptions );

                    }               

                }

            break;

#endif

        default:

            break;

        }

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandlePhoneEngineMessageL

// -----------------------------------------------------------

//

EXPORT_C void CPhoneStateIdle::HandlePhoneEngineMessageL( 

    const TInt aMessage, 

    TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandlePhoneEngineMessageL( ) ");

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageIncoming:

            HandleIncomingL( aCallId );

            break;

        case MEngineMonitor::EPEMessageDialing:

            HandleDialingL( aCallId );

            break;

        case MEngineMonitor::EPEMessageConnected:

            HandleConnectedL( aCallId );

            break;

        case MEngineMonitor::EPEMessageIssuedUSSDRequest:

            // Note that after the sending of SS 

            // strings the view stays in Dialer.

            if ( !iOnScreenDialer )  

                {

                if ( IsNumberEntryUsedL() )

                    {

                    // Show the number entry if it exists

                    SetNumberEntryVisibilityL(ETrue);    

                    }    

                else if ( NeedToReturnToForegroundAppL() )

                    {

                    // Continue displaying current app but set up the 

                    // idle screen in the background

                    SetupIdleScreenInBackgroundL();

                    }

                else

                    {

                     // Display idle screen

                    DisplayIdleScreenL();

                    }

                }

            break;

        case MEngineMonitor::EPEMessageIdle:

            HandleIdleL( aCallId );

            break;

        case MEngineMonitor::EPEMessageInValidEmergencyNumber:                

            SendGlobalWarningNoteL( EPhoneEmergencyCallsOnly );                           

            break;

        case MEngineMonitor::EPEMessageValidEmergencyNumber:

            DialVoiceCallL();

            break; 

        default:

            CPhoneState::HandlePhoneEngineMessageL( aMessage, aCallId );

            break;

        }

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleIncomingL( TInt aCallId )

// Default handling for incoming message

// (other items were commented in a header).

// -----------------------------------------------------------

//

void CPhoneStateIdle::HandleIncomingL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleIncomingL( ) ");

    HandleAudioAvailableOutputChangedL();

    iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNaviPaneAudioVolume );

    SetRingingTonePlaybackL( aCallId );

    CPhonePubSubProxy::Instance()->ChangePropertyValue(

        KPSUidScreenSaver,

        KScreenSaverAllowScreenSaver,

        EPhoneScreensaverNotAllowed );

    BeginUiUpdateLC();

    // Hide the number entry if it exists

    if ( IsNumberEntryUsedL() )

        {

        SetNumberEntryVisibilityL(EFalse);    

        }

    // Close fast swap window if it's displayed

    CEikonEnv::Static()->DismissTaskList();

    // Show incoming call buttons

    SetTouchPaneButtons( EPhoneIncomingCallButtons );

    SetTouchPaneButtonEnabled( EPhoneCallComingCmdSilent );

    // Display incoming call

    DisplayIncomingCallL( aCallId );

    EndUiUpdate();

    // Go to incoming state

    iCbaManager->UpdateIncomingCbaL( aCallId );

    UpdateSilenceButtonDimming();

    UpdateIncomingContextMenuL( aCallId );

    //Dim toolbar items

    SetToolbarDimming( ETrue );

    //request that dimmed toolbar is visible.

    iViewCommandHandle->HandleCommandL( EPhoneViewShowToolbar );

    iStateMachine->ChangeState( EPhoneStateIncoming );

    // Reset divert indication

    SetDivertIndication( EFalse );

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleDiallingL

// Default handling for dialling message

// (other items were commented in a header).

// -----------------------------------------------------------

//

EXPORT_C void CPhoneStateIdle::HandleDialingL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleDialingL( ) ");

    BeginUiUpdateLC();

    SetNumberEntryVisibilityL(EFalse);

    // Show call setup buttons

    SetTouchPaneButtons( EPhoneCallSetupButtons );

    // Display call setup 

    DisplayCallSetupL( aCallId );            

    EndUiUpdate();

    // Remove any phone dialogs if they are displayed

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );

    // Go to call setup state

    iCbaManager->UpdateCbaL( EPhoneCallHandlingCallSetupCBA );

    SetToolbarDimming( ETrue );

    iStateMachine->ChangeState( EPhoneStateCallSetup );

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleConnectedL

// Message Handling function for message EPEMessageConnected

// This could happen during transaction from Emergency mode

// to Normal mode where a network status change is received

// from PE after PE initiates an MO call. Since PE messages

// are asynchronous, this sequence can occur in any order.

// (other items were commented in a header).

// -----------------------------------------------------------

//

void CPhoneStateIdle::HandleConnectedL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleConnectedL( ) ");

    // Keep Phone app in the foreground if it is external

    if ( !TopAppIsDisplayedL() )

        {

        TPhoneCmdParamInteger uidParam;

        uidParam.SetInteger( KUidPhoneApplication.iUid );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground, 

            &uidParam );

        }

    BeginUiUpdateLC();

    // Remove the number entry

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );

    // Display call setup header

    DisplayCallSetupL( aCallId );

    // Update single active call

    UpdateSingleActiveCallL( aCallId );

    // Update touch buttons

    SetTouchPaneButtons( EPhoneIncallButtons );

    SetToolbarDimming( EFalse );

    EndUiUpdate();

    // Go to single state

    iCbaManager->UpdateCbaL( EPhoneCallHandlingInCallCBA );

    iStateMachine->ChangeState( EPhoneStateSingle );

    }

// -----------------------------------------------------------

// CPhoneStateIdle::HandleCommandL

// -----------------------------------------------------------

//

EXPORT_C TBool CPhoneStateIdle::HandleCommandL( TInt aCommand )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneStateIdle::HandleCommandL( ) ");

    TBool commandStatus = ETrue;

    switch( aCommand )

        {

        case EPhoneCmdOptions:

            {

            // Open number entry menubar