// 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 SubConnection Provider Factory

//

//

/**

 @file

 @internalComponent

*/

#include <implementationproxy.h>

#include <ss_glob.h>

#include "ReferenceCPR_connProv.h"

#include "ReferenceCPR_connProvFactory.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_RefCprConProvFac, "RefCprConProvFac");

#endif

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

// Data/functions required for instantiating ECOM Plugin

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

const TInt KReferenceConnectionProviderImplementationUid=0x102738D0;

const TImplementationProxy ImplementationTable[] =

	{

	IMPLEMENTATION_PROXY_ENTRY(KReferenceConnectionProviderImplementationUid, CReferenceProviderFactory::NewL)

	};

/**

ECOM Implementation Factory

*/

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

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

// CReferenceProviderFactory

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

/**NewL is the actual ECOM Connection Provider interface implemented.

ESOCK will call it to instantiate the factory and store it in the

CConnectionProviderFactoryContainer.

@param aConstructionParameters construction data passed by ECOM

@returns pointer to a constructed factory

*/

CReferenceProviderFactory* CReferenceProviderFactory::NewL(TAny* aParentContainer)

	{

 	return new (ELeave) CReferenceProviderFactory(KReferenceConnectionProviderFactoryId,

 					*(reinterpret_cast<CConnectionFactoryContainer*>(aParentContainer)));

	}

/**C'tor

@param aFactoryId - the id of this factory. The id should represent the type of subconnection

                    providers this factory can produce.

@param aParentContainer - the factory container the new factory object should add itself to.

*/

CReferenceProviderFactory::CReferenceProviderFactory(TUint aFactoryId, CConnectionFactoryContainer& aParentContainer)

:CConnectionProviderFactoryBase(aFactoryId, aParentContainer)

	{

	}

CConnectionProviderBase* CReferenceProviderFactory::DoCreateProviderL()

	{

    return CReferenceConnectionProvider::NewL(*this);

	}

/**A sample/reference derivation of DoSelectProvider. The method is responsible for:

- selecting an instance of the connection provider at this level of the connection provider stack.

- determining the connection provider type at the layer below this

- triggering the selection at the layer below.

@param aPreferences     - connection preferences for the connection to be selected.

@param aSelectionNotify - the notify interface (see class ISelectionNotify and see its usage

                          in the implementation file).

@param aMessage         - the orignal IPC message.

@returns pointer to a MProviderSelector object. The pointer can be used by the caller to cancel the

selection. Please note, this is a self-destructing object - the caller should assume the pointer

becomes invalid after the selection.

*/

MProviderSelector* CReferenceProviderFactory::DoSelectProvider( Meta::SMetaData& aPreferences, ISelectionNotify& aSelectionNotify, const RMessagePtr2* aMessage )

	{

	CReferenceSelector* selector = new CReferenceSelector(aSelectionNotify,*this);

	if (NULL == selector)

		{

		aSelectionNotify.SelectComplete(NULL, KErrNoMemory);

		}

	else if (selector->Select(aPreferences, aMessage) != KErrNone)

		{

		selector = NULL;

		}

	return selector;

  	}

/**A sample/reference derivation of DoSelectNextLayerProvider. The method is responsible for:

- determining the connection provider type at the layer below this

- triggering the selection at the layer below.

One can observe that DoSelectNextLayerProvider has a subset of the responsibilities held by

DoSelectNextLayerProvider.

@param aPreferences     - connection preferences for the connection to be selected.

@param aSelectionNotify - the notify interface (see class ISelectionNotify and see its usage

                          in the implementation file).

@param aMessage         - the orignal IPC message.

@returns pointer to a MProviderSelector object. The pointer can be used by the caller to cancel the

selection. Please note, this is a self-destructing object - the caller should assume the pointer

becomes invalid after the selection.

*/

MProviderSelector* CReferenceProviderFactory::DoSelectNextLayerProvider( Meta::SMetaData& aPreferences, ISelectionNotify& aSelectionNotify, const RMessagePtr2* aMessage )

	{

	//This method should determine the type (factoryId) of the connection below this layer.

	TInt factoryId = KInvalidFactoryId;

	//When done

	CConnectionFactoryContainer* connectionFactories = SockManGlobals::Get()->iConnectionFactories;

	__ASSERT_DEBUG(connectionFactories, User::Panic(KSpecAssert_RefCprConProvFac, 1));

	CConnectionProviderFactoryBase* factory = connectionFactories->FindFactory(factoryId);

	return factory->SelectProvider(aPreferences, aSelectionNotify, aMessage);

	}

void CReferenceProviderFactory::DoEnumerateConnectionsL(RPointerArray<TConnectionInfo>& /*aConnectionInfoPtrArray*/)

	{

	//TODO: enumerate connections.

	}

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

// CReferenceSelector

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

CReferenceSelector::CReferenceSelector(ISelectionNotify& aNotify, CReferenceProviderFactory& aFactory)

:iNotify(aNotify),

 iFactory(aFactory),

 iNextLayerSelector(NULL)

	{

	}

//CReferenceSelector

TInt CReferenceSelector::Cancel()

	{

	//TODO: cancel the selection

    if (iNextLayerSelector)

        {

        return iNextLayerSelector->Cancel();

        }

    return KErrNotReady;

	}

TInt CReferenceSelector::Cancel(TInt aReason, const RMessage2* aMessage)

	{

	//TODO: cancel the selection

    if (iNextLayerSelector)

        {

        return iNextLayerSelector->Cancel(aReason, aMessage);

        }

    return KErrNotReady;

	}

TInt CReferenceSelector::Select(Meta::SMetaData& aPreferences, const RMessagePtr2* aMessage)

    {

	//Prepare ISelectionNotify. MProviderSelector may choose the events it wishes to be notified

	//about by implementing a subset of the possible upcalls. The list of the actually implemented

	//is used to create an ISelectionNotify object (a loose function pointer holder) and passed

	//to the factory below to perform the selection at the lower level.

	ISelectionNotify selectNotify( this, TSelectionNotify<CReferenceSelector>::SelectComplete,

	                                     TProgressNotify<CReferenceSelector>::ProgressNotification,

	                                     TServiceChangeNotify<CReferenceSelector>::ServiceChangeNotification,

	                                     TLayerUp<CReferenceSelector>::LayerUp,

	                                     TSubConnectionEventTmpl<CReferenceSelector>::SubConnectionEvent,

	                                     TDetachNotify<CReferenceSelector>::Detach);

	iNextLayerSelector = iFactory.SelectNextLayerProvider(aPreferences, selectNotify, aMessage);

	return (iNextLayerSelector ? KErrNone : KErrNotReady);

    }

void CReferenceSelector::SelectComplete(CConnectionProviderBase* aConnProvider, TInt aError)

    {

    CReferenceConnectionProvider* connProvider = NULL;

    if (aError == KErrNone)

        {

	    __ASSERT_DEBUG(aConnProvider, User::Panic(KSpecAssert_RefCprConProvFac, 2));

        XConnectionFindSameLowerLayerQuery query(aConnProvider);

        TRAP( aError, connProvider = static_cast<CReferenceConnectionProvider*>(iFactory.FindOrCreateProviderL(query)));

        if (aError == KErrNone && connProvider->NextLayer() == NULL)

            {

            //the factory returned a new instance - must set the lower layer

            TRAP(aError,connProvider->JoinNextLayerL(aConnProvider));

            }

        }

    iNotify.SelectComplete(connProvider, aError);

    }

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

    {

    iNotify.ProgressNotification(aStage, aError);

    }

void CReferenceSelector::LayerUp(TInt aError)

	{

    iNotify.LayerUp(aError);

	}

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

	{

	iNotify.SubConnectionEvent(aSubConnNextLayerProvider, aSubConnectionEvent);

	}

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

	{

    iNotify.ServiceChangeNotification(aId, aType);

	}

void CReferenceSelector::Detach()

	{

	iNotify.Detach();

	iNextLayerSelector = NULL;

	delete this;

	}

CReferenceSelector::~CReferenceSelector()

    {

	if (iNextLayerSelector)

		{

		iNextLayerSelector->Cancel();

		}

    }

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

// XConnectionFindSameLowerLayerQuery

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

MCommsFactoryQuery::TMatchResult XConnectionFindSameLowerLayerQuery::Match( TFactoryObjectInfo& aProviderInfo )

	{

	CConnectionProviderBase* prov = static_cast<CConnectionProviderBase*>(aProviderInfo.iInfo.iFactoryObject);

	return prov->NextLayer() == iConnectionProviderBase ? EMatch : EContinue;

	}