/**
*   Copyright (c) 2010 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:
*   Source file for tundriver agent.
* 
*
*/

/**
 @file tundriveragent.cpp
 @internalTechnology
*/

#include "tundriveragent.h"
extern "C" EXPORT_C CNifAgentFactory* NewAgentFactoryL()
/**
Agent Factory
First ordinal export

@internalComponent
@return an object to class CTunAgentFactory,which Perform Agent initialisation.
*/
	{	
	return new(ELeave) CTunDriverAgentFactory;
	}

void CTunDriverAgentFactory::InstallL() 
/**
Performs a new Agent initialisation
*/
	{}
 
CNifAgentBase* CTunDriverAgentFactory::NewAgentL(const TDesC& /*aName*/)
/**
Creates a new TunDriverAgent to TunDriver

@param aName , name of the TunDriverAgent
@return a new instance of class TunDriverAgent
*/
	{
	return CTunDriverAgent::NewL();
	}

TInt CTunDriverAgentFactory::Info(TNifAgentInfo& aInfo, TInt /*aIndex*/) const
/**
Retrieves information about the Agent

@param aInfo,a reference of class TNifAgentInfo which contains information about TunDriverAgent
@return KErrNone if information retrieved successfully.
*/
	{
	aInfo.iName = KTunDriverAgentName;
	aInfo.iVersion = TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
	return KErrNone;
	}

CTunDriverAgent::CTunDriverAgent() :	iServiceStartedCallback(CActive::EPriorityStandard),
							iConnectCompleteCallback(CActive::EPriorityStandard), 
							iDisconnectCallback(CActive::EPriorityStandard)
/**
Default Constructor
*/
	{
	TCallBack serviceStartedCallback(ServiceStartedCb, this);
	iServiceStartedCallback.Set(serviceStartedCallback);
	
	TCallBack connectionCompleteCallback(ConnectCompleteCb, this);
	iConnectCompleteCallback.Set(connectionCompleteCallback);

	TCallBack disconnectionCompleteCallback(DisconnectCompleteCb, this);
	iDisconnectCallback.Set(disconnectionCompleteCallback);
	}
 
CTunDriverAgent::~CTunDriverAgent()
/**
Destructor
*/
	{
	iServiceStartedCallback.Cancel();
	iConnectCompleteCallback.Cancel();
	iDisconnectCallback.Cancel();
	}


CTunDriverAgent* CTunDriverAgent::NewL()
/**
Static NewL function constructing an object of class CTunDriverAgent

@return self,pointer to class TunDriverAgent,that owns a CAsyncCallback used to 
control the asynchronous ServiceStarted() and DisconnectComplete() call from the Agent to TunDriver. 
*/
	{
	CTunDriverAgent* self = new (ELeave) CTunDriverAgent();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

void CTunDriverAgent::ConstructL()
/**
2nd Phase Constructor
Calls CAgentBase::ConstructL()
construct the database and dialog processor
*/
	{
	CAgentBase::ConstructL();
	iCancelled = EFalse;
	iAgentProgress = ETunDriverAgtIdle;
	}

void CTunDriverAgent::Info(TNifAgentInfo& aInfo) const
/**
Information about this Agent

@param aInfo on return contains information about the agent
*/
	{
	aInfo.iName = KTunDriverAgentName;
	aInfo.iName.AppendFormat(_L("-AgentFactory[0x%08x]"), this);
	aInfo.iVersion = TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
	}

void CTunDriverAgent::Connect(TAgentConnectType aType)
/**
Connects this TunDriverAgent to TunDriver

@internalComponent  
@param aType, a variable of enum TAgentConnectType describing connection types.
*/
	{
	if (EAgentReconnect == aType)
		{
		iConnectCompleteCallback.CallBack();
		}
	else
		{
		iCancelled = EFalse;
		iServiceStartedCallback.CallBack();		
		}
	}

void CTunDriverAgent::Connect(TAgentConnectType aType, CStoreableOverrideSettings* /*aOverrideSettings*/)
/**
Connects this TunDriverAgent to TunDriver with store and retrieve commDB override sets to and from both
streams and buffers.

@param aType,a variable of enum TAgentConnectType describing connection types.
@param aOverrideSettings, a pointer to class CStoreableOverrideSettings which store CommDB overrides.
*/
	{
	Connect(aType);
	}

void CTunDriverAgent::CancelConnect()
/**
Cancels Connection of the TunDriverAgent to TunDriver 
*/
	{
	iServiceStartedCallback.Cancel();
	iConnectCompleteCallback.Cancel();
	iConnected = EFalse;
	iCancelled = ETrue;
	}

void CTunDriverAgent::Disconnect(TInt aReason)
/**
Disconnects from the TunDriverAgent to TunDriver with reason 

@param aReason, reason for disconnection to the agent.
*/
	{	   
	iLastErrorCode = aReason;
	iDisconnectCallback.CallBack();
	}

void CTunDriverAgent::ServiceStarted(TInt /*aError*/)
/**
ConnectionComplete from TunDriverAgent to TunDriver
This function is calling CallBack() function if connect is not cancelled

@param aError, error number for which service needs to be started.
*/
	{
	iAgentProgress = ETunDriverAgtConnecting;
	iNotify->AgentProgress(iAgentProgress, KErrNone);
	iNotify->ServiceStarted();
	
	/* if the connect has been cancelled during ServiceStarted() then we need to avoid 
	 * calling ConnectComplete() - done in this next callback - otherwise we get a panic */
	if (!iCancelled)
		iConnectCompleteCallback.CallBack();
	}

void CTunDriverAgent::ConnectionComplete(TInt aError)
/**
Second phase of completing connection of TunDriveragent to TunDriver

@param aError,error number for which connection is complete.
*/
    {
    if(aError==KErrNone)
	    {
        iAgentProgress = ETunDriverAgtConnected;
        iNotify->AgentProgress(ETunDriverAgtConnected, aError);
        iNotify->ConnectComplete(aError);
        iConnected = ETrue;
        return;
	    }
	iNotify->AgentProgress(iAgentProgress,aError);
	iNotify->ConnectComplete(aError);
	iConnected = EFalse;
    }

void CTunDriverAgent::DisconnectionComplete()
/**
Completes the disconnection of TunDriveragent from TunDriver
*/
	{
	
	if ( iDisconnecting )
	        {
            iNotify->AgentProgress(iAgentProgress, KErrNone);
	        }
	    else
	        {
            iAgentProgress = ETunDriverAgtDisconnected;
            iDisconnecting = ETrue;
	        iNotify->AgentProgress(iAgentProgress, KErrNone);
	        iNotify->DisconnectComplete();
	        iConnected = EFalse;
	        }
	}

TInt CTunDriverAgent::GetExcessData(TDes8& /*aBuffer*/)
/**
Gets excessData from TunDriveragent to TunDriver

@param aBuffer, variable containing the name of TunDriveragent
@return KErrNotSupported,error code if it does not get excess data from TunDriveragent.
*/
	{
	return KErrNotSupported;
	}


TInt CTunDriverAgent::Notification(TNifToAgentEventType /*aEvent*/, TAny* /*aInfo*/)
 /*
Establishes the Notification types from Nif to Agent for the TunDriveragent

@param aEvent,a variable of enum TNifToAgentEventType, which contains Notification types from TunDriver to TunDriverAgent
@param aInfo, information about the agent
@return KErrNotSupported,error code if the notification type does not exist.
*/
	{
	return KErrNone;		
	}

void CTunDriverAgent::GetLastError(TInt& aError)
/**
Gets the LastError
*/
	{
	aError = iLastErrorCode;
	}



TInt CTunDriverAgent::IncomingConnectionReceived()
/**
IncomingConnectionReceived

@return KErrNotSupported, error code if incoming connection is not received.
*/
	{
	return KErrNotSupported;
	}

TInt CTunDriverAgent::ServiceStartedCb(TAny* aThisPtr)
/**
 * Connection Callback static function 
 *
 */
	{
	CTunDriverAgent* self = (CTunDriverAgent*)aThisPtr;
	self->ServiceStarted(KErrNone);
	return KErrNone;
	}

TInt CTunDriverAgent::ConnectCompleteCb(TAny* aThisPtr)
/**
 * Second callback used during connection creation
 *
 */
    {
	CTunDriverAgent* self = (CTunDriverAgent*) aThisPtr;
	self->ConnectionComplete(KErrNone);
	return KErrNone;
    }

TInt CTunDriverAgent::DisconnectCompleteCb(TAny* aThisPtr)
/**
 * Disconnection callback static function
 *
 */
    {
	CTunDriverAgent* self = (CTunDriverAgent*) aThisPtr;
	self->DisconnectionComplete();
	return KErrNone;
    }