/**

* Copyright (c) 2006-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:

* DataMonitoringProvider.h

* 

*

*/

/**

 @file

 @internalComponent 

*/

#if !defined(DATAMONITORINGPROVIDER_H_INCLUDED)

#define DATAMONITORINGPROVIDER_H_INCLUDED

#include <e32const.h>

#include <comms-infras/ss_datamon_apiext.h>

#include <comms-infras/ss_nodemessages.h>

namespace ESock

{

class TCFDataMonitoringNotification

	{

private:

	enum

	{

    ECFDataMonitoringNotification   = 1

	};

public:

    enum { ERealmId = 0x10285A78 }; //UID allocated on 21/11/2007

    /*==========================================================================

    [Name]:      TDataMonitoringNotification

    [Semantics]: [399TODO] RZ: Simon please finish.

    [Type]:

    [Fallible]:

    [Structure]:

    ===========================================================================*/

	typedef Messages::TMessageSigNumberNumber<ECFDataMonitoringNotification, TCFDataMonitoringNotification::ERealmId> TDataMonitoringNotification;

	};

/*

	Enumerations for typeids

*/

enum 

    {

    EDataMonitoringProvisioningInfoBase,

    EDataMonitoringConnProvisioningInfo,

    EDataMonitoringSubConnProvisioningInfo

    };

/**

	@internalTechnology

*/

enum TDataMonitoringDirection

	{

	EReceived,

	ESent

	};

/**

	@internalTechnology

*/

struct TDataVolumes

	{

	volatile TUint32 iReceivedBytes;

	volatile TUint32 iSentBytes;

	};

/**

	@internalTechnology

*/

struct TNotificationThresholds

	{

	volatile TUint32 iReceivedThreshold;

	volatile TUint32 iSentThreshold;

	};

const TUint32 KDataMonitoringProvisioningUid = 0x10281E0D;

/**

	Base class for flow provisioning data

	@internalTechnology

*/

class TDataMonitoringProvisioningInfoBase : public Meta::SMetaData

	{

public:

    enum 

        { 

        iId = EDataMonitoringProvisioningInfoBase,

        iUid = KDataMonitoringProvisioningUid

        };

protected:

	TDataMonitoringProvisioningInfoBase(TDataVolumes* aDataVolumesPtr, TNotificationThresholds* aThresholdsPtr) :

		iDataVolumesPtr(aDataVolumesPtr), iThresholdsPtr(aThresholdsPtr)

		{

		}

private:

	TDataMonitoringProvisioningInfoBase();

public:        

	TDataVolumes* iDataVolumesPtr;

	TNotificationThresholds* iThresholdsPtr;

	EXPORT_DATA_VTABLE_AND_FN

	};

/**

	@internalTechnology

*/

class TDataMonitoringConnProvisioningInfo : public TDataMonitoringProvisioningInfoBase

	{

public:

    enum 

        { 

        iId = EDataMonitoringConnProvisioningInfo

        };

	IMPORT_C TDataMonitoringConnProvisioningInfo(TDataVolumes* aDataVolumesPtr, TNotificationThresholds* aThresholdsPtr);

	EXPORT_DATA_VTABLE_AND_FN

private:

	TDataMonitoringConnProvisioningInfo();

	};

/**

	@internalTechnology

*/

class TDataMonitoringSubConnProvisioningInfo : public TDataMonitoringProvisioningInfoBase

	{

public:

    enum 

        { 

        iId = EDataMonitoringSubConnProvisioningInfo

        };

	IMPORT_C TDataMonitoringSubConnProvisioningInfo(TDataVolumes* aDataVolumesPtr, TNotificationThresholds* aThresholdsPtr);

	EXPORT_DATA_VTABLE_AND_FN

private:

	TDataMonitoringSubConnProvisioningInfo();		

	};

/**

	@internalTechnology

*/

class TNotificationRequest

	{

public:

	TNotificationRequest(CDataMonitoringResponder* aResponder, TSubSessionUniqueId aClientId) 

		: iThreshold(0), iResponder(aResponder), iClientId(aClientId), iCancelled(EFalse), iWrapped(EFalse)

		}

	TUint32 Threshold() const

		{

		return iThreshold;

		}

	void SetThreshold(TUint32 aThreshold)

		{

		iThreshold = aThreshold;

		}

	void SetThresholdFromDelta(TUint32 aVolume, TUint32 aDelta);		

	CDataMonitoringResponder*& Responder()

		{

		return iResponder;

		}

	TSubSessionUniqueId ClientId() const

		{

		return iClientId;

		}

	TBool Cancelled() const

		{

		return iCancelled;

		}

	void SetCancelled()

		{

		}

	TBool Wrapped() const

		{

		return iWrapped;

		}

	void SetWrapped(TBool aWrapped)

		{

		iWrapped = aWrapped;

		}

	static TInt CompareThresholds(const TNotificationRequest& aFirst, const TNotificationRequest& aSecond);

	static TBool CompareClientIds(const TNotificationRequest& aFirst, const TNotificationRequest& aSecond);

private:

	TUint32 iThreshold;	

	CDataMonitoringResponder* iResponder;

	TSubSessionUniqueId iClientId;

	TBool iCancelled;

	TBool iWrapped;

	};

typedef RPointerArray<TNotificationRequest> RNotificationRequestArray;

/**

	@internalTechnology

*/

class ADataMonitoringProvider : public ADataMonitoringProtocolReq

	{

public:

	IMPORT_C virtual ~ADataMonitoringProvider();	

	// MExtensionInterfaceBase virtuals

	IMPORT_C virtual void CancelClientExtItfRequests(TSubSessionUniqueId aClientId);

	// ADataMonitoringProtocolReq virtuals

	IMPORT_C virtual void RequestDataTransferred(CDataMonitoringResponder*& aResponder, TSubSessionUniqueId aClientId);

	IMPORT_C virtual void CancelDataTransferredRequest(TSubSessionUniqueId aClientId);

	IMPORT_C virtual void RequestDataReceivedNotification(CDataMonitoringResponder*& aResponder, TUint32 aDelta, TUint32 aReceivedBytes, TSubSessionUniqueId aClientId);

	IMPORT_C virtual void CancelDataReceivedNotificationRequest(TSubSessionUniqueId aClientId);

	IMPORT_C virtual void RequestDataSentNotification(CDataMonitoringResponder*& aResponder, TUint32 aDelta, TUint32 aSentBytes, TSubSessionUniqueId aClientId);

	IMPORT_C virtual void CancelDataSentNotificationRequest(TSubSessionUniqueId aClientId);

  	IMPORT_C void DataReceivedNotificationL(TUint32 aNotificationValue);

  	IMPORT_C void DataSentNotificationL(TUint32 aNotificationValue);

  	IMPORT_C void DataNotificationL(const TCFDataMonitoringNotification::TDataMonitoringNotification& aNotification);

	TDataVolumes* DataVolumesPtr() { return &iDataVolumes; }

	TNotificationThresholds* NotificationThresholdsPtr() { return &iThresholds; }

protected:

	IMPORT_C ADataMonitoringProvider();

	IMPORT_C void ConstructL();

private:

	RNotificationRequestArray* NotificationRequestArray(TDataMonitoringDirection aDirection);

	void InsertWrapMarkerL(TDataMonitoringDirection aDirection);	

	TInt InsertNotificationRequest(TNotificationRequest* aRequest, TDataMonitoringDirection aDirection);

	void SetNextNotificationThreshold(TDataMonitoringDirection aDirection);

private:	

	// Notification request arrays

	RNotificationRequestArray iReceivedNotificationRequests;

	RNotificationRequestArray iSentNotificationRequests;

protected:

	// Shared memory

	TDataVolumes iDataVolumes;

	TNotificationThresholds iThresholds;

	};

} //namespace ESock

#endif