/*

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

    CPhoneState( aStateMachine, aViewCommandHandle, 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( ) ");

        aKeyEvent, aEventCode ) )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

        }

    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:

                {

                    {

                    }

                    {

                }

            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;

        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.

                {

                }

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

    if ( IsNumberEntryUsedL() )

        {

        }

    DisplayIncomingCallL( aCallId );

    SetTouchPaneButtons( EPhoneIncomingCallButtons );

    CheckDisableHWKeysAndCallUIL();

    SetBackButtonActive(EFalse);

    EndUiUpdate();

    iCbaManager->UpdateIncomingCbaL( aCallId );

    iViewCommandHandle->HandleCommandL( EPhoneViewShowToolbar );

    iStateMachine->ChangeState( EPhoneStateIncoming );

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

    EndUiUpdate();

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );

    iCbaManager->UpdateCbaL( EPhoneCallHandlingCallSetupCBA );

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

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );

    DisplayCallSetupL( aCallId );

    UpdateSingleActiveCallL( aCallId );

    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:

            break;

        case EPhoneNumberAcqCmdCall:

            HandleVoiceCallCommandL();

            break;

        case EPhoneNumberAcqCmdSendCommand:

            HandleSendCommandL();

            break;

        case EPhoneNumberAcqCmdVideoCall:

            DialVideoCallL();

            break;

        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;

    }

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

// CPhoneStateIdle::DialL

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

//

EXPORT_C void CPhoneStateIdle::DialL( 

        const TDesC& aNumber, 

        TPhoneNumberType aNumberType,

        TDialInitiationMethod /*aDialMethod*/ )

    {

    iStateMachine->PhoneEngineInfo()->SetPhoneNumber( aNumber );

    if ( aNumberType == EPhoneNumberTypeVideo &&

        FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) )

        {

        DialMultimediaCallL();

        }

    else if ( EPhoneNumberTypeVoip == aNumberType &&

              iCustomization )

        {

        iCustomization->HandleDialL( aNumber );

        }

    else

        {

        }

    }

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

// CPhoneStateIdle::DialVideoCallL

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

//

void CPhoneStateIdle::DialVideoCallL()

    {

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

    if ( IsNumberEntryUsedL() )

        {

        // get the number entry contents

        HBufC* phoneNumber = PhoneNumberFromEntryLC();

#ifdef _DEBUG

        if ( (*phoneNumber).Compare( KExit ) == 0 )

            {

            CleanupStack::PopAndDestroy( phoneNumber );

            SendExitCommandL();

            }

        else

#endif // _DEBUG

            {

            // call the number

            iStateMachine->PhoneEngineInfo()->SetPhoneNumber( *phoneNumber );

            DialMultimediaCallL();

            CleanupStack::PopAndDestroy( phoneNumber );

            }

    }

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

// CPhoneStateIdle::DisplayIncomingCallL

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

//

EXPORT_C void CPhoneStateIdle::DisplayIncomingCallL( TInt aCallId )

    {

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

    __ASSERT_DEBUG( iStateMachine->PhoneEngineInfo() && aCallId >= 0,

        Panic( EPhoneCtrlInvariant ) );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );

    TPhoneCmdParamKeyCapture captureParam;

    captureParam.SetKeyCode( EKeyNo );

    iViewCommandHandle->ExecuteCommand( EPhoneViewStartCapturingKey, &captureParam );

    // Indicate that the Phone needs to be sent to the background if

    // an application other than the top application is in the foreground

    TPhoneCmdParamBoolean booleanParam;

    booleanParam.SetBoolean( !TopAppIsDisplayedL() );

    iViewCommandHandle->ExecuteCommandL( 

        EPhoneViewSetNeedToSendToBackgroundStatus,

        &booleanParam );

    TPhoneCmdParamInteger uidParam;

    uidParam.SetInteger( KUidPhoneApplication.iUid );