// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

 // which accompanies this distribution, and is available

 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #ifndef __TzLocalizer_H__

 #define __TzLocalizer_H__

 #include <e32base.h> //CBase

 #include <tzlocalizationdatatypes.h> 	//CTzLocalizedCity, CTzLocalizedCityGroup etc

 // Forward Declarations

 class MTzLocalizationReader;

 class MTzLocalizationWriter;

 /**

 Retrieves localized time zone information based on a time zone ID.

 Time zone information is available in the following forms:

 - Standard Name, for instance Greenwich Mean Time,

 - Short Standard Name, for instance GMT,

 - Daylight Savings Name, for instance British Summer Time,

 - Short Daylight Savings Name, for instance BST.

 This information is encapsulated in a CTzLocalizedTimeZone object.

 A collection of localizable cities for a specific time zone can also be returned.

 New cities can be added to a time zone.  Cities may also be added to groups, but 

 a city may only be a member of one group.

 @publishedAll

 @released

 */

 class CTzLocalizer : public CBase

 	{

 	public:

 		/** Panic reasons for the time zone localization component. */

 		enum TTzLocalizerPanics

 			{

 			/** The time zone server was not found. */

 			ETzLocalizerPanicTimeZoneServerNotFound,

 			/** A resource file was not found. */

 			ETzLocalizerPanicResourceFileNotFound

 			};

 		/** Used to specify the sort order of localized time zone information. */

 		enum TTzSortOrder

 			{

 			/** Unsorted. This is the fastest way to get localized data. */

 			ETzUnsorted,

 			/** Sort by UTC offset starting with the lowest. */

 			ETzUTCAscending,

 			/** Sort by UTC offset starting with the highest. */

 			ETzUTCDescending,

 			/** Sort by name (city name/group name/standard time zone name), from A-Z. */

 			ETzAlphaNameAscending,

 			/** Sort by name (city name/group name/standard time zone name), from Z-A. */

 			ETzAlphaNameDescending,

 			/** Sort by standard name from A-Z. */

 			ETzAlphaStandardNameAscending,

 			/** Sort by daylight savings name from A-Z. */

 			ETzAlphaDaylightNameAscending,

 			/** Sort by short standard name from A-Z. */

 			ETzAlphaShortStandardNameAscending,

 			/** Sort by short daylight savings name from A-Z. */

 			ETzAlphaShortDaylightNameAscending,

 			/** Sort by standard name from Z-A. */

 			ETzAlphaStandardNameDescending,

 			/** Sort by daylight savings name from Z-A. */

 			ETzAlphaDaylightNameDescending,

 			/** Sort by short standard name from Z-A. */

 			ETzAlphaShortStandardNameDescending,

 			/** Sort by short daylight savings name from Z-A. */

 			ETzAlphaShortDaylightNameDescending

 			};

 	public:

 		//Construction / Destruction

 		IMPORT_C static CTzLocalizer* NewL();

 		IMPORT_C static CTzLocalizer* NewLC();

 		IMPORT_C ~CTzLocalizer();

 		//Time zones

 		IMPORT_C CTzLocalizedTimeZone* GetLocalizedTimeZoneL(TInt aTimeZoneId) const;

 		IMPORT_C CTzLocalizedTimeZone* GetLocalizedTimeZoneL(const CTzLocalizedCity& aCity) const;

 		IMPORT_C CTzLocalizedTimeZoneArray* GetAllTimeZonesL(const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C void SetTimeZoneL(TInt aTimeZoneId);

 		//City Management

 		IMPORT_C CTzLocalizedCity* GetDefaultCityL(TInt aTimeZoneId) const;

 		IMPORT_C CTzLocalizedCity* GetDefaultCityL(const CTzLocalizedCity& aCity) const;

 		IMPORT_C CTzLocalizedCity* GetDefaultCityL(const CTzLocalizedTimeZone& aTimeZone) const;

 		IMPORT_C CTzLocalizedCityArray* GetCitiesL(const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedCityArray* GetCitiesL(TInt aTimeZoneId,const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedCityArray* GetCitiesL(const CTzLocalizedTimeZone& aTimeZone,const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedCityArray* GetCitiesL(const CTzLocalizedCity& aCity,const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedCity* AddCityL(TInt aTimeZoneId,const TDesC& aCityName, TInt aGroupId = 0);

 		IMPORT_C void RemoveCityL(CTzLocalizedCity* aCity);

 		//City Groups

 		IMPORT_C CTzLocalizedCityGroupArray* GetAllCityGroupsL(const TTzSortOrder aSortOrder = ETzUnsorted) const;

 		IMPORT_C CTzLocalizedCityGroup* GetCityGroupL(TInt aGroupId) const;

 		IMPORT_C CTzLocalizedCityGroup* GetCityGroupL(const CTzLocalizedCity& aCity) const ;

 		IMPORT_C CTzLocalizedCityArray* GetCitiesInGroupL(TInt aGroupId,const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedCityArray* GetCitiesInGroupL(const CTzLocalizedCity& aCity,const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedCityArray* GetCitiesInGroupL(const CTzLocalizedCityGroup& aCityGroup,const TTzSortOrder aSortOrder = ETzUnsorted);

 		//Frequently Used Zones

 		IMPORT_C CTzLocalizedTimeZone* GetFrequentlyUsedZoneL(const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone);

 		IMPORT_C CTzLocalizedCity* GetFrequentlyUsedZoneCityL(const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone);

 		IMPORT_C void SetFrequentlyUsedZoneL(TInt aTimeZoneId,const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone);

 		IMPORT_C void SetFrequentlyUsedZoneL(const CTzLocalizedTimeZone& aTimeZone,const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone);

 		IMPORT_C void SetFrequentlyUsedZoneL(const CTzLocalizedCity& aCity,const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone);

 		//Find functions

 		IMPORT_C CTzLocalizedCity* FindCityByNameL(const TDesC& aCityName, const TInt aTimeZoneId = 0);

 		IMPORT_C CTzLocalizedTimeZone* FindTimeZoneByNameL(const TDesC& aTimeZoneName);

 		IMPORT_C CTzLocalizedCityGroup* FindCityGroupByNameL(const TDesC& aCityGroupName);

 		IMPORT_C TBool CheckLanguage();

 		//Cities and Time Zones with a specified UTC offset

 		IMPORT_C CTzLocalizedCityArray* GetCitiesWithUTCOffsetL(TInt aUTCOffsetInMinutes, const TTzSortOrder aSortOrder = ETzUnsorted);

 		IMPORT_C CTzLocalizedTimeZoneArray* GetTimeZonesWithUTCOffsetL(TInt aUTCOffsetInMinutes, const TTzSortOrder aSortOrder = ETzUnsorted);

 	private:

 		void ConstructL();

 		CTzLocalizer();

 		TBool PrepareFrequentlyUsedZonesL();

 		void UpdateFrequentlyUsedZonesL();

 		CTzLocalizedTimeZone* GetFrequentlyUsedDefaultZoneL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFreqUsedZone);

 		TUint32 GetFrequentlyUsedDefaultZoneCenRepKeyL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFreqUsedZone);

 		void GetCitiesL(CTzLocalizedCityArray& aCities, const TTzLocalizedId& aLocalizedId, const TTzSortOrder aSortOrder = ETzUnsorted);

 		TLinearOrder<CTzLocalizedCity> CitySortOrderL(const TTzSortOrder aSortOrder);

 		TLinearOrder<CTzLocalizedTimeZone> TimeZoneSortOrderL(const TTzSortOrder aSortOrder);

 		template <class T> void PrepareForUTCSortL(T& aArray);

 		TInt GetTimeZoneIdFromTzServerL();

 		void DoSetTimeZoneL(TInt aTimeZoneId);

 		void ChangeHomeTimeZoneL(TInt aNewId);

 		void ValidateDbL();

         void RecreateDbL();

         TBool DbNeedsUpdatingL() const;

 		TBool DbIsInvalidL() const;

         void UpgradeDbVersionL();

         void FetchCityToUpgradeL(CTzLocalizedTimeZoneArray& aTimeZoneArray, CTzLocalizedCityArray& aCityArray, CTzLocalizedTimeZone::TTzFrequentlyUsedZone aCachedZone);

 	private:

 		//Member data

 		MTzLocalizationReader* iStaticDataReader;

 		MTzLocalizationReader* iPersistedDataReader;

 		MTzLocalizationWriter* iPersistedDataWriter;

 		TLanguage iLanguage;

 	};

 #endif//__TzLocalizer_H__