/*

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

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

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

// might leave.

//

EXPORT_C CPhoneStateIdle::CPhoneStateIdle( 

    MPhoneStateMachine* aStateMachine, 

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aCustomization ) : 

    {

    }

// Destructor

EXPORT_C CPhoneStateIdle::~CPhoneStateIdle()

    {

    }

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

// CPhoneStateIdle::ConstructL()

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

//

EXPORT_C void CPhoneStateIdle::ConstructL()

    {

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

    CPhoneState::BaseConstructL();

    }

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

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

        }

        {

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

    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:

            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;

                        }

                        {

                        // 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 // iOnScreenDialer false, non-touch.

                {

                HandleSendCommandL();

                }

            break;

        case EKeyApplication0:

            {

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

                {

                }           

            }

            break;

#ifdef RD_INTELLIGENT_TEXT_INPUT   

        case EKeyEnter:

            if ( IsNumberEntryVisibleL() )

                {

                }

            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

                    }    

                    {

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

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

    SetRingingTonePlaybackL( aCallId );

    BeginUiUpdateLC();

    // Hide the number entry if it exists

    if ( IsNumberEntryUsedL() )

        {

        SetNumberEntryVisibilityL(EFalse);    

        }

    // Show incoming call buttons

    SetTouchPaneButtons( EPhoneIncomingCallButtons );

    EndUiUpdate();

    // Go to incoming state

    iCbaManager->UpdateIncomingCbaL( aCallId );

    //request that dimmed toolbar is visible.

    iViewCommandHandle->HandleCommandL( EPhoneViewShowToolbar );

    }

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

// Default handling for dialling message

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

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

//

EXPORT_C void CPhoneStateIdle::HandleDialingL( TInt aCallId )

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

    // Show call setup buttons

    }

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

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

    EndUiUpdate();

    // Go to single state

    iCbaManager->UpdateCbaL( EPhoneCallHandlingInCallCBA );

    }

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

// CPhoneStateIdle::HandleCommandL

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

//

EXPORT_C TBool CPhoneStateIdle::HandleCommandL( TInt aCommand )

    {

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

    TBool commandStatus = ETrue;

    switch( aCommand )

        {

        case EPhoneCmdOptions:

            {

            }

        case EPhoneNumberAcqCmdCall:

            break;

        case EPhoneNumberAcqCmdSendCommand:

            HandleSendCommandL();

            break;

        case EPhoneNumberAcqCmdVideoCall:

            DialVideoCallL();

            break;

        case EPhoneCmdBack:

        default:

            commandStatus = CPhoneState::HandleCommandL( aCommand );

            break;

        }

    return commandStatus;

    }

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

// CPhoneStateIdle::ProcessCommandL

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

//

EXPORT_C TBool CPhoneStateIdle::ProcessCommandL( TInt aCommand )

    {

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

    TBool commandStatus = EFalse;

    switch( aCommand )

       {

       case EAknSoftkeyContextOptions:

           {

           }

       default:

           commandStatus = CPhoneState::ProcessCommandL( aCommand );

           break;

       }

    return commandStatus;

    }

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

// CPhoneStateIdle::HandleRemConCommandL

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

//

EXPORT_C TBool CPhoneStateIdle::HandleRemConCommandL(

    TRemConCoreApiOperationId /*aOperationId */, 

    TRemConCoreApiButtonAction /*aButtonAct*/ )

    {

    return EFalse;

    }