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

//

#include <comms-infras/ss_mcprnodemessages.h>

#include <comms-infras/ss_mmcommsprov.h>

#include <comms-infras/ss_protflow.h>

#include <comms-infras/ss_subconnflow.h>

#include "SS_conn.H"

#include <comms-infras/ss_log.h>

#include <ss_glob.h>

#include <ecom/ecom.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockSSocks_prt2, "ESockSSocks_prt2");

#endif

using namespace ESock;

using namespace Factories;

using namespace Messages;

CProtocolIntfFactoryContainer::CProtocolIntfFactoryContainer()

:CCommsFactoryContainer((CCommsFactoryContainer::TContaineeType)CProtocolIntfFactoryContainer::EId)

	{

	LOG_NODE_CREATE(KESockDataFactTag, CProtocolIntfFactoryContainer);

	}

CProtocolIntfFactoryContainer::~CProtocolIntfFactoryContainer()

	{

	LOG_NODE_DESTROY(KESockDataFactTag, CProtocolIntfFactoryContainer);

	}

CProtocolIntfFactoryContainer* CProtocolIntfFactoryContainer::NewL()

/** Create a new instance of a sub-connection factory container

@exception Leaves in out of memory conditions

@return Pointer to new instance of a sub-connection factory container

*/

	{

	return new (ELeave) CProtocolIntfFactoryContainer();

	}

EXPORT_C CProtocolIntfFactoryBase* CProtocolIntfFactoryContainer::FindOrCreateFactoryL(TUid aFactoryUid)

    {

	CProtocolIntfFactoryBase* factory = static_cast<CProtocolIntfFactoryBase*>(FindFactory(aFactoryUid));

	if (NULL==factory)

		{

		CSubConnectionFlowFactoryBase* flowFactory = static_cast <CSubConnectionFlowFactoryBase* > (SockManGlobals::Get()->iSubConnectionFlowFactories->FindOrCreateFactoryL(aFactoryUid));

		if (NULL==flowFactory)

    		{

    		User::Leave(KErrNotFound);

    		}

		factory = flowFactory->CreateProtocolIntfFactoryL(*this);

		}

	__ASSERT_DEBUG(factory, User::Panic(KSpecAssert_ESockSSocks_prt2, 1));

	return static_cast<CProtocolIntfFactoryBase*>(factory);

    }

EXPORT_C CProtocolIntfBase* CProtocolIntfFactoryContainer::FindOrCreateProtocolIntfL( TUid aFactoryId, TFactoryQueryBase& aQuery)

/**

@internalTechnology

@released Since 9.2 */

	{

	CProtocolIntfFactoryBase* factory = CProtocolIntfFactoryContainer::FindOrCreateFactoryL(aFactoryId);

	__ASSERT_DEBUG(factory, User::Panic(KSpecAssert_ESockSSocks_prt2, 2));

	return static_cast<CProtocolIntfBase*>(factory->FindOrCreateProtocolIntfL( aQuery ));

	}

EXPORT_C CProtocolIntfFactoryBase::CProtocolIntfFactoryBase(TUid aFactoryId, CProtocolIntfFactoryContainer& aParentContainer)

/** Sub-connection flow factory constructor

@param aFactoryId Unique Integer Identifier of the sub-connection provider factory

@param aParentContainer Container to add the factory to */

	: CFactoryBase(aFactoryId, aParentContainer)

	{

	}

EXPORT_C CProtocolIntfBase* CProtocolIntfFactoryBase::FindOrCreateProtocolIntfL(TFactoryQueryBase& aQuery)

	{

	CProtocolIntfBase* prov = FindProtocolIntf(aQuery);

	return prov ? prov : CreateProtocolIntfL(aQuery);

	}

EXPORT_C CProtocolIntfBase* CProtocolIntfFactoryBase::FindProtocolIntf(TFactoryQueryBase& aQuery)

	{

	return static_cast<CProtocolIntfBase*>(FindObject(aQuery));

	}

EXPORT_C CProtocolIntfBase* CProtocolIntfFactoryBase::CreateProtocolIntfL(TFactoryQueryBase& aQuery)

	{

	//at this point we are either:

	//1. Given aSubConnectionProviderBase => control side initialised sub-connection<->flow creation

	//2. aSubConnectionProviderBase == NULL => data side initialised sub-connection<->flow creation for

	//	implicit connection

	//in all other cases we should find a proper sub-connection flow already created

	CProtocolIntfBase* pintf = DoCreateProtocolIntfL(aQuery);

	LOG( ESockLog::Printf(KESockDataFactTag, _L8("CProtocolIntfFactoryBase %08x:\t\tCreateProtocolIntfL(): pintf %08x"), this, pintf) );

	CleanupStack::PushL(pintf);

	AddManagedObjectL(*pintf);

	CleanupStack::Pop(pintf);

	return pintf;

	}

EXPORT_C CProtocolIntfBase::CProtocolIntfBase(CProtocolIntfFactoryBase& aFactory,const Messages::TNodeId& aCprId)

:	AFactoryObject(aFactory),

	iCprId(aCprId)

	{

	}

EXPORT_C CProtocolIntfBase::~CProtocolIntfBase()

	{

	// All Flows must have been deleted as it is last Flow deleted causes

	// the ProtocolIntf to be deleted.

	__ASSERT_DEBUG(iFlowCount == 0, User::Panic(KSpecAssert_ESockSSocks_prt2, 3));

	}

TBool CProtocolIntfBase::FlowBeingDeleted(CSubConnectionFlowBase& aFlow)

/**

Called when one of the Flows associated with this ProtocolIntf is being

deleted.  Called from the context of the Flow.

@return ETrue if this is the last Flow on this ProtocolIntf and the intf deletes itslef, else EFalse.

*/

	{

	__ASSERT_DEBUG(iFlowCount > 0, User::Panic(KSpecAssert_ESockSSocks_prt2, 4));

	DoFlowBeingDeleted(aFlow);

	TBool b = --iFlowCount == 0;

	if (b)

	    {

    	DeleteMeNow();

	    }

	return b;

	}

void CProtocolIntfBase::FlowCreated(CSubConnectionFlowBase& aFlow)

	{

	__ASSERT_DEBUG(iFlowCount >= 0, User::Panic(KSpecAssert_ESockSSocks_prt2, 5));

	DoFlowCreated(aFlow);

	++iFlowCount;

	}