// under the terms of "Eclipse Public License v1.0"

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

#include <s32strm.h>

#include <tzid.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzlocalizedcityrecord.h> //This should be be included as it is internalTechnology.

#include <tzlocalizedtimezonerecord.h> // Same as above and probably should not be exported to the epoc include

#endif

// Forward class references.

class CTzLocalizedCityRecord;

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS // This can be forward declared i.e. it should not be included as it is internal.

class CTzLocalizedTimeZoneRecord;

#endif

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

/**

The CTzUserNames class is used to encapsulate the names for a user-defined

time zone.

When creating an instance of this class the client can specify the following

names:

- Long standard time name, for example "Mountain Standard Time"

- Short standard time name, for example "MST"

- Long daylight saving time name, for example "Mountain Daylight Time"

- Short daylight saving time name, for example "MDT"

- City name, for example "Shiprock"

- Region name, for example "America"

The client can also read these names.  

@publishedPartner

@released

*/ 

class CTzUserNames : public CBase

    {

public:

    IMPORT_C static CTzUserNames* NewL(const TDesC& aStandardName,

    	const TDesC& aShortStandardName, const TDesC& aDaylightSaveName,

    	const TDesC& aShortDaylightSaveName, const TDesC& aCityName,

    	const TDesC& aRegionName);

    IMPORT_C static CTzUserNames* NewLC(const TDesC& aStandardName,

    	const TDesC& aShortStandardName, const TDesC& aDayLightSaveName,

    	const TDesC& aShortDaylightSaveName, const TDesC& aCityName,

    	const TDesC& aRegionName);

	IMPORT_C ~CTzUserNames();

	IMPORT_C const TDesC& StandardName() const;

	IMPORT_C const TDesC& ShortStandardName() const;

	IMPORT_C const TDesC& DaylightSaveName() const;

	IMPORT_C const TDesC& ShortDaylightSaveName() const;

	IMPORT_C const TDesC& CityName() const;

	IMPORT_C const TDesC& RegionName() const;

	IMPORT_C static CTzUserNames* NewL(RReadStream& aStream);

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C TInt SizeOfObject() const;

    CTzUserNames();

	void ConstructL(const TDesC& aStandardName, const TDesC& aShortStandardName,

		const TDesC& aDayLightSaveName, const TDesC& aShortDayLightSaveName,

		const TDesC& aCityName, const TDesC& aRegionName);

    HBufC* iStandardName;

    HBufC* iShortStandardName;

    HBufC* iDaylightName;

    HBufC* iShortDaylightName;	

    HBufC* iCityName;

    HBufC* iRegionName;

    };

#else

class CTzUserNames;

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

User::SetUTCTimeAndOffset().  The time zone server is shutdown when the last

session (RTz) is closed.  Therefore, to maintain consistent time related

behaviour, licensees may want to keep a system level time zone server session

open at all times.

Exceptional cases occur when a user requests conversion for a non-existent local

time or a double local time. 

Non-existent local times occur when the local time changes from winter to summer

for DST.

For example, 01:59 local time is non-existent on the day of a change to BST in

Europe/London since the time changes directly from 12:59:59 to 2:00.

A double local time occurs when the local time changes from summer to winter. 

For example, if the time changes at 02:00 AM BST to 01:00 AM GMT then local

times between 01:00 and 01:59 occur twice.

The conversion applies the DST offset if the local time value is double and

applies the standard UTC offset if the local time does not exists.

This decision makes the conversion process asymmetrical around the discontinuity

in the local time when there is a DST change.

An example conversion from a double local time to UTC and from UTC to a double

local time is:

	Automatic DST update mode.

		/** Automatic time update will occur and the client app will be

			notified. */

		/** Client app needs to confirm that the time should be updated whenever

			a DST event occurs. */

	/**

	Time zone server change events.

	*/

		/** Used for notifying that the system timezone has changed.*/

		ETZAutomaticTimeUpdate,

		/** Used for notifying that a change in localization resources has taken

			place. */

		ETZLocalizationDataChanged

	/**

	Time zone server panic codes.

	*/

		/** This panic indicates that there are no rules present for this time

			zone.*/

		/** This panic indicates  that an unsupported time reference has been

			accessed.*/

		/** This panic indicates that a request for notification is already

			pending from the client.*/

		/** This panic indicates that an incorrect data has been sent to the

			server.*/

		EPanicInvalidArgument,

		/** This panic indicates that a table in the user-defined time zone

			database has not conformed to the declared schema. */

		EPanicBadSchema

	/**

	The software install observer plugin can distinguish between changes to the

	resource files or the rules database.  This enumeration indicates the filter

	index that is used for the resource files and rules database filters.

	This enum should not be used externally.

	*/

	enum TSWIObserverFilterIndex

		{

		/** The index of the Tz private directory filter. */

		EFilterTzPrivate=0,

		/** The index of the resources filter. */

		EFilterResourceTimezonelocalization

		};

public:

	This should not be used externally.

	This should not be used externally.

	This should not be used externally.

	IMPORT_C void GetOffsetsForTimeZoneIdsL(const RArray<TInt>& aTzNumericIds,

		RArray<TInt>& aOffsets) const; 

	IMPORT_C CTzRules* GetTimeZoneRulesL(const TTime& aStartTime,

		const TTime& aEndTime, TTzTimeReference aTimeRef) const;

	IMPORT_C CTzRules* GetTimeZoneRulesL(const CTzId& aZone,

		const TTime& aStartTime, const TTime& aEndTime,

		TTzTimeReference aTimeRef) const;

	IMPORT_C void NotifyHomeTimeZoneChangedL(const NTzUpdate::TTimeZoneChange&

		aChange) const;

	IMPORT_C void SetUnknownZoneTimeL(const TTime& aUTCTime,

		const TInt aUTCOffset);

	IMPORT_C void SetUnknownZoneTimeL(const TTime& aUTCTime,

		const TInt aUTCOffset, TBool aPersistInCenRep);

	IMPORT_C void LocalizationReadCitiesL(RPointerArray<CTzLocalizedCityRecord>&

		aCities);

	IMPORT_C void LocalizationReadCitiesL(RPointerArray<CTzLocalizedCityRecord>&

		aCities, TInt aTimeZoneId);

	IMPORT_C void LocalizationReadCitiesInGroupL(RPointerArray<CTzLocalizedCityRecord>&

		aCities, TUint8 aGroupId);

	IMPORT_C CTzLocalizedTimeZoneRecord* LocalizationReadFrequentlyUsedZoneL(

		TInt aFrequentlyUsedZone);

	IMPORT_C CTzLocalizedCityRecord* LocalizationReadCachedTimeZoneCityL(

		TInt aFrequentlyUsedZone);

	IMPORT_C void LocalizationCloseDbL();

	IMPORT_C void LocalizationOpenDbL();

	IMPORT_C void LocalizationWriteCityL(const TDesC& aCityName, TInt aCityTzId,

		TUint8 aCityGroupId, TUint aCityTzResourceId);

	IMPORT_C void LocalizationDeleteCityL(const TDesC& aCityName,

		TInt aCityTzId);

	IMPORT_C void LocalizationWriteFrequentlyUsedZoneL(const CTzLocalizedTimeZoneRecord&

		aTimeZone, const CTzLocalizedCityRecord& aCity,

		TInt aFrequentlyUsedZone);

	IMPORT_C void LocalizationWriteAllFrequentlyUsedZonesL(const RPointerArray<CTzLocalizedTimeZoneRecord>& aTimeZones,

		const RPointerArray<CTzLocalizedCityRecord>& aCities);

	// Debug only methods.

	IMPORT_C void SwiObsBeginL();

	IMPORT_C void SwiObsFileChangedL(TSWIObserverFilterIndex aType);

	IMPORT_C void SwiObsEndL();

	// Debug only methods.

	IMPORT_C TInt __dbgRequestAllocatedCellsL(TInt aHeapSizeInBytes);

	IMPORT_C void __dbgSetHeapFailL(RAllocator::TAllocFail aType, TInt aRate);

	IMPORT_C void __dbgResetHeapL();

	// User-defined time zone access.

    CTzId* CreateUserTimeZoneL(const CTzRules& aTzUserRules, const CTzUserNames& aTzUserNames);

    CTzUserNames* GetUserTimeZoneNamesL(const CTzId& aTzId) const;

    void UpdateUserTimeZoneL(const CTzId& aTzId, const CTzRules& aTzUserRules, const CTzUserNames& aTzUserNames);

    void DeleteUserTimeZoneL(const CTzId& aTzId);

	void GetUserTimeZoneIdsL(RPointerArray<CTzId>& aTzIds) const;

	: iTime(0), iTimeReference(ETzUtcTimeReference)

	: iTime(aTime), iTimeReference(aTimeReference)

	: iTime(aTime), iTimeReference(aTimeReference)

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

/**

The CTzUserData class allows the client to create, read, update or delete

user-defined time zones. 

A user-defined time zone is comprised of time zone rules (encapsulated in a

CTzRules object) and time zone names (encapsulated in a CTzUserNames object).

A time zone identifier (encapsulated in a CTzId object) is used to uniquely

identify a user-defined time zone.

The CTzUserData class also allows the time zone identifiers for all existing

user-defined time zones to be determined. 

@publishedPartner

@released

*/

class CTzUserData : public CBase

    {

public:

    IMPORT_C static CTzUserData* NewL(RTz& aTzServer);

    IMPORT_C ~CTzUserData();

    IMPORT_C CTzId* CreateL(const CTzRules& aTzUserRules, const CTzUserNames&

    	aTzUserNames);

    IMPORT_C CTzRules* ReadRulesL(const CTzId& aTzId) const;

	IMPORT_C CTzUserNames* ReadNamesL(const CTzId& aTzId) const;

    IMPORT_C void UpdateL(const CTzId& aTzId, const CTzRules& aTzUserRules,

    	const CTzUserNames& aTzUserNames);

    IMPORT_C void DeleteL(const CTzId& aTzId);

    IMPORT_C void GetTzIdsL(RPointerArray<CTzId>& aTzIds) const;

private:

    CTzUserData(RTz& aTzServer);

private:

    RTz& iTzServer;

	};

#endif // SYMBIAN_ENABLE_SPLIT_HEADERS