/*

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

                {

                TPhoneCmdParamBoolean isNoteVisible;

                iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsNoteVisible,

                      &isNoteVisible );

                if ( !isNoteVisible.Boolean() )

                    {

                    ShowNoteL( EPhoneEmergencyConnectWaitNote );

                    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

    if ( iOnScreenDialer && IsDTMFEditorVisibleL() )

        {

        CloseDTMFEditorL();

        }

    if ( aCallId == KEmergencyCallId )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId );

        // Make sure that toolbar is not shown any more

        iViewCommandHandle->ExecuteCommandL( EPhoneViewHideToolbar );

        // Remove emergency connecting note if still there

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

        // Close menu bar, if it is displayed

        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

        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() || iStateMachine->SecurityMode()->IsAutolockEnabled() )

                {

                // Continue displaying current app but set up the

                // idle screen in the background

                SetupIdleScreenInBackgroundL();

                // Update toolbar

                iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateToolbar );

                }

            else if ( iOnScreenDialer && IsNumberEntryContentStored() )

                {

                if ( !IsNumberEntryUsedL() )

                    {

                    CreateNumberEntryL();

                    }

                // Restore the number entry content from cache

                RestoreNumberEntryContentL();

                SetNumberEntryVisibilityL(ETrue);

                }

            else if ( IsNumberEntryUsedL() )

                {

                // Show the number entry if it exists

                SetNumberEntryVisibilityL(ETrue);

                // Update toolbar

                iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateToolbar );

                }

            else

                {

                 // Display idle screen

                DisplayIdleScreenL();

                }

            // Display call termination note, if necessary

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

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

                    {

                    // Setup idle as next active app.

                    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 )

        {

            {

            TPhoneCmdParamBoolean visibleMode;

            visibleMode.SetBoolean( ETrue );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewSetStatusPaneVisible, &visibleMode );

            }

        // Close menu bar, if it is displayed

        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

        // Dim toolbar items

        SetToolbarDimming( ETrue );

        // Request that dimmed toolbar is visible.

        // Do it already here. Otherwice a white/black toolbar area is shortly shown and

        // a white screen can be a result when touching it.

        iViewCommandHandle->HandleCommandL( EPhoneViewShowToolbar );

        // Disable global notes when the phone is dialling

        // Capture keys when the phone is dialling

        CaptureKeysDuringCallNotificationL( ETrue );

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

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

        // Bring Phone app in the foreground

        TPhoneCmdParamInteger uidParam;

        uidParam.SetInteger( KUidPhoneApplication.iUid );

        iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,

            &uidParam );

        // Set Phone as the top application

        iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,

            &uidParam );

        // Hide the number entry if it is visible

        if ( IsNumberEntryUsedL() )

            {

            // Remove number entry

            iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNumberEntry );

            }

        // Remove exit emergency mode query, if it exists

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveQuery );

        // Enable the volume display

        iViewCommandHandle->ExecuteCommandL( EPhoneViewShowNaviPaneAudioVolume );

        SetTouchPaneButtons( EPhoneEmergencyCallButtons );

        ShowNoteL( EPhoneEmergencyConnectWaitNote );

        UpdateSetupCbaL();

        }

    }

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

// CPhoneEmergency::HandleConnectingL

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

//

void CPhoneEmergency::HandleConnectingL( TInt aCallId )

    {

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

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveGlobalNote );

    // Re-enable global notes

    if(  TouchCallHandlingSupported() )

        {

        if ( !IsSimStateNotPresentWithSecurityModeEnabled() )

            {

            // Stop capturing keys

            CaptureKeysDuringCallNotificationL( EFalse );

            }

        }

    else if ( !iStateMachine->SecurityMode()->IsAutolockEnabled() && SimState() == EPESimUsable )

        {

        // Stop capturing keys

        CaptureKeysDuringCallNotificationL( EFalse );

        }

    // Remove emergency connecting note

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveNote );

    TPhoneCmdParamEmergencyCallHeaderData emergencyHeaderParam;

    // Set call header

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

    // Notify the view

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewUpdateBubble,

        aCallId,

        &headerParam );

    UpdateInCallCbaL();

    }

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

// CPhoneEmergency::HandleConnectedL

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

//

void CPhoneEmergency::HandleConnectedL( TInt aCallId )

    {

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

    TPhoneCmdParamCallHeaderData emergencyHeaderParam;

    emergencyHeaderParam.SetCallState( EPEStateConnected );

    // Notify the view

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewUpdateBubble,

        aCallId,

        &emergencyHeaderParam );

    SetToolbarDimming( ETrue );

    UpdateInCallCbaL();

    }

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

// CPhoneEmergency::OpenMenuBarL

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

//

void CPhoneEmergency::OpenMenuBarL()

    {

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

    TInt resourceId;

    if ( iOnScreenDialer && IsDTMFEditorVisibleL() )

        {

        resourceId = EPhoneDtmfDialerMenubar;

        }

    else if ( IsNumberEntryVisibleL() )

        {

        resourceId = EPhoneCallHandlingEmergencyMenubarWithNumberEntry;

        }

    else

        {

        resourceId = EPhoneCallHandlingEmergencyMenubar;

        }

    TPhoneCmdParamInteger integerParam;

    integerParam.SetInteger(

        CPhoneMainResourceResolver::Instance()->

        ResolveResourceID( resourceId ) );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarOpen,

        &integerParam );

    }