// 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:

// Reference (empty) implementation file for a Connection Provider

//

//

/**

 @file

 @internalComponent

*/

#include "ReferenceCPR_connProv.h"

_LIT(KPanicReferenceCPRText,"Reference CPR not filled in properly");

#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_RefCprConProv, "RefCprConProv");

#endif

//-=========================================================

// Custom methods

//-=========================================================

CReferenceConnectionProvider* CReferenceConnectionProvider::NewL(CConnectionProviderFactoryBase& aFactory)

	{

	CReferenceConnectionProvider* p = new (ELeave) CReferenceConnectionProvider(aFactory);

	return p;

	}

CReferenceConnectionProvider::CReferenceConnectionProvider(CConnectionProviderFactoryBase& aFactory)

:CConnectionProviderBase(aFactory),

 iNextLayer(NULL)

	{

	__FLOG_OPEN(KReferenceLogTag1, KReferenceLogTag2);

	}

CReferenceConnectionProvider::~CReferenceConnectionProvider()

	{

	__FLOG_CLOSE;

	}

//-=========================================================

// MConnectionControlClient methods

//-=========================================================

void CReferenceConnectionProvider::ConnectionGoingDown(CConnectionProviderBase& aConnProvider)

	{

	__FLOG_2(_L("CReferenceConnectionProvider %08x:\tConnectionGoingDown(aConnProvider %08x)"), this, &aConnProvider);

	if (&aConnProvider == iNextLayer)

		{

		iNextLayer = NULL;

		DeleteMeNow();

		}

	}

void CReferenceConnectionProvider::ProgressNotification(TInt aStage, TInt aError)

	{

	__FLOG_3(_L("CReferenceConnectionProvider %08x:\tProgressNotification(aStage %d aError %d)"), this, aStage, aError);

	TInt max = iControlClients.Count();

	for (TInt i = max - 1 ; i >= 0 ; i--)

   		{

	   	iControlClients[i]->ProgressNotification(aStage, aError);

		}

	}

void CReferenceConnectionProvider::ConnectionError(TInt aStage,  TInt aError)

	{

	__FLOG_3(_L("CReferenceConnectionProvider %08x:\tConnectionError(aStage %d aError %d)"), this, aStage, aError);

	TInt max = iControlClients.Count();

	for (TInt i = max - 1 ; i >= 0 ; i--)

		{

		iControlClients[i]->ConnectionError(aStage, aError);

		}

	max = iDataClients.Count();

	for (TInt i = max - 1 ; i >= 0 ; i--)

		{

		iDataClients[i]->ConnectionError(aStage, aError);

		}

  	}

void CReferenceConnectionProvider::ServiceChangeNotification(TUint32 aId, const TDesC& aType)

	{

	__FLOG_3(_L("CReferenceConnectionProvider %08x:\tServiceChangeNotification(aId %u aType %s)"), this, aId, &aType);

   	TInt max = iControlClients.Count();

	for (TInt i = max - 1 ; i >= 0 ; i--)

   		{

	   	iControlClients[i]->ServiceChangeNotification(aId, aType);

		}

  	}

void CReferenceConnectionProvider::SubConnectionEvent(CSubConnectionProviderBase* aSubConnNextLayerProvider, const TSubConnectionEvent& aSubConnectionEvent)

	{

	TInt max = iControlClients.Count();

	for (TInt i = max - 1 ; i >= 0 ; i--)

		{

	   	iControlClients[i]->SubConnectionEvent(aSubConnNextLayerProvider, aSubConnectionEvent);

		}

	}

void CReferenceConnectionProvider::LayerUp(TInt aError)

	{

	TInt max = iControlClients.Count();

	for (TInt i = max - 1 ; i >= 0 ; --i)

		{

		iControlClients[i]->LayerUp(aError);

		}

	// broadcast the event to the data clients also, sideways

	max = iDataClients.Count();

	for (TInt j = max - 1; j >= 0 ; --j)

		{

		iDataClients[j]->Notify(MConnectionDataClient::ENotifyLayerUp, this, aError, NULL);

		}

   }

MConnectionControlClient::TCtlType CReferenceConnectionProvider::CtlType() const

	{

	return MConnectionControlClient::ENormal;

	}

//-=========================================================

// CConnectionProviderBase methods

//-=========================================================

void CReferenceConnectionProvider::DoDataClientJoiningL(MConnectionDataClient& /*aDataClient*/)

	{

	__FLOG_2(_L("CReferenceConnectionProvider %08x:\tDoDataClientJoiningL number %d"), this, iDataClients.Count());

	//TODO: fill up with handling code if applicable.

	}

void CReferenceConnectionProvider::DoDataClientLeaving(MConnectionDataClient& /*aDataClient*/)

	{

	__FLOG_2(_L("CReferenceConnectionProvider %08x:\tDoDataClientLeaving number %d"), this, iDataClients.Count());

	//TODO: fill up with handling code if applicable.

	}

void CReferenceConnectionProvider::DoControlClientJoiningL(MConnectionControlClient& /*aControlClient*/)

	{

	__FLOG_2(_L("CReferenceConnectionProvider %08x:\tDoControlClientJoiningL number %d"), this, iControlClients.Count());

	//TODO: fill up with handling code if applicable.

	}

void CReferenceConnectionProvider::DoControlClientLeaving(MConnectionControlClient& /*aControlClient*/)

	{

	__FLOG_2(_L("CReferenceConnectionProvider %08x:\tDoControlClientLeaving number %d"), this, iControlClients.Count());

	//TODO: fill up with handling code if applicable.

  	}

void CReferenceConnectionProvider::DoStartL(Meta::SMetaData& aParams, const RMessagePtr2* aMessage)

	{

	//TODO: start this connection

	if (NULL != iNextLayer)

		{

		iNextLayer->StartL(aParams, aMessage);

		}

  	}

TInt CReferenceConnectionProvider::DoStop(TInt aError, const RMessagePtr2* aMessage)

	{

	if (NULL != iNextLayer)

		{

		//The next layer present. We'll now stop it here and anticipate ConnectionGoingDown() called on 'this'

		//when indeed, the connection is stopped.

		return iNextLayer->Stop(aError, aMessage);

		}

	else

    	{

    	//No next layer present, we're just need to delete this connection to complete the Stop message.

    	DeleteMeNow();

    	}

	return KErrNotReady;

  	}

void CReferenceConnectionProvider::DoProgressL(Meta::SMetaData& aBuffer) const

	{

	//TODO: update the progress info.

	if (NULL != iNextLayer)

		{

		iNextLayer->ProgressL(aBuffer);

		}

  	}

void CReferenceConnectionProvider::DoLastProgressError(Meta::SMetaData& aBuffer)

	{

	//TODO: return the last error actually ocurred.

	if (NULL != iNextLayer)

		{

		return iNextLayer->LastProgressError(aBuffer);

		}

  	}

void CReferenceConnectionProvider::DoRequestServiceChangeNotificationL()

	{

	if (NULL != iNextLayer)

		{

		iNextLayer->RequestServiceChangeNotificationL();

		}

  	}

void CReferenceConnectionProvider::DoCancelServiceChangeNotification()

	{

	if (NULL != iNextLayer)

		{

		iNextLayer->CancelServiceChangeNotification();

		}

  	}

void CReferenceConnectionProvider::DoControlL(TUint aOptionLevel, TUint aOptionName, Meta::SMetaData& aOption, const RMessagePtr2* aMessage)

	{

	if (NULL != iNextLayer)

		{

		return iNextLayer->ControlL(aOptionLevel, aOptionName, aOption, aMessage);

		}

  	}

TInt CReferenceConnectionProvider::DoEnumerateSubConnectionsL(TUint& /*aCount*/)

	{

	return KErrNotReady;

	//TODO: fill up aCount with the number of subconnections active.

	}

TUint CReferenceConnectionProvider::DoEnumerateClientsL(HBufC8*& aClientInfoBuffer, TEnumClients aClientType)

/**

Returns information about the clients of this Interface

@param aCount on return contains the number of clients using this Interface

@param aClientInfoBuffer on return contains a TPckg<> containing information about each client

@exception leaves with KErrNoMemory if memory allocation fails

*/

	{

	const TInt KInfoBufMaxLength = 1024;  //is this large enough?

	TBuf8<KInfoBufMaxLength> infoBuf;

	TUint count = 0;

	STypeId tid(KConnectionClientExtUid,EConnectionClientDesc);

	TInt max = iControlClients.Count();

	for ( TInt n = 0; n < max; n++ )

		{

		MConnectionClientDesc* intf = reinterpret_cast<MConnectionClientDesc*>(iControlClients[n]->FetchInterfaceInstanceL(*this,tid));

		if ( intf )

			{

			TConnectionProcessInfo cinfo;

			cinfo.GetInfoL(aClientType, count, *intf, infoBuf);

			}

		}

	STypeId tid2(KConnectionClientExtUid,EConnectionEnumerateClients);

	max = iDataClients.Count();

	for ( TInt n = 0; n < max; n++ )

		{

		MConnectionEnumerateClients* intf = reinterpret_cast<MConnectionEnumerateClients*>(iDataClients[n]->FetchInterfaceInstanceL(*this,tid2));

		if ( intf )

			{

			intf->EnumerateClientsL(count, infoBuf, aClientType);

			}

		}

	aClientInfoBuffer = infoBuf.AllocL();

	return count;

	}

void CReferenceConnectionProvider::DoConnectionControlActivityL( CConnectionProviderBase::TControlActivity /*aControlActivity*/, const Meta::SMetaData* /*aData*/, const RMessagePtr2* /*aMessage*/ )

	{

	//TODO:

	}

CConnectionSettings& CReferenceConnectionProvider::DoSettingsAccessL()

	{

	//TODO: If no lower layer, derive your own CConnectionSettings

	//class and return a reference to an instance of it here.

	if (NULL != iNextLayer)

		{

		return iNextLayer->SettingsAccessL();

		}

	User::Panic(KPanicReferenceCPRText, KErrNotFound);

	CConnectionSettings* null = NULL;

	return *static_cast<CConnectionSettings*>(null);

	}

TInt CReferenceConnectionProvider::DoAllSubConnectionNotificationEnable()

	{

	if (NULL != iNextLayer)

		{

		return iNextLayer->AllSubConnectionNotificationEnable();

		}

	return KErrNotReady;

  	}

TInt CReferenceConnectionProvider::DoCancelAllSubConnectionNotification()

	{

	if (NULL != iNextLayer)

		{

		return iNextLayer->CancelAllSubConnectionNotification();

		}

	return KErrNotReady;

  	}

void CReferenceConnectionProvider::DoSendIoctlMessageL(const RMessage2& aMessage)

	{

	if (NULL != iNextLayer)

		{

		iNextLayer->SendIoctlMessageL(aMessage);

		}

  	}

void CReferenceConnectionProvider::DoSendCancelIoctl()

	{

	if (NULL != iNextLayer)

		{

		iNextLayer->SendCancelIoctl();

		}

  	}

TInt CReferenceConnectionProvider::DoCanDoSubConnection(RSubConnection::TSubConnType /*aSubConnType*/) const

	{

	return ETrue;

  	}

void CReferenceConnectionProvider::DoJoinNextLayerL(CConnectionProviderBase* aNextLayer)

	{

	__ASSERT_DEBUG(( !iNextLayer && aNextLayer), User::Panic(KSpecAssert_RefCprConProv, 1));

	iNextLayer = aNextLayer;

    SetConnectionInfo(iNextLayer->ConnectionInfo());

    // join ourselves as a connection control client to the lower provider

    iNextLayer->JoinL(*this);

	}

CConnectionProviderBase* CReferenceConnectionProvider::DoNextLayer() const

	{

  	return iNextLayer;

  	}