// 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:
// Support for TCP/IP stack calling NIFMAN via MNifIfNotify pointer in CNIfIfBase.
// 
//

/**
 @file notify.cpp
*/

#include "notify.h"
#include "panic.h"
#include "idletimer.h"
#include <comms-infras/ss_datamonitoringprovider.h>

using namespace ESock;

//
// CIPShimNotify methods //
//

CIPShimNotify::CIPShimNotify(CIPShimIfBase* aIntf) : iIntf(aIntf)
	{
	}

CIPShimNotify* CIPShimNotify::NewL(CIPShimIfBase* aIntf)
	{
	return new (ELeave) CIPShimNotify(aIntf);
	}

void CIPShimNotify::OpenRoute()
	{ 
   	iIntf->ProtcolIntf()->OpenRoute();
	}
	
void CIPShimNotify::CloseRoute()
	{	       	
   	iIntf->ProtcolIntf()->CloseRoute();
	}
	
TInt CIPShimNotify::PacketActivity(TDataTransferDirection aDirection, TUint aBytes, TBool aResetTimer)
	{
	ASSERT(iPacketActivity);
	ASSERT(iConnectionVolumesPtr);
	ASSERT(iSubConnectionVolumesPtr);
			
	*iPacketActivity = aResetTimer;

	switch(aDirection)
		{
	case EIncoming:
		/******************************
		 * NOTE: shared memory write
		 ******************************/
		iConnectionVolumesPtr->iReceivedBytes += aBytes;
		
		if(iConnectionVolumesPtr->iReceivedBytes < aBytes)
			{
			iIntf->Flow().PostConnDataReceivedThresholdReached(KMaxTUint32);
			}
		else 
			{
			if(iConnectionThresholdsPtr->iReceivedThreshold && iConnectionVolumesPtr->iReceivedBytes >= iConnectionThresholdsPtr->iReceivedThreshold)
				{
				iConnectionThresholdsPtr->iReceivedThreshold = 0;
				iIntf->Flow().PostConnDataReceivedThresholdReached(iConnectionVolumesPtr->iReceivedBytes);
				}
			}
			
		/******************************
		 * NOTE: shared memory write
		 ******************************/
		iSubConnectionVolumesPtr->iReceivedBytes += aBytes;
		
		if(iSubConnectionVolumesPtr->iReceivedBytes < aBytes)
			{
			iIntf->Flow().PostSubConnDataReceivedThresholdReached(KMaxTUint32);
			}
		else
			{
			if(iSubConnectionThresholdsPtr->iReceivedThreshold && iSubConnectionVolumesPtr->iReceivedBytes >= iSubConnectionThresholdsPtr->iReceivedThreshold)
				{
				iSubConnectionThresholdsPtr->iReceivedThreshold = 0;
				iIntf->Flow().PostSubConnDataReceivedThresholdReached(iSubConnectionVolumesPtr->iReceivedBytes);
				}				
			}			
		break;
		
	case EOutgoing:
		/******************************
		 * NOTE: shared memory write
		 ******************************/
		iConnectionVolumesPtr->iSentBytes += aBytes;
		
		if(iConnectionVolumesPtr->iSentBytes < aBytes)
			{
			iIntf->Flow().PostConnDataSentThresholdReached(KMaxTUint32);
			}
		else 
			{
			if(iConnectionThresholdsPtr->iSentThreshold && iConnectionVolumesPtr->iSentBytes >= iConnectionThresholdsPtr->iSentThreshold)
				{
				iConnectionThresholdsPtr->iSentThreshold = 0;
				iIntf->Flow().PostConnDataSentThresholdReached(iConnectionVolumesPtr->iSentBytes);
				}
			}
			
		/******************************
		 * NOTE: shared memory write
		 ******************************/
		iSubConnectionVolumesPtr->iSentBytes += aBytes;
		
		if(iSubConnectionVolumesPtr->iSentBytes < aBytes)
			{
			iIntf->Flow().PostSubConnDataSentThresholdReached(KMaxTUint32);
			}
		else
			{
			if(iSubConnectionThresholdsPtr->iSentThreshold && iSubConnectionVolumesPtr->iSentBytes >= iSubConnectionThresholdsPtr->iSentThreshold)
				{
				iSubConnectionThresholdsPtr->iSentThreshold = 0;
				iIntf->Flow().PostSubConnDataSentThresholdReached(iSubConnectionVolumesPtr->iSentBytes);
				}				
			}			
		break;
		
	default:
		break;
		
		} // switch(aDirection)

	return KErrNone;
	}

void CIPShimNotify::SetPacketActivityFlag(volatile TBool* aPacketActivity)
	{
	ASSERT(aPacketActivity);
	iPacketActivity = aPacketActivity;
	}

void CIPShimNotify::SetDataVolumePtrs(TDataVolumes* aConnectionVolumesPtr, TDataVolumes* aSubConnectionVolumesPtr)
	{
	ASSERT(aConnectionVolumesPtr);
	ASSERT(aSubConnectionVolumesPtr);
	
	iConnectionVolumesPtr = aConnectionVolumesPtr;
	iSubConnectionVolumesPtr = aSubConnectionVolumesPtr;
	}
	
void CIPShimNotify::SetNotificationThresholdPtrs(TNotificationThresholds* aConnectionThresholdsPtr, TNotificationThresholds* aSubConnectionThresholdsPtr)
	{
	ASSERT(aConnectionThresholdsPtr);
	ASSERT(aSubConnectionThresholdsPtr);
	
	iConnectionThresholdsPtr = aConnectionThresholdsPtr;
	iSubConnectionThresholdsPtr = aSubConnectionThresholdsPtr;
	}


//
// Methods stubbed out to panic
//

void CIPShimNotify::LinkLayerDown(TInt /*aReason*/, TAction /*aAction*/)
	{
	Panic(EBadNotifyCall);
	}
	
void CIPShimNotify::LinkLayerUp()
	{
	Panic(EBadNotifyCall);
	}
	
void CIPShimNotify::NegotiationFailed(CNifIfBase* /*aIf*/, TInt /*aReason*/)
	{
	Panic(EBadNotifyCall);
	}
	
TInt CIPShimNotify::Authenticate(TDes& /*aUsername*/, TDes& /*aPassword*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
void CIPShimNotify::CancelAuthenticate()
	{
	Panic(EBadNotifyCall);
	}
	
TInt CIPShimNotify::GetExcessData(TDes8& /*aBuffer*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
void CIPShimNotify::IfProgress(TInt /*aStage*/, TInt /*aError*/)
	{
	Panic(EBadNotifyCall);
	}
	
void CIPShimNotify::IfProgress(TSubConnectionUniqueId /*aSubConnectionUniqueId*/, TInt /*aStage*/, TInt /*aError*/)
	{
	Panic(EBadNotifyCall);
	}
	
TInt CIPShimNotify::Notification(TNifToAgentEventType /*aEvent*/, void * /*aInfo*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
void CIPShimNotify::BinderLayerDown(CNifIfBase* /*aBinderIf*/, TInt /*aReason*/, TAction /*aAction*/)
	{
	Panic(EBadNotifyCall);
	}
		
void CIPShimNotify::NotifyDataSent(TSubConnectionUniqueId /*aSubConnectionUniqueId*/, TUint /*aUplinkVolume*/)
	{
	Panic(EBadNotifyCall);
	}
	
void CIPShimNotify::NotifyDataReceived(TSubConnectionUniqueId /*aSubConnectionUniqueId*/, TUint /*aDownlinkVolume*/)
	{
	Panic(EBadNotifyCall);
	}
	
void CIPShimNotify::NifEvent(TNetworkAdaptorEventType /*aEventType*/, TUint /*aEvent*/, const TDesC8& /*aEventData*/, TAny* /*aSource*/)
	{
	Panic(EBadNotifyCall);
	}
	
TInt CIPShimNotify::DoReadInt(const TDesC& /*aField*/, TUint32& /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoWriteInt(const TDesC& /*aField*/, TUint32 /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoReadDes(const TDesC& /*aField*/, TDes8& /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoReadDes(const TDesC& /*aField*/, TDes16& /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoWriteDes(const TDesC& /*aField*/, const TDesC8& /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoWriteDes(const TDesC& /*aField*/, const TDesC16& /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoReadBool(const TDesC& /*aField*/, TBool& /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}
	
TInt CIPShimNotify::DoWriteBool(const TDesC& /*aField*/, TBool /*aValue*/, const RMessagePtr2* /*aMessage*/)
	{
	Panic(EBadNotifyCall);
	return KErrNotSupported;
	}