/*

* Copyright (c) 2006-2008 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:  Base class of emergency call object

*

*/

//  INCLUDE FILES

#include <mccpcall.h>

#include "cconvergedcallprovider.h"

#include "mccecallobserver.h"

#include "ccceemergencycall.h"

#include "cccecallcontainer.h"

#include "ccce.h"

#include "cccelogger.h"

#include "ccceutility.h"

#include "mccpcscall.h"

#include "cccedurationtimer.h"

#include "tccecallindex.h"

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

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

// Constructor

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

//

CCCEEmergencyCall::CCCEEmergencyCall(CCCECallContainer& aCallContainer, 

                                     CCCEPluginManager& aPluginManager ):

                                     CActive(EPriorityNormal), iCallContainer(aCallContainer), 

                                     iPluginManager(aPluginManager),

                                     iCallIndex( KInvalidCallIndex )

    {

    }

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

// Construct object

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

//

void CCCEEmergencyCall::ConstructL()

    {

    CActiveScheduler::Add(this);

    iIsInProgress = EFalse;

    iExitCode = KErrNone;

    iCallParameters = CCCECallParameters::NewL();

    iCallParameters->SetCallType( CCPCall::ECallTypeCSVoice );

    iCallParameters->SetServiceId(0);

    iCCEDurationTimer = CCCEDurationTimer::NewL();

    iObserver = CCCECallObserverAsynchroniser::NewL();

    // TODO iStartTime = set starting time ...

    }

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

// Default Symbian constructor

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

//

CCCEEmergencyCall* CCCEEmergencyCall::NewL(CCCECallContainer& aCallContainer,

                                           CCCEPluginManager& aPluginManager )

    {

    CCCEEmergencyCall* self = CCCEEmergencyCall::NewLC(aCallContainer, aPluginManager);

    CleanupStack::Pop( self );

    return self;

    }

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

// Default Symbian constructor (object is left into cleanupstack)

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

//

CCCEEmergencyCall* CCCEEmergencyCall::NewLC(CCCECallContainer& aCallContainer, 

                                            CCCEPluginManager& aPluginManager )

    {

    CCCEEmergencyCall* self = new( ELeave ) CCCEEmergencyCall(aCallContainer, aPluginManager);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CCCEEmergencyCall::~CCCEEmergencyCall()

    {

    Cancel();

    delete iCCEDurationTimer;

    delete iObserver;

    delete iCallParameters;

    }

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

// Return ETrue if emergency call is in progress

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

//

TBool CCCEEmergencyCall::IsInProgress()

    {

    return iIsInProgress;

    }

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

// SetObserver( MCCECallObserver& aObserver )

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

//

void CCCEEmergencyCall::SetObserver( const MCCECallObserver& aObserver )

    {

    CCELOGSTRING("CCCEEmergencyCall::SetObserver()");

    iObserver->SetMCCECallObserver( const_cast<MCCECallObserver*>( &aObserver ));

    if ( iCCEDurationTimer )

        {

        iCCEDurationTimer->SetObserver( iObserver );

        }

    }

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

// Notify observers about call status change

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

//

void CCCEEmergencyCall::NotifyCallStatusChange( 

    CCPCall::TCallState aCallState, 

    TBool aInband, 

    CCECallEnums::TNotifyType aNotify )

    {

    CCELOGSTRING2("CCCEEmergencyCall::NotifyCallStatusChange: Status = %d", aCallState );

    iCallState = aCallState;

    if ( CCPCall::EStateConnected == aCallState )

        {

        // Start airtime duration timer

        iCallContainer.AirTimeDurationStart( NULL );

        }

    else if ( CCPCall::EStateIdle == aCallState )

        {

        // Stop airtime duration timer

        iCallContainer.AirTimeDurationStop( NULL );

        iIsInProgress = EFalse;

        iCallIndex = KInvalidCallIndex;

        }

    if ( aNotify != CCECallEnums::ENoNotify )

        {

        if ( CCPCall::EStateDialling == aCallState )

            {

            TCCECallIndex callIndex( iCallContainer );

            iCallIndex = callIndex.CurrentCallIndex();

            }

         // Notify observer immediately

        if ( aInband )

            {

            iObserver->CallStateChangedWithInband( aCallState );

            }

        else

            {

            iObserver->CallStateChanged( aCallState );

            }

        }

    iCallContainer.HandleEmergencyCallStatusChange( aNotify );

    }

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

// CActive RunL

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

//

void CCCEEmergencyCall::RunL()

    {

    if( iState == ETerminated )

        {

        CCELOGSTRING("CCCEEmergencyCall::RunL -> Emergency Terminated" );

        ReleasePlugin();

        return;

        }

    // is success?    

    if ( iStatus == KErrNone )

        {

        CCELOGSTRING("CCCEEmergencyCall::RunL -> Emergency Connected" );

        return;

        }

    else

        {

        // is retry needed or is plugin done?

        if ( iStatus != ECCPEmergencyFailed ) // error 2, retry needed:

            {

            CCELOGSTRING("CCCEEmergencyCall::RunL ->Error !ECCPEmergencyFailed -> Retry plugin!" );

            switch( iState )

                {

                case EOther:                

                    CCELOGSTRING("CCCEEmergencyCall::RunL Other Recoverable failure,trying again");

                    // release call from plugin

                    iPluginManager.GetPluginL( iEmergencyProvider )->

                        ReleaseEmergencyCall( *iEmergencyCallInUse );

                    iEmergencyCallInUse = NULL;

                    TRAP_IGNORE( iEmergencyCallInUse = iPluginManager.GetPluginL( iEmergencyProvider )->

                        NewEmergencyCallL( 0, iEmergencyNumber, *this ) );

                    if( !iEmergencyCallInUse )

                        {

                        CCELOGSTRING("CCCEEmergencyCall::RunL Recovering failled, try next plugin");

                        NextPluginL();

                        }

                    break;

                case EPrimary:

                    CCELOGSTRING("CCCEEmergencyCall::RunL Primary Recoverable failure, retrying" );

                    // in case of primary recoverable error we just ry again.     

                    break;

                }

            }

        else    // error 1, plugin done

            {

            CCELOGSTRING("CCCEEmergencyCall::RunL-> ECCPEmergencyFailed -> Try load new plugin" );

            switch( iState )

                {

                case EOther:

                    // Fallthru is intentional

                case EPrimary: 

                    iState = EOther;

                    // Find "other" plugin to be used

                    NextPluginL();

                    iCallParameters->SetCallType( CCPCall::ECallTypePS );

                    break;

                }

            }

        if ( iEmergencyCallInUse )    

            {

            SetActive();

            iStatus = KRequestPending;

            iInitializing = &iStatus;

            CCELOGSTRING("CCCEEmergencyCall::RunL Dialing.." );

            if ( !iPrimaryEmergencyCall )

                {

                // not notifed earlier

                NotifyCallStatusChange( 

                    CCPCall::EStateDialling, 

                    EFalse, CCECallEnums::ENotifyAsynchronously );

                }

            iEmergencyCallInUse->Dial( iEmergencyNumber );  

            }

        else

            {

            CCELOGSTRING("CCCEEmergencyCall::RunL Failed..." );

            // Emergency call failed. report error

            CCELOGSTRING("CCCEEmergencyCall::Inform UI..." );

            iExitCode = KErrCouldNotConnect;

            iObserver->ErrorOccurred( ECCPEmergencyFailed );

            NotifyCallStatusChange( CCPCall::EStateIdle, 

                EFalse, CCECallEnums::ENotifyAsynchronously );

            }

        }    

    }

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

// CActive RunError

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

//

TInt CCCEEmergencyCall::RunError(TInt /*aError*/)

    {

    // Emergency call failed. report error

    CCELOGSTRING("CCCEEmergencyCall::RunError" );

    iObserver->ErrorOccurred( ECCPEmergencyFailed );

    return KErrNone;

    }

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

// CActive DoCancel

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

//   

void CCCEEmergencyCall::DoCancel()

    {

    if( iInitializing )

        {

        User::RequestComplete( iInitializing, KErrCancel );

        }

    }

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

// Load next available plugin providing emergency support

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

//

void CCCEEmergencyCall::NextPluginL()

    { 

    TInt err = KErrNone;

    CCELOGSTRING("CCCEEmergencyCall::NextPluginL, checking plugin availability" );

    iAltEmergencyCallPlugins = iPluginManager.AlternativeEmergencyPlugins();

    // Primary plugin = -1

    TInt index = iAltEmergencyCallPlugins.Find( iEmergencyProvider );

     // Try next other plugin, or if out of plugins primary plugin again

    if ( iAltEmergencyCallPlugins.Count() > index+1 )

        {

        CCELOGSTRING("CCCEEmergencyCall::NextPluginL,  More plugins available!" );

        // loop plugins to find one really returning emergency object

        do

            {

            ReleasePlugin();

            index++;

            iEmergencyProvider = iAltEmergencyCallPlugins[index];

            iEmergencyCallInUse = NULL;

            TRAP( err, iEmergencyCallInUse = 

                iPluginManager.GetPluginL( iEmergencyProvider )->

                    NewEmergencyCallL( 0, iEmergencyNumber, *this ) );

            CCELOGSTRING2(

                "CCCEEmergencyCall:: Emergency call loaded err = %i", err );

            }

        while( !iEmergencyCallInUse && 

            iAltEmergencyCallPlugins.Count() > index+1 );

        }

    else

        {

        CCELOGSTRING("CCCEEmergencyCall::NextPluginL,  No more plugins available" );

        ReleasePlugin();

        }

    }

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

// Removes old plugin if was other than primary

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

//

void CCCEEmergencyCall::ReleasePlugin()

    {

    if( iEmergencyCallInUse && 

        ( iAltEmergencyCallPlugins.Find( iEmergencyProvider ) != KErrNotFound ) )

        {

        CCELOGSTRING("CCCEEmergencyCall:: Deleting previous emergency call" );

        TRAP_IGNORE( iPluginManager.GetPluginL( iEmergencyProvider )->

            ReleaseEmergencyCall( *iEmergencyCallInUse ); );

        iEmergencyCallInUse = NULL;

        }

    else if( iEmergencyCallInUse && 

        ( iEmergencyProvider == iPluginManager.PrimaryEmergencyCallUid() ) )

        {

        CCELOGSTRING("CCCEEmergencyCall:: Null emergency call" );

        iEmergencyCallInUse = NULL;

        }

    if ( iAltEmergencyCallPlugins.Find( iEmergencyProvider ) != KErrNotFound )

        {

        CCELOGSTRING("CCCEEmergencyCall:: Deleting previous emergency plugin" );

        iPluginManager.RemovePlugin( iEmergencyProvider );

        }

    }

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

// From class MCCECall.

// ?implementation_description

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

//

TInt CCCEEmergencyCall::HangUp()

    {

    CCELOGSTRING("CCCEEmergencyCall::HangUp()" );

    iAllowDisconnect = ETrue;

    TInt ret = KErrNone;

    // Inform of cancel if active request

    if( iActiveRequest != ECCENone )

        {

        iObserver->ErrorOccurred( ECCPErrorCancel );

        iActiveRequest = ECCENone;

        }

    // Cancel active object

    Cancel();

    switch( iCallState )

        {

        case  CCPCall::EStateDialling: 

            if ( iEmergencyCallInUse )

                {

                iEmergencyCallInUse->Cancel();

                }

            HandleCallStateChanged( MCCPCallObserver::ECCPStateIdle, EFalse );

            break;            

        case CCPCall::EStateConnecting:

        case CCPCall::EStateConnected:

            NotifyCallStatusChange( 

                    CCPCall::EStateDisconnecting, EFalse, CCECallEnums::ENoNotify );

            iActiveRequest = ECCEReleaseActive;

            iEmergencyCallInUse->HangUp();

            break;    

        case CCPCall::EStateDisconnecting:

            ret = KErrAlreadyExists;

            break;

        case CCPCall::EStateIdle:

            ret = KErrNotFound;

            break;

        default:

            break;

        }

    return ret;

    }

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

// From class MCCECall.

// ?implementation_description

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

//

TInt CCCEEmergencyCall::Answer()

    {

    CCELOGSTRING("CCCEEmergencyCall::Answer()");

    return KErrNotSupported;

    }

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

// Return if call is an emergency call or not.

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

//

TBool CCCEEmergencyCall::IsEmergency() const

    {

    return ETrue;

    }

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

// DialEmergencyCall( const TDesC16& /*aNumber*/ )

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

//

void CCCEEmergencyCall::DialEmergencyCall( const TDesC16& aNumber )

    {

    CCELOGSTRING("CCCEEmergencyCall::DialEmergencyCall()");

    if ( !iIsInProgress && !IsActive() )

        {

        iIsInProgress = ETrue;

        iEmergencyNumber.Zero();

        iEmergencyNumber.Copy(aNumber);

        iActiveRequest = ECCEDial;

        iAllowDisconnect = EFalse;

        iExitCode = KErrNone;

        iCallParameters->SetCallType( CCPCall::ECallTypeCSVoice );

        iCallParameters->SetServiceId(0);

        iPrimaryEmergencyCall = iPluginManager.PrimaryEmergencyCall();

        iEmergencyCallInUse = NULL;

        iEmergencyProvider = iPluginManager.PrimaryEmergencyCallUid();

        // disconnect all VoIP calls

        iCallContainer.TerminateAllVoIPCalls();

        iEmergencyCallInUse = iPrimaryEmergencyCall;

        iState = EPrimary;

        SetActive();

        iInitializing = &iStatus;

        iStatus = KRequestPending; 

        if ( iEmergencyCallInUse )

            {

            CCELOGSTRING("CCCEEmergencyCall::DialEmergencyCall() Using primary call");

            NotifyCallStatusChange( 

                    CCPCall::EStateDialling, 

                EFalse, CCECallEnums::ENotifyAsynchronously );

            iEmergencyCallInUse->Dial( iEmergencyNumber );

            }

        else // no can do

            {

            CCELOGSTRING("CCCEEmergencyCall::DialEmergencyCall() No primary call available...");

            User::RequestComplete( iInitializing, ECCPEmergencyFailed );

            }

        }

    else

        {

        CCELOGSTRING("CCCEEmergencyCall::DialEmergencyCall() Already in call!!");

        return;

        }

    }

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

// From class MCCECall.

// Close call object

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

//

TInt CCCEEmergencyCall::Release()

    {

    CCELOGSTRING("CCCEEmergencyCall::Release" );

    if( iCCEDurationTimer )

        {

        iCCEDurationTimer->Reset();     

        }

    iObserver->SetMCCECallObserver( NULL );

    return KErrNone;

    }

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