--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tzservices/tzloc/src/TzLocalizationResourceReader.cpp Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,873 @@
+// 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 "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:
+//
+
+#include "TzLocalizationResourceReader.h" //CTzLocalizationResourceReader
+#include "TzLocalizationDataTypes.h" //CTzLocalizedCity etc
+#include "TzLocalizer.h" //TTzLocalizerPanics
+
+#include <bautils.h> //BaflUtils::NearestLanguageFile
+
+// Resource File locations
+_LIT(KTzLocalizationTimeZoneResourceFileName,"\\Resource\\TimeZoneLocalization\\timezones.rSC");
+_LIT(KTzLocalizationGroupResourceFileName,"\\Resource\\TimeZoneLocalization\\timezonegroups.rSC");
+_LIT(KFlashPath,"c:\\Resource\\TimeZoneLocalization\\");
+_LIT(KFlashDrive, "c:");
+_LIT(KRom, "z:");
+
+/**
+Allocates and constructs a new CTzLocalizationResourceReader object
+@return the newly constructed CTzLocalizationResourceReader
+@internalTechnology
+*/
+CTzLocalizationResourceReader* CTzLocalizationResourceReader::NewL()
+ {
+ CTzLocalizationResourceReader* self = CTzLocalizationResourceReader::NewLC();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/**
+Allocates and constructs a new CTzLocalizationResourceReader object
+The pointer to the new object is left on the cleanup stack
+@return the newly constructed CTzLocalizationResourceReader
+@internalTechnology
+*/
+CTzLocalizationResourceReader* CTzLocalizationResourceReader::NewLC()
+ {
+ CTzLocalizationResourceReader* self = new (ELeave) CTzLocalizationResourceReader();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+/**
+Second phase contructor
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ConstructL()
+ {
+ User::LeaveIfError(iFs.Connect());
+
+ // Assign Panic category, in case it's needed
+ _LIT(KTzLocalizationCategory,"TZLOCALIZATION");
+
+ // If resource files are found on flash drive,
+ // these will be used exclusively otherwise the
+ // default ones on ROM will be used.
+ CDir* dirList;
+ // Get a list of files on flash drive
+ TInt ret = iFs.GetDir(KFlashPath, KEntryAttMaskSupported, ESortNone, dirList);
+ CleanupStack::PushL(dirList);
+ TFileName* timeZoneResourceFileName = new(ELeave) TFileName;
+ CleanupStack::PushL(timeZoneResourceFileName);
+ TFileName* groupResourceFileName = new(ELeave) TFileName;
+ CleanupStack::PushL(groupResourceFileName);
+ TInt count = 0;
+ if(dirList != NULL)
+ {
+ count = dirList->Count();
+ }
+
+ // Use the files on ROM
+ if(ret == KErrPathNotFound || count == 0)
+ {
+ timeZoneResourceFileName->Format(KRom);
+ timeZoneResourceFileName->Append(KTzLocalizationTimeZoneResourceFileName);
+
+ groupResourceFileName->Format(KRom);
+ groupResourceFileName->Append(KTzLocalizationGroupResourceFileName);
+ }
+ // Use the files on system drive
+ else if(ret == KErrNone)
+ {
+ if(count > 0)
+ {
+ timeZoneResourceFileName->Format(KFlashDrive);
+ timeZoneResourceFileName->Append(KTzLocalizationTimeZoneResourceFileName);
+
+ groupResourceFileName->Format(KFlashDrive);
+ groupResourceFileName->Append(KTzLocalizationGroupResourceFileName);
+ }
+ }
+ else
+ {
+ User::Leave(ret);
+ }
+ // Form the time zone resource filename using BaflUtils::NearestLanguageFile
+ BaflUtils::NearestLanguageFile(iFs,*timeZoneResourceFileName);
+
+ // Form the time zone group resource filename using BaflUtils::NearestLanguageFile
+ BaflUtils::NearestLanguageFile(iFs,*groupResourceFileName);
+
+ // Open resource files - this can be done now, as it is opened in EFileShareReadersOnly mode
+ TRAPD(timeZoneResErr,iTimeZoneResourceFile.OpenL(iFs,*timeZoneResourceFileName));
+ if(timeZoneResErr == KErrNotFound || timeZoneResErr == KErrPathNotFound)
+ {
+ User::Panic(KTzLocalizationCategory,CTzLocalizer::ETzLocalizerPanicResourceFileNotFound);
+ }
+ User::LeaveIfError(timeZoneResErr);
+ iTimeZoneResourceFile.ConfirmSignatureL();
+
+ TRAPD(groupResErr,iGroupResourceFile.OpenL(iFs,*groupResourceFileName));
+
+ // Set iGroupResourceFileExists to so that it can be checked before
+ // iGroupResourceFile is used
+ iGroupResourceFileExists = (groupResErr == KErrNone);
+ if(iGroupResourceFileExists)
+ {
+ iGroupResourceFile.ConfirmSignatureL();
+ iGroupResourceFileExists = ETrue;
+ }
+ CleanupStack::PopAndDestroy(3, dirList); // groupResourceFileName, timeZoneResourceFileName, dirList
+ }
+
+/**
+Destructor
+@internalTechnology
+*/
+CTzLocalizationResourceReader::~CTzLocalizationResourceReader()
+ {
+ iTimeZoneResourceFile.Close();
+ if(iGroupResourceFileExists)
+ {
+ iGroupResourceFile.Close();
+ }
+ delete iResourceBuffer;
+ iFs.Close();
+ }
+
+/**
+Searches the time zone resource file for the given time zone ID. This function will
+leave if the specified ID is not found.
+@param aTimeZoneId time zone to search for.
+@return The resource ID or KErrNotFound.
+@internalTechnology
+*/
+TInt CTzLocalizationResourceReader::FindTimeZoneResourceIdL(const TInt aTimeZoneId)
+ {
+ TInt initialOffset = FirstTimeZoneResourceIdL();
+
+ TInt idToCheck;
+
+ // Search through all resources
+ TInt i = 0;
+ while(iTimeZoneResourceFile.OwnsResourceIdL(initialOffset + i))
+ {
+ // Read current resource contents
+ BufferResourceL(iTimeZoneResourceFile,initialOffset + i);
+
+ // get the first int16 (WORD in resource STRUCT)
+ idToCheck = iResourceReader.ReadInt16();
+
+ // get rid of the buffer, it's no longer needed
+ ResetResourceBuffer();
+
+ // perform check
+ if(idToCheck == aTimeZoneId)
+ {
+ // return the current resource ID
+ return initialOffset + i;
+ }
+ ++i;
+ }
+
+ // If it's got to here the aId hasn't been found, so leave
+ User::Leave(KErrNotFound);
+
+ return KErrNotFound; // To satisfy compiler
+ }
+
+/**
+Returns the resource Id of the specified resource. This
+leaves if this resource is not found in the resource file.
+@param aResourceFile The resource file that the offset belongs to.
+@param aOffset The offset to return.
+@return The resource Id of the first resource containing localised data.
+@internalTechnology
+*/
+TInt CTzLocalizationResourceReader::LocalizedResourceIdL(const RResourceFile& aResourceFile, const TTzResourceOffset aOffset)
+ {
+ TInt resourceIdToReturn = aResourceFile.Offset();
+
+ // Skip on the relevant number of resources, using the Offset enum
+ resourceIdToReturn += aOffset;
+
+ if(!aResourceFile.OwnsResourceIdL(resourceIdToReturn))
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ return resourceIdToReturn;
+ }
+
+/**
+Returns the resource Id of the first time zone resource. This
+leaves if this resource is not found in the resource file.
+@return The resource Id of the first time zone resource.
+@internalTechnology
+*/
+TInt CTzLocalizationResourceReader::FirstTimeZoneResourceIdL()
+ {
+ return LocalizedResourceIdL(iTimeZoneResourceFile,ETzFirstTimeZoneResource);
+ }
+
+/**
+Returns the resource Id of the first group resource. This
+leaves if this resource is not found in the resource file.
+This should only be called if iGroupResourceFile != NULL
+@return The resource Id of the first group resource.
+@internalTechnology
+*/
+TInt CTzLocalizationResourceReader::FirstGroupResourceIdL()
+ {
+ return LocalizedResourceIdL(iGroupResourceFile,ETzFirstLocalizedResource);
+ }
+
+/**
+Returns the resource Id of the resource containing the default cached zone
+information. This leaves if this resource is not found in the resource file.
+@return The resource Id of the resource containing the default cached zone
+information.
+@internalTechnology
+*/
+TInt CTzLocalizationResourceReader::CachedTimeZoneResourceIdL()
+ {
+ return LocalizedResourceIdL(iTimeZoneResourceFile,ETzFirstLocalizedResource);
+ }
+
+/**
+Fills iResourceBuffer with the resource specified by aResourceId and sets up
+iResourceReader to read from this resource. This should always be followed by a
+call to ResetResourceBuffer. This function will leave if the requested resource
+is not found in the specified resource file.
+@param aResourceFile The resourcefile to read from.
+@param aResourceId The resource to read from.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::BufferResourceL(const RResourceFile& aResourceFile, const TInt aResourceId)
+ {
+ if(!aResourceFile.OwnsResourceIdL(aResourceId))
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ // Assign buffer for holding resource
+ iResourceBuffer = aResourceFile.AllocReadL(aResourceId);
+
+ // TResourceReader for getting data out of the buffer
+ iResourceReader.SetBuffer(iResourceBuffer);
+ }
+
+/**
+Resets the iResourceBuffer that contains the binary data of a resource.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ResetResourceBuffer()
+ {
+ delete iResourceBuffer;
+ iResourceBuffer = NULL;
+ }
+
+/**
+From MTzLocalizationReader
+Reads the specified time zone from the resource file.
+@param aTimeZoneId The ID of the time zone to return
+@return The specfied localized time zone object.
+@leave KErrNotFound Leaves if the requested Time Zone is not found.
+@internalTechnology
+*/
+CTzLocalizedTimeZone* CTzLocalizationResourceReader::ReadTimeZoneL(const TInt aTimeZoneId)
+ {
+ TInt resourceId = FindTimeZoneResourceIdL(aTimeZoneId);
+
+ return DoReadTimeZoneL(resourceId);
+ }
+
+/**
+From MTzLocalizationReader
+Reads the time zone specified in aTzLocalizedId time
+zone from the resource file. If the resource ID is invalid, the time zone is
+read using the time zone ID.
+@param aTzLocalizedId The TTzLocalizedId specifying the resource ID and Time
+zone Id of the Time zone to return.
+@return The specfied localized time zone object.
+@leave KErrNotFound Leaves if the requested Time Zone is not found.
+@internalTechnology
+*/
+CTzLocalizedTimeZone* CTzLocalizationResourceReader::ReadTimeZoneL(const TTzLocalizedId& aTzLocalizedId)
+ {
+ CTzLocalizedTimeZone* timeZoneToReturn;
+
+ // Check if the resource is in the time zone resource file
+ if(iTimeZoneResourceFile.OwnsResourceIdL(aTzLocalizedId.ResourceId()))
+ {
+ timeZoneToReturn = DoReadTimeZoneL(aTzLocalizedId.ResourceId());
+ }
+ // If the resource ID of aTzLocalizedId isn't found in the reource file,
+ // attempt to search for the timezone using the timezone id.
+ else
+ {
+ timeZoneToReturn = ReadTimeZoneL(aTzLocalizedId.TimeZoneId());
+ }
+
+ return timeZoneToReturn;
+ }
+
+/**
+From MTzLocalizationReader
+Reads all time zones from the resource file and appends them to the supplied array.
+@param aTimeZones An array that at the end of this function contains all time zones.
+@leave KErrNotFound Leaves if the no time zones are found in the resource file.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ReadAllTimeZonesL(CTzLocalizedTimeZoneArray& aTimeZones)
+ {
+ TInt initialOffset = FirstTimeZoneResourceIdL();
+
+ // Variables for us in loop
+ CTzLocalizedTimeZone* timeZone;
+
+ // Search through all resources
+ TInt i = 0;
+ while(iTimeZoneResourceFile.OwnsResourceIdL(initialOffset + i))
+ {
+ // Read new time zone
+ timeZone = DoReadTimeZoneL(initialOffset + i);
+ CleanupStack::PushL(timeZone);
+
+ // Add new time zone to the array (ownership is transferred into array)
+ aTimeZones.AppendL(timeZone);
+ CleanupStack::Pop(timeZone);
+ timeZone = NULL;
+
+ ++i;
+ }
+
+ // If no owned resources were found - Leave
+ if(i == 0)
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+
+/**
+Reads in and returns a localized time zone found at the specified resource id.
+@param aResourceId The resource ID of the time zone in the time zone resource
+file
+@return The localized time zone found at the specified resource ID.
+@internalTechnology
+*/
+CTzLocalizedTimeZone* CTzLocalizationResourceReader::DoReadTimeZoneL(const TInt aResourceId)
+ {
+ BufferResourceL(iTimeZoneResourceFile,aResourceId);
+
+ CTzLocalizedTimeZone* timeZone = CreateTimeZoneFromResourceL(aResourceId);
+
+ ResetResourceBuffer();
+
+ return timeZone;
+ }
+
+/**
+This does the actual reading of a localized time zone from the resource file.
+The iResourceReader MUST already have been set up with a call to
+BufferResourceL(iTimeZoneResourceFile,...), BEFORE this function is called.
+
+@return A CTzLocalizedTimeZone containing the localized time zone information
+that is currently found in iResourceReader.
+
+@internalTechnology
+*/
+CTzLocalizedTimeZone* CTzLocalizationResourceReader::CreateTimeZoneFromResourceL(const TInt aResourceId)
+ {
+ // Read localized time zone data form the resource file in the correct order
+ TInt16 timeZoneId = (TInt16)iResourceReader.ReadInt16();
+ TPtrC standardName(iResourceReader.ReadTPtrC());
+ TPtrC daylightName(iResourceReader.ReadTPtrC());
+ TPtrC shortStandardName(iResourceReader.ReadTPtrC());
+ TPtrC shortDaylightName(iResourceReader.ReadTPtrC());
+
+ TTzLocalizedId tzlocalId(timeZoneId,aResourceId);
+ CTzLocalizedTimeZone* timeZone = CTzLocalizedTimeZone::NewL
+ (
+ tzlocalId,
+ standardName,
+ daylightName,
+ shortStandardName,
+ shortDaylightName
+ );
+
+ return timeZone;
+ }
+
+/**
+From MTzLocalizationReader Reads all cities from the resource file and appends
+them to the supplied array.
+@param aCities An array that at the end of this function will contain all
+cities contained in the resource file.
+
+@leave KErrNotFound Leaves if no cities are found.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ReadCitiesL(CTzLocalizedCityArray& aCities)
+ {
+ TInt initialOffset = FirstTimeZoneResourceIdL();
+
+ // Search through all resources
+ TInt i = 0;
+
+ while(iTimeZoneResourceFile.OwnsResourceIdL(initialOffset + i))
+ {
+ // Read new city into the city array
+ DoReadCitiesL(aCities, initialOffset + i);
+ ++i;
+ }
+
+ // If no owned resources were found - Leave
+ if(i == 0)
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+
+/**
+From MTzLocalizationReader Read the cities that are in the specified time zone
+into the specified city array.
+@param aCities An array of cities that will contain the cities from the
+specified time zone.
+@param aTimeZoneId The ID of the time zone containing the cities to return,.
+@leave KErrNotFound Leaves if the specified time zone is not found or it
+contains no cities.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ReadCitiesL(CTzLocalizedCityArray& aCities, const TInt aTimeZoneId)
+ {
+ TInt resourceId = FindTimeZoneResourceIdL(aTimeZoneId);
+
+ DoReadCitiesL(aCities, resourceId);
+ }
+
+/**
+From MTzLocalizationReader Read the cities that are in the specified time zone
+into the specifed city array. If the resource ID is invalid, the correct
+resource ID is found in the resource file.
+@param An array of cities that will contain the cities from the specified time
+zone.
+@param aTzLocalizedId The TTzLocalizedId specifying of the time zone ID and
+resource ID of the time zone containing the cities to return,.
+@leave KErrNotFound Leaves if the specified time zone is not found or it
+contains no cities.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ReadCitiesL(CTzLocalizedCityArray& aCities, const TTzLocalizedId& aTzLocalizedId)
+ {
+ // Check if the resource is in the time zone resource file
+ if(iTimeZoneResourceFile.OwnsResourceIdL(aTzLocalizedId.ResourceId()))
+ {
+ DoReadCitiesL(aCities, aTzLocalizedId.ResourceId());
+ }
+ // search for aTzLocalizedId's timezone ID instead
+ else
+ {
+ ReadCitiesL(aCities, aTzLocalizedId.TimeZoneId());
+ }
+ }
+
+/**
+Reads in and adds the array of cities contained in the specified resource ID to
+the supplied city array
+@param The array of cities to which the the cities found in the time zone at
+the specified resource ID will be appended to.
+@param aResourceId The resource ID of the time zone that contains the cities to
+be read.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::DoReadCitiesL(CTzLocalizedCityArray& aCities, const TInt aResourceId)
+ {
+ BufferResourceL(iTimeZoneResourceFile,aResourceId);
+
+ AddCityArrayFromResourceL(aCities,aResourceId);
+
+ ResetResourceBuffer();
+ }
+
+/**
+This does the actual reading of the localized cities from the resource file.
+The iResourceReader MUST already have been set up with a call to
+BufferResourceL(iTimeZoneResourceFile,...) BEFORE this function is called.
+@param aCities The array of cities to add the resource cities to.
+@param aResourceId The resource ID of the time zone containing the cities to
+read.
+@return An array of CTzLocalizedCity objects containing the cities that are
+currently found in iResourceReader.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::AddCityArrayFromResourceL(CTzLocalizedCityArray& aCities, const TInt aResourceId)
+ {
+ // Eat up the localised time zone info from the resource
+ CTzLocalizedTimeZone* timeZone = CreateTimeZoneFromResourceL(aResourceId);
+
+ // Create a TTZlocalizedId to give to all the cities
+ TTzLocalizedId tzLocalizedId(timeZone->TimeZoneId(),aResourceId);
+
+ // Delete timeZone as it is no longer needed
+ delete timeZone;
+ timeZone = NULL;
+
+ // Get the number of cities (which automatically precedes the array as a WORD in the STRUCT)
+ TInt numCities = iResourceReader.ReadInt16();
+
+ // Leave if no cities are found
+ if(numCities < 1)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ // variables for use in the loop
+ TUint8 groupId;
+ TPtrC cityName;
+ CTzLocalizedCity* city;
+
+ // Loop through all the cities
+ for(TInt i = 0; i < numCities; ++i)
+ {
+ groupId = iResourceReader.ReadUint8();
+ cityName.Set(iResourceReader.ReadTPtrC());
+
+ city = CTzLocalizedCity::NewLC(cityName,tzLocalizedId,groupId);
+ city->SetCityIndex(i);
+
+ aCities.AppendL(city);
+
+ CleanupStack::Pop(city);
+ city = NULL;
+ }
+ }
+
+/**
+From MTzLocalizationReader
+Reads the cities from the specified city group and adds them to the specified city array.
+@param aCities The array to add the cities from the specified group to.
+@param aGroupId The ID of the group containing the cities to return.
+@leave KErrNotFound Leaves if no groups are found in the resource file, or if
+the group numbering in the resource file is incorrect.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ReadCitiesInGroupL(CTzLocalizedCityArray& aCities, const TUint8 aGroupId)
+ {
+ if(iGroupResourceFileExists)
+ // Only do this if a groups resource file exists - otherwise no groups have been specified
+ {
+ TInt initialOffset = FirstTimeZoneResourceIdL();
+
+ // Variables for use in loop
+ TUint8 groupIdToCheck;
+ CTzLocalizedCityArray* citiesInTimeZone = CTzLocalizedCityArray::NewLC();
+ CTzLocalizedCity* currentCity;
+
+ // Loop through all time zones looking for cities in the requested group
+ TInt i = 0;
+ while(iTimeZoneResourceFile.OwnsResourceIdL(initialOffset + i))
+ {
+ DoReadCitiesL(*citiesInTimeZone, initialOffset + i);
+
+ // Check cities in this time zone to see if they are in the specified group
+ // in reverse order, because we remove as we go.
+ TInt numCitiesInZone = citiesInTimeZone->Count();
+ for(TInt j = numCitiesInZone - 1; j>=0; --j)
+ {
+ groupIdToCheck = citiesInTimeZone->At(j).GroupId();
+ currentCity = &(citiesInTimeZone->At(j));
+
+ // Remove currentCity from citiesInTimeZone now, so that we
+ // don't have to PopAndDestroy citiesInGroup and reallocate
+ // once per while loop
+ citiesInTimeZone->Remove(j);
+
+ // If we are adding this city, move it from citiesInTimeZone to the aCities
+ if(groupIdToCheck == aGroupId)
+ {
+ aCities.AppendL(currentCity);
+ }
+ // otherwise get rid of it while we still have a pointer to it.
+ else
+ {
+ delete currentCity;
+ }
+ currentCity = NULL;
+ }
+ ++i;
+ }
+ CleanupStack::PopAndDestroy(citiesInTimeZone);
+ citiesInTimeZone = NULL;
+ }
+ }
+
+/**
+From MTzLocalizationReader
+Reads all groups from the resource file and adds them to the specified group array.
+No groups are added to the array if none are found.
+@param aGroups The array to add the city groups to.
+@internalTechnology
+*/
+void CTzLocalizationResourceReader::ReadAllGroupsL(CTzLocalizedCityGroupArray& aGroups)
+ {
+ if(iGroupResourceFileExists)
+ {
+ TInt initialOffset = FirstGroupResourceIdL();
+
+ // Variables for use in the loop
+ CTzLocalizedCityGroup* groupToAdd;
+
+ TInt i = 0;
+ while(iGroupResourceFile.OwnsResourceIdL(initialOffset + i))
+ {
+ groupToAdd = DoReadGroupL(initialOffset + i);
+
+ CleanupStack::PushL(groupToAdd);
+ aGroups.AppendL(groupToAdd);
+ // we are transferring ownership into the array
+ CleanupStack::Pop(groupToAdd);
+ groupToAdd = NULL;
+
+ ++i;
+ }
+ }
+ }
+
+/**
+From MTzLocalizationReader Reads the specified group and returns it.
+@param aGroupId The ID of the group to return.
+@return The specified city group object or NULL if the groups resource file
+does not exist.
+@leave KErrNotFound Leaves if the specified group ID is not found.
+@internalTechnology
+*/
+CTzLocalizedCityGroup* CTzLocalizationResourceReader::ReadGroupL(const TUint8 aGroupId)
+ {
+ if(aGroupId < 1)
+ {
+ User::Leave(KErrArgument);
+ }
+
+ CTzLocalizedCityGroup* group = NULL;
+
+ if(iGroupResourceFileExists)
+ {
+ TInt initialOffset = FirstGroupResourceIdL();
+
+ // The groups are numbered 1 to N, where N is the number of resources
+ TInt resourceToRead = initialOffset + aGroupId - 1;
+
+ // Assign a group to return
+ group = DoReadGroupL(resourceToRead);
+ }
+ else
+ // The group resource file doesn't exist - leave with KErrNotFound
+ // This means that it is transparent to the user, whether the groups
+ // resource file exists or not, because this function already leaves
+ // with KErrNotFound if the specified Group ID is not found.
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ return group;
+ }
+
+
+/**
+Reads in the group at the specified resource ID from the group resource file.
+Should only be called if iGroupResourceFile != NULL
+@param aResourceId The resource ID to get the group from.
+@return The group specifed by aResourceId.
+@leave KErrNotFound Leaves if the specified resouce ID is not found.
+@internalTechnology
+*/
+CTzLocalizedCityGroup* CTzLocalizationResourceReader::DoReadGroupL(const TInt aResourceId)
+ {
+ BufferResourceL(iGroupResourceFile,aResourceId);
+
+ CTzLocalizedCityGroup* group = CreateGroupFromResourceL();
+
+ ResetResourceBuffer();
+
+ return group;
+ }
+
+/**
+This does the actual reading of a city group from the group resource file.
+The iResourceReader MUST already have been set up with a call to
+BufferResourceL(iGroupResourceFile,...), BEFORE this function is called.
+@param aResourceId The resource ID of the group to read.
+@return The group at the specifed resource ID in the the group resource file.
+@leave KErrNotFound Leaves if the specified resouce ID is not found.
+@internalTechnology
+*/
+CTzLocalizedCityGroup* CTzLocalizationResourceReader::CreateGroupFromResourceL()
+ {
+ TUint8 groupId = iResourceReader.ReadUint8();
+ TPtrC groupName(iResourceReader.ReadTPtrC());
+
+ CTzLocalizedCityGroup* group = CTzLocalizedCityGroup::NewL(groupName,groupId);
+
+ return group;
+ }
+
+/**
+From MtzLocalizationReader
+Read and return the default city from the specified time zone.
+@param aTimeZoneId The ID of the time zone of the default city to return
+@return The defulat city of the specified time zone.
+@internalTechnology
+*/
+CTzLocalizedCity* CTzLocalizationResourceReader::ReadDefaultCityL(const TInt aTimeZoneId)
+ {
+ // Read the cities from the specified resource
+ CTzLocalizedCityArray* cities = CTzLocalizedCityArray::NewLC();
+ ReadCitiesL(*cities,aTimeZoneId);
+
+ // Move first element (which is the default city) out of cities
+ // to stop it being deleted when cities is
+ CTzLocalizedCity* defaultCity = &(cities->At(0));
+ cities->Remove(0);
+
+ CleanupStack::PopAndDestroy(cities);
+
+ return defaultCity;
+ }
+
+/**
+From MtzLocalizationReader
+Read and return the default city from the specified time zone.
+@param aTzLocalizedId The TTzLocalizedId of the time zone of the default city to return
+@return The defulat city of the specified time zone.
+@internalTechnology
+*/
+CTzLocalizedCity* CTzLocalizationResourceReader::ReadDefaultCityL(const TTzLocalizedId& aTzLocalizedId)
+ {
+ // Read the cities from the specified resource
+ CTzLocalizedCityArray* cities = CTzLocalizedCityArray::NewLC();
+ ReadCitiesL(*cities,aTzLocalizedId);
+
+ // Move first element (which is the default city) out of cities
+ // to stop it being deleted when cities is
+ CTzLocalizedCity* defaultCity = &(cities->At(0));
+ cities->Remove(0);
+
+ CleanupStack::PopAndDestroy(cities);
+
+ return defaultCity;
+ }
+
+/**
+From MTzLocalizationReader
+Read and return the specified cached zone.
+@param aFrequentlyUsedZone the cached zone to return
+@return The specified cached zone.
+@internalTechnology
+*/
+CTzLocalizedTimeZone* CTzLocalizationResourceReader::ReadFrequentlyUsedZoneL(const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone)
+ {
+ // You cannot pass ECachedTimeZones in as the argument, because it is only
+ // used to keep count of how many cached zones there are.
+ __ASSERT_ALWAYS(aFrequentlyUsedZone != CTzLocalizedTimeZone::ECachedTimeZones, User::Leave(KErrArgument));
+
+ TInt offset = CachedTimeZoneResourceIdL();
+
+ BufferResourceL(iTimeZoneResourceFile,offset);
+
+ TInt defaultHomeZoneId = iResourceReader.ReadInt16();
+ TInt defaultInterestZoneId = iResourceReader.ReadInt16();
+ TInt defaultRecentZone1Id = iResourceReader.ReadInt16();
+ TInt defaultRecentZone2Id = iResourceReader.ReadInt16();
+
+ ResetResourceBuffer();
+
+ CTzLocalizedTimeZone* cachedTimeZone = NULL;
+
+ switch(aFrequentlyUsedZone)
+ {
+ case CTzLocalizedTimeZone::EHomeZone:
+ cachedTimeZone = ReadTimeZoneL(defaultHomeZoneId);
+ break;
+ case CTzLocalizedTimeZone::EInterestZone:
+ cachedTimeZone = ReadTimeZoneL(defaultInterestZoneId);
+ break;
+ case CTzLocalizedTimeZone::ERecentZone1:
+ cachedTimeZone = ReadTimeZoneL(defaultRecentZone1Id);
+ break;
+ case CTzLocalizedTimeZone::ERecentZone2:
+ cachedTimeZone = ReadTimeZoneL(defaultRecentZone2Id);
+ break;
+ case CTzLocalizedTimeZone::ECurrentZone: // FALL THROUGH to default - current zone not supported
+ default:
+ User::Leave(KErrArgument);
+ }
+
+ return cachedTimeZone;
+ }
+
+/**
+From MTzLocalizationReader
+Read and return the city used to set thespecified cached zone.
+@param aFrequentlyUsedZone the cached zone specifying which city to return.
+@return The city used to set thespecified cached zone.
+@internalTechnology
+*/
+CTzLocalizedCity* CTzLocalizationResourceReader::ReadCachedTimeZoneCityL(const CTzLocalizedTimeZone::TTzFrequentlyUsedZone aFrequentlyUsedZone)
+ {
+ // You cannot pass ECachedTimeZones in as the argument, because it is only
+ // used to keep count of how many cached zones there are.
+ __ASSERT_ALWAYS(aFrequentlyUsedZone != CTzLocalizedTimeZone::ECachedTimeZones, User::Leave(KErrArgument));
+
+ TInt offset = CachedTimeZoneResourceIdL();
+
+ BufferResourceL(iTimeZoneResourceFile,offset);
+
+ TInt defaultHomeZoneId = iResourceReader.ReadInt16();
+ TInt defaultInterestZoneId = iResourceReader.ReadInt16();
+ TInt defaultRecentZone1Id = iResourceReader.ReadInt16();
+ TInt defaultRecentZone2Id = iResourceReader.ReadInt16();
+
+ ResetResourceBuffer();
+
+ CTzLocalizedCity* cachedCity = NULL;
+
+ switch(aFrequentlyUsedZone)
+ {
+ case CTzLocalizedTimeZone::EHomeZone:
+ cachedCity = ReadDefaultCityL(defaultHomeZoneId);
+ break;
+ case CTzLocalizedTimeZone::EInterestZone:
+ cachedCity = ReadDefaultCityL(defaultInterestZoneId);
+ break;
+ case CTzLocalizedTimeZone::ERecentZone1:
+ cachedCity = ReadDefaultCityL(defaultRecentZone1Id);
+ break;
+ case CTzLocalizedTimeZone::ERecentZone2:
+ cachedCity = ReadDefaultCityL(defaultRecentZone2Id);
+ break;
+ case CTzLocalizedTimeZone::ECurrentZone: // FALL THROUGH to default - current zone not supported
+ default:
+ User::Leave(KErrArgument);
+ }
+
+ return cachedCity;
+ }
+//============================================================================
+// End of file
+//============================================================================
+
+