/*

* 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 <mpeengineinfo.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 "tphonecmdparamkeycapture.h"

#include "tphonecmdparamstring.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 "mphonecustomization.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( ) ");

    // Security mode check

    TPhoneCmdParamBoolean isSecurityMode;      

    iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode );  

    // 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 ( isSecurityMode.Boolean() && 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() )

                    {

                    // Security mode check

                    TPhoneCmdParamBoolean isSecurityMode;      

                    iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode );

                    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 && !isSecurityMode.Boolean())

                        {

                        // 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() )

                    {

                    // Security mode check

                    TPhoneCmdParamBoolean isSecurityMode;      

                    iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &isSecurityMode );

                    if ( isSecurityMode.Boolean())

                        {

                        // launch dialer.

                        HandleCommandL(EPhoneNumberAcqSecurityDialer);

                        }

                    }           

                }

            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. No need own

            // securitymode check because Applicationkey only captured in securitymode.

            if ( !IsNumberEntryUsedL() )

                {

                HandleCommandL(EPhoneNumberAcqSecurityDialer);

                }           

            }

            break;

        // "O" key

        case KPhoneDtmf0Character:

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

                {

                LaunchApplicationL();

                }

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT   

        case EKeyEnter:

            if ( IsNumberEntryVisibleL() )

                {

                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 ( NeedToSendToBackgroundL() )

                    {

                    // 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, ETrue );                           

            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 );

    BeginTransEffectLC( ENumberEntryClose );

    BeginUiUpdateLC();

    // Hide the number entry if it exists

    if ( IsNumberEntryUsedL() )

        {

        SetNumberEntryVisibilityL(EFalse);    

        }

    // Display incoming call

    DisplayIncomingCallL( aCallId );

    // Show incoming call buttons

    SetTouchPaneButtons( EPhoneIncomingCallButtons );

    // Disable HW keys and Call UI if needed

    CheckDisableHWKeysAndCallUIL();

    SetBackButtonActive(EFalse);

    EndUiUpdate();

    EndTransEffect();

    // 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( ) ");

    BeginTransEffectLC( ENumberEntryClose );

    BeginUiUpdateLC();

    // Display call setup 

    DisplayCallSetupL( aCallId );  

    // Show call setup buttons

    SetTouchPaneButtons( EPhoneCallSetupButtons );          

    EndUiUpdate();

    // Remove any phone dialogs if they are displayed

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );

    // Go to call setup state

    iCbaManager->UpdateCbaL( EPhoneCallHandlingCallSetupCBA );

    SetToolbarDimming( ETrue );

    EndTransEffect();

    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 );

        }

    BeginTransEffectLC( ENumberEntryClose );

    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();

    EndTransEffect();

    // 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

            TPhoneCmdParamInteger integerParam;  

            integerParam.SetInteger( 

             CPhoneMainResourceResolver::Instance()->

                ResolveResourceID( EPhoneNumberAcqMenubar ) );               

            iViewCommandHandle->ExecuteCommandL( 

                EPhoneViewMenuBarOpen, &integerParam );

            break;

            }

        case EPhoneNumberAcqCmdCall:

            HandleVoiceCallCommandL();

            break;

        case EPhoneNumberAcqCmdSendCommand:

            HandleSendCommandL();

            break;

        case EPhoneNumberAcqCmdVideoCall:

            DialVideoCallL();