/*

* 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:  Implementation for call object container

*

*/

#ifndef CCCECALLCONTAINER_H

#define CCCECALLCONTAINER_H

#include <e32base.h>

#include "ccpdefs.h"

#include "mccecallobserver.h"           // TCCECallState

#include "mcceconferencecallobserver.h" // TCCEConferenceCallState

#include "ccce.h"                       // CCCECallParameters

#include "mccecallarray.h"

#include "ccecallenums.h"

class CCCE;

class CCCEDtmf;

class CCCECall;

class CCCEDurationTimer;

class CCCEConferenceCall;

class CCCEPluginManager;

class MCCEConferenceCallObserver;

class MCCEDtmfObserver;

class MCCPCall;

class CConvergedCallProvider;

class CCCEExtension;

class MCCESsObserver;

class MCCECallInfo;

class CCCECallInfoMediator;

// UID of CSPlugin

const TUid KCSProviderUid = { 0x102828E5 }; 

const TUid KVCCProviderUid = { 0x2000CFAA }; 

/**

 *  Container

 *

 *  This object contains normal calls, emergency call and conference call.

 *  Also Dtmf and extension interfaces are located here.

 *  

 *  Multicall situations are also handled here.

 *  

 *  @lib cce.dll

 *  @since S60 v3.2

 */

NONSHARABLE_CLASS(CCCECallContainer) : public CBase, public MCCECallArray

    {

public:

    /**

     * Two-phased constructor.

     * @param aObserver Reference to observer

     */

    static CCCECallContainer* NewL( MCCEObserver& aObserver );

    /**

     * Destructor.

     */

    virtual ~CCCECallContainer();

public: 

    /** @see CCCE::SetObserver */

    void SetObserver( MCCEObserver& aObserver, MCCESsObserver& aSsObserver );

    /** @see CCCE::OpenNewCallL */

    MCCECall& OpenNewCallL( const TDesC& aAddress,

         const CCCECallParameters& aCallParameters,

         const MCCECallObserver& aCallObserver );

    /** @see CCCE::ConferenceCallL */

    CCCEConferenceCall& ConferenceCallL(

        const MCCEConferenceCallObserver& aObserver );

    /** @see CCCE::EmergencyCall */

    MCCECall& EmergencyCall( const MCCECallObserver& aCallObserver );

    /** @see CCCE::GetAirTimeDuration */

    void GetAirTimeDuration( TTimeIntervalSeconds& aCSDuration, 

        TTimeIntervalSeconds& aPSDuration);

    /** @see CCCE::DtmfInterfaceL */

    CCCEDtmf& DtmfInterfaceL(

        const MCCEDtmfObserver& aObserver );

    /** @see CCCE::ExtensionInterfaceL */

    MCCEExtensionInterface& ExtensionInterfaceL(

        const MCCEExtensionObserver& aObserver );

    /**

     * Get call which isnt in use.

     *

     * @since S60 v3.2

     * @return Found call, NULL if none is found.

     */

    CCCECall* GetNextFreeCall() const;

    /**

     * Get call with specific id.

     *

     * @since S60 v3.2

     * @param aCallId Specifies which call is returned

     * @return Found call, NULL if none is found.

     */

    CCCECall* GetCall( TInt aCallId ) const;

    /**

     * This is called from cccecall.cpp when it is taken in use.

     *

     * @since S60 v3.2

     * @param aCallId CallId to be reserved

     */

    void ReserveCallInfoCallId( TInt aCallId );

    /**

     * This is called from cccecall.cpp when it is removed from use.

     *

     * @since S60 v3.2

     * @param aCallId CallId to be released

     */

    void ReleaseCallInfoCallId( TInt aCallId );

    /**

     * This is called when call status is changed.

     *

     * @since S60 v3.2

     * @param aStatus New call state

     * @param aCall Pointer to call which is changed

     * @aNotify Type of notify

     */

    void HandleCallStatusChange( 

        CCPCall::TCallState aStatus, 

        CCCECall* aCall,

        CCECallEnums::TNotifyType aNotify );

    /**

     * This is called when conference status is changed.

     *

     * @since S60 v3.2

     * @param aStatus New conference state 

     */

    void HandleConferenceStatusChange( 

        MCCEConferenceCallObserver::TCCEConferenceCallState aStatus );   

    /**

     * Indication from emergency call about status change.

     * 

     * @since S60 v5.0

     * @param aNotify Type of notify.

     */

    void HandleEmergencyCallStatusChange( CCECallEnums::TNotifyType aNotify );

    /**

     * Releases call

     *

     * @since S60 v3.2

     * @param aCalltoRemove Call to be removed

     * @param aUid Uid for this call

     * @return KErrNone if succesful

     */

    TInt ReleaseCall( MCCPCall& aCalltoRelease, const TUid aUid );

    /**

     * Releases call

     *

     * @since S60 v3.2

     * @param aCalltoRemove Call to be removed

     * @return KErrNone if succesful

     */

    TInt ReleaseCall( MCCPCall& aCalltoRelease );

    /**

     * Returns reference to conferencecall

     *

     * @since S60 v3.2

     * @return Conference call

     */

    CCCEConferenceCall& ConferenceCall() const;

    /**

     * Get call with specific state, Skip given call

     *

     * @since S60 v3.2

     * @param aCallStatus Specified callstatus.

     * @param aSkippedCall Skip this call

     * @return Found call, NULL if none is found.

     */

    CCCECall* GetCall( 

        CCPCall::TCallState aCallStatus, 

        CCCECall* aSkippedCall ) const;

    /**

     * Get call which owns specific MCCPCall.

     * If specified call is NULL return next free call

     *

     * @since S60 v3.2

     * @param aMCCPCall Call to be found.

     * @return Found call.

     */

    CCCECall* GetCall( const MCCPCall* aMCCPCall) const;

    /**

     * Get call array of specific type

     *

     * @since S60 v3.2

     * @param aImplementationUid Specifies calltype to be found

     * @param aCallArray Calls are inserted in this array

     * @return Count of found calls, KErrNotFound if none found

     */

    TInt GetCall( TUid aImplementationUid, 

        RPointerArray<CCCECall>& aCallArray ) const;

    /**

     * Checks if there is any connected, connecting or dialling calls

     *

     * @since S60 v3.2

     * @param aCallArray Calls are inserted in this array

     * @return Count of found calls, KErrNotFound if none found

     */

    TInt GetActiveOrConnectingCalls( RPointerArray<MCCECallInfo>& aCallArray ) const;

    /**

     * Counts calls of specified type

     *

     * @since S60 v3.2

     */

    TInt CountCalls( TUid aImplementationUid ) const;

    /**

     * Counts calls of specified type

     * Check implementation UID and call type

     * so that call provided by CS plugin

     */

    TInt CountCsCalls( TUid aImplementationUid ) const;

    /**

     * Create room to incoming emergency

     *

     * @since S60 v3.2

     */

    void TerminateAllButRingingAndQueuedCalls();

     /**

     * Create room to emergency

     *

     * @since S60 v3.2

     */

    void TerminateAllCalls();

    /**

    * Create room to emergency

    *

    * @since S60 v3.2

    */

   void TerminateAllVoIPCalls();

    /**

     * Call propagated error

     *

     * @since S60 v3.2

     * @param aCall CCCECall failed

     * @param aError error occured

     */

    void ErrorOccurred( CCCECall* aCall, TCCPError aError );

    /**

     * Get CCE observer

     * @since S60 v3.2

     * @param none

     * @return CCE observer reference.

     */

    MCCEObserver* CCEObserver();

    /**

     * Get ss observer

     * @since S60 v3.2

     * @param none

     * @return CCE observer reference.

     */

    MCCESsObserver* SsObserver();

    /**

     * Get life time info from CS plugin.

     * @since S60 v3.2

     * @param aLifeTimeInfo Life time info.

     * @return Get succeeded ot not.

     */

    /**

     * Get CS specific misc info from CS plugin.

     * @since S60 v3.2

     * @param aCSInfo CS info.

     * @return Get succeeded ot not.

     */

     * Stop airtime duration timer

     *

     * @since S60 v3.2

     * @param aCall CCCECall is used for checking call type

     */

    void AirTimeDurationStop( CCCECall* aCall ) const;

     * Switch Air Duration timer, is needed for handover

     * 

     * Stop current timer and starts another one. New timer is initialized 

     * with the same value that old timer had when it was stopped

     *

     * @since S60 v3.2

     * @param aCall aNewCallType new call type, indicated direction of 

     * timer switching

     */

    void AirTimeDurationSwap(const CCPCall::TCallType aNewCallType);

    /**

     * Start airtime duration timer

     *

     * @since S60 v3.2

     * @param aCall CCCECall is used for checking call type

     */

    void AirTimeDurationStart( CCCECall* aCall ) const;

    /**

     * From base class MCCECallArray

     * @see MCCECallArray

     */

    MCCECallInfo* EmergencyCallInfo() const;

    /**

     * From base class MCCECallArray

     * @see MCCECallArray

     */

    MCCECallInfo* CallInfo( TInt aIndex ) const;

    /**

     * From base class MCCECallArray

     * @see MCCECallArray

     */

    TInt MaxNumberOfCalls() const;

private:

    /**

     * Gets call with active request, skip call which is given as param

     *

     * @since S60 v3.2

     * @param aCall Call to be skipped

     * @return Found call, NULL if notfound

     */

    CCCECall* GetCallWithActiveRequest( CCCECall* aCall ) const;

    /**

     * Creates call array

     *

     * @since S60 v3.2

     */

    void CreateCallDataArraysL();

    /**

     * Add a call to release list

     *

     * @since S60 v3.2

     * @param aCall CCCECall is used for checking call type

     */

     void ScheduleReleaseCall( MCCPCall& aCalltoRelease, const TUid aUid );

   /**

     * This is called when call(s) is(are) scheduled to be released

     *

     * @since S60 v3.2

     * @param aPluginManager 

     * @return KErrNone if successful

     *         ( KErrNone always or else there is posiibility to loop

     */

    static TInt ReleaseCalls( TAny* aCallContainer );

    /**

     * Clear the array of calls to be released

     *

     * @since S60 v3.2

     */

    void DoReleaseCalls();

    /**

     * Gets call which isnt part of conference

     *

     * @since S60 v3.2

     */

    CCCECall* GetNonConferenceCall() const;

    /**

     * Tells if cs plugin is used in current call

     *

     * @since S60 v3.2

     * @param aCall Call to be checked

     * @return ETrue if cs plugin used

     */

    TBool IsCsPlugin( CCCECall* aCall, TBool aConference ) const;

private:

    /** Constructor */

    CCCECallContainer( MCCEObserver& aObserver );

    /** Leaving stuff in constructor */

    void ConstructL();

private: // data

    /**

     * Class to hold removed cal information 

     * used in delayed release

     */

    class TCallReleaseEntry

        {

        public:

            /**

             * Pointer to call object

             * Not own

             */

            MCCPCall* iCallToRelease;

            /**

             * Uid of plugin where call is located 

             */

            TUid iUid; 

         };

     RArray<TCallReleaseEntry> iCallstoRelease;

    /**

     * Dealyed releaser

     * Own

     */

    CIdle* iIdle;    

    /**

     * Observer

     * Not own

     */

    MCCEObserver* iMCCEObserver;

    /**

     * Observer

     * Not own

     */

    MCCESsObserver* iMCCESsObserver;

    /**

     * Conference call object

     * Own

     */

    CCCEConferenceCall* iConferenceCall;

    /**

     * Pluginmanager, manages plugin loading

     * Own

     */

    CCCEPluginManager* iPluginManager;

    /**

     * Emergency call object

     * Own

     */

    CCCEEmergencyCall*  iEmergencyCall;

    /**

     * Transfer controller

     * Own

     */

    CCCETransferController* iTransferController;

    /**

     * Dtmf logic container

     * Own

     */

    CCCEDtmf* iDtmf;

    /**

     * Extension interface logic

     * Own

     */

    CCCEExtension* iExtension;

    /**

     * Array of call objects

     * Own

     */

    CArrayPtrFlat<CCCECall>* iCallArray;

    /**

     * CS call duration

     * Own

     */

    CCCEDurationTimer* iCSDuration;

    /**

     * PS call duration

     * Own

     */

    CCCEDurationTimer* iPSDuration;

    /**

     * Table is filled so that call info callid 0 is used by

     * callid in table index 0 etc.

     */

    TFixedArray<TInt, KCCECallObjects> iCallInfoCallId;