/*

* Copyright (c) 2005 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 CPhoneEmergency class.

*

*/

// INCLUDES

#include <eikmenub.h>

#include <StringLoader.h>

#include <ccpdefs.h>

#include <featmgr.h>

#include <cpephonemodelif.h>

#include <mpeengineinfo.h>

#include <AknUtils.h>

#include "cphoneemergency.h"

#include "tphonecmdparamstring.h"

#include "tphonecmdparaminteger.h"

#include "tphonecmdparamboolean.h"

#include "tphonecmdparamemergencycallheaderdata.h"

#include "tphonecmdparamcallheaderdata.h"

#include "tphonecmdparamkeycapture.h"

#include "mphonestatemachine.h"

#include "phonestatedefinitionsgsm.h"

#include "phoneviewcommanddefinitions.h"

#include "phoneui.hrh"

#include "phonerssbase.h"

#include "cphonemainresourceresolver.h"

#include "phonelogger.h"

#include "cphonepubsubproxy.h"

#include "cphonekeys.h"

#include "tphonecmdparamaudiooutput.h"

#include "phoneresourceids.h"

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

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

// might leave.

//

CPhoneEmergency::CPhoneEmergency(

    MPhoneStateMachine* aStateMachine,

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization ) :

    CPhoneGsmInCall( aStateMachine, aViewCommandHandle, aPhoneCustomization ),

    iCallSetup( ETrue )

    {

    }

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

// CPhoneEmergency::~CPhoneEmergency()

// Destructor

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

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

CPhoneEmergency::~CPhoneEmergency()

    {

    }

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

// CPhoneEmergency::ConstructL()

// Constructor

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

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

//

void CPhoneEmergency::ConstructL()

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::ConstructL()");

    CPhoneGsmInCall::ConstructL();

    }

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

// CPhoneEmergency::NewL()

// Constructor

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

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

//

CPhoneEmergency* CPhoneEmergency::NewL(

    MPhoneStateMachine* aStateMachine,

    MPhoneViewCommandHandle* aViewCommandHandle,

    MPhoneCustomization* aPhoneCustomization )

    {

    CPhoneEmergency* self = new (ELeave)

        CPhoneEmergency( aStateMachine, aViewCommandHandle, aPhoneCustomization );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPhoneEmergency::HandleNumberEntryClearedL()

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

//

void CPhoneEmergency::HandleNumberEntryClearedL()

    {

    __LOGMETHODSTARTEND(EPhoneUIStates,

        "CPhoneEmergency::HandleNumberEntryClearedL()");

    UpdateInCallCbaL();

    }

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

// CPhoneEmergency::HandlePhoneEngineMessageL

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

//

void CPhoneEmergency::HandlePhoneEngineMessageL(

    const TInt aMessage,

    TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneUIStates,

        "CPhoneEmergency::HandlePhoneEngineMessageL() ");

    switch ( aMessage )

        {

        case MEngineMonitor::EPEMessageIdle:

            iCallSetup = ETrue;

            HandleIdleL( aCallId );

            iConnected = EFalse;

            break;

        case MEngineMonitor::EPEMessageDialing:

            HandleDialingL( aCallId );

            break;

        case MEngineMonitor::EPEMessageConnected:

            if( iCallSetup )

                {

                HandleConnectingL( aCallId );

                iCallSetup = EFalse;

                }

            HandleConnectedL( aCallId );

            iConnected = ETrue;

            break;

        case MEngineMonitor::EPEMessageConnecting:

            HandleConnectingL( aCallId );

            iCallSetup = EFalse;

            break;

        case MEngineMonitor::EPEMessageDisconnecting:

            // Explicitly override this handling from CPhoneStateInCall

            // where DTMF sending is cancelled and that causes emergency

            // progress bar destroyed

            CPhoneState::HandlePhoneEngineMessageL( aMessage, aCallId );

            break;

        case MEngineMonitor::EPEMessageAudioOutputChanged:

            if ( iCallSetup )

                {

                HandleAudioOutputChangedL();

                }

            else

                {

                CPhoneGsmInCall::HandlePhoneEngineMessageL( aMessage, aCallId );

                }

            break;

        case MEngineMonitor::EPEMessageStoppedDTMF:      // fall through

        case MEngineMonitor::EPEMessageSentDTMF:         // fall through

        case MEngineMonitor::EPEMessageDTMFSendingAborted:

            CPhoneGsmInCall::HandlePhoneEngineMessageL( aMessage, aCallId );

            if ( iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) == EPEStateDialing )

                {

                UpdateSetupCbaL();

                }

            break;

        case MEngineMonitor::EPEMessageColpNumberAvailable:

            //Don't show COLP note during emergency call.

            break; 

        default:

            CPhoneGsmInCall::HandlePhoneEngineMessageL(

                aMessage, aCallId );

            break;

        }

    }

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

// CPhoneEmergency::HandleIdleL

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

//

void CPhoneEmergency::HandleIdleL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::HandleIdleL() ");

    // Re-enable global notes, this enables secui (if needed) to come on top

    // if call creation was rejected by user

    TPhoneCmdParamBoolean globalNotifierParam;

    globalNotifierParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

        &globalNotifierParam );

    if ( aCallId == KEmergencyCallId )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId );

        // Remove emergency connecting note if still there

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

        TPhoneCmdParamKeyCapture captureParam;

        captureParam.SetKeyCode( EKeyNo );

        iViewCommandHandle->ExecuteCommand( 

                EPhoneViewStopCapturingKey, &captureParam );

        const TBool isSimStateNotPresentWithSecurityMode = IsSimStateNotPresentWithSecurityModeEnabled();

        // Sim IS not ok when making emergency call from Pin query, no note

        if ( (!IsSimOk() && !iStartupInterrupted) || isSimStateNotPresentWithSecurityMode )

            {

            StartShowSecurityNoteL();

            }

        else

            {

            if ( !TopAppIsDisplayedL() || iDeviceLockOn  )

                {

                // Continue displaying current app but set up the

                // idle screen in the background

                SetupIdleScreenInBackgroundL();

                }

                {

                SetNumberEntryVisibilityL(ETrue);

                }

            else

                {

                DisplayIdleScreenL();

                }

            if ( iConnected )

                {

                DisplayCallTerminationNoteL();

                }

            }

        // Go to emergency idle state or to startup state if emergency call

        // initiated from PIN query

        if ( iStartupInterrupted )

            {

            iStartupInterrupted = EFalse;

            iStateMachine->ChangeState( EPhoneStateStartup );

            }

        else

            {

            if ( !isSimStateNotPresentWithSecurityMode )

                {

                SetDefaultFlagsL();

                }

            // As long as security note is not shown with feature flag 

            // KFeatureIdFfSimlessOfflineSupport undef it is ok to do SetupIdleScreenInBackgroundL.

            if ( ( !IsNumberEntryUsedL() ) && 

                 !( IsSimStateNotPresentWithSecurityModeEnabled() && 

                    !FeatureManager::FeatureSupported( KFeatureIdFfSimlessOfflineSupport ) ) )

                {

                UpdateCbaL( EPhoneEmptyCBA );

                TPhoneCmdParamBoolean securityMode;

                iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &securityMode );

                if ( !securityMode.Boolean() )

                    {

                    SetupIdleScreenInBackgroundL();

                    }

                }

            iStateMachine->ChangeState( EPhoneStateIdle );

            }

        }

    else

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveAllCallHeaders );

        }

    }

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

// CPhoneEmergency::HandleDialingL

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

//

void CPhoneEmergency::HandleDialingL( TInt aCallId )

    {

    // Discard all messages related to other calls than the emergency call

    // We trust that the ISA call server has taken care of them. However,

    // there could be a race condition between returning to Normal

    // mode (receiving a network registration status message from PE)

    // and receiving an EPEMessageDialling message. This can occur

    // because PE messages are processed asynchronously.

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::HandleDialingL() ");

    if ( aCallId == KPEEmergencyCallId )

        {

        iDeviceLockOn = IsAutoLockOn();

        TPhoneCmdParamBoolean globalNotifierParam;

        globalNotifierParam.SetBoolean( ETrue );

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewSetGlobalNotifiersDisabled,

            &globalNotifierParam );

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

        iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,

            &uidParam );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,

            &uidParam );

        if ( IsNumberEntryUsedL() )

            {

            // Remove number entry

            iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );

            }

        // Remove exit emergency mode query, if it exists

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveQuery );

        BeginUiUpdateLC();

        TPhoneCmdParamEmergencyCallHeaderData emergencyHeaderParam;

        TBuf<KPhoneCallHeaderLabelMaxLength> headerText( KNullDesC );

        StringLoader::Load(

            headerText,

            CPhoneMainResourceResolver::Instance()->ResolveResourceID(

                EPhoneEmergencyCallHeader ),

            CCoeEnv::Static() );

        emergencyHeaderParam.SetHeaderText( headerText );

        // Set call header ciphering status

        emergencyHeaderParam.SetCiphering(

            iStateMachine->PhoneEngineInfo()->IsSecureCall( aCallId ) );

        emergencyHeaderParam.SetCipheringIndicatorAllowed(

            iStateMachine->PhoneEngineInfo()->SecureSpecified() );

        // Notify the view

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewCreateEmergencyCallHeader,

            aCallId,

            &emergencyHeaderParam );

        TPhoneCmdParamCallHeaderData headerParam;

        headerParam.SetCallState( EPEStateDialing );

        StringLoader::Load(

            headerText,

            CPhoneMainResourceResolver::Instance()->ResolveResourceID(

                    EPhoneAttemptingEmergencyText ),

            CCoeEnv::Static() );

        headerParam.SetLabelText( headerText );

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewUpdateBubble,

            aCallId,

            &headerParam );

        SetTouchPaneButtons( EPhoneEmergencyCallButtons );

        SetBackButtonActive(EFalse);

        UpdateSetupCbaL();

        }

    }

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

// CPhoneEmergency::HandleConnectingL

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

//

void CPhoneEmergency::HandleConnectingL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::HandleConnectingL() ");

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveGlobalNote );

    TPhoneCmdParamBoolean globalNotifierParam;

    globalNotifierParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

        &globalNotifierParam );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetEikonNotifiersDisabled,

          &globalNotifierParam );

    TPhoneCmdParamBoolean booleanParam;

    booleanParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewSetNeedToSendToBackgroundStatus, &booleanParam );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

    TPhoneCmdParamCallHeaderData headerParam;

    headerParam.SetCallState( EPEStateConnecting );

    // Notify the view

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewUpdateBubble,

        aCallId,

        &headerParam );

    SetToolbarButtonLoudspeakerEnabled();

    UpdateInCallCbaL();

    }

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

// CPhoneEmergency::HandleConnectedL

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

//

void CPhoneEmergency::HandleConnectedL( TInt aCallId )

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::HandleConnectedL() ");

    BeginUiUpdateLC();

    TPhoneCmdParamCallHeaderData emergencyHeaderParam;

    emergencyHeaderParam.SetCallState( EPEStateConnected );

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewUpdateBubble,

        aCallId,

        &emergencyHeaderParam );

    SetBackButtonActive(ETrue);

    EndUiUpdate();

    UpdateInCallCbaL();

    }

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

// CPhoneEmergency::UpdateInCallCbaL

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

//

void CPhoneEmergency::UpdateInCallCbaL()

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::UpdateInCallCbaL() ");

    }

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

// CPhoneEmergency::HandleKeyMessageL

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

//

void CPhoneEmergency::HandleKeyMessageL(

    TPhoneKeyEventMessages aMessage,

    TKeyCode aCode )

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::HandleKeyMessageL()");

    switch ( aCode )

        {

            DisconnectEmergencyCallL();

            break;

                {

                TPhoneCmdParamInteger numberEntryCountParam;

                            &numberEntryCountParam );

                if ( neLength )

                    {

                    SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );

                    }

                else

                    {

                    CallFromNumberEntryL();

                    }

                }

            else

                {

                SendGlobalErrorNoteL( EPhoneNoteTextNotAllowed, ETrue );

                }

            break;

        default:

            {

            break;

            }

        }

    }

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

// CPhoneEmergency::HandleCommandL

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

//

TBool CPhoneEmergency::HandleCommandL( TInt aCommand )

    {

    __LOGMETHODSTARTEND(EPhoneUIStates, "CPhoneEmergency::HandleCommandL()");

    TBool commandStatus = ETrue;

    switch( aCommand )

        {

        case EPhoneInCallCmdDtmfManualQuery:

            if ( iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) == EPEStateDialing )

                {

                // Remove emergency connecting note

                iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

                }

            commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

            break;

        case EPhoneDtmfDialerExit:      // fall through

        case EPhoneDtmfDialerCancel:

             {

             if ( iStateMachine->PhoneEngineInfo()->CallState( KPEEmergencyCallId ) == EPEStateDialing )

                 {

                 UpdateSetupCbaL();

                 }

             else

                 {

                 commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

                 }

             }

             break;

        case EPhoneInCallCmdEndThisOutgoingCall:

        case EPhoneInCallCmdEndThisActiveCall:

            DisconnectEmergencyCallL();

            break;