/*

* 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:  class of call objects

*

*/

//  INCLUDE FILES

#include "cccecallcontainer.h"

#include "mccpcall.h"

#include "mccpcscall.h"

#include "mcceobserver.h"

#include "mccessobserver.h"

#include "cccecall.h" 

#include "cccelogger.h"

#include "ccceutility.h"

#include "ccceconferencecall.h"

#include "ccceemergencycall.h"

#include "cccedtmf.h"

#include "cccetransfercontroller.h"

#include "cconvergedcallprovider.h"

#include "ccceextension.h"

#include "cccepluginmanager.h"

#include "cccedurationtimer.h"

#include "cccecallinfomediator.h"

#include <featmgr.h>

//CONSTANTS

const TInt KCSServiceId = 1;

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

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

// Constructor

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

//

CCCECallContainer::CCCECallContainer( MCCEObserver& aObserver ): iMCCEObserver(&aObserver)

    {

    // Initialize callinfo call ids

    for ( TInt i = 0; i < KCCECallObjects; i++ )

        {

        iCallInfoCallId[ i ] = KErrNotFound;

        }

    }

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

// Construct object

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

//

void CCCECallContainer::ConstructL()

    {

    iCallStateMediator = CCCECallInfoMediator::NewL( *this );

    CreateCallDataArraysL();

    iTransferController = CCCETransferController::NewL( *this );

    iPluginManager = CCCEPluginManager::NewL( *this, *iTransferController );

    iEmergencyCall =  CCCEEmergencyCall::NewL(*this, *iPluginManager);

    iPluginManager->SetEmergencyCallObserver(*iEmergencyCall);

    iExtension = CCCEExtension::NewL(*iPluginManager );

    iConferenceCall = CCCEConferenceCall::NewL( *this, *iPluginManager );

    if( iMCCEObserver )

        {

        iPluginManager->SetObserver(*iMCCEObserver);

        }

    // AirTime Timer

    iCSDuration = CCCEDurationTimer::NewL();

    iPSDuration = CCCEDurationTimer::NewL();

    iIdle = CIdle::NewL( CActive::EPriorityIdle );

    }

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

// Default Symbian constructor

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

//

CCCECallContainer* CCCECallContainer::NewL( MCCEObserver& aObserver )

    {

    CCCECallContainer* self = new( ELeave ) CCCECallContainer(aObserver);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CCCECallContainer::~CCCECallContainer()

    {

    delete iConferenceCall;

    delete iEmergencyCall;

    delete iDtmf;

    delete iExtension;

    delete iPluginManager;

    delete iTransferController;

    if( iCallArray )

        {

        iCallArray->ResetAndDestroy();

        delete iCallArray;

        }

    delete iCallStateMediator;

    iCallstoRelease.Reset();

    iCallstoRelease.Close();

    delete iCSDuration;

    delete iPSDuration;

    if( iIdle )

        {

        iIdle->Cancel();

        delete iIdle;

        }

    FeatureManager::UnInitializeLib();

    }

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

// SetObserver()

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

//

void CCCECallContainer::SetObserver( MCCEObserver& aObserver, MCCESsObserver& aSsObserver )

    {

    iMCCEObserver = &aObserver;

    iMCCESsObserver = &aSsObserver;

    iPluginManager->SetObserver(aObserver );

    }

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

// Create call objects

// CS objects are located in the beginning of array and VoIP objects after those

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

//

void CCCECallContainer::CreateCallDataArraysL()

    {

    CCCECall* call = NULL;

    TInt callIndex = 0;

    iCallArray = new ( ELeave ) CArrayPtrFlat<CCCECall>( KCCECallObjects );

    for( callIndex = 0; callIndex < KCCECallObjects; callIndex++ )

        {

        call = CCCECall::NewLC( *this, callIndex );

        iCallArray->AppendL( call );

        CleanupStack::Pop( call );

        }

    }

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

// Swap PS and CS air duration timers

// Is called after handover, when call type has changed

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

//

void CCCECallContainer::AirTimeDurationSwap(

                           const CCPCall::TCallType aNewCallType)

    CCELOGSTRING("CCCECallContainer::AirTimeDurationSwap(): IN");

    CCCECall* call = NULL;

    TInt calls(0);

    for ( TInt i = 0; i < KCCECallObjects; i++ )

        {

        call = GetCall( i );

        if ( call->State() == CCPCall::EStateConnected ||

             call->State() == CCPCall::EStateHold  )

            {

            calls ++;

            }

        }

    if( CCPCall::EStateConnected == iEmergencyCall->State() )

        {

        calls ++;

        }

    if( 1 == calls )

    CCELOGSTRING("CCCECallContainer::AirTimeDurationSwap(): OUT");

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

// AirTimeDurationStop()

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

//

void CCCECallContainer::AirTimeDurationStop( CCCECall* /*aCall*/ ) const

    {

    CCELOGSTRING("CCCECallContainer::AirTimeDurationStop(): IN");

    CCCECall* call = NULL;

    TInt csCalls=0;

    TInt psCalls=0;

    // Check if any other calls    

    for ( TInt i = 0; i < KCCECallObjects; i++ )

        {

        call = GetCall( i );

        if ( call->State() == CCPCall::EStateConnected ||

             call->State() == CCPCall::EStateHold  )

            {           

            if ( IsCsPlugin( call, EFalse ) )

                {

                csCalls++;

                CCELOGSTRING2("   AirTimeDurationStop() csCalls=%d ", csCalls);

                }

            // ps call found

            else

                {

                psCalls++;

                CCELOGSTRING2("   AirTimeDurationStop() psCalls=%d ", psCalls);

                }

            }

        }

    if( CCPCall::EStateConnected == iEmergencyCall->State() )

        {

        if(  CCPCall::ECallTypePS == iEmergencyCall->Parameters().CallType() )

            {

            psCalls++;

            }

        else

            {

            csCalls++;

            }

        }

    // No other cs calls found

    if( !csCalls )

        {

        CCELOGSTRING("   AirTimeDurationStop() stop CS timer");

        iCSDuration->Stop();

        }

    // No other ps calls found

    if( !psCalls )

        {

        CCELOGSTRING("   AirTimeDurationStop() stop PS timer");

        iPSDuration->Stop();

        }

    CCELOGSTRING("CCCECallContainer::AirTimeDurationStop(): IN");

    }

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

// AirTimeDurationStart()

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

//

void CCCECallContainer::AirTimeDurationStart( CCCECall* /*aCall*/ ) const

    {

    CCELOGSTRING("CCCECallContainer::AirTimeDurationStart(): IN");

    CCCECall* call = NULL;

    TInt csCalls=0;

    TInt psCalls=0;

    // Check if any other calls    

    for ( TInt i = 0; i < KCCECallObjects; i++ )

        {

        call = GetCall( i );

        if ( call->State() == CCPCall::EStateConnected ||

             call->State() == CCPCall::EStateHold  )

            if ( IsCsPlugin( call, EFalse ) )

                {

                csCalls++;

                CCELOGSTRING2("   AirTimeDurationStart() csCalls=%d ", csCalls);

                }

            // ps call found

            else

                {

                psCalls++;

                CCELOGSTRING2("   AirTimeDurationStart() pscalls=%d ", psCalls);

                }

            }

        }

    if( CCPCall::EStateConnected == iEmergencyCall->State() )

        {

        if(  CCPCall::ECallTypePS == iEmergencyCall->Parameters().CallType() )

            {

            psCalls++;

            }

        else

            {

            csCalls++;

            }

        }

    // No other cs calls found

    if( csCalls )

        {

        iCSDuration->StartAirTimeDuration();

        }

    // No other ps calls found

    if( psCalls )

        {

        iPSDuration->StartAirTimeDuration();

        }

    CCELOGSTRING("CCCECallContainer::AirTimeDurationStart(): OUT");

    }

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

// From base class MCCECallArray

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

//

MCCECallInfo* CCCECallContainer::EmergencyCallInfo() const

    {

    return iEmergencyCall;

    }

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

// From base class MCCECallArray

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

//

MCCECallInfo* CCCECallContainer::CallInfo( TInt aIndex ) const  

    {

    return iCallArray->At( aIndex );

    }

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

// From base class MCCECallArray

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

//  

TInt CCCECallContainer::MaxNumberOfCalls() const

    {

    return iCallArray->Count();

    }

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

// Add calls to be removed, and start releasing if not already running

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

//

void CCCECallContainer::ScheduleReleaseCall( MCCPCall& aCalltoRemove, const TUid aUid )

    {

    TCallReleaseEntry entry;

    entry.iCallToRelease = &aCalltoRemove;

    entry.iUid = aUid;

    if (!iIdle->IsActive())

        {

        iIdle->Start( TCallBack(ReleaseCalls,this) );

        }

    }

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

// Callback to CIdle class to actually release calls

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

// 

TInt CCCECallContainer::ReleaseCalls( TAny* aCallContainer )

    {

    CCCECallContainer* container = 

        static_cast< CCCECallContainer* >( aCallContainer );

        container->DoReleaseCalls();

    return KErrNone;

    }

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

// Callback to CIdle class to actually release calls

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

//     

void CCCECallContainer::DoReleaseCalls()

    {

    CCELOGSTRING("CCCECallContainer::DoReleaseCalls()")

    while( iCallstoRelease.Count() > 0 )

        {

        CConvergedCallProvider* plugin = NULL;

        TUid pluginUid = iCallstoRelease[0].iUid;

        TRAP_IGNORE( plugin = iPluginManager->GetPluginL( pluginUid ) );

        if( plugin )

            {

            // release call

            plugin->ReleaseCall( *iCallstoRelease[0].iCallToRelease );

            // first check can we indicate plugin release

            if( !iEmergencyCall->IsInProgress() &&

                iPluginManager->ReleaseWhenIdle( pluginUid ) &&

                pluginUid != iConferenceCall->ImplementationUid() )

                {

                // 2nd step

                if( 0 == CountCalls( pluginUid ) )

                    {

                    TBool releasePlugin = ETrue;

                    // and last test

                    if( 1 < iCallstoRelease.Count() )

                        {

                        for( TInt a = 1; a < iCallstoRelease.Count(); a++ )

                            {

                            if( iCallstoRelease[a].iUid == pluginUid )

                                {

                                releasePlugin = EFalse;

                                }

                            }

                        }

                    if( releasePlugin )

                        {

                        iPluginManager->RemovePlugin( pluginUid );

                        }

                    }

                }

            }

        iCallstoRelease.Remove(0);

        }

    };

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

// ConferenceCallL()

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

//

CCCEConferenceCall& CCCECallContainer::ConferenceCallL( 

    const MCCEConferenceCallObserver& aObserver )

    {

    if( iConferenceCall )

        {

        iConferenceCall->SetObserver( 

            const_cast<MCCEConferenceCallObserver&>( aObserver ) );

        }

    else

        {

        iConferenceCall = CCCEConferenceCall::NewL( *this, *iPluginManager );

        iConferenceCall->SetObserver( 

            const_cast<MCCEConferenceCallObserver&>( aObserver ) );

        }

    return *iConferenceCall;

    }

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

// ConferenceCall()

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

//

CCCEConferenceCall& CCCECallContainer::ConferenceCall() const

    {

    return *iConferenceCall;

    }

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

// DtmfInterfaceL()

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

//

CCCEDtmf& CCCECallContainer::DtmfInterfaceL( 

    const MCCEDtmfObserver& aObserver )

    {

    if( iDtmf )

        {

        iDtmf->SetObserver( aObserver );

        }

    else

        {

        iDtmf = CCCEDtmf::NewL( *this, *iPluginManager );

        iDtmf->AddObserverL( aObserver );

        }

    return *iDtmf;

    }

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

// ExtensionInterfaceL()

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

// 

MCCEExtensionInterface& CCCECallContainer::ExtensionInterfaceL(

        const MCCEExtensionObserver& aObserver )

    {

    if( iExtension )

        {

        iExtension->AddObserverL( aObserver );

        }

    else

        {

        iExtension = CCCEExtension::NewL(*iPluginManager );

        iExtension->AddObserverL( aObserver ); 

        }

    return *iExtension;

    }

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

// GetNextFreeCall()

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

//

CCCECall* CCCECallContainer::GetNextFreeCall() const

    {

    CCCECall* call = NULL;

    if ( !iEmergencyCall->IsInProgress())

        {

        for (TInt i = 0; i < KCCECallObjects; i++ )

            {

            call = GetCall( i );

            if ( !call->IsInUse() )

                {