/*

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

                {

                TPhoneCmdParamBoolean isProgressNoteVisible;

                iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsProgressNoteVisible,

                      &isProgressNoteVisible );

                if ( !isProgressNoteVisible.Boolean() )

                    {

                    UpdateSetupCbaL();

                    }

                 }

            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 ( iOnScreenDialer && IsDTMFEditorVisibleL() )

        {

        CloseDTMFEditorL();

        }

    if ( aCallId == KEmergencyCallId )

        {

        iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveCallHeader, aCallId );

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

                {

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

                TPhoneCmdParamBoolean securityMode;

                iViewCommandHandle->ExecuteCommandL( EPhoneViewGetSecurityModeStatus, &securityMode );

                if ( !securityMode.Boolean() )

                    {

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

        {

        if ( !IsSimOk() )

            {

            TPhoneCmdParamBoolean visibleMode;

            visibleMode.SetBoolean( ETrue );

            iViewCommandHandle->ExecuteCommandL( EPhoneViewSetStatusPaneVisible, &visibleMode );

            }

        iDeviceLockOn = IsAutoLockOn();

        // Close menu bar, if it is displayed

        iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

        // Disable global notes when the phone is dialling

        TPhoneCmdParamBoolean globalNotifierParam;

        globalNotifierParam.SetBoolean( ETrue );

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewSetGlobalNotifiersDisabled,

            &globalNotifierParam );

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

        TPhoneCmdParamBoolean booleanParam;

        booleanParam.SetBoolean( !TopAppIsDisplayedL() );

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewSetNeedToSendToBackgroundStatus,

            &booleanParam );

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

        BeginUiUpdateLC();

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

        StringLoader::Load(

            headerText,

            CPhoneMainResourceResolver::Instance()->ResolveResourceID(

                    EPhoneAttemptingEmergencyText ),

            CCoeEnv::Static() );

        headerParam.SetLabelText( headerText );

        iViewCommandHandle->ExecuteCommandL(

            EPhoneViewUpdateBubble,

            aCallId,

            &headerParam );

        SetTouchPaneButtons( EPhoneEmergencyCallButtons );

        SetBackButtonActive(EFalse);

        EndUiUpdate();        

        // ShowNoteL( EPhoneEmergencyConnectWaitNote );

        UpdateSetupCbaL();

        }

    }

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

// CPhoneEmergency::HandleConnectingL

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

//

void CPhoneEmergency::HandleConnectingL( TInt aCallId )

    {

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

    iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveGlobalNote );

    // Re-enable global notes

    TPhoneCmdParamBoolean globalNotifierParam;

    globalNotifierParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

        &globalNotifierParam );

    iViewCommandHandle->ExecuteCommandL( EPhoneViewSetEikonNotifiersDisabled,

          &globalNotifierParam );

    if(  TouchCallHandlingSupported() )

        {

        if ( !IsSimStateNotPresentWithSecurityModeEnabled() )

            {

            // Stop capturing keys

            CaptureKeysDuringCallNotificationL( EFalse );

            }

        }

    else if ( !iDeviceLockOn && SimState() == EPESimUsable )

        {

        // Stop capturing keys

        CaptureKeysDuringCallNotificationL( EFalse );

        }

    // Keep Phone in the foreground

    TPhoneCmdParamBoolean booleanParam;

    booleanParam.SetBoolean( EFalse );

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewSetNeedToSendToBackgroundStatus, &booleanParam );

    // Remove emergency connecting note

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

    // Notify the view

    iViewCommandHandle->ExecuteCommandL(

        EPhoneViewUpdateBubble,

        aCallId,

        &emergencyHeaderParam );

    SetBackButtonActive(ETrue);

    EndUiUpdate();

    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;