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

//

/**

 @file SHIMDATATRANSFER.CPP

*/

#include "shimnifmansconn.h"

#include "shimdatatransfer.h"

#include "es_prot.h" //CConnectionProvdBase alias NIFMAN

CConnDataTransferShim::CConnDataTransferShim(CNifManSubConnectionShim& aSubConnectionProviderShim) :

	iSubConnectionProviderShim(aSubConnectionProviderShim)

	{

	}

CConnDataTransferShim::~CConnDataTransferShim()

	{

	iUplinkGranularities.Close();

	iDownlinkGranularities.Close();

	}

TInt CConnDataTransferShim::DoDataTransferred(TUint& aUplinkVolume, TUint& aDownlinkVolume)

	{

	// Find out the amount of data transferred from the connection provider

	TInt ret = iSubConnectionProviderShim.Provider().DataTransferred(iSubConnectionProviderShim.Id(), aUplinkVolume, aDownlinkVolume);

	// Let the subinterface know in case any subconnections have outstanding data notification requests that might be completed by this

	NotifyDataTransferred(aUplinkVolume, aDownlinkVolume);

	// And return the results to the connection

	return(ret);

	}

TInt CConnDataTransferShim::DoDataTransferredCancel()

	{

	// do nothing

	return KErrNone;

	}

TInt CConnDataTransferShim::DoDataSentNotificationRequest(TUint aRequestedGranularity, TUint aRequestedNotificationVolume)

	{

	TInt requiredGranularity;

	if(aRequestedGranularity == 0)	// absolute mode

		{

		// Start by finding out how much data has been sent, then calculate granularity

		TUint uplinkDataVolume;

		TUint dummyDataVolume;

		DoDataTransferred( uplinkDataVolume, dummyDataVolume);

		requiredGranularity = aRequestedNotificationVolume - uplinkDataVolume;

		if(requiredGranularity < 0)	// we've already achieved this so notify immediately

			{

			// possible optimisation: pass reference to caller in here and 

            // only notify them if this condition is met

            // essentially we don't know what the granularity was here

			for(TInt i=0; i < iClients.Count(); i++)

				{

				iClients[i]->NotifyDataSent(uplinkDataVolume, 0);

				}

			}

		}

	else	// relative mode

		{

		requiredGranularity = aRequestedGranularity;

		}

	return CalculateNewUplinkGranularity(requiredGranularity);

	}

TInt CConnDataTransferShim::DoDataSentNotificationCancel()

	{

	// Do nothing.  Not worth trying to adjust granularity array.

	return KErrNone;

	}

TInt CConnDataTransferShim::DoDataReceivedNotificationRequest(TUint aRequestedGranularity, TUint aRequestedNotificationVolume)

	{

	TInt requiredGranularity;

	if(aRequestedGranularity == 0)	// absolute mode

		{

		// Start by finding out how much data has been sent, then calculate granularity

		TUint dummyDataVolume;

		TUint downlinkDataVolume;

		DoDataTransferred( dummyDataVolume, downlinkDataVolume);

		requiredGranularity = aRequestedNotificationVolume - downlinkDataVolume;

		if(requiredGranularity < 0)	// we've already achieved this so notify immediately

			{

			// possible optimisation: pass reference to caller in here 

			// and only notify them if this condition is met

            // essentially we don't know what the granularity was here

			for(TInt i=0; i < iClients.Count(); i++)

				{

				iClients[i]->NotifyDataReceived(downlinkDataVolume, 0);

				}

			}

		}

	else	// relative mode

		{

		requiredGranularity = aRequestedGranularity;

		}

	return CalculateNewDownlinkGranularity(requiredGranularity);

	}

TInt CConnDataTransferShim::DoDataReceivedNotificationCancel()

	{

	// Do nothing.  Not worth trying to adjust granularity array.

	return KErrNone;

	}

TInt CConnDataTransferShim::NotifyDataTransferred(TUint aUplinkVolume, TUint aDownlinkVolume)

/**

Called as a side-effect of someone calling DataTransferredRequest(), to allow any absolute volume notifications that may be outstanding to be completed if the required amount of data has been sent/received

@param aUplinkVolume The total volume of data sent on this subconnection

@param aDownlinkVolume The total volume of data received on this subconnection

@return KErrNone, or one of the system-wide error codes

*/

	{

	__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: New data transferred notification (uplink: %d, downlink: %d)"), 

						 iSubConnectionProviderShim.Id(), aUplinkVolume, aDownlinkVolume));

	for(TInt i=0; i < iClients.Count(); i++)

		{

		iClients[i]->NotifyDataTransferred(aUplinkVolume, aDownlinkVolume);

		}

	return KErrNone;

	}

TInt CConnDataTransferShim::NotifyDataSent(TUint aUplinkVolume)

/**

Notification from connection provider via CInterface that the requested granularity for data sent has been met or exceeded

@note The granularity system is not perfect, as it may be the case that we get notifications for more than "granularity" quantity of data.  

@param aUplinkVolume The total volume of data sent so far on this subconnection

@return KErrNone, or one of the system-wide error codes

*/

	{

	__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: New data sent notification (uplink: %d)"), 

						 iSubConnectionProviderShim.Id(), aUplinkVolume));

	// Pass notification up to all subconnections, including the current granularity setting in case they are in relative notification mode

	for(TInt i=0; i < iClients.Count(); i++)

		{

		iClients[i]->NotifyDataSent(aUplinkVolume, iCurrentUplinkGranularity);

		}

	// Set the new granularity required of the interface

	return SetNextUplinkGranularity();

	}

TInt CConnDataTransferShim::NotifyDataReceived(TUint aDownlinkVolume)

/**

Notification from connection provider via CInterface that the requested granularity for data received has been met or exceeded

@param aDownlinkVolume The total volume of data received so far on this subconnection

@return KErrNone, or one of the system-wide error codes

*/

	{

	__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: New data received notification (downlink: %d)"), iSubConnectionProviderShim.Id(), aDownlinkVolume));

	// Pass notification up to all subconnections, including the current granularity setting in case they are in relative notification mode

	for(TInt i=0; i < iClients.Count(); i++)

		{

		iClients[i]->NotifyDataReceived(aDownlinkVolume, iCurrentDownlinkGranularity);

		}

	// Set the new granularity required of the interface

	return SetNextDownlinkGranularity();

	}

TInt CConnDataTransferShim::CalculateNewUplinkGranularity(TUint aRequestedGranularity)

/**

Calculate the required granularity to satisfy client requests

This function calculates the delta between client requests and stores it in an array.

@param aRequestedGranularity The new requested granularity

@return KErrNone if successful, otherwise one of the system-wide error codes

@todo Quantise requests to granularity of 1K

*/

	{

	TInt ret = KErrNone;

	TInt requestedGranularity = static_cast<TInt>(aRequestedGranularity);

	//@todo In the future, this method could be rewritten to expand the maximum

	//granularity from 2GB to 4GB.  Probably not necessary...

	if(requestedGranularity < 0)	// check that the cast didn't produce an invalid result

		{

		__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: ERROR - calculating new uplink granularity - overflow when casting integer"), 

							 iSubConnectionProviderShim.Id()));

		return(KErrOverflow);

		}

	__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: Calculating new uplink granularity..."), 

						 iSubConnectionProviderShim.Id()));

	TUint newGranularity = 0;

	ret = CalculateNewGranularity(requestedGranularity, iCurrentUplinkGranularity, iUplinkGranularities, newGranularity);

	if (ret == KErrNone && newGranularity)

		{

		ret = SetUplinkGranularity(newGranularity);

		}

	return(ret);

	}

TInt CConnDataTransferShim::CalculateNewDownlinkGranularity(TUint aRequestedGranularity)

/**

Calculate the required granularity to satisfy client requests

This function calculates the delta between client requests and stores it in an array.

@param aRequestedGranularity The new requested granularity

@return KErrNone if successful, otherwise one of the system-wide error codes

@todo Quantise requests to granularity of 1K

*/

	{

	TInt ret;

	TInt requestedGranularity = static_cast<TInt>(aRequestedGranularity);

	//@todo In the future, this method could be rewritten to expand the maximum 

	//      granularity from 2GB to 4GB.  Probably not necessary...

	if(requestedGranularity < 0)	// check that the cast didn't produce an invalid result

		{

		__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: ERROR - calculating new downlink granularity - overflow when casting integer"), 

							 iSubConnectionProviderShim.Id()));

		return(KErrOverflow);

		}

	__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("ESock: CConnDataTransferShim[id: %d]: Calculating new downlink granularity..."), 

						 iSubConnectionProviderShim.Id()));

	TUint newGranularity = 0;

	ret = CalculateNewGranularity(requestedGranularity, iCurrentDownlinkGranularity, iDownlinkGranularities, newGranularity);

	if (ret == KErrNone && newGranularity)

		{

		ret = SetDownlinkGranularity(newGranularity);

		}

	return(ret);

	}

TInt CConnDataTransferShim::CalculateNewGranularity(TInt aRequestedGranularity, TUint aCurrentGranularity, RArray<TUint>& aGranularities, TUint& aNewCurrentGranularity)

/**

Given a new granularity, calculate new values for the Current granularity and granularity array.

Helper function used for processing new uplink and downlink granularities.

@param aRequestedGranularity new granularity (in).

@param aCurrentGranularity current granularity in the lower provider (in).

@param aGranularities ordered array of delta granularities which will become the current granularity

after the latter has expired (in/out).

@param aNewCurrentGranularity new value of current granularity to be set in lower provider (out).

@return KErrNone or a system wide error code.

*/

	{

	TInt ret = KErrNone;

	TInt i = 0;

	TInt count = aGranularities.Count();		// granularities in the array

	// The reason we have the three way if statement below is because we have to deal with

	// the fact that there is a "current" granularity (set in the lower provider), and 

	// an array of delta granularities which will become the current granularity in turn:

	//

	//  +---+   +---+---+---+

	//  |   |   |   |   |   |... 

	//  +---+   +---+---+---+

	//            0   1   2

	// Current      Array

	//

	// The complexity comes when a new granularity needs to be notionally inserted either before the

	// current granularity or between the current granularity and the first entry in the array.

	if (count == 0 && aCurrentGranularity == 0)

		{

		// Empty granularity array and no current granularity.

		//

		// - set current granularity to the requested granularity (no entries needed in array)

		aNewCurrentGranularity = aRequestedGranularity;

		}

	else

	if (aRequestedGranularity < aCurrentGranularity)

		{

		// Requested granularity is less than current granularity.  The requested granularity

		// needs to be notionally inserted before the current granularity.

		// add a new entry into the beginning of the array that contains the delta between the requested

		// granularity and current granularity.  This new entry represents the "old" current granularity.

		ret = aGranularities.Insert(aCurrentGranularity - aRequestedGranularity, 0);

		if (ret == KErrNone)

			{

			// the requested granularity becomes the new current granularity

			aNewCurrentGranularity = aRequestedGranularity;

			}

		}

	else

	if (aRequestedGranularity > aCurrentGranularity)

		{

		// Requested granularity is greater than current granularity.  The requested granularity

		// needs to be inserted into the array at the appropriate place.  The current granularity

		// remains unchanged.

		// Take into account the current granularity by subtracting it from requested granularity

		aRequestedGranularity -= aCurrentGranularity;

		// Find correct insertion position.  Each entry visited in the array will subtract from the

		// requested granularity, leaving the latter as being delta based.

		for(i=0; i < count ; i++)

			{

			aRequestedGranularity -= aGranularities[i];

			if (aRequestedGranularity <= 0)

				{

				break;

				}

			}

		if (aRequestedGranularity < 0)

			{

			// Insertion position found within the array - held in "i".

			aRequestedGranularity += aGranularities[i];

			ret = aGranularities.Insert(aRequestedGranularity, i);

			if (ret == KErrNone)

				{

				// Adjust the next granularity in the array by the Requested granularity

				// that we've just inserted.  "i+1" because of the Insert() above.

				aGranularities[i+1] -= aRequestedGranularity;

				}

			}

		else

		if (aRequestedGranularity > 0)

			{

			// Reached end of the array while searching - insert requested granularity at the end.

			ret = aGranularities.Append(aRequestedGranularity);

			}

		// aRequestedGranularity == 0 is a no-op case (setting zero granularity).

		}

	// (aRequestedGranularity == iCurrentUplinkGranularity) is a no-op case (setting the same

	// granularity as current value).

	return (ret);

	}

TInt CConnDataTransferShim::SetUplinkGranularity(TUint aRequestedGranularity)

/**

Set data sent notification granularity in lower provider.

@param aRequestedGranularity granularity to set.  If zero, cancel data sent notifications.

@return KErrNone or a system wide error code.

*/

	{

	iCurrentUplinkGranularity = aRequestedGranularity;

	if (iCurrentUplinkGranularity)

		{

		return iSubConnectionProviderShim.Provider().SetDataSentNotificationGranularity(iSubConnectionProviderShim.Id(), iCurrentUplinkGranularity);

		}

	else

		{

		return iSubConnectionProviderShim.Provider().DataSentNotificationCancel(iSubConnectionProviderShim.Id());

		}

	}

TInt CConnDataTransferShim::SetNextUplinkGranularity()

/**

Get the next uplink granularity from the array, and send it to the connection provider

@return KErrNone if successful, otherwise one of the system-wide error codes

*/

	{

	if(iUplinkGranularities.Count())

		{

		__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: setting new uplink granularity (%d)"), 

							 iSubConnectionProviderShim.Id(), iCurrentUplinkGranularity));

		// Read the next granularity from the array

		TUint granularity = iUplinkGranularities[0];

		// Remove the value read

		iUplinkGranularities.Remove(0);

		return SetUplinkGranularity(granularity);

		}

	else

		{

		__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: cancelling data sent notifications - no values remaining in granularity array"), 

							 iSubConnectionProviderShim.Id()));

		return SetUplinkGranularity(0);		// cancel notifications

		}

	}

TInt CConnDataTransferShim::SetDownlinkGranularity(TUint aRequestedGranularity)

/**

Set data received notification granularity in lower provider.

@param aRequestedGranularity granularity to set.  If zero, cancel data received notifications.

@return KErrNone or a system wide error code.

*/

	{

	iCurrentDownlinkGranularity = aRequestedGranularity;

	if (iCurrentDownlinkGranularity)

		{

		return iSubConnectionProviderShim.Provider().SetDataReceivedNotificationGranularity(iSubConnectionProviderShim.Id(), iCurrentDownlinkGranularity);

		}

	else

		{

		return iSubConnectionProviderShim.Provider().DataReceivedNotificationCancel(iSubConnectionProviderShim.Id());

		}

	}

TInt CConnDataTransferShim::SetNextDownlinkGranularity()

/**

Get the next downlink granularity from the array, and send it to the connection provider

@return KErrNone if successful, otherwise one of the system-wide error codes

*/

	{

	if(iDownlinkGranularities.Count())

		{

		__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("CConnDataTransferShim[id: %d]: setting new downlink granularity (%d)"), 

							 iSubConnectionProviderShim.Id(), iCurrentDownlinkGranularity));

		// Read the next granularity from the array

		TUint granularity = iDownlinkGranularities[0];

		// Remove the value read

		iDownlinkGranularities.Remove(0);

		return SetDownlinkGranularity(granularity);

		}

	else

		{

		__CFLOG_VAR((KShimScprTag, KShimScprDataTag, _L8("ESock: CConnDataTransferShim[id: %d]: cancelling data received notifications - no values remaining in granularity array"), 

							 iSubConnectionProviderShim.Id()));

		return SetDownlinkGranularity(0);	// cancel notifications

		}

	}