// Copyright (c) 2004-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 "CNetConDlgProcessor.h"

#include <comms-infras/dialogprocessor.h>

#include "CNetworkController.h"

#include "MNetConDialogProcAccess.h"

#include "NetConPanic.h"

/*

Template adapter class:

Implement MNetConDialogProcAccess by forwarding all calls to 'Implementor' class

Also can optionally 'own' the instance of the implementor (i.e. deletes it on destruction)

*/

template<typename Implementor>

class CMDialogProcessorImpl : public CBase, public MNetConDialogProcAccess

	{

protected:

	typedef Implementor TImplementation; //< Type of the implementor

public:

	/**

	   Construct an MDialogProcessorImpl object.

	   @param aPimpl  Points to implementation object

	   @param aOwnImpl If ETrue, then the aPimpl will be destroyed when *this is destroyed.

	   @return Instance of CMDialogProcessorImpl

	*/

	static CMDialogProcessorImpl* NewL( TImplementation* aPimpl, TBool aOwnImpl )

		{

		CMDialogProcessorImpl* self = new (ELeave) CMDialogProcessorImpl( aPimpl, aOwnImpl );

		return self;

		}

	/**

	   Forward the CancelEverything request to the implementation

	*/

	virtual void CancelEverything()

		{

		GetImpl()->CancelEverything();

		}

	/**

	   Forward the SelectConnection request to the implementation

	*/

	virtual void SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs)

		{

		GetImpl()->SelectConnection( aObserver, aPrefs );

		}

	/**

	   Forward the SelectConnection request to the implementation

	*/

	virtual void SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, TInt aLastError )

		{

		GetImpl()->SelectConnection( aObserver, aPrefs, aLastError );

		}

	/**

	   Forward the SelectModemAndLocation request to the implementation

	*/

	virtual void SelectModemAndLocation(MDialogProcessorObserver& aObserver)

		{

		GetImpl()->SelectModemAndLocation( aObserver );

		}

	/**

	   Forward the WarnNewConnection request to the implementation

	*/

	virtual void WarnNewConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, const TDesC* aNewIapName, const TIspConnectionNames* aNewConnectionNames, TInt aLastError )

		{

		GetImpl()->WarnNewConnection( aObserver, aPrefs, aNewIapName, aNewConnectionNames, aLastError );

		}

	/**

	   Forward the Reconnect request to the implementation

	*/

	virtual void Reconnect(MDialogProcessorObserver& aObserver )

		{

		GetImpl()->Reconnect( aObserver );

		}

	/**

	   Destroy this object.

	*/

	virtual ~CMDialogProcessorImpl()

		{

		if( iOwnImpl )

			{

			delete iPimpl;		// We own it, so get rid of it

			}

		iPimpl = 0;

		}

protected:

	/**

	   Constructor. Unexciting in the extreme.

	   @param aPimpl pointer to implementation

	   @param aOwnImpl If ETrue, transfers ownership of the implementation to this wrapper

	*/

	CMDialogProcessorImpl( TImplementation *aPimpl, TBool aOwnImpl )

		:iPimpl(aPimpl), iOwnImpl(aOwnImpl)

		{

		__ASSERT_DEBUG( iPimpl, NetConPanic(NetworkController::ETelBearerBadState));

		}

private:

	/**

	   Return the implementation pointer

	*/

	inline TImplementation* GetImpl() const

		{

		__ASSERT_DEBUG( iPimpl, NetConPanic(NetworkController::ETelBearerBadState));

		return iPimpl;

		}

private:

	TImplementation* iPimpl;	//< Pointer to class that implements the interface in a non-virtual fashion

	TBool iOwnImpl;				//< ETrue if the destructor should delete iPimpl

	};

/**

   Implement MNetConDialogProcAccess destructor

*/

MNetConDialogProcAccess::~MNetConDialogProcAccess()

	{

	}

/**

  Construct a CNetConDlgProcessor using the default CDialogProcessor implementation

  @return a pointer to the newly created CNetConDlgProcessor

*/

CNetConDlgProcessor* CNetConDlgProcessor::NewL()

	{

	// To do this, we have to wrap a CDialogProcessor up so it looks like a MNetConDialogProcAccess.

	// so use the CMDialogProcessorImpl wrapper class

	// First, construct the CDialogProcessor itself...

	CDialogProcessor* processor = CDialogProcessor::NewL();

	CleanupStack::PushL( processor );

	// Now costruct the MNetConDialogProcAccess wrapper for it

	CMDialogProcessorImpl<CDialogProcessor>* impl = CMDialogProcessorImpl<CDialogProcessor>::NewL( processor, ETrue );

	// impl now owns aProcess, so get it back from the cleanup stack

	CleanupStack::Pop( processor );

	// and save impl...

	CleanupStack::PushL( impl );

	// Construct the CNetConDlgProcessor itself

	CNetConDlgProcessor* self = new (ELeave) CNetConDlgProcessor( impl );

	// and cleanup the cleanup

	CleanupStack::Pop( impl );

	return self;

	}

/**

  Construct a CNetConDlgProcessor using a supplied MNetConDialogProcAccess implementation

  @param aImpl The supplied implementation

  @param aOwnImpl True if the CNetConDlgProcessor takes ownership of aImpl

  @return a pointer to the newly created CNetConDlgProcessor

*/

CNetConDlgProcessor* CNetConDlgProcessor::NewL( MNetConDialogProcAccess* aImpl, TBool aOwnImpl )

	{

	// Note: We can probably get away without the CMDialogProcessorImpl wrapper in the case where aOwnImpl is true

	// Construct a wrapper for the implementation

	CMDialogProcessorImpl<MNetConDialogProcAccess>* impl = CMDialogProcessorImpl<MNetConDialogProcAccess>::NewL( aImpl, aOwnImpl );

	CleanupStack::PushL( impl );

	// Transfer ownership of the wrapper to the dialog processor itself

	CNetConDlgProcessor* self = new (ELeave) CNetConDlgProcessor( impl );

	CleanupStack::Pop( impl );

	return self;

	}

CNetConDlgProcessor::~CNetConDlgProcessor()

	{

	delete iDialogProc;

	}

/**

   Constructor

   @param aImpl  Pointer to dialog processor implementation

*/

CNetConDlgProcessor::CNetConDlgProcessor( MNetConDialogProcAccess* aImpl )

	:iDialogProc( aImpl )

	{

	ASSERT( aImpl );

	}

/**

   Retrieve the implementation pointer

*/

MNetConDialogProcAccess* CNetConDlgProcessor::GetImpl() const

	{

	__ASSERT_DEBUG( iDialogProc, NetConPanic(NetworkController::ETelBearerBadState));

	return iDialogProc;

	}

/**

   Cancel all outstanding dialog processor requests

*/

void CNetConDlgProcessor::CancelEverything()

	{

	GetImpl()->CancelEverything();

	}

/**

   Display a dialog to the user asking them to select an IAP to connect to

   @param aObserver the object to receive notification when the dialog box completes

   @param aPrefs the connection preferences used to select this IAP

*/

void CNetConDlgProcessor::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs)

	{

	GetImpl()->SelectConnection( aObserver, aPrefs );

	}

/**

   Display a dialog to the user asking them to select an IAP to connect to

   @param aObserver the object to receive notification when the dialog box completes

   @param aPrefs the connection preferences used to select this IAP

   @param aLastError if this is not the 1st connection attempt this is the error of the last attempt

*/

void CNetConDlgProcessor::SelectConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, TInt aLastError )

	{

	GetImpl()->SelectConnection( aObserver, aPrefs, aLastError );

	}

/**

   Display a dialog to the user asking the user to select a modem and location entry from CommDb

   @param aObserver the object to receive notification when the dialog box completes

*/

void CNetConDlgProcessor::SelectModemAndLocation(MDialogProcessorObserver& aObserver)

	{

	GetImpl()->SelectModemAndLocation( aObserver );

	}

/**

   Display a dialog to the user warning that a new connection is about to be attempted to the specified IAP

   @param aObserver the object to receive notification when the dialog box completes

   @param aPrefs the connection preferences used to select this IAP

   @param aNewIapName the name of the IAP used for the connection.

   @param aNewConnectionNames this parameter is no-longer used.

   @param aLastError if this is not the 1st connection attempt this is the error of the last attempt

*/

void CNetConDlgProcessor::WarnNewConnection(MDialogProcessorObserver& aObserver, const TConnectionPrefs& aPrefs, const TDesC* aNewIapName, const TIspConnectionNames* aNewConnectionNames, TInt aLastError )

	{

	GetImpl()->WarnNewConnection( aObserver, aPrefs, aNewIapName, aNewConnectionNames, aLastError );

	}

/**

   Display a dialog to the user asking whether to reconnect a failed connection

   @param aObserver the object to receive notification when the dialog box completes

*/

void CNetConDlgProcessor::Reconnect(MDialogProcessorObserver& aObserver )

	{

	GetImpl()->Reconnect( aObserver );

	}