/*
* 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: Voice Call Continuity proxy
*
*/
#ifndef CVCCDIRECTOR_H
#define CVCCDIRECTOR_H
#include <cconvergedcallprovider.h>
#include <mccpobserver.h>
#include <mccpcsobserver.h> // MCCPCSObserver
#include <mspnotifychangeobserver.h>
#include <mccpcall.h>
#include <cccpcallparameters.h>
#include "mvccengpspropertylistenerobserver.h"
#include "ccpdefs.h"
//state machine, in order to maintain only one instance
#include "tvccstateinit.h"
#include "tvccstatecalling.h"
#include "tvccstatereleasing.h"
#include "tvccstatefailing.h"
class CVccPerformer;
class CVccHoTrigger;
class CVccEngPsPropertyListener;
class CVccEngPsProperty;
class CSPNotifyChange;
class CVccConferenceCall;
class CVccDtmfProvider;
/** Service Provider Name */
_LIT( KCSPName,"VCC" );
/** VCC implementation UID */
const TInt KVCCImplementationUidInt = 0x2000CFAA;
/**
* Implementation uid of VCC Plugin.
*/
const TUid KVCCImplementationUid = { KVCCImplementationUidInt };
/**
*
*
* Proxies all calls to the relevant call providers
* and keeps the house hold.
*
* @lib svp.dll
* @since S60 3.2
*/
class CVccDirector : public CConvergedCallProvider,
public MCCPCSObserver,
public MVccEngPsPropertyListenerObserver,
public MSPNotifyChangeObserver
{
public:
/**
* Two-phased constructor.
*/
static CVccDirector* NewL();
/**
* Destructor.
*/
~CVccDirector();
/**
* Gets the instance of the MCCPMonitor
* @return Reference to MCCPMonitor
*/
const MCCPCSObserver* CPPObserver() const;
// from base class CConvergedCallProvider
/**
* From CConvergedCallProvider
* Initializes plug-in. All required parameters must be passed
* with this function in order to use services.
* Simplifies pluging construct removing need to pass parameters
* to ECom interface
*
* @since S60 v3.2
* @param aMonitor CCP observer
* @param aSsObserver SS observer
*/
void InitializeL( const MCCPObserver& aMonitor,
const MCCPSsObserver& aSsObserver );
/**
* From CConvergedCallProvider
* Creates a new session and checks secure status from profile.
*
* @since S60 v3.2
* @param aParameters Call parameters, SVP uses Service ID parameter
* @param aRecipient Recipients address/number
* @param aObserver Observer
* @return Reference to created MCCPCall object.
*/
MCCPCall* NewCallL( const CCCPCallParameters& aParameters,
const TDesC& aRecipient,
const MCCPCallObserver& aObserver );
/**
* From CConvergedCallProvider
* Returns Uid of plug-in which is on use.
*
* @since S60 v3.2
* @return Uid of plug-in
*/
const TUid& Uid() const;
/**
* From CConvergedCallProvider
* Creates a new Emergency call and add user-agent header.
*
* @since S60 v3.2
* @param aServiceId Service ID, obsolete!
* @param aAddress Emergency number
* @param aObserver Observer
* @return MCCPEmergencyCall
*/
MCCPEmergencyCall* NewEmergencyCallL( const TUint32 aServiceId,
const TDesC& aAddress,
const MCCPCallObserver& aObserver );
/**
* From CConvergedCallProvider
* Creates a new conference session.
*
* @since S60 v3.2
* @param aObserver Observer
* @return MCCPConferenceCall
*/
MCCPConferenceCall* NewConferenceL( const TUint32 aServiceId,
const MCCPConferenceCallObserver& aObserver );
/**
* From CConvergedCallProvider
* Releases call
*
* @since S60 v3.2
* @param aCall Call to be removed
* @return Symbian error code
*/
TInt ReleaseCall( MCCPCall& aCall );
/**
* From CConvergedCallProvider
* Releases emergency call
*
* @since S60 v3.2
* @param aCall Call to be removed
* @return Symbian error code
*/
TInt ReleaseEmergencyCall( MCCPEmergencyCall& aCall );
/**
* From CConvergedCallProvider
* Releases conference call
*
* @since S60 v3.2
* @param aCall Call to be removed
* @return Symbian error code
*/
TInt ReleaseConferenceCall( MCCPConferenceCall& aCall );
/**
* From CConvergedCallProvider
* Get Plug-In capabilities
*
* @since Series 60 v3.2
* @return TUint32 On return contains the capability flags of plug-In
*/
TUint32 Caps() const;
/**
* From CConvergedCallProvider
* Get DTMF provider
*
* @since Series 60 v3.2
* @param aObserver CCP Dtmf observer for informing events
* @return Pointer to MCCPDTMFProvider if succesfull,
* NULL if not available
*/
MCCPDTMFProvider* DTMFProviderL( const MCCPDTMFObserver& aObserver );
/**
* From CConvergedCallProvider
* Get extension provider
*
* @since Series 60 v3.2
* @param aObserver observer for extension(custom) events
* @return Pointer to MCCPExtensionProvider if succesfull,
* NULL if not available
*/
MCCPExtensionProvider* ExtensionProviderL(
const MCCPExtensionObserver& aObserver );
/**
* From CConvergedCallProvider
* Add an observer for DTMF related events.
* Plug-in dependent feature if duplicates or more than one observers
* are allowed or not. Currently CCE will set only one observer.
*
* @since S60 v3.2
* @param aObserver Observer
* @return none
* @leave system error if observer adding fails
*/
void AddObserverL( const MCCPDTMFObserver& aObserver );
/**
* From CConvergedCallProvider
* Remove an observer.
*
* @since S60 v3.2
* @param none
* @param aObserver Observer
* @return KErrNone if removed succesfully. KErrNotFound if observer
* was not found.
* Any other system error depending on the error.
*/
TInt RemoveObserver( const MCCPDTMFObserver& aObserver );
/**
* @see CConvergedCallProvider::GetLifeTime
*/
TBool GetLifeTime( TDes8& aLifeTimeInfo );
/**
* @see CConvergedCallProvider::GetCSInfo
*/
TBool GetCSInfo( CSInfo& aCSInfo );
// from base class MCCPCSObserver
// from base class MCCPObserver (inhereded by MCCPCSObserver)
/**
* From MCCPObserver (inhereded by MCCPCSObserver)
*
* @see MCCPObserver::ErrorOccurred
*/
void ErrorOccurred( TCCPError aError );
/** From MCCPObserver (inhereded by MCCPCSObserver)
*
* @see MCCPObserver::IncomingCall
*/
void IncomingCall( MCCPCall* aCall, MCCPCall& aTempCall );
/**
* From MCCPObserver (inhereded by MCCPCSObserver)
*
*
* @see MCCPObserver::IncomingCall
*/
void IncomingCall( MCCPCall* aCall );
/**
* The actual implementation for IncomingCall.
*/
void IncomingCallL( MCCPCall* aCall );
/**
* From MCCPObserver (inhereded by MCCPCSObserver)
*
* @see MCCPObserver::CallCreated
*/
void CallCreated( MCCPCall* aCall,
MCCPCall* aOriginator,
TBool aAttented );
/**
* From MCCPCSObserver
* see MCCPCSObserver::PluginInitiatedCSMoCallCreated
*/
//void PluginInitiatedCSMoCallCreated( MCCPCall* aCall ) const;
void MoCallCreated( MCCPCall& aCall );
/**
* Notify of conference call that is not requested.
* @since S60 3.2
* @param aConferenceCall Created conference
* @return none
*/
void ConferenceCallCreated( MCCPConferenceCall& aConferenceCall );
/**
* From MCCPObserver (inhereded by MCCPCSObserver)
*
* @see MCCPObserver::DataPortName
*/
void DataPortName( TName& aPortName );
// from base class MVccEngPsPropertyListenerObserver
/**
* From MVccEngPsPropertyListenerObserver
* Observer interface. Called when a P&S property value
* has been updated.
*
* @since S60 v3.2
* @param aCategoryId The category uid of the property
* @param akeyId The key uid of the property
* @param aValue Current value of the property.
*/
void PropertyChangedL(
const TUid aCategoryId,
const TUint aKeyId,
const TInt aValue );
//from base class MSPNotifyChangeObserver
/**
* From MSPNotifyChangeObserver.
* Handle notify change event from the service provider table observer.
*
* @param aServiceId the service ID of added/changed/deleted service
* ( only notification about the changes to VCC service are revceived)
*/
void HandleNotifyChange( TServiceId aServiceId );
/**
* From MSPNotifyChangeObserver.
* Handle error notification received from the service provider table
* observer.
*
* @param aError error code
* @since S60 3.2
*/
void HandleError( TInt aError );
/**
* Gets the call type of the currently active call from the performer array.
*
* @return Call type of the currently active call, KErrNotFound if no active call
* @since S60 3.2
*/
TInt CurrentCallTypeForDTMF();
/**
* Gets the call type of the currently active call and returns it's provider.
*
* @return CConvergedCallProvider of the active call
* @since S60 5.0
*/
CConvergedCallProvider* GetProvider();
private:
/**
* C++ default constructor.
*/
CVccDirector();
/**
* Symbian second-phase constructor
*/
void ConstructL();
/**
* for destroying an array
*/
static void PointerArrayCleanup( TAny* aArray );
/**
* Creates call provider array
*/
void FillCallProviderArrayL();
/**
* Checks if given plugin is used by VCC
*
* @aparam aPluginId call provider plugin id
* @return ETrue if plugin is used by VCC
*/
TBool IsVccOwnedPlugin( TInt aPluginId );
/**
* Tries to initialize all call provider plugins VCC uses.
*
* @param aMonitor CCP observer
* @param aSsObserver SS observer
* @return ETrue if all plugins were initialized
*/
TBool Initialize( const MCCPObserver& aMonitor,
const MCCPSsObserver& aSsObserver );
/**
* Tries to initialize the given call provider plugin.
* Leaves if initialization fails.
*
* @param aMonitor CCP observer
* @param aSsObserver SS observer
* @param aPlugin call provider plugin
*/
void InitializeL( const MCCPObserver& aMonitor,
const MCCPSsObserver& aSsObserver,
CConvergedCallProvider& aPlugin );
/**
* for checking state of calls and making handover
*/
void SwitchL( const TInt aValue );
/**
* Checks are converged call provider plugins initialized
*/
TBool IsPluginInitialized();
/*
* Starts notifications from service provider table observer.
* Is notified about VCC service settings changes.
*/
void StartSpNotifierL();
/*
* Stops notifications from service provider table observer.
*/
void StopSpNotifierL();
/*
* Triesto initialize call provider plugins used by VCC that
* were not initialized .
*
* */
void RetryInitialization();
/*
* The leaving-part implementation on ConferenceCallCreated.
* @since S60 3.2
* @param aConferenceCall Created conference
*/
void CreateConferenceL( MCCPConferenceCall& aConferenceCall );
private: // data
/**
* Implementation UID
*/
TUid iImplementationUid;
/**
* Array of Call providers
* Own.
*/
RPointerArray <CConvergedCallProvider> iProviders;
/*
* VCC needs to handle both cs and ps calls.
* MCCPCSObserver can do both
* Not own.
*/
MCCPCSObserver* iCCPObserver;
/*
* Supplementary service observer.
* Not own.
*/
MCCPSsObserver* iCCPSsObserver;
/*
* Handle to handover trigger.
* Own.
*/
CVccHoTrigger* iHoTrigger;
/**
* Array of Performers
* Own.
*/
RPointerArray<CVccPerformer> iPerfArray;
/*
* Handle to Conference call object.
* Own.
*/
CVccConferenceCall* iConference;
/*
* Listener for the hand-over commands
* Own.
*/
CVccEngPsPropertyListener* iPropListener;
//VCC state machine implementation
TVccStateInit iStateInit;
TVccStateCalling iStateCalling;
TVccStateReleasing iStateReleasing;
TVccStateFailing iStateFailing;
/**
* Used for checking in ReleaseCall, that was this ReleaseCall due to
* multicall handover situation
*/
TInt iHoKeyValue;
/**
* Notifies service provider setting change
* Own
*/
CSPNotifyChange* iSpNotifier;
/*
* Array of initialized plugins
* Own.
*/
RArray<TInt> iInitialisedPlugins;
/**
* Proxy object for DTMF providers
* Own.
*/
CVccDtmfProvider* iDtmfProvider;
/**
* Used in initialization logic to inform of
* failed converged call provider plugin.
*/
TInt iMandatoryPluginFailedError;
friend class T_CVccDirector;
friend class T_CVccDTMFProvider;
};
#endif // CVCCDIRECTOR_H