// Copyright (c) 2007-2009 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:

// Name        : sipplugindirector

// Part of     : sip agent server

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include	"sipplugindirector.h"

#include	"sipprofileagent.h"

#include	"sipprofileagentinitparams.h"

#include	"SipProfileLog.h"

#include 	<sipprofileagentextensionparams.h>

const TInt KPluginMicroSecInSec = 1;

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

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

// CSIPPluginDirector::CSIPPluginDirector

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSIPPluginDirector::CSIPPluginDirector(MSIPProfileAgentObserver& aObserver) 

 : iProfileAgentObserver(aObserver),

   iDeltaTimerCallBack(CleanupTimerExpired, this)

    {

    TUid KSIPProfileServerUid = {0x0};

	iServerId = KSIPProfileServerUid;

	iDeltaTimerEntry.Set(iDeltaTimerCallBack);

    }

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

// CSIPPluginDirector::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSIPPluginDirector::ConstructL()

    {

    iDeltaTimer = CDeltaTimer::NewL(CActive::EPriorityStandard);

    iConfigExtension = CSipProfileAgentConfigExtension::NewL();

    }

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

// CSIPPluginDirector::NewLC

// Two-phased constructor.

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

//

CSIPPluginDirector* CSIPPluginDirector::NewLC(

	MSIPProfileAgentObserver& aObserver)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CSIPPluginDirector::NewL

// Two-phased constructor.

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

//

CSIPPluginDirector* CSIPPluginDirector::NewL(

	MSIPProfileAgentObserver& aObserver)

    {

    CSIPPluginDirector* self = CSIPPluginDirector::NewLC(aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSIPPluginDirector::~CSIPPluginDirector

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

//

CSIPPluginDirector::~CSIPPluginDirector()

    {

	iSIPProfileAgents.ResetAndDestroy();

	delete iDeltaTimer;

	delete iConfigExtension;

	REComSession::FinalClose();

    }

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

// CSIPPluginDirector::FindImplementation 

// (other items were commented in a header).

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

//

CSIPProfileAgent* CSIPPluginDirector::FindImplementation(

	const TSIPProfileTypeInfo& aType)

	{

	PROFILE_DEBUG6("CSIPPluginDirector::FindImplementation", 

		aType.iSIPProfileName)

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

		{

		if (iSIPProfileAgents[i]->Type().iSIPProfileName == 

			aType.iSIPProfileName && 

			iSIPProfileAgents[i]->Type().iSIPProfileClass == 

			aType.iSIPProfileClass)

			{

			return iSIPProfileAgents[i];

			}

		}

	PROFILE_DEBUG2("CSIPPluginDirector::FindImplementation", "Not found!")

	return NULL;

	}

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

// CSIPPluginDirector::CreateImplementationL

// (other items were commented in a header).

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

//

CSIPProfileAgent& CSIPPluginDirector::CreateImplementationL(

	const TSIPProfileTypeInfo& aType)

	{

	PROFILE_DEBUG6("CSIPPluginDirector::CreateImplementationL", 

		aType.iSIPProfileName)

	TSIPProfileAgentInitParams initParams(*iDeltaTimer,

			iProfileAgentObserver);

	TBuf8<30> plugin;

	plugin.Format(_L8("%u_"), aType.iSIPProfileClass);

	plugin.Append(aType.iSIPProfileName);

	CSIPProfileAgent* sipProfileAgent = 

	    CSIPProfileAgent::NewL(plugin,initParams);

	CleanupStack::PushL( sipProfileAgent);

	sipProfileAgent->Extension(KSipProfileAgentConfigExtension,

			iConfigExtension);

	User::LeaveIfError(iSIPProfileAgents.Append(sipProfileAgent));

	CleanupStack::Pop(sipProfileAgent);

	return *sipProfileAgent;

	}

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

// CSIPPluginDirector::ProvideImplementationL

// provides correct implementation

// (other items were commented in a header).

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

//

CSIPProfileAgent& CSIPPluginDirector::ProvideImplementationL(

	const TSIPProfileTypeInfo& aType)

	{

	PROFILE_DEBUG6("CSIPPluginDirector::ProvideImplementationL", aType.iSIPProfileName)

	CSIPProfileAgent* implementation = FindImplementation(aType);

	if (implementation)

		return *implementation;

	else

		return CreateImplementationL(aType);

	}

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

// CSIPPluginDirector::DeltaTimer

// returns iDeltaTimer as reference

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

//

CDeltaTimer& CSIPPluginDirector::DeltaTimer()

	{

	return *iDeltaTimer;

	}

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

// CSIPPluginDirector::RegisterL

// registers profile

// (other items were commented in a header).

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

//

void CSIPPluginDirector::RegisterL(

	CSIPConcreteProfile& aSIPProfile)

	{

	PROFILE_DEBUG3("CSIPPluginDirector::RegisterL", aSIPProfile.Id())

	ProvideImplementationL(aSIPProfile.ProfileType()).RegisterL(aSIPProfile);

	}

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

// CSIPPluginDirector::DeregisterL

// deregisters profile

// (other items were commented in a header).

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

//

void CSIPPluginDirector::DeregisterL(

	CSIPConcreteProfile& aSIPProfile)

	{

	PROFILE_DEBUG3("CSIPPluginDirector::DeregisterL", aSIPProfile.Id())

	CSIPProfileAgent* profileagent = FindImplementation(aSIPProfile.ProfileType());

	__ASSERT_ALWAYS (profileagent, User::Leave(KErrArgument));

	profileagent->DeregisterL(aSIPProfile);

	}

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

// CSIPPluginDirector::UpdateRegistrationL

// deregisters profile

// (other items were commented in a header).

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

//

void CSIPPluginDirector::UpdateRegistrationL(

	CSIPConcreteProfile& aNewProfile,

	CSIPConcreteProfile& aOldProfile)

	{

	PROFILE_DEBUG3("CSIPPluginDirector::UpdateRegistrationL", aNewProfile.Id())

	__ASSERT_ALWAYS(aNewProfile.Id() == aOldProfile.Id(), 

	                User::Leave(KErrArgument));

	CSIPProfileAgent* profileagent = FindImplementation(aOldProfile.ProfileType());

	__ASSERT_ALWAYS(profileagent, User::Leave(KErrArgument));

	profileagent->UpdateL(aNewProfile, aOldProfile);

	}

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

// CSIPPluginDirector::ListImplementationsL

// Lists all implementations

// (other items were commented in a header).

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

//

void CSIPPluginDirector::ListImplementationsL(

	RImplInfoPtrArray& aImplementations)

	{

	PROFILE_DEBUG1("CSIPPluginDirector::ListImplementationsL")

	CSIPProfileAgent::ListAllImplementationsL(aImplementations);

	}

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

// CSIPPluginDirector::IsRegisterPending

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

//

TBool CSIPPluginDirector::IsRegisterPending(CSIPConcreteProfile& aSIPProfile)

	{

	PROFILE_DEBUG3("CSIPPluginDirector::IsRegisterPending", aSIPProfile.Id())

	CSIPProfileAgent* implementation = 

	    FindImplementation(aSIPProfile.ProfileType());

	if (implementation)

		{

        return implementation->RegisterPending(aSIPProfile);

		}

	return EFalse;

	}

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

// CSIPPluginDirector::State

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

//

TInt CSIPPluginDirector::State(CSIPConcreteProfile::TStatus& aStatus,

							   CSIPConcreteProfile& aSIPProfile)

	{

	TInt err(KErrNotFound);

	aStatus = CSIPConcreteProfile::EUnregistered;

	CSIPProfileAgent* implementation =

	    FindImplementation(aSIPProfile.ProfileType());

	if (implementation)

		{

		err = implementation->GetProfileState(aStatus, aSIPProfile);

		}

	return err;

	}

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

// CSIPPluginDirector::TerminateHandling

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

//

TInt CSIPPluginDirector::TerminateHandling(CSIPConcreteProfile& aSIPProfile)

	{

	CSIPProfileAgent* implementation = 

	    FindImplementation(aSIPProfile.ProfileType());

	if (implementation)

		{

		return implementation->TerminateHandling(aSIPProfile);

		}

	return KErrNotFound;

	}

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

// CSIPPluginDirector::Cleanup

// initiate cleanup; idle agent will be deleted

// (other items were commented in a header).

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

//

void CSIPPluginDirector::Cleanup()

	{

	CSIPProfileAgent* agent;

	for (TInt i=iSIPProfileAgents.Count()-1; i >= 0; i-- )

		{

		agent = iSIPProfileAgents[i];

		if ( agent->IsIdle() )

			{

			iSIPProfileAgents.Remove(i);

			delete agent;

			agent = 0;

			}//if

		}//for

	}

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

// CSIPPluginDirector::StartTimerForCleanup

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

//

void CSIPPluginDirector::StartTimerForCleanup ()

	{

	PROFILE_DEBUG1("CSIPPluginDirector::StartTimerForCleanup")

	iDeltaTimer->Remove(iDeltaTimerEntry);

	TTimeIntervalMicroSeconds32 interval(KPluginMicroSecInSec);

	iDeltaTimer->Queue(interval, iDeltaTimerEntry);

	}

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

// CSIPPluginDirector::CleanupTimerExpired

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

//

TInt CSIPPluginDirector::CleanupTimerExpired(TAny* aPtr)

	{

	PROFILE_DEBUG1("CSIPPluginDirector::CleanupTimerExpired")

	CSIPPluginDirector* self = reinterpret_cast<CSIPPluginDirector*>(aPtr);

  	self->Cleanup();

  	return ETrue;

	}

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

// CSIPPluginDirector::CreateProfileL

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

//

CSIPConcreteProfile* CSIPPluginDirector::CreateProfileL (

	const TSIPProfileTypeInfo& aType)

	{

	PROFILE_DEBUG1("CSIPPluginDirector::CreateProfileL")

	return ProvideImplementationL(aType).CreateL();

	}