// Copyright (c) 2003-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:
//

#ifndef __LBSCOMMON_H__
#define __LBSCOMMON_H__

#include <e32std.h>
#include <e32math.h>
#include <lbsrequestor.h>
#include <lbsclasstypes.h>
#include <lbserrors.h>
#include <lbsvariant.h>

/** 
@publishedAll
@released
// A compile time assert macro. The aExpr parameter must evaluate to an
// integer value at compile time.
// eg. sizeof(TTime) == KSizeOfTInt64
// If aExpr is false, the compiler generates an error.
// If aExpr is true, the compilation continues, and use of this macro will not
// result in any extra object code.
*/
#define POSITION_COMPILE_TIME_ASSERT(aExpr)   typedef char assert_type[aExpr ? 1 : -1]

/** 
@publishedAll
@released

Maximum characters in module name.
If __S60_ is defined in lbsvariant.h the constant is 64 otherwise it is 20
*/
const TInt KPositionMaxModuleName = __LBS_MAX_MODULE_NAME;

/** 
@publishedAll
@released

Maximum size for TUInt
*/
const TUint KPositionMaxSizeQualityItem = sizeof(TInt64);

/** 
@publishedAll
@released

Maximum size for fields
*/
const TUint KPositionMaxSectionFields = 10;

/** 
@publishedAll
@released

Defines typedef for TPositionModuleId
*/
typedef TUid  TPositionModuleId;

/** 
@publishedAll
@released

Defines NULL TUid
*/
const TPositionModuleId KPositionNullModuleId = {KNullUidValue};


class TPositionClassTypeBase
/**
The base class for classes used to store position information

@publishedAll
@released
 */
	{
public:
	IMPORT_C TUint32 PositionClassType() const;
	IMPORT_C TUint PositionClassSize() const;

protected:
	TPositionClassTypeBase();

protected:
	/** The type of the derived class */
	TUint32 iPosClassType;
	/** The size of the derived class */
	TUint iPosClassSize;
	};

class TPositionQualityItem
/**
The class for classes used to store position quality

@publishedAll
@released
 */
	{
public:
	/** Quality result */
	enum TResult
		{
		/** Better */
		EIsBetter,
		/** Equal */
		EIsEqual,
		/** Worse */
		EIsWorse
		};

	/** Preference */
	enum TValuePreference
		{
		/** Smaller values */
		EPreferSmallerValues,
		/** Greater values */
		EPreferGreaterValues
		};

	/** Size of data type
	 */
	enum TDataType
		{
		/** Undefined */
		EUndefined,
		/** TInt8 */
		ETInt8,
		/** TInt16 */
		ETInt16,
		/** TInt32 */
		ETInt32,
		/** Tint64 */
		ETInt64,
		/** TUint8 */
		ETUint8,
		/** TUint16 */
		ETUint16,
		/** TUint 32 */
		ETUint32,
		/** TReal32 */
		ETReal32,
		/** TReal64 */
		ETReal64,
		/** ETime */
		ETTime,
		/** Time in microseconds */
		ETTimeIntervalMicroSeconds
		};
	/**
	Constructor for TPositionQualityItem
	 */
	TPositionQualityItem();
	
	/**
	Compare  method
	 */			
	TInt Compare(const TPositionQualityItem& aItem, TResult& aComparison) const;
	/**
	Sets Position Quality
	 */	
	void Set(TDataType aDataType, TValuePreference aValuePreference,
			 const TAny* aData, TUint aSizeOfData);
	/**
	Gets position quality
	 */	
	TInt Get(TDataType aDataType, TAny* aData, TUint aSizeOfData) const;
	
	/**
	Whether or not this element has a defined state
	 */
	TBool IsDefined() const;

private:
	/** Internal datatype */
	TDataType iDataType;
	/** Internel value preference */
	TValuePreference iScaleDirection;
	/** Unused variable for future expansion. */
	TUint8 iData[KPositionMaxSizeQualityItem];
	};

class TPositionQualityBase : public TPositionClassTypeBase
/**
The base class for classes used to store position quality information

@publishedAll
@released
 */
	{
public:
	IMPORT_C TInt Compare(const TPositionQualityBase& aPositionQuality,
						  TInt aElementToCompare,
						  TPositionQualityItem::TResult& aComparison) const;

	/**
 	Returns whether an element is defined
	@param aElementId The element Id of that we're interested in.
	@return TBool if defined
 	*/
	IMPORT_C TBool IsDefined(TInt aElementId) const;
	IMPORT_C TInt HighWaterMark() const;
protected:
	IMPORT_C TPositionQualityBase();

	IMPORT_C void ResetElement(TInt aElementId);


	/**
	Sets the data of an element from the array of elements.
	@param aElementId The element Id of that we're interested in.
	@param aDataType The datatype of the data to be fetched.
	@param aValuePreference Quality preferences
	@param aData A pointer to the data to be written into.
 	*/
	template <class T>
		inline void SetElement(TInt aElementId, TPositionQualityItem::TDataType aDataType,
							   TPositionQualityItem::TValuePreference aValuePreference, T aData)
		{DoSetElement(aElementId, aDataType, aValuePreference, &aData, sizeof(T));}

	/**
	Gets the data of an element from the array of elements.
	@param aElementId The element Id of that we're interested in.
	@param aDataType The datatype of the data to be fetched.
	@param aData A pointer to the data to be written into.
	@return Standard Symbian OS Error code
 	*/	
	template <class T>
		inline TInt GetElement(TInt aElementId, TPositionQualityItem::TDataType aDataType,
							    T& aData) const
		{return DoGetElement(aElementId, aDataType, &aData, sizeof(T));}

private:
	IMPORT_C void DoSetElement(TInt aElementId, TPositionQualityItem::TDataType aDataType,
							   TPositionQualityItem::TValuePreference aValuePreference,
							   const TAny* aData, TUint aSizeOfData);

	IMPORT_C TInt DoGetElement(TInt aElementId, TPositionQualityItem::TDataType aDataType,
								TAny* aData, TUint aSizeOfData) const;
private:
	/** Internal array */
	TFixedArray<TPositionQualityItem, KPositionMaxSectionFields> iPositionQualityData;
	/** Internal highwater mark */
	TInt iHighwaterMark;
	};

class TPositionQuality : public TPositionQualityBase
/**
The standard position quality class.

@publishedAll
@released
 */
	{
public:
	/** Cost Indicator for position request */
	enum TCostIndicator
		{
		/** Unknown cost
		This is the unassigned value and should not be returned */
		ECostUnknown,

		/** Zero cost
		No cost is expected to be incurred when obtaining a position fix */
		ECostZero,

		/** Possible cost
		The positioning module is uncertain if the user will incur a charge. */
		ECostPossible,

		/** Charged
		The positioning module expects a charge to be levied when obtaining
 		position information */
		ECostCharge
		};

	/** Power consumption */
	enum TPowerConsumption
		{
		/** Unknown power consumption
		The positioning module is unable to determine the likely power drain */
		EPowerUnknown,

		/** Zero power consumption
		No internal power will be used when obtaining a position fix */
		EPowerZero,

		/** Low power consumption
		The positioning module expects a minimum power drain when using the
		associated technology. This may be comparable to the power usage when
		the phone is in standby mode. */
		EPowerLow,

		/** Medium power consumption
		The positioning module expects a moderate power drain when using the
		associated technology. This may be comparable to the power usage when
		the phone is being actively used */
		EPowerMedium,

		/** High power consumption
		The positioning module expects a high power drain when using the
		associated technology. Use of this module will quickly consume the phone's batteries */
		EPowerHigh
		};

public:
	IMPORT_C TPositionQuality();

	IMPORT_C TTimeIntervalMicroSeconds TimeToFirstFix() const;
	IMPORT_C TTimeIntervalMicroSeconds TimeToNextFix()  const;  

	IMPORT_C TReal32 HorizontalAccuracy() const;
	IMPORT_C TReal32 VerticalAccuracy()   const;

	IMPORT_C TCostIndicator CostIndicator() const;
	IMPORT_C TPowerConsumption PowerConsumption() const;

	IMPORT_C void SetTimeToFirstFix(TTimeIntervalMicroSeconds aTimeToFirstFix);
	IMPORT_C void SetTimeToNextFix(TTimeIntervalMicroSeconds aTimeToNextFix);

	IMPORT_C void SetHorizontalAccuracy(TReal32 aHorizontalAccuracy);
	IMPORT_C void SetVerticalAccuracy(TReal32 aVerticalAccuracy);

	IMPORT_C void SetCostIndicator(TCostIndicator aCost);
	IMPORT_C void SetPowerConsumption(TPowerConsumption aPower);

private:
	/** Unused variable for future expansion. */
	TUint8 iReserved[16];
	};


class TPositionModuleInfoBase : public TPositionClassTypeBase
/**
The base class for classes storing information on position modules

@publishedAll
@released
 */
	{
protected:
	IMPORT_C TPositionModuleInfoBase();
	};

class TPositionModuleInfo : public TPositionModuleInfoBase
/**
The standard class for storing information on position modules

@publishedAll
@released
 */
	{
public:
	/**
	 Technology types
	 */
	typedef TUint32 TTechnologyType;

	/**
	 Technology Type
	 */ 
	enum _TTechnologyType
		{
		/** Indicates that the positioning module is unaware of the technology
		used to obtain position information */
		ETechnologyUnknown	= 0,
		/** The primary positioning technology is handset based.
		For example standard GPS */
		ETechnologyTerminal	= 0x01,
		/** The primary positioning technology is network based.
		For example, E-OTD */
		ETechnologyNetwork	= 0x02,
		/** The primary positioning mechanism receives assistance in some form.
		Generally to obtain a quicker or more accurate fix */
		ETechnologyAssisted	= 0x04
		};

	/**
	 Device locations
	 */
	typedef TUint32 TDeviceLocation;

	/**
	 Device location
	 */ 
	enum _TDeviceLocation
		{
		/** The positioning module is unaware of the hardware used to supply
		positioning information */
		EDeviceUnknown	= 0,
		/** The positioning hardware is integral to the terminal */
		EDeviceInternal	= 0x01,
		/** The positioning hardware is separate from the terminal */
		EDeviceExternal	= 0x02
		};

	/**
	 Position module capabilities
	 */
	typedef TUint32 TCapabilities;

	/**
	 Module Capabilities
	 */ 
	enum _TCapabilities
		{
		/** No Capabilities */
		ECapabilityNone	       = 0,

		/** Positioning modules with this capability will support the
		TPositionInfo class and are able to provide latitude and longitude
		related information
		 */
		ECapabilityHorizontal  = 0x0001,

		/** Positioning modules with this capability will support the
	 	TPositionInfo class and are able to provide height related information
		 */
		ECapabilityVertical    = 0x0002,

		/** Positioning modules with this capability will support the
		TPositionCourseInfo class and are able to provide information related
		to the current horizontal speed
		 */
		ECapabilitySpeed       = 0x0004,

		/** Positioning modules with this capability will support the
		TPositionCourseInfo class and are able to provide heading related information
		 */
		ECapabilityDirection   = 0x0008,

		/** Positioning modules with this capability will support the
		TPositionSatelliteInfo class. Such a module will be able to return at
		least some satellite data - but the extent of the information could vary.
		Applications must ensure that any value returned is valid before it is used 
		*/
		ECapabilitySatellite   = 0x0010,

		/** This value is reserved for future expansion.
		Positioning modules with this capability will be able to return
		information related to a magnetic compass. The API does not currently
		define an extended class that encapsulates this type of information
 		*/
		ECapabilityCompass     = 0x0020,

		/** This value is reserved for future expansion.
		Positioning modules with this capability will be able to return
		location information using NMEA formatted text strings.
		The API does not currently define an extended class that encapsulates
		this type of information
 		*/
		ECapabilityNmea        = 0x0040,

		/** This value is reserved for future expansion.
		Positioning modules with this capability will be able to return
		information related to the postal address of the current location
		 */
		ECapabilityAddress     = 0x0080,

		/** This value is reserved for future expansion.
		Positioning modules with this capability will be able to return the
		current position in terms of where within a building it is. For
		example, this may include the floor and the room name.	
		The API does not currently define an extended class that encapsulates
		this type of information
		 */
		ECapabilityBuilding    = 0x0100,

		/** This value is reserved for future expansion.
		Positioning modules with this capability will be able to return provide
		a link to further information about the location. The standard mechanism
		is via a URL.
		The API does not currently define an extended class that encapsulates
		this type of information
 		*/
		ECapabilityMedia       = 0x0200
		};

public:
	IMPORT_C TPositionModuleInfo();

	IMPORT_C TPositionModuleId ModuleId() const;
	IMPORT_C TBool IsAvailable() const;
	IMPORT_C void GetModuleName(TDes& aModuleName) const;
	IMPORT_C void GetPositionQuality(TPositionQuality& aPosQuality) const;
	IMPORT_C TTechnologyType TechnologyType() const;
	IMPORT_C TDeviceLocation DeviceLocation() const;
	IMPORT_C TCapabilities Capabilities() const ;
	IMPORT_C TUint32 ClassesSupported(TPositionClassFamily aClassType) const;
	IMPORT_C TVersion Version() const;

	IMPORT_C void SetModuleId(TPositionModuleId aModuleId);
	IMPORT_C void SetIsAvailable(TBool aIsAvailable);
	IMPORT_C void SetModuleName(const TDesC& aModuleName);
	IMPORT_C void SetPositionQuality(const TPositionQuality& aPosQuality);
	IMPORT_C void SetTechnologyType(TTechnologyType aTechnologyType);
	IMPORT_C void SetDeviceLocation(TDeviceLocation aDeviceLocation);
	IMPORT_C void SetCapabilities(TCapabilities aDeviceCapabilities);
	IMPORT_C void SetClassesSupported(TPositionClassFamily aClassType,
									  TUint32 aSupportedClasses);
	IMPORT_C void SetVersion(TVersion aVersion);

protected:
	/** The module ID */
	TPositionModuleId	iModuleId;
	/** Whether or not the module is available */
	TBool iIsAvailable;
	/** The module name */
	TBuf<KPositionMaxModuleName> iModuleName;
	/** The position quality */
	TPositionQuality    iPosQuality;
	/** The technology type */
	TTechnologyType     iTechnologyType;
	/** The location of the device associated with this module */
	TDeviceLocation     iDeviceLocation;
	/** The capabilities of this module */
	TCapabilities		iCapabilities;
	/** The array of supported classes for the different class types */
	TFixedArray<TUint32, EPositionLastFamily> iSupportedClassTypes;
	/** The version of this module */
	TVersion            iVersion;

private:
	/** Unused variable for future expansion. */
	TUint8 iReserved[16];
	};


class TPositionModuleStatusBase : public TPositionClassTypeBase
/**
The base class for classes storing a position module's status

@publishedAll
@released
 */
	{
protected:
	IMPORT_C TPositionModuleStatusBase();
	};

class TPositionModuleStatus : public TPositionModuleStatusBase
/**
The normal class for storing a position module's status

@publishedAll
@released
 */
	{
public:
	/** defined type for TDeviceStatus */
	typedef TInt TDeviceStatus;

	/**
	 * The device status
	 */
	enum _TDeviceStatus 
		{
		/** Device unknown
		This is not a valid state and should never be reported */
		EDeviceUnknown,

		/** Device error
		There are problems using the device. For example, there may be
		hardware errors. It should not be confused with complete loss of data
		quality which indicates that the device is functioning correctly but
		is currently unable to obtain position information.
		The error state will be reported if the device can not be successfully
		brought on line. For example, the positioning module may have been unable
		to communicate with the device or it is not responding as expected.
 		*/
		EDeviceError,

		/** Device disabled
		Although the device may be working properly, it has been taken off line
		and is regarded as being unavailable to obtain position information.
		This will generally have been done by the user via the control panel.
		In this state, positioning framework will not use the device.
		 */
		EDeviceDisabled,

		/** Device inactive
		The device is not being used by the positioning framework. This is
		typically because there are no clients currently obtaining the position
		from it. This is the normal status that is returned for a module that
		is not currently loaded by the system
	 	*/
		EDeviceInactive,

		/** Device initialising
		This is a transient state. The device is being brought out of the
		"inactive" state but has not 	reached either the "ready" or "stand by"
		modes. The initialising state will occur when the positioning module
		is first selected to provide a client application with location information	
		 */
		EDeviceInitialising,

		/** Device standby
		This state indicates the device has entered "sleep" or "power save"
		mode. This signifies that the device is online, but is not actively
		retrieving position information. A device will generally enter this mode
		when the next position update is not required for some time and it is
		more 	efficient to partially power down.
		Note: Not all positioning modules will support this state - particularly
		when there is external hardware
		 */
		EDeviceStandBy,

		/** Device ready
		The positioning device is online and is ready to retrieve
		position information
		 */
		EDeviceReady,

		/** Device active
		The positioning device is actively in the process of retrieving
		position information.
		Note: Not all positioning modules will support this state - particularly
		when there is external hardware
		 */
		EDeviceActive
		};

	/** defined type for TDataQualityStatus */
	typedef TInt TDataQualityStatus;

	/**
	 * The data quality status
	 */
	enum _TDataQualityStatus
		{
		/** Data Quality Unknown
		This is the unassigned valued. This state should only be reported
		during an event indicating that a positioning module has been removed 
		or is not yet loaded.
 		*/
		EDataQualityUnknown,

		/** Data Quality Loss
		The accuracy and contents of the position information has been
		completely compromised. It is no longer possible to return any
		coherent data.
		This situation will occur if the device has lost track of all the
		transmitters (for example, satellites or base stations).
		It should be noted although it is currently not possible to obtain
		position information, the device may still be functioning correctly.
		This state should not be confused with a device error.
 		*/
		EDataQualityLoss,

		/** Data Quality Partial
		There has been a partial degradation in the available position
		information. In particular, it is not possible to provide the required
		(or expected) quality of information.
		This situation could occur if the device has lost track of one of the
		transmitters (for example, satellites or base stations)
		 */
		EDataQualityPartial,

		/** Data Quality Normal
		The positioning device is functioning as expected
 		*/
		EDataQualityNormal
		};

	IMPORT_C TPositionModuleStatus();

	IMPORT_C TDeviceStatus DeviceStatus() const;
	IMPORT_C TDataQualityStatus DataQualityStatus() const;


	IMPORT_C void SetDeviceStatus(TDeviceStatus aStatus);
	IMPORT_C void SetDataQualityStatus(TDataQualityStatus aStatus);
	
protected:
	/** The device status */
	TDeviceStatus      iDeviceStatus;
	/** The data quality status */
	TDataQualityStatus iDataQualityStatus;

private:
	/** Unused variable for future expansion. */
	TUint8 iReserved[8];
	};


class TPositionModuleStatusEventBase : public TPositionClassTypeBase
/**
The base class for classes storing position module status events

@publishedAll
@released
 */
	{
public:
	/** defined type for TSystemModuleEvent */
	typedef TUint32 TSystemModuleEvent;

	/**
	 * Module events
	 */
	enum _TSystemModuleEvent
		{
		/** System Unknown
		This is not a valid state and should never be reported */
		ESystemUnknown				= 0,

		/** System Error
		There are problems using the module. For example, the module may have
		terminated abnormally. It should not be confused with the module
		reporting the error EDeviceError via TPositionModuleStatus::DeviceStatus().
		That signifies the module itself is up and running - but it may be
		unable to successful communicate with the hardware
 		*/
		ESystemError,
	
		/** System Module Installed
		A new positioning module has been dynamically added to the system. To
		receive this event, the client application must have expressed interest
		in status notifications from any positioning module. The Id of the newly
		installed module can be found by calling TPositionModuleStatusEvent::ModuleId().
		 */
		ESystemModuleInstalled,

		/** System Module Removed
		A positioning module is uninstalled. The Id of the removed module can
		be found by calling TPositionModuleStatusEvent::ModuleId()
		 */
		ESystemModuleRemoved
		};

	/** defined type for TModuleEvent */
	typedef TUint32 TModuleEvent;

	/**
	 Module events
	 */
	enum _TModuleEvent
		{
		/** No module event
		This is the unassigned value and should not be reported or used
 		*/
		EEventNone				= 0,

		/** Module event device status
		Events about the general status of the device. When this type of event
		occurs, client applications should inspect the value returned by the
 		TPositionModuleInfo::DeviceStatus() method for more information
 		*/
		EEventDeviceStatus      = 0x01,
		
		/** Module Data Quality status
		Events about the quality of the data a module is able to return. When
		this type of event occurs, client applications should inspect the
		value returned by the TPositionModuleInfo::DataQualityStatus() method
		for more information.
 		*/
		EEventDataQualityStatus = 0x02,

		/** Module System Event
		System level events about the status of modules. Events of this type
		indicate when modules have been added or removed from the system. When
		this event type occurs, client applications should inspect the value
		returned by TPositionModuleInfo::SystemModuleEvent() to determine which
		particular event was responsible
 		*/
		EEventSystemModuleEvent = 0x04,

		/** All events */
		EEventAll				= EEventDeviceStatus |
								  EEventDataQualityStatus |
								  EEventSystemModuleEvent
		};

protected:
	IMPORT_C TPositionModuleStatusEventBase();
	IMPORT_C TPositionModuleStatusEventBase(TModuleEvent aRequestedEventMask);

public:
	IMPORT_C void SetRequestedEvents(TModuleEvent aRequestedEventMask);
	IMPORT_C TModuleEvent RequestedEvents() const;

	IMPORT_C void SetOccurredEvents(TModuleEvent aOccurredEventMask);
	IMPORT_C TModuleEvent OccurredEvents() const;

	IMPORT_C TPositionModuleId ModuleId() const;
	IMPORT_C void SetModuleId(TPositionModuleId aModuleId);

	IMPORT_C void SetSystemModuleEvent(TSystemModuleEvent aSystemModuleEvent);
	IMPORT_C TSystemModuleEvent SystemModuleEvent() const;

protected:
	IMPORT_C virtual void DoReset(TInt aSizeOfClass);

private:
	friend class RPositionServer;
	void Reset();

protected:
	/** A bitmask of the requested events */
	TModuleEvent iRequestedEvents;
	/** A bitmask of the events which occurred */
	TModuleEvent iOccurredEvents;
	/** System level module status events*/
	TSystemModuleEvent iSystemModuleEvent;
	/** The module ID causing the event*/
	TPositionModuleId  iModuleId;
	};

class TPositionModuleStatusEvent : public TPositionModuleStatusEventBase
/**
The normal class for storing position module status events

@publishedAll
@released
 */
	{
public:
	IMPORT_C TPositionModuleStatusEvent();
	IMPORT_C TPositionModuleStatusEvent(TModuleEvent aRequestedEventMask);

	IMPORT_C void SetModuleStatus(const TPositionModuleStatus& aModuleStatus);
	IMPORT_C void GetModuleStatus(TPositionModuleStatus& aModuleStatus) const;

protected:
	IMPORT_C virtual void DoReset(TInt aSizeOfClass);

protected:
	/** The module status */
	TPositionModuleStatus iModuleStatus;
	};


class TPositionUpdateOptionsBase : public TPositionClassTypeBase
/**
The base class for classes storing position update options

@publishedAll
@released
 */
	{
protected:
	IMPORT_C TPositionUpdateOptionsBase();
	IMPORT_C TPositionUpdateOptionsBase(TTimeIntervalMicroSeconds aInterval,
	                                    TTimeIntervalMicroSeconds aTimeOut = TTimeIntervalMicroSeconds(0),
	                                    TTimeIntervalMicroSeconds aMaxAge = TTimeIntervalMicroSeconds(0));

public:
	IMPORT_C void SetUpdateInterval(TTimeIntervalMicroSeconds aInterval);
	IMPORT_C void SetUpdateTimeOut(TTimeIntervalMicroSeconds aTimeOut);
	IMPORT_C void SetMaxUpdateAge(TTimeIntervalMicroSeconds aMaxAge);

	IMPORT_C TTimeIntervalMicroSeconds UpdateInterval() const;
	IMPORT_C TTimeIntervalMicroSeconds UpdateTimeOut() const;
	IMPORT_C TTimeIntervalMicroSeconds MaxUpdateAge() const;

protected:
	/** The update interval */
	TTimeIntervalMicroSeconds iUpdateInterval;
	/** The update timeout */
	TTimeIntervalMicroSeconds iUpdateTimeOut;
	/** The maximum update age */
	TTimeIntervalMicroSeconds iMaxUpdateAge;

private:
	/** Unused variable for future expansion. */
	TUint8 iReserved[8];
	};

class TPositionUpdateOptions : public TPositionUpdateOptionsBase
/**
The normal class for storing position update options

@publishedAll
@released
 */
	{
public:
	IMPORT_C TPositionUpdateOptions();
	IMPORT_C TPositionUpdateOptions(TTimeIntervalMicroSeconds aInterval,
	                                TTimeIntervalMicroSeconds aTimeOut = TTimeIntervalMicroSeconds(0),
	                                TTimeIntervalMicroSeconds aMaxAge = TTimeIntervalMicroSeconds(0),
	                                TBool aAcceptPartialUpdates = EFalse);

	IMPORT_C void SetAcceptPartialUpdates(TBool aAcceptPartialUpdates);
	IMPORT_C TBool AcceptPartialUpdates() const;

protected:
	/** Whether partial updates are accepted */
	TBool iAcceptPartialUpdates;

private:
	/** Unused variable for future expansion. */
	TUint8 iReserved[16];
	};


#endif //__LBSCOMMON_H__