diff -r 000000000000 -r 2e3d3ce01487 tzservices/tzserver/Server/Include/tzlocalizationdb.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tzservices/tzserver/Server/Include/tzlocalizationdb.h Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,196 @@ +// Copyright (c) 2008-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 __TZLOCALIZATIONDB_H__ +#define __TZLOCALIZATIONDB_H__ + +#include +#include +#include +#include +#include "tzsystemdata.h" +#include "tzuserdata.h" +#include "mtimezonedataaccess.h" + +class CTzServer; + +/** +This class provides access to a database containing the localization information. + +The database contains two tables : one called "FrequentlyUsedZones" containing time zones +and one called "UserCities" containing cities. + +The "FrequentlyUsedZones" table contains one entry (row) for each of the frequently used zones +as defined by the CTzLocalizedTimeZone::TTzFrequentlyUsedZone enum (i.e. 5 rows at the time of +writing). The table always contains this number of rows. When the database is created all the +rows are initialized to a "null" value. + +The table contains 9 columns containing the following information: +Column 1: The time zone id (note this column is a TUint16 while CTzId uses a TUint32) +Column 2: The standard name of the time zone +Column 3: The DST name of the time zone +Column 4: The short standard name of the time zone +Column 5: The short DST name of the time zone +Column 6: The name of the city that is representative of this time zone +Column 7: The group id of the city that is representative of this time zone +Column 8: The resource id associated with the time zone id. +Column 9: The index of the city in the resource file (note this is not the resource id but the +position of this city in the list of cities in the resource file) + +In other words columns 1 and 8 store the values of CTzLocalizedTimeZone::iTzLocalizedId columns 2 to 5 +store the other members of CTzLocalizedTimeZone. + +As we mentioned above this table always has the same number of rows but they may have been initialized to +a "null". The code in CTzLocalizer::PrepareFrequentlyUsedZonesL() checks if this is the case and replaces +the "null" value with the correct data. + +Column 9 holds an index that is used when changing language. This is used in the +CTzLocalizer::UpdateFrequentlyUsedZonesL() function. When changing language the UpdateFrequentlyUsedZonesL() +code first tries to find a city with the same name in the new resource file. If it can't find a city with +the same name it will use the city that has the same index. The index is simply the position of the city in +the resource file so this code assumes that cities are in the same order in the different resource files. See +CTzLocalizationResourceReader::AddCityArrayFromResourceL() for the code that initializes the index. + +Note that this table used to have only 8 columns. Column 9 was added as part of a defect fix in +October 2006. The CTzLocalizer class will check whether the database has 8 or 9 columns on construction +and upgrade the database format if needed. However because of this the CTzLocalizationDb code must cope +with the absence of the 9th column. + +The "UserCities" table contains the list of cities that have been added by the user using the +@see CTzLocalizer::AddCityL() function. The table contains 4 columns containing the following +information: +Column 1: The id of the time zone in which the city is +Column 2: The name of the city +Column 3: The id of the group this city is part of or 0 if the city doesn't belong to a group +Column 4: The resource id associated with the time zone id. + +In other words columns 1 and 2 store the values of CTzLocalizedCity::iTzLocalizedId, column 2 stores +the value of CTzLocalizedCity::iName and column stores the value of CTzLocalizedCity::iGroupId. + +The columns can be addressed using the TTzCityColumn enum. + +@internalComponent +*/ +class CTzLocalizationDb : public CBase, public MTzUserDataChangeObserver, public MTzDataObserver + { +public: + static CTzLocalizationDb* NewL(CTzServer& aServer); + ~CTzLocalizationDb(); + +private: + CTzLocalizationDb(CTzServer& aServer); + void ConstructL(); + +public: + void OpenDbL(); + void CloseDb(); + +private: + void CreateBlankDatabaseL(); + void CreateBlankFrequentlyUsedZoneTableL(); + void CreateBlankUserCityTableL(); + TBool IsInvalidL(); + void RecreateBlankDatabaseL(); + TBool NeedsUpdatingL(); + +public: // from MTzUserDataChangeObserver + void NotifyUserTzRulesChange(TTzUserDataChange aChange); + void NotifyUserTzNamesChange(TTzUserDataChange aChange); + + // from MTzDataObserver + void NotifyTZDataStatusChangeL(RTz::TTzChanges); + +public: + void ReadCitiesL(RPointerArray& aCities); + void ReadCitiesL(RPointerArray& aCities, TInt aTimeZoneId); + void ReadCitiesInGroupL(RPointerArray& aCities, TUint8 aGroupId); + CTzLocalizedTimeZoneRecord* ReadFrequentlyUsedZoneL(TInt aFrequentlyUsedZone); + CTzLocalizedCityRecord* ReadCachedTimeZoneCityL(TInt aFrequentlyUsedZone); + void WriteCityL(const TDesC& aCityName, TUint16 aCityTzId, TUint8 aCityGroupId, TUint aCityTzResourceId); + void DeleteCityL(const TDesC& aCityName, TUint16 aCityTzId); + void WriteFrequentlyUsedZoneL(const CTzLocalizedTimeZoneRecord& aTimeZone, + const CTzLocalizedCityRecord& aCity, TInt aFrequentlyUsedZone); + void WriteAllFrequentlyUsedZonesL(const RPointerArray& aTimeZones, + const RPointerArray& aCities); + + // methods to handle backup-restore + void BackupBeginningL(); + void BackupCompletedL(); + void RestoreBeginningL(); + void RestoreCompletedL(); + +private: + void PrepareCityViewL(RDbView& aCityView, const TDesC& aSqlQuery); + void PrepareZoneViewL(RDbView& aZoneView); + HBufC* GetCityQueryLC(const TDesC& aCityName, TInt aCityTimeZoneId); + HBufC* GetCityQueryLC(TInt aCityTimeZoneId); + void DoReadCitiesL(RPointerArray& aCities, const TDesC& aSqlString); + void DoWriteFrequentlyUsedZoneL(RDbView& aZoneView, const CTzLocalizedTimeZoneRecord& aTimeZone, + const CTzLocalizedCityRecord& aCity); + TInt GetTimeZoneIdFromTzServerL(CTzSystemDataDb& aSystemDataDb); + void NotifyUserTzNamesChangeL(TTzUserDataChange aChange); + TBool ExistsL(TUint aTzId); + static void ReleaseMutex(TAny* iTarget); + void DeleteCitiesL(TTzUserDataChange aChange); + void UpdateTimeZoneAndCityRecordL(RPointerArray& aFrequentlyUsedZones, + RPointerArray& aCachedCities, TInt aTzId); + static void CleanupTimeZonePointerArray(TAny* aArray); + static void CleanupCityPointerArray(TAny* aArray); + TBool ExistsInSystemDbL(TUint aTzId, CTzSystemDataDb& aSystemDataDb); + void UpdateTimeZoneAndCityRecordForSystemDataL(RPointerArray& aFrequentlyUsedZones, + RPointerArray& aCachedCities, TInt aTzId, CTzSystemDataDb& aSystemDataDb); + void RestoreDbL(); + TUint32 GetFrequentlyUsedDefaultZoneCenRepKeyL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFreqUsedZone); + CTzLocalizedTimeZoneRecord* DoReadFrequentlyUsedZoneL(TInt aFrequentlyUsedZone); + void DoWriteAllFrequentlyUsedZonesL(const RPointerArray& aTimeZones, + const RPointerArray& aCities); + TInt GetFrequentlyUsedDefaultZoneIdL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFreqUsedZone, CTzSystemDataDb& aSystemDataDb); + +private: + enum TTzCityColumn + { + // Enum will used as a DB column index, so it must start at 1 + ETzCityId =1, + ETzCityCity, + ETzCityGroup, + ETzCityResourceId, + }; + + // enum that specifies the maximum length of the strings corresponding + // to time zone IDs and group IDs + enum TTzStringLength + { + // Group ID is an unsigned 8-bit integer + EMaxGroupIdStringLength = 3, + // Time Zone ID is an unsigned 16-bit integer + EMaxTimeZoneIdStringLength = 5 + }; + +private: + CTzServer& iServer; + RDbs iDbsSession; + RDbNamedDatabase iLocalizedTimeZoneDb; + /** + This is used to forbid clients to access the database when a backup/restore + is taking place. The database can also be locked permanently if there has been + an unrecoverable error during an update, in which case only a server reboot + will unlock it. + */ + TBool iLocked; + // Protecting iZoneView changes + RMutex iZoneMutex; + }; + +#endif