/*

* Copyright (c) 2006-2007 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 conference call object

*

*/

//  INCLUDE FILES

#include "cconvergedcallprovider.h"

#include "ccceconferencecall.h"

#include "mccpconferencecall.h"

#include "mcceconferencecallobserver.h"

#include "cccepluginmanager.h"

#include "cccecallcontainer.h"

#include "cccecall.h"

#include "cccelogger.h"

#include "cccedurationtimer.h"

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

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

// Constructor

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

//

CCCEConferenceCall::CCCEConferenceCall(

        CCCECallContainer& aCallContainer,

        CCCEPluginManager& aPluginManager ):

        iPluginManager( aPluginManager ),

        iCallContainer( aCallContainer ),

        iCCEDurationTimer( NULL )

    {

    }

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

// Construct object

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

//

void CCCEConferenceCall::ConstructL()

    {

    iCallParameters = CCCECallParameters::NewL();

    iCCEDurationTimer = CCCEDurationTimer::NewL();

    Reset();

    }

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

// Default Symbian constructor

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

//

CCCEConferenceCall* CCCEConferenceCall::NewL(

        CCCECallContainer& aCallContainer,

        CCCEPluginManager& aPluginManager )

    {

    CCCEConferenceCall* self = new( ELeave ) CCCEConferenceCall(

        aCallContainer,

        aPluginManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CCCEConferenceCall::~CCCEConferenceCall()

    {

    Reset();

    delete iCCEDurationTimer;

    delete iCallParameters;

    }

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

// SetObserver

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

//

void CCCEConferenceCall::SetObserver(

    const MCCEConferenceCallObserver& aObserver )

    {

    CCELOGSTRING("CCCEConferenceCall::SetObserver()");

    iObserver = const_cast<MCCEConferenceCallObserver*>( &aObserver );

    if (iCCEDurationTimer)

        {

        iCCEDurationTimer->SetConferenceObserver(iObserver);

        }

    }

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

// Release()

//

// Closes conference call

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

//

TInt CCCEConferenceCall::Release()

    {

    CCELOGSTRING("CCCEConferenceCall::Release()");

    // Reset timer observer

    iCCEDurationTimer->SetObserver( NULL );

    Reset();

    return KErrNone;

    }

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

// Reset()

//

// Resets conference call

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

//

void CCCEConferenceCall::Reset()

    {

    CCELOGSTRING("CCCEConferenceCall::Reset()");

    iConferenceCaps = 1;

    iCallArray.Close();

    iState = MCCEConferenceCallObserver::ECCEConferenceIdle;

    if( iConferenceCall )

        {

        TRAP_IGNORE(iPluginManager.GetPluginL(

            iImplementationUid )->ReleaseConferenceCall( *iConferenceCall ));

        iConferenceCall = NULL;

        }

    iImplementationUid.iUid = 0; 

    iCallParameters->SetServiceId( 0 );

    if( iCCEDurationTimer )

        {

        iCCEDurationTimer->Reset();     

        }

    }

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

// State

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

//

MCCEConferenceCallObserver::TCCEConferenceCallState 

    CCCEConferenceCall::State() const

    {

    return iState;

    }

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

// ServiceId

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

//

TUint32 CCCEConferenceCall::ServiceId() const 

    {

    return iCallParameters->ServiceId();

    }

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

// ServiceId

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

//

TUid CCCEConferenceCall::ImplementationUid() const 

    {

    return iImplementationUid;

    }

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

// AddCallL( const TName& aCallName )

//

// Adds the single voice call to an existing conference call. 

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

//

void CCCEConferenceCall::AddCallL( MCCECall& aCall )

    {

    CCELOGSTRING("CCCEConferenceCall::AddCall()");

    CCCECall* call = static_cast<CCCECall*>( &aCall );

    if( !iConferenceCall )

        {

        iCallParameters->SetServiceId( call->ServiceId() );

        //This is needed for ccecallcontainer to check conf call type

        iCallParameters->SetCallType( call->CallType() );

        iImplementationUid = call->ImplementationUid();

        iConferenceCall = iPluginManager.GetPluginL(

            call->ImplementationUid() )->NewConferenceL( ServiceId(), *this );

        if(iConferenceCall)

            {

            iConferenceCall->AddCallL( &call->GetCCPCall() );

            }

        else

            {

            User::Leave( KErrBadHandle );

            }

        }

    else // Add call to current conferencecall if possible

        {

        iConferenceCall->AddCallL( &call->GetCCPCall() );

        }

    }

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

// RemoveCallL( const TName& aCallName )

//

// Removes the single voice call to an existing conference call. 

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

//

void CCCEConferenceCall::RemoveCallL( MCCECall& aCall )

    {

    CCELOGSTRING("CCCEConferenceCall::RemoveCallL()");

    CCCECall* call = static_cast<CCCECall*>( &aCall );

    if( iConferenceCall )

        {

        iConferenceCall->RemoveCallL( &call->GetCCPCall() );

        }

    else

        {

        User::Leave( KErrBadHandle );

        }

    }

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

// IsPartOfConference()

//

// Returns ETrue if aCall is part of conference 

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

//

TBool CCCEConferenceCall::IsPartOfConference( CCCECall& aCall )

    {

    CCELOGSTRING("CCCEConferenceCall::IsPartOfConference()");

    TBool ret = EFalse;

    TInt index = iCallArray.FindInAddressOrder( &aCall );

    if( index != KErrNotFound )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// SetOngoingConferenceCall()

//

// Sets plugin created conference call

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

//

TInt CCCEConferenceCall::SetOngoingConferenceCall( 

    MCCPConferenceCall& aConferenceCall, 

    TUid aImplementationUid  )

    {

    CCELOGSTRING("CCCEConferenceCall::SetOngoingConferenceCall() IN");

    TInt err(KErrInUse);

    if( !iConferenceCall )

        {

        iConferenceCall = &aConferenceCall;

        TRAP_IGNORE( iConferenceCall->AddObserverL( *this ) );

        iConferenceCaps = 

            MCCEConferenceCallObserver::KCCECapsHangUp |

            MCCEConferenceCallObserver::KCCECapsSwap;

        iImplementationUid = aImplementationUid;

        err = KErrNone;

        RPointerArray<MCCPCall> array;

        iConferenceCall->GetCallArray( array );

        for( TInt i = 0; i < array.Count(); i++ )

            {

            const CCCECall* call = iCallContainer.GetCall( array[i] );

            // Check if cce call matching to ccp call is available

            iCallParameters->SetServiceId( call->ServiceId() );

            CCELOGSTRING("CCCEConferenceCall:: Call added to conferencecall");

            }

        TInt offset(0);

        for (TInt a = 0; a < iCallArray.Count(); a++)

            {

            TInt beats = iCallArray[a]->CallDuration().Int();

            if (beats > offset)   

                {

                offset = beats;   

                }

            } 

        iCCEDurationTimer->Start(offset);

        array.Close();

        }

    CCELOGSTRING("CCCEConferenceCall::SetOngoingConferenceCall() OUT");

    return err;

    }

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

// EnumerateCalls()

//

// Returns the member count of the conference call. 

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

//

TInt CCCEConferenceCall::EnumerateCalls()

    {

    CCELOGSTRING("CCCEConferenceCall::EnumerateCalls()");

    return iCallArray.Count();

    }

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

// GetCaps()

//

// Gets the current capabilities of the conference call.

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

//

MCCEConferenceCallObserver::TCCEConferenceCallCaps CCCEConferenceCall::Caps() const

    {

    CCELOGSTRING("CCCEConferenceCall::GetCaps()");

    return (MCCEConferenceCallObserver::TCCEConferenceCallCaps)iConferenceCaps;

    }

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

// Parameters() const

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

//

const CCCPCallParameters& CCCEConferenceCall::Parameters() const

    {

    return *iCallParameters;

    }

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

// HangUp()

//

// Terminates the conference.

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

//

TInt CCCEConferenceCall::HangUp()

    {

    CCELOGSTRING("CCCEConferenceCall::HangUp()");

    iCCEDurationTimer->Stop();

    return iConferenceCall->HangUp();

    }

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

// Swap()

//

// Allows a client to switch a conference call between "Active" 

// and "Hold" states.

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

//

TInt CCCEConferenceCall::Swap()

    {

    CCELOGSTRING("CCCEConferenceCall::Swap()");

    return iConferenceCall->Swap();

    }

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

// GoOneToOneL()

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

//

void CCCEConferenceCall::GoOneToOneL( MCCECall& aCall )

    {

    CCELOGSTRING("CCCEConferenceCall::GoOneToOne()");

    CCCECall* call = static_cast<CCCECall*>( &aCall );

    iConferenceCall->GoOneToOneL( call->GetCCPCall() );

    }

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

// GetCallArray()

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

//

TInt CCCEConferenceCall::GetCallArray( RPointerArray<MCCECall>& aCallArray )

    {

    TInt err( KErrNotFound );

        {

        }

    return err;

    }

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

// ConferenceCallEventOccurred()

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

//

void CCCEConferenceCall::ErrorOccurred( const TCCPConferenceCallError aError )

    {

    CCELOGSTRING("CCCEConferenceCall::ErrorOccurred()");

    iCallContainer.ErrorOccurred( NULL, ECCPErrorGeneral );

    iObserver->ErrorOccurred( aError );

    }

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

// ConferenceCallCapsChanged()

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

//

void CCCEConferenceCall::ConferenceCallCapsChanged( 

    const TCCPConferenceCallCaps aCaps )

    {

    CCELOGSTRING2(

        "CCCEConferenceCall::ConferenceCallStateChanged() Caps = %d", aCaps );

    CapsChanged( aCaps );

    }

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

// ConferenceCallEventOccurred()

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

//

void CCCEConferenceCall::ConferenceCallStateChanged( 

    const TCCPConferenceCallState aState )

    {

    CCELOGSTRING2(

        "CCCEConferenceCall::ConferenceCallStateChanged() State = %d", aState );

    TInt offset(0);

    switch( aState )

        {

        /** The conference call is in the idle state. */

        case ECCPConferenceIdle:

            CCELOGSTRING(

                "CCCEConferenceCall::ConferenceCallStateChanged() ECCPConferenceIdle");

            iState = MCCEConferenceCallObserver::ECCEConferenceIdle;

            DeActivate();

            iObserver->CallStateChanged( 

                MCCEConferenceCallObserver::ECCEConferenceIdle );

            iCallContainer.HandleConferenceStatusChange( 

                MCCEConferenceCallObserver::ECCEConferenceIdle );

            // Stop duration timer

            iCCEDurationTimer->Stop();

            break;

        /** The conference call is in the active, connected state. */

        case ECCPConferenceActive:

            CCELOGSTRING(

                "CCCEConferenceCall::ConferenceCallStateChanged() ECCPConferenceActive");

            iState = MCCEConferenceCallObserver::ECCEConferenceActive;

            iObserver->CallStateChanged( 

                MCCEConferenceCallObserver::ECCEConferenceActive );

            iCallContainer.HandleConferenceStatusChange( 

                MCCEConferenceCallObserver::ECCEConferenceActive );

            // Start call duration timer

            for (TInt a = 0; a < iCallArray.Count(); a++)

                {

                 TInt beats = iCallArray[a]->CallDuration().Int();

                 if (beats > offset)   

                    {

                     offset = beats;   

                    }

                } 

            iCCEDurationTimer->Start(offset);

            break;

        /** The conference call is in the held, connected state. */

        case ECCPConferenceHold:

            CCELOGSTRING(

                "CCCEConferenceCall::ConferenceCallStateChanged() ECCPConferenceHold");

            iState = MCCEConferenceCallObserver::ECCEConferenceHold;

            iObserver->CallStateChanged( 

                MCCEConferenceCallObserver::ECCEConferenceHold );

            iCallContainer.HandleConferenceStatusChange( 

                MCCEConferenceCallObserver::ECCEConferenceHold );

            break;

        default:

            break;

        }

    }

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

// ConferenceCallEventOccurred()

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

//

void CCCEConferenceCall::ConferenceCallEventOccurred( 

     const TCCPConferenceCallEvent aEvent,

     MCCPCall* aReferredCall )

    {

    CCELOGSTRING2(

        "CCCEConferenceCall::ConferenceCallEventOccurred() aEvent = %d", aEvent );

    CCCECall* call = NULL;

    if( aReferredCall )

        {

        call = iCallContainer.GetCall( aReferredCall );

        }

    switch( aEvent )

        {

        /** Conference call added. TODO, do we need call pointer with this 

            notification? and a existing call pointer list of the conference?*/

        case ECCPConferenceCallAdded:

            if( call )

                {

                CCELOGSTRING(

                    "CCCEConferenceCall::ConferenceCallEventOccurred():CallAdded");

                iCallArray.InsertInAddressOrder( call );

                iObserver->CallEventOccurred( 

                    MCCEConferenceCallObserver::ECCEConferenceCallAdded, call);