/*

* 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:   Handles all common logic for VCC proxy and handles sessions.

*

*/

//cleanup stack operations

#include <mccpssobserver.h>

#include <spnotifychange.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include "vcchotrigger.h"

#include "cvccdirector.h"

#include "cvccconferencecall.h"

#include "cvccperformer.h"

#include "vccengpspropertylistener.h"

#include "vccsubscribekeys.h"

#include "vccsettingsreader.h"

#include "vccdefinitions.h"

#include "rubydebug.h"

#include "cvccdtmfprovider.h"

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

// CVccDirector::CVccDirector

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

//

CVccDirector::CVccDirector(): 

	iImplementationUid( KVCCImplementationUid )

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::CVccDirector" );

    }

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

// CVccDirector::PointerArrayCleanup

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

//

void CVccDirector::PointerArrayCleanup( TAny* aArray )

    {

    static_cast<RPointerArray<CConvergedCallProvider>*>( aArray )->ResetAndDestroy();

    static_cast<RPointerArray<CConvergedCallProvider>*>( aArray )->Close();

    }

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

// CVccDirector::ConstructL

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

//

void CVccDirector::ConstructL()

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::ConstructL" );

    FillCallProviderArrayL();

    // Create the HO-trigger and connect to the wlan network

    iHoTrigger = CVccHoTrigger::NewL();

	iPropListener = CVccEngPsPropertyListener::NewL( KPSVccPropertyCategory, 

            KVccPropKeyHoRequest );

	RUBY_DEBUG0( "- Called CVccEngPsPropertyListener::NewL" );

	iPropListener->AddObserverL( *this );

	RUBY_DEBUG0( "- Called iPropListener->AddObserverL" );

	iPropListener->Start();

	RUBY_DEBUG0( "- Called iPropListener->Start()" );

	//notifies about the changes to SP table

	iSpNotifier = CSPNotifyChange::NewL( *this );

	//start service provider table notifier

    StartSpNotifierL();

	//link states

  	iStateInit.LinkState(iStateCalling);

  	iStateCalling.LinkState(iStateReleasing, iStateInit, iStateFailing );

  	iStateReleasing.LinkState(iStateInit);

  	iStateFailing.LinkState( iStateInit );

  	iHoKeyValue = KErrNotFound;

    }

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

// CVccDirector::NewL

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

//

CVccDirector* CVccDirector::NewL()

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::NewL" );

    CVccDirector* self = new ( ELeave ) CVccDirector();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CVccDirector::~CVccDirector

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

//

CVccDirector::~CVccDirector()

    {

    RUBY_DEBUG0( "CVccDirector::~CVccDirector() - ENTER" );

    delete iConference;

    iProviders.ResetAndDestroy();

    iProviders.Close();

    iPerfArray.ResetAndDestroy();

    iPerfArray.Close();

    iInitialisedPlugins.Close();

    delete iPropListener;

    if( iSpNotifier )

    	{

    	iSpNotifier->Cancel();

    	}

   	delete iSpNotifier;

    delete iHoTrigger;

    delete iDtmfProvider;

    REComSession::FinalClose();

    RUBY_DEBUG0( "CVccDirector::~CVccDirector() - EXIT" );

    }

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

// CVccDirector::FillCallProviderArrrayL

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

//

void CVccDirector::FillCallProviderArrayL()

	{

    //no supplementary services

    //creating cs and sipvoipproviders

    //List implementations

    RImplInfoPtrArray implementations;

    TCleanupItem arrayCleanup( PointerArrayCleanup, &implementations );

    CleanupStack::PushL( arrayCleanup );

    CConvergedCallProvider::ListImplementationsL( implementations );

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

        {

        RUBY_DEBUG1( "- for loop counter value: %d", i );

        CImplementationInformation *info = implementations[i];

        if ( IsVccOwnedPlugin ( info->ImplementationUid().iUid ) )

            {

            CConvergedCallProvider* provider =

                CConvergedCallProvider::NewL( info->ImplementationUid() );

            CleanupStack::PushL( provider );

            User::LeaveIfError( iProviders.Append( provider ) );

            CleanupStack::Pop( provider ); //aProvider

            }

        }

    CleanupStack::PopAndDestroy();//implementations

	}

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

// CVccDirector::IsVccOwnedPlugin

// Checks is the given call provider plugin used by VCC 

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

//

TBool CVccDirector::IsVccOwnedPlugin( TInt aPluginId )

	{

	if( aPluginId == KSipVoipCallProviderPlugId || 

		aPluginId == KCSCallProviderPlugId	)

			return ETrue;

	return EFalse;

	}

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

// CVccDirector::InitializeL

// Tries to initialize all call provider plugins used by VCC.

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

//

void CVccDirector::InitializeL( const MCCPObserver& aMonitor,

                                  const MCCPSsObserver& aSsObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::InitializeL" );

    if ( iProviders.Count() == 0 )

    	{

    	User::Leave( KErrNotFound );

    	}

    iMandatoryPluginFailedError = KErrNone;

    //MT: setting CVccDirector as observer to plugin

    Initialize( *this, aSsObserver );

    // Leave if mandatory plugins failed

    User::LeaveIfError( iMandatoryPluginFailedError );

    // save CCP monitor ; CCCEPluginMCCPObserver

    const MCCPCSObserver& obs = static_cast<const MCCPCSObserver&>( aMonitor );

    iCCPObserver = const_cast<MCCPCSObserver*>(&obs);

    const MCCPSsObserver& ssObs = static_cast<const MCCPSsObserver&>( aSsObserver );

    iCCPSsObserver = const_cast<MCCPSsObserver*>(&ssObs);

    }

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

// CVccDirector::InitializeL

// Tries to initialize call provider plugins VCC uses. 

// Informs if  failure.

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

//

TBool CVccDirector::Initialize( const MCCPObserver& aMonitor,

        const MCCPSsObserver& aSsObserver )

	{

    RUBY_DEBUG_BLOCK( "CVccDirector::Initialize" );

    TBool initSucceeded = ETrue;

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

        {

        TUid pluginUid = iProviders[ i ]->Uid();

        RUBY_DEBUG1( "starting to initialize plugin index= %d", i );

        TRAPD( err, InitializeL( aMonitor, aSsObserver, *(iProviders[ i ]) ) );

        RUBY_DEBUG1( "initialization err = %d", err );

        if ( KErrNone != err && KCSCallProviderPlugId == pluginUid.iUid ) // CS plugin mandatory

            {

            RUBY_DEBUG0( "-- Mandatory VCC plugin initialization FAILED" );    

            initSucceeded = EFalse; 

            iMandatoryPluginFailedError = err;

            }

        else

            {

            switch( err )

                {

                case KErrNone:

                    iInitialisedPlugins.Append(  pluginUid.iUid );

                    //fall-through

                case KErrAlreadyExists:

                    RUBY_DEBUG0( "-- VCC plugin initialization OK" );

                    break;

                default:

                    RUBY_DEBUG0( "-- VCC plugin initialization FAILED" );

                    initSucceeded = EFalse;

                    break;

                }

            }

        }

	RUBY_DEBUG1( "-- VCC plugin nbr of initialized plugins:%d",

			iInitialisedPlugins.Count() );

	return initSucceeded; 

    }

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

// CVccDirector::InitializeL

// Finds from the VCC settings the service id that should be used with the 

// given plugin. Uses the service id to initialize plugin.

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

//

void CVccDirector::InitializeL( const MCCPObserver& aMonitor,

        const MCCPSsObserver& aSsObserver, CConvergedCallProvider& aPlugin )

	{

    RUBY_DEBUG_BLOCKL( "CVccDirector::InitializeL" );

	TInt serviceId = VccSettingsReader::ServiceIdL( aPlugin.Uid().iUid );

	RUBY_DEBUG1( "Initialize plugin with serviceId = %d", serviceId );	   

	User::LeaveIfError( serviceId );

	aPlugin.InitializeL( serviceId, aMonitor, 

			aSsObserver );

	}

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

// CVccDirector::NewCallL

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

//

MCCPCall* CVccDirector::NewCallL(

                            const CCCPCallParameters& aParameters,

                            const TDesC& aRecipient,

                            const MCCPCallObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::NewCallL" );

    // Check call type and translate it into domain type

    CVccPerformer* perf;

    TBool csOriginated = EFalse;

    if( aParameters.CallType() == CCPCall::ECallTypeCSVoice )

        {

        csOriginated = ETrue;

        iHoTrigger->ReadHoAllowedWhenCsOriginatedSettingL();

        }

    perf = CVccPerformer::NewL( iProviders, 

                                iStateInit, 

                                *iHoTrigger, 

                                csOriginated );

    CleanupStack::PushL( perf );

    User::LeaveIfError( iPerfArray.Append( perf ) ); 

    CleanupStack::Pop( perf ); // perf

    return perf->CreatePrimaryCallL( aParameters, aRecipient, aObserver );

    }

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

// Releases call

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

//

TInt CVccDirector::ReleaseCall( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::ReleaseCall" );

    TInt err = KErrNotFound;

    //Go through the performer array to see which performer should be deleted.

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

    	{

    	if( iPerfArray[i] == &aCall )

    		{

            err = iPerfArray[ i ]->ReleaseCall( aCall ); 

            iPerfArray[ i ]->ReleaseSecondaryCallLeg();

            delete iPerfArray[ i ];

            iPerfArray.Remove( i );

            iPerfArray.Compress();

            break;

    		}

    	}

    if( iPerfArray.Count() == 0 )

        {

        //make it possible to initiate HOs in new call

        iHoTrigger->ManualHoCallReleased();

        iHoTrigger->HoAllowed();

        iHoTrigger->Stop();

        }

    //If iHoKeyValue it means that PropertyChanged function has been visited

    //i.e. handover should be made. Non-active calls need to be released

    //before handover can be made.

    if ( iHoKeyValue >= KErrNone )

        {

        TRAP( err, PropertyChangedL( KPSVccPropertyCategory, 

                            KVccPropKeyHoRequest, 

                            iHoKeyValue ) );

        }

    return err;

    }

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

// Releases emergency call

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

//

TInt CVccDirector::ReleaseEmergencyCall( MCCPEmergencyCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::ReleaseEmergencyCall" );

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

           {

           TUid pluginUid = iProviders[ i ]->Uid();

           if (pluginUid.iUid == KCSCallProviderPlugId )

               {

               RUBY_DEBUG0( "CS Plugin found" ); 

               return iProviders[i]->ReleaseEmergencyCall( aCall );

               }

           }

    return KErrNotFound;

    }

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

// Releases conference call

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

//

TInt CVccDirector::ReleaseConferenceCall( MCCPConferenceCall& /*aCall*/ )

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::ReleaseConferenceCall" );

    iConference->ReleaseConference();

    delete iConference;

    iConference = NULL;

    iHoTrigger->HoAllowed();

    if( iPerfArray.Count() > 0 )

    	{

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

    		{

    		iPerfArray[i]->ConferenceEnded();

    		}

    	}

    return KErrNone;

    }

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

// CVccDirector::Uid

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

//

const TUid& CVccDirector::Uid() const

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::Uid" );

    return iImplementationUid;

    }

// from ConvergedCallProvider

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

// CVccDirector::NewEmergencySessionL

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

//

MCCPEmergencyCall* CVccDirector::NewEmergencyCallL(

    const TUint32 aServiceId,

    const TDesC&  aAddress,

    const MCCPCallObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::NewEmergencyCallL" );

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

        {

        TUid pluginUid = iProviders[ i ]->Uid();

        if (pluginUid.iUid == KCSCallProviderPlugId )

            {

            RUBY_DEBUG0( "CS Plugin found" ); 

            return iProviders[i]->NewEmergencyCallL( aServiceId, aAddress, aObserver );

            }

        }

    return NULL;

    }

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

// CVccDirector::NewConferenceL

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

//

MCCPConferenceCall* CVccDirector::NewConferenceL(

        const TUint32 aServiceId,

        const MCCPConferenceCallObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::NewConferenceL" );

    if ( !iConference )

        {

        iConference = CVccConferenceCall::NewL( aServiceId, aObserver, iPerfArray );

        }

    else

        {

        iConference->AddObserverL( aObserver );

        }

    iHoTrigger->HoNotAllowedL();

    return iConference;

    }

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

// CVccDirector::Caps

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

//

TUint32 CVccDirector::Caps() const

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::Caps()" );

    return 0;

    }

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

// CVccDirector::DTMFProvider

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

//

MCCPDTMFProvider* CVccDirector::DTMFProviderL(

                                           const MCCPDTMFObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::DTMFProviderL" );

    if( !iDtmfProvider )

        {

        iDtmfProvider = CVccDtmfProvider::NewL( iProviders, aObserver, *this );

        }

    return iDtmfProvider; 

    }

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

// CVccDirector::ExtensionProvider

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

//

MCCPExtensionProvider* CVccDirector::ExtensionProviderL(

                                const MCCPExtensionObserver& /*aObserver*/ )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::ExtensionProviderL" );

    return NULL;

    }

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

// CVccDirector::AddObserverL

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

//

void CVccDirector::AddObserverL( const MCCPDTMFObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccDirector::AddObserverL" );

    if(iDtmfProvider)

        {

        iDtmfProvider->AddObserverL(aObserver);

        }

    }

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

// CVccDirector::RemoveObserver

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

//

TInt CVccDirector::RemoveObserver( const MCCPDTMFObserver& aObserver )

    {

    RUBY_DEBUG_BLOCK( "CVccDirector::RemoveObserver" );

    if(iDtmfProvider)

        {

        return iDtmfProvider->RemoveObserver(aObserver);

        }

    return KErrNotFound;

    }