/*

* 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 call object

*

*/

//  INCLUDE FILES

#include "cccecall.h"

#include <exterror.h>                // GSM error codes

#include <gsmerror.h>

#include <etelmm.h>

#include <ccpdefs.h>

#include <featmgr.h>

#include "mccptransferprovider.h"

#include "mccpcall.h"

#include "mccecallobserver.h"

#include "ccce.h"

#include "cccelogger.h"

#include "ccceutility.h"

#include "cccedurationtimer.h"

#include "mccpcscall.h"

#include "cccecallcontainer.h"

#include "cccetransfercontroller.h"

#include "ccceconferencecall.h"

#include "mccpforwardprovider.h"

#include "cccecallobserverasynchroniser.h"

#include "tccecallindex.h"

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

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

// Constructor

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

//

CCCECall::CCCECall( CCCECallContainer& aCallContainer, TInt aCallId ) :

    iCallId( aCallId ),

    iCallContainer( aCallContainer ),

    iCallIndex( KInvalidCallIndex )

    {

    Reset();

    }

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

// Construct object

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

//

void CCCECall::ConstructL()

    {

    FeatureManager::InitializeLibL();

    iCCEDurationTimer = CCCEDurationTimer::NewL();

    iObserver = CCCECallObserverAsynchroniser::NewL();

    }

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

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

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

//

CCCECall* CCCECall::NewLC( CCCECallContainer& aCallContainer, TInt aCallId )

    {

    CCCECall* self = new( ELeave ) CCCECall( aCallContainer, aCallId );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CCCECall::~CCCECall()

    {

    Reset();

    delete iCCEDurationTimer;

    delete iObserver;

    delete iCallParameters;

    }

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

// SetObserver( MCCECallObserver& aObserver )

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

//

void CCCECall::SetObserver( const MCCECallObserver& aObserver )

    {

    CCELOGSTRING2("id:%d CCCECall::SetObserver()", iCallId);

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

    if (iCCEDurationTimer)

        {

        iCCEDurationTimer->SetObserver( iObserver );

        }

    }

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

// SetConvergedCall( MCCPCall* aCall )

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

//

void CCCECall::SetConvergedCallL( MCCPCall* aCall, 

                                 TUid aImplementationUid,

                                 TBool aTransferred )

    {

    CCELOGSTRING2("id:%d CCCECall::SetConvergedCall():IN", iCallId);

    iCall = aCall;

    iImplementationUid = aImplementationUid;

    delete iCallParameters;

    iCallParameters = NULL;

    iCallParameters = aCall->Parameters().CloneL();

    // This object is now in use

    CCELOGSTRING3("id:%d CCCECall::SetConvergedCall: CallId = %d", iCallId, iCallId);

    // Reserve call id for this call

    // If this is transferred call then call id has been already reserved

    if( !aTransferred )

        {

        iCallContainer.ReserveCallInfoCallId( iCallId );    

        }

    CCELOGSTRING2("id:%d CCCECall::SetConvergedCall: CallId reserved", iCallId);

    // Set call direction

    if( aCall->IsMobileOriginated() ) 

        {

        CCELOGSTRING2("id:%d CCCECall::SetConvergedCall:Mobile originated call", iCallId);

        iCallDirection = CCPCall::EMobileOriginated;

        }

    else

        {

        CCELOGSTRING2("id:%d CCCECall::SetConvergedCall():Mobile terminated call", iCallId);

        if ( !aTransferred )

            {

            iCallState  = CCPCall::EStateRinging;

            }

        iCallDirection = CCPCall::EMobileTerminated;

        aCall->AddObserverL(*this);

        }

    TRAP_IGNORE( iTransferProvider = iCall->TransferProviderL(*this) );

    TRAP_IGNORE( iForwardProvider = iCall->ForwardProviderL(*this) );

    CCELOGSTRING2("id:%d CCCECall::SetConvergedCall():OUT", iCallId);

    }

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

// Returns implementationuid

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

//

const TUid CCCECall::ImplementationUid() const

    {

    return iImplementationUid;

    }

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

// From base class MCCECallInfo

// Returns direction of the call

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

//

CCPCall::TCallDirection CCCECall::Direction() const

    {

    return iCallDirection;

    }

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

// From base class MCCECallInfo

// Returns the type of the call

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

//

CCPCall::TCallType CCCECall::CallType() const

    {

    if ( iCallParameters )

        {

        return iCallParameters->CallType();

        }

    return CCPCall::ECallTypeCSVoice;

    }

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

// From base class MCCECallInfo, MCCECall

// Returns the index of the call

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

//

TInt CCCECall::CallIndex() const

    {

    return iCallIndex;

    }

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

// ServiceId

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

//

TUint32 CCCECall::ServiceId() const 

    {

    if( iCall )

        {

        return iCall->Parameters().ServiceId(); 

        }

    return 0;

    }

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

// Return ETrue if this call object is in use

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

//

TBool CCCECall::IsInUse() const

    {

    CCELOGSTRING3("id:%d CCCECall::IsInUse() %d", iCallId, ( iCall != NULL ) );

    return ( iCall != NULL );

    }

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

// Return ETrue if this calls secure status can be specified

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

//

TBool CCCECall::SecureSpecified() const

    {

    return iCall->SecureSpecified();

    }

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

// Return ETrue if this call object is secured

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

//

TBool CCCECall::IsSecured() const

    {

    return iCall->IsSecured();

    }

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

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

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

//

TBool CCCECall::IsEmergency() const

    {

    return EFalse;

    }

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

// CCCECall::RemoteParty

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

//

const TDesC& CCCECall::RemoteParty() const

    {

    if( iCall )

        {

        return iCall->RemoteParty();

        }

    return KNullDesC;

    }

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

// CCCECall::RemotePartyName

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

//

const TDesC& CCCECall::RemotePartyName() const

    {

    if( iCall )

        {

        return iCall->RemotePartyName();

        }

    return KNullDesC;

    }

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

// CCCECall::DialledParty

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

//

const TDesC& CCCECall::DialledParty() const

    {

    if( iCall )

        {

        return  iCall->DialledParty();

        }

    return KNullDesC;

    }

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

// Return current active request

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

//

CCCECall::TCallRequest CCCECall::Request() const

    {

    return iActiveRequest;

    }

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

// Returns reference to converged call provider call object

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

//

MCCPCall& CCCECall::GetCCPCall() const

    {

    return *iCall;

    }

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

// CallId()

// Returns ID of the call

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

//

TInt CCCECall::CallId() const

    {

    return iCallId;

    }

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

// From class MCCECall.

// Hold()

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

//

TInt CCCECall::Hold()

    {

    CCELOGSTRING2( "id:%d CCCECall::Hold() ", iCallId);

    TInt error = KErrNone;

    if( iCallState != CCPCall::EStateConnected )

        {

        if( iCallState == CCPCall::EStateHold )

            {

            error = KErrAlreadyExists;

            }

        else

            {

            error = KErrNotReady;

            }

        }

    else

        {

        iActiveRequest = ECCEHold;

        error = iCall->Hold();

        }

    return error;

    }

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

// From class MCCECall.

// Resume()

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

//

TInt CCCECall::Resume()

    {

    CCELOGSTRING2( "id:%d CCCECall::Resume()", iCallId );

    TInt error = KErrNone;

    if( iCallState != CCPCall::EStateHold )

        {

        if( iCallState == CCPCall::EStateConnected )

            {

            error = KErrAlreadyExists;

            }

        else

            {

            error = KErrNotReady;

            }

        }

    else

        {

        iActiveRequest = ECCEResume;

        error = iCall->Resume();

        }

    return error;

    }

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

// From class MCCECall.

// HangUp()

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

//

TInt CCCECall::HangUp()

    {

    CCELOGSTRING3("id:%d CCCECall::HangUp() callstate = %d", iCallId, iCallState);

    TInt error = KErrNone;

    // Inform that currently ongoing request is canceled

    if( iActiveRequest != ECCENone &&

        iActiveRequest != ECCEReleaseActive &&

        iActiveRequest != ECCEReleaseHeld &&

        iActiveRequest != ECCEReleaseOutgoing &&

        iActiveRequest != ECCETerminateDisconnected )

        {

        RequestComplete( ECCPErrorCancel );

        }

    switch(iCallState)

        {

        case CCPCall::EStateDialling:

            CCELOGSTRING2("id:%d CCCECall::HangUp(): DialCancel: Cancel", iCallId);

            iActiveRequest = ECCEReleaseOutgoing;

            error = iCall->Cancel();

            RequestComplete( ECCPErrorNone );

            CallStateChanged( MCCPCallObserver::ECCPStateIdle, EFalse );

            break;

        case CCPCall::EStateConnecting:

            CCELOGSTRING2("id:%d CCCECall::HangUp(): DialCancel: HangUp", iCallId);

            iActiveRequest = ECCEReleaseOutgoing;

            NotifyCallStatusChange( 

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

            error = iCall->HangUp();

            break;

        case CCPCall::EStateAnswering:

        case CCPCall::EStateRinging:

        case CCPCall::EStateQueued:

            CCELOGSTRING2("id:%d CCCECall::HangUpL: Reject", iCallId);

            iActiveRequest = ECCERejectIncoming;

            // Set exitcode to rejected to avoid 

            // missed call notification

            iExitCode = ECCPErrorRejected;

            NotifyCallStatusChange( 

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

            error = iCall->Reject();

            break;

        case CCPCall::EStateDisconnecting: 

            if( ECCETerminateDisconnected != iActiveRequest &&

                ECCEReleaseOutgoing != iActiveRequest )

                {

                RequestComplete( ECCPErrorNone );

                iActiveRequest = ECCETerminateDisconnected;

                error = iCall->HangUp();

                }

            else 

                {

                error = KErrGeneral;  

                }   

            break;

        case CCPCall::EStateIdle:

            error = KErrAlreadyExists;

            break;

        case CCPCall::EStateHold:

            iActiveRequest = ECCEReleaseHeld;

            iCCEDurationTimer->Stop();

            NotifyCallStatusChange( 

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

            error = iCall->HangUp();

            break;

        case CCPCall::EStateConnected:

            iActiveRequest = ECCEReleaseActive;

            iCCEDurationTimer->Stop();

            NotifyCallStatusChange( 

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

            error = iCall->HangUp();

            break;

        default:

            CCCEUtility::Panic( ECCEPanicInvalidState ); 

            break;

        }

    // If hangup was completed successfully, change

    // call status to disconnecting. This must be done

    // because if hangup was caused by replace -command

    // and in that case AnswerIncomingCall is called right

    // after hangup. If call is not changed to disconnecting

    // state, ResumeAutomaticallyHeldCall would try to

    // resume this call and it causes error.

    return error;

    }

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

// Swap()

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

//

TInt CCCECall::Swap()

    {

    CCELOGSTRING2( "id:%d CCCECall::Swap()", iCallId );

    TInt error = KErrNone;

    // if there is other CSProvider call use swap instead of Hold

    if ( ( iImplementationUid == KCSProviderUid || 

           iImplementationUid == KVCCProviderUid ) && 

         ( IsCsPlugin() ) && 

           1 < iCallContainer.CountCsCalls( iImplementationUid ) )

        {

        error = iCall->Swap();

        }

    else if( iCallState == CCPCall::EStateConnected )

        {

        // Swapping starts - 1.phase

        error = HoldNoNotify();

        }

    else

        {

        error = KErrNotReady;

        iActiveRequest = ECCENone;

        }

    if( !error )

        {

        // Everything went ok

        iActiveRequest = ECCESwap;

        }

    return error;

    }