diff -r 000000000000 -r ff3b6d0fd310 convergedcallengine/cce/inc/cccecallcontainer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/convergedcallengine/cce/inc/cccecallcontainer.h Tue Feb 02 01:11:09 2010 +0200 @@ -0,0 +1,538 @@ +/* +* 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 + +#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& 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& 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. + */ + TBool GetLifeTime( TDes8& aLifeTimeInfo ); + + /** + * Get CS specific misc info from CS plugin. + * @since S60 v3.2 + * @param aCSInfo CS info. + * @return Get succeeded ot not. + */ + TBool GetCSInfo( CSInfo& aCSInfo ); + + /** + * 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 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* 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 iCallInfoCallId; + + /** + * Call info mediator. + * Own. + */ + CCCECallInfoMediator* iCallStateMediator; + + }; + + +#endif