FCL/sf/mw/appsupport: comparison tzservices/tzserver/Server/Source/timezoneconfig.cpp

equal deleted inserted replaced

-:175a0d824084
+:676b6116ca93
-// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 1997-2010 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".
 #include "tzlocalizationdb.h"
 #include <bautils.h>
 #include "CBackupRestoreNotification.h"
 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
 #include <tzuserdefineddata.h>
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "timezoneconfigTraces.h"
+#endif
 #endif
 _LIT8(KUnknownTZName, "Unknown/Zone");
 const TUint32 KUnknownTZId = 0x0ffffff0;
 	PublishTzDbChangeInfoL();
 	}
 void CTzConfigAgent::PublishTzDbChangeInfoL()
 	{
+OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_PUBLISHTZDBCHANGEINFOL_ENTRY, "CTzConfigAgent::PublishTzDbChangeInfoL Entry" );
 	RFile file;
 	CleanupClosePushL(file);
 	TTime tzDbModified = Time::NullTTime();
 	TTime userDbModified = Time::NullTTime();
 			{
 			//Publish the tz rules change
 			NTzUpdate::TTzRulesChange rulesChange;
 			rulesChange.iUTCTimeOfRulesChange.UniversalTime();
 			TPckgBuf<NTzUpdate::TTzRulesChange> bufRules(rulesChange);
+			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, PUBLISH_UPDATE_NOTIFICATION, TZRULES_CHANGE_NOTIFICATION_2, "Time zone rules change" );
 			RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ETzRulesChange, bufRules);
 			}
 		if(tzNameChanged )
 			{
 			//Publish the names change for user defined DB or resource file change
 			NTzUpdate::TTzNamesChange namesChange;
 			namesChange.iUTCTimeOfNamesChange.UniversalTime();
 			TPckgBuf<NTzUpdate::TTzNamesChange> bufNames(namesChange);
+			OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, PUBLISH_UPDATE_NOTIFICATION, TZNAMES_CHANGE_NOTIFICATION_2, "Time zone names change notification" );
 			RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ETzNamesChange, bufNames);
 			}
 		}
+	OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_PUBLISHTZDBCHANGEINFOL_EXIT, "CTzConfigAgent::PublishTzDbChangeInfoL Exit" );
 	}
 void CTzConfigAgent::ReadTimeStampsL(RFile& aFile, TTime& aTzdbSaved, TTime& aUserDbSaved, TTime& aResourceFileSaved)
 	{
+OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_READTIMESTAMPSL_ENTRY, "CTzConfigAgent::ReadTimeStampsL Entry" );
 	RFileReadStream readStream(aFile);
 	CleanupClosePushL(readStream);
 	TUint32 low = readStream.ReadUint32L();
 	TUint32 high = readStream.ReadUint32L();
 	low = readStream.ReadUint32L();
 	high = readStream.ReadUint32L();
 	aResourceFileSaved = TTime(MAKE_TINT64(high, low));
 	CleanupStack::PopAndDestroy(&readStream);
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_READTIMESTAMPSL_EXIT, "CTzConfigAgent::ReadTimeStampsL Exit" );
 	}
 void CTzConfigAgent::WriteTimeStampsL(RFile& aFile, const TTime& aTzdbModified, const TTime& aUserDbModified, const TTime& aResourceFileModified)
 	{
 	RFileWriteStream writeStream(aFile);
 /* Get the sum of time stamps of time zone resource files
 * It returns Time::NullTTime() if there is no resorece files in the "c:\\resource\\timezonelocalization\\"
 */
 TTime  CTzConfigAgent::GetResourceFileTimeStampsL()
 	{
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_GETRESOURCEFILETIMESTAMPSL_ENTRY, "CTzConfigAgent::GetResourceFileTimeStampsL Entry" );
 	CDir* files = NULL;
 	TInt err = iFs.GetDir(KResourceDir, KEntryAttNormal, ESortNone, files);
 	CleanupStack::PushL(files);
 	TInt64 sum = 0;
 	if(err != KErrNone && err != KErrNotFound && err != KErrPathNotFound)
 			const TEntry& entry = (*files)[ii];
 			sum = sum + entry.iModified.Int64();
 			}
 		}
 	CleanupStack::PopAndDestroy(files);
+	OstTraceDefExt1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_GETRESOURCEFILETIMESTAMPSL_EXIT, "CTzConfigAgent::GetResourceFileTimeStampsL Exit;sum=%Ld", sum );
 	if(sum==0)
 		{
 		return Time::NullTTime();
 		}
 	return TTime(sum);
 	}
 void CTzConfigAgent::PublishNewDstChangeInfoL()
 	{
+OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_PUBLISHNEWDSTCHANGEINFOL_ENTRY, "CTzConfigAgent::PublishNewDstChangeInfoL Entry" );
 TInt propertyDefineError = RProperty::Define(KUidSystemCategory,
 												KNextDSTChangePropertyKey,
 												RProperty::EByteArray,
 												KReadPolicy,
 												KWritePolicy,
 													sizeof(NTzUpdate::TDSTChangeInfo));
 	if (propertyDefineError != KErrAlreadyExists)
 		{
 	    // if there was an actual error defining the property then we should leave
+	    OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_ERROR, PROPERTY_DEFINITION, "Property definition return value: =%d", propertyDefineError );
 		User::LeaveIfError(propertyDefineError);
 		}
 // create the next DST change and set some default values
 NTzUpdate::TDSTChangeInfo newDSTChangeInfo;
 		|| (currentNextDSTChangeBuf().iPreviousDSTChangeUTC != newDSTChangeInfo.iPreviousDSTChangeUTC)
 		|| (propertyDefineError != KErrAlreadyExists))
 		{
 		// package the data and set the property value
 		TPckgBuf<NTzUpdate::TDSTChangeInfo> newDSTChangeInfoBuf(newDSTChangeInfo);
+		OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,PUBLISH_UPDATE_NOTIFICATION, NEXT_DST_CHANGE, "Publish New   Dst Change " );
 	    User::LeaveIfError(RProperty::Set(KUidSystemCategory, KNextDSTChangePropertyKey, newDSTChangeInfoBuf));
 		}
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_PUBLISHNEWDSTCHANGEINFOL_EXIT, "CTzConfigAgent::PublishNewDstChangeInfoL Exit" );
 	}
 /*
 */
 CTzConfigAgent* CTzConfigAgent::NewL(MTZCfgAgentObserver& aServer, CTzUserDataDb& aUserDataDb,
 		CTzSwiObserver& aTzSwiObserver)
 	{
 	CTzConfigAgent* self = new(ELeave) CTzConfigAgent(aServer, aUserDataDb, aTzSwiObserver);
 	CleanupStack::PushL(self);
 	self->ConstructL();
 	CleanupStack::Pop(self);
 	return self;
 	return iSystemTzCache->TimeZoneId();
 	}
 const CTzId& CTzConfigAgent::SetTimeZoneL(const CTzId& aZoneId, const TAny* aRequester, TBool aUpdateCentralRepository, TBool aForceCacheUpdate)
 	{
+OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETTIMEZONEL_ENTRY, "CTzConfigAgent::SetTimeZoneL Entry;aZoneId=%u;aUpdateCentralRepository=%u;aForceCacheUpdate=%u", aZoneId.TimeZoneNumericID(), aUpdateCentralRepository, aForceCacheUpdate );
 	TInt oldTzId = 0;
 	TBool zoneChanged = EFalse;
 	TTime now;
 	now.UniversalTime();
 		//For Invalid Timezone, rules doesnot exist
 		CTzRules& newZoneRules =  newZone->GetEncodedTimeZoneRulesL();
 		if (newZoneRules.Count() == 0)
 		    {
+		    OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_ERROR, INVALID_TIME_ZONE, "Invalid Time zone;KErrNotFound=%u", KErrNotFound );
 		    User::Leave(KErrNotFound);
 		    }
 		delete iSystemTzCache;
 		iSystemTzCache = newZone;
 		}
 	iTzDataProvider->ReleaseTzRules();
 	TRAP_IGNORE(PublishNewDstChangeInfoL());
+	OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETTIMEZONEL_EXIT, "CTzConfigAgent::SetTimeZoneL Exit;retun value;Time Zone Id=%u;Time Zone Name=%s", iSystemTzCache->TimeZoneId().TimeZoneNumericID(), iSystemTzCache->TimeZoneId().TimeZoneNameID() );
 	return (iSystemTzCache->TimeZoneId());
 	}
 CTzRules& CTzConfigAgent::GetEncodedTimeZoneRulesL()
 // There is a change to the TZ database. A new one may have been installed
 // Reset the current time zone information to take advantage of any changes.
 void CTzConfigAgent::NotifyTZDataStatusChangeL(RTz::TTzChanges aChange)
 	{
+OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_NOTIFYTZDATASTATUSCHANGEL_ENTRY, "CTzConfigAgent::NotifyTZDataStatusChangeL Entry;aChange=%u", aChange );
 	if (aChange == RTz::ETZLocalizationDataChanged)
 		{
 		TInt j = 0;
 		TInt jEnd = iChangeObservers.Count();
 		while (j < jEnd)
 			}
 		NTzUpdate::TTzNamesChange namesChange;
 		namesChange.iUTCTimeOfNamesChange.UniversalTime();
 		TPckgBuf<NTzUpdate::TTzNamesChange> bufNames(namesChange);
+		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, PUBLISH_UPDATE_NOTIFICATION, TZNAMES_CHANGE_NOTIFICATION, "Time zone names change notification" );
 		User::LeaveIfError(RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ETzNamesChange, bufNames));
 		}
 	else
 		{
 		delete iOtherTzCache;
 		//Publish the property
 		NTzUpdate::TTzRulesChange rulesChange;
 		rulesChange.iUTCTimeOfRulesChange.UniversalTime();
 		TPckgBuf<NTzUpdate::TTzRulesChange> bufRules(rulesChange);
+		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, PUBLISH_UPDATE_NOTIFICATION, TZRULES_CHANGE_NOTIFICATION, "Time zone rules change notification" );
 		User::LeaveIfError(RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ETzRulesChange, bufRules));
 		}
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_NOTIFYTZDATASTATUSCHANGEL_EXIT, "CTzConfigAgent::NotifyTZDataStatusChangeL Exit" );
 	}
 /**
 Calculates the time/date (in UTC) of the next DST change event that will take
 place for the current time zone. Note that there may not be a DST change for
 @internalComponent
 */
 TBool CTzConfigAgent::CalculateNextDstChangeL(TTime& aNextDstEvent, TTime& aPreviousDstEvent)
 {
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_CALCULATENEXTDSTCHANGEL_ENTRY, "CTzConfigAgent::CalculateNextDstChangeL Entry" );
 // Get the current time/date.
 TTime now;
 now.UniversalTime();
 // Get the actualised rules for the current time zone
 	aPreviousDstEvent = utcTimeOfChange;
 	}
 else
 {
 aNextDstEvent = utcTimeOfChange;
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_CALCULATENEXTDSTCHANGEL_EXIT2, "CTzConfigAgent::CalculateNextDstChangeL :DST has changed" );
 return ETrue;
 }
 }
 // No DST change has been found.
+OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_CALCULATENEXTDSTCHANGEL_EXIT, "CTzConfigAgent::CalculateNextDstChangeL Exit: No DST change" );
 return EFalse;
 }
 /**
 @internalComponent
 */
 void CTzConfigAgent::HandleDstChangeTimerL()
 {
+OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_HANDLEDSTCHANGETIMERL_ENTRY, "CTzConfigAgent::HandleDstChangeTimerL Entry" );
 	// UTC offset must be updated only when Auto Update is ON
 	if (iEnabled == RTz::ETZAutoDSTUpdateOn)
 		{
 		UpdateUtcOffsetL();
 		}
 		SetDstChangeTimerL();
 		// Publish update notification.
 		// Note that the value published is the same as
 		// the AutoUpdate Configuration
+		OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,PUBLISH_UPDATE_NOTIFICATION, UTC_OFF_SET_CHANGE, "CTzConfigAgent::HandleDstChangeTimerL:EUtcOffsetChangeNotification" );
 		TInt err = RProperty::Set(
 				NTzUpdate::KPropertyCategory,
 				NTzUpdate::EUtcOffsetChangeNotification, iEnabled);
 			User::LeaveIfError(err);
 	    }
 	TRAP_IGNORE(PublishNewDstChangeInfoL());
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_HANDLEDSTCHANGETIMERL_EXIT, "CTzConfigAgent::HandleDstChangeTimerL Exit" );
 }
 /**
 Calculates what the UTC Offset should be - if this differs from the current
 @internalComponent
 */
 void CTzConfigAgent::SetAutoUpdateBehaviorL(TInt aUpdateEnabled)
 {
+OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETAUTOUPDATEBEHAVIORL_ENTRY, "CTzConfigAgent::SetAutoUpdateBehaviorL Entry;aUpdateEnabled=%u", aUpdateEnabled );
 // Check if the configuration has changed.
 if (aUpdateEnabled != iEnabled)
 {
 // Persist the new configuration.
 iEnabled = aUpdateEnabled;
 iDstTimer->Cancel();
 }
 }
 TRAP_IGNORE(PublishNewDstChangeInfoL());
+OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETAUTOUPDATEBEHAVIORL_EXIT, "CTzConfigAgent::SetAutoUpdateBehaviorL Exit" );
 }
 /**
 Change current local time.
 @internalComponent
 */
 TInt CTzConfigAgent::SetHomeTimeL(const TTime& aHomeTime)
 	{
+OstTraceDefExt5(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETHOMETIMEL_ENTRY, "CTzConfigAgent::SetHomeTimeL Entry;YY=%d;MM=%d;DD=%d;HH=%d;Min=%d", aHomeTime.DateTime().Year(),aHomeTime.DateTime().Month(),aHomeTime.DateTime().Day(),aHomeTime.DateTime().Hour(), aHomeTime.DateTime().Minute() );
+OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETHOMETIMEL_PARAM, "Parameter..;SS=%d", aHomeTime.DateTime().Second() );
 	TTime utcTime(aHomeTime);
 	ConvertL(utcTime, ETzWallTimeReference);
 	//Cancel environment change notification in case double updating UTC offset.
 	//Restart observe environment change notification.
 	iChangeNotifier->Start();
 	TRAP_IGNORE(PublishNewDstChangeInfoL());
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETHOMETIMEL_EXIT, "CTzConfigAgent::SetHomeTimeL Exit;result=%u", result );
 	return result;
 	}
 TInt CTzConfigAgent::SetUnknownTimeZoneTimeL(const TTime& aUTCTime, const TInt aUTCOffset, TBool aPersistInCenRep)
 	{
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETUNKNOWNTIMEZONETIMEL_ENTRY, "CTzConfigAgent::SetUnknownTimeZoneTimeL Entry;aUTCOffset=%d;aPersistInCenRep=%u", aUTCOffset, aPersistInCenRep );
 	//
 	// Cancel DST timer. (It will not be restarted, as we won't have DST rules for this unknown zone)
 	//
 	iDstTimer->Cancel();
 	TInt result = User::SetUTCTimeAndOffset(aUTCTime, newUtcOffset);
 	//
 	// Restart environment change notification.
 	//
 	iChangeNotifier->Start();
 	User::LeaveIfError(result);
 	TInt oldTzId = iSystemTzCache->TimeZoneId().TimeZoneNumericID();
 	// replace the rule, create an new unknown before deleting old
 	NTzUpdate::TTimeZoneChange change;
 	change.iNewTimeZoneId = 0;
 	change.iOldTimeZoneId = oldTzId;
 	TPckgBuf<NTzUpdate::TTimeZoneChange> changeBuf(change);
+	OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,PUBLISH_UPDATE_NOTIFICATION, TZCHANGE_NOTIFICATION, "CTzConfigAgent::SetUnknownTimeZoneTimeL:TTimeZoneChange Notification" );
 	RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ECurrentTimeZoneId, changeBuf);
 	iTzDataProvider->ReleaseTzRules();
+	OstTraceDef1( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZCONFIGAGENT_SETUNKNOWNTIMEZONETIMEL_EXIT, "CTzConfigAgent::SetUnknownTimeZoneTimeL Exit;KErrNone=%d", KErrNone );
 	return KErrNone;
 	}
 /**
 	{
 	TRAP_IGNORE(NotifyUserTzRulesChangeL(aChange));
 	}
 void CTzConfigAgent::NotifyUserTzRulesChangeL(TTzUserDataChange aChange)
 	{
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_NOTIFYUSERTZRULESCHANGEL_ENTRY, "CTzConfigAgent::NotifyUserTzRulesChangeL Entry;Operation=%u;Time zone Id=%u",aChange.iOperation , aChange.iTzId );
 	//Only interested when a user TZ rule is updated or deleted
 	if (aChange.iOperation == ETzUserDataUpdated ||	aChange.iOperation == ETzUserDataDeleted)
 		{
 		//Chached time zone (iOtherTzCache) should be cleaned off.
 		delete iOtherTzCache;
 			CleanupStack::PushL(tzid);
 			SetTimeZoneL(*tzid, static_cast<TAny*>(this), ETrue, ETrue);
 			CleanupStack::PopAndDestroy(tzid);
 			}
 		}
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_NOTIFYUSERTZRULESCHANGEL_EXIT, "CTzConfigAgent::NotifyUserTzRulesChangeL Exit" );
 	}
 void CTzConfigAgent::NotifyUserTzNamesChange(TTzUserDataChange /*aChange*/)
 {// There is no action needed when the names of a user defined time zone has been changed.
 }
 	iTzDataProvider->RestoreBeginningL();
 	}
 void CTzConfigAgent::RestoreCompletedL(TInt aRestoreResult)
 	{
+OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZCONFIGAGENT_RESTORECOMPLETEDL_ENTRY, "CTzConfigAgent::RestoreCompletedL Entry;aRestoreResult=%u", aRestoreResult );
 	if(aRestoreResult == KErrNone)
 		{
 		//Both read only DB and user defined DB will refresh the data
 		iTzDataProvider->RestoreCompletedL();
 		//Publish the names change for user defined DB
 		NTzUpdate::TTzNamesChange namesChange;
 		namesChange.iUTCTimeOfNamesChange.UniversalTime();
 		TPckgBuf<NTzUpdate::TTzNamesChange> bufNames(namesChange);
+		OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,PUBLISH_UPDATE_NOTIFICATION, TZNAMES_CHANGE_NOTIFICATION_4, "CTzConfigAgent::RestoreCompletedL: TzNames change notification" );
 		RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ETzNamesChange, bufNames);
 		}
+	OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,PUBLISH_UPDATE_NOTIFICATION, CTZCONFIGAGENT_RESTORECOMPLETEDL_EXIT, "CTzConfigAgent::RestoreCompletedL Exit" );
 	}
 //------------------------------------------------------------------------------------
 CTZRulesCache::~CTZRulesCache()
 	{
 	delete iTimeZoneId;		// time zone Id
 	User::Leave(KErrNotFound);
 	}
 const CTzRules& CTZRulesCache::doGetEncodedTimeZoneRulesL(TInt aStartYear, TInt aEndYear)
 	{
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZRULESCACHE_DOGETENCODEDTIMEZONERULESL_ENTRY, "CTZRulesCache::doGetEncodedTimeZoneRulesL Entry;aStartYear=%d;aEndYear=%d", aStartYear, aEndYear );
 	CTzDataProvider& tzDataProvider = iTimeZoneConfigAgent.TzDataProvider();
 	CTzRules* newRules = CTzRules::NewL(aStartYear, aEndYear);
 	CleanupStack::PushL(newRules);
 	CleanupStack::Pop(newRules);
 	// replace current cached rules
 	delete iEncodedRules;
 	iEncodedRules = newRules;
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZRULESCACHE_DOGETENCODEDTIMEZONERULESL_EXIT, "CTZRulesCache::doGetEncodedTimeZoneRulesL Exit" );
 	return *iEncodedRules;
 	}
 void CTZRulesCache::doGetActualisedTimeZoneRulesL(const TTime& aTime)
 	{
+OstTraceDefExt5(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZRULESCACHE_DOGETACTUALISEDTIMEZONERULESL_ENTRY, "CTZRulesCache::doGetActualisedTimeZoneRulesL Entry;YY=%d;MM=%d;DD=%d;HH=%d;MIN=%d", aTime.DateTime().Year(),aTime.DateTime().Month(),aTime.DateTime().Day(),aTime.DateTime().Hour(),aTime.DateTime().Minute() );
+OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZRULESCACHE_DOGETACTUALISEDTIMEZONERULESL_PARAM, "Parameters..;SS=%d",aTime.DateTime().Second());
 	TDateTime dateTime(aTime.DateTime() );
 	// At least we need the rule for the year preceeding the converted time
 	// in order to convert the time to use it to find the correct rule. (Sounds roundabout!)
 	// hence the extra one added to the cache limit
 	CleanupStack::Pop(newRules);
 	// replace current cached rules
 	delete iActualisedRules;
 	iActualisedRules = newRules;
+	OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZRULESCACHE_DOGETACTUALISEDTIMEZONERULESL_EXIT, "CTZRulesCache::doGetActualisedTimeZoneRulesL Exit" );
 	}
 void CTZRulesCache::ConstructL(const CTzId& aTimeZoneId, const TTime& aTime)
 	{
 	if (aTimeZoneId.TimeZoneNumericID() != KUnknownTZId)
 	return *iEncodedRules;
 	}
 TInt CTZRulesCache::GetEncodedTimeZoneRulesSizeL(const TTime& aStartTime, const TTime& aEndTime, TTzTimeReference /*aTimeRef */)
 	{
 	// fetch a new set of rules from the data provider if the range of the rules in iEncodedRules does not
 	// contain both aStartTime and aEndTime
 	if (
 		(iTimeZoneId->TimeZoneNumericID() != KUnknownTZId)
 		&&
 		}
 	}
 CVTzActualisedRules& CTZRulesCache::GetTimeZoneRulesL(const TTime& aTime,TTzTimeReference aTimerRef)
 	{
 if ((iTimeZoneId->TimeZoneNumericID() != KUnknownTZId)
 		&& (!(RuleApplies(*iActualisedRules, aTime, aTimerRef))))
 		{
 		doGetActualisedTimeZoneRulesL(aTime);
 		}
 Tests if the period covered by the cached rules applies to the supplied time.
 */
 TBool CTZRulesCache::RuleApplies(CVTzActualisedRules& actRules,
 const TTime& aTime, TTzTimeReference aTimerRef) const
 	{
+OstTraceDefExt5( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZRULESCACHE_RULEAPPLIES_ENTRY, "CTZRulesCache::RuleApplies Entry;actRules Start year=%d;actRules End year=%d;aTime:YY=%d;aTime:MM=%d;aTime:DD=%d", actRules.StartYear(),  actRules.EndYear(),aTime.DateTime().Year(),aTime.DateTime().Month(),aTime.DateTime().Day() );
+OstTraceDefExt4(OST_TRACE_CATEGORY_DEBUG, TRACE_FLOW_PARAM, CTZRULESCACHE_RULEAPPLIES_ENTRY_PARAM, "Parametere cont..;aTime:Hours=%d;aTime:Min=%d;aTime:Sec=%d;aTimerRef=%u",aTime.DateTime().Hour(), aTime.DateTime().Minute(), aTime.DateTime().Second(), aTimerRef );
 	TInt startYear = actRules.StartYear();
 	TInt endYear = actRules.EndYear();
 	TDateTime dateTime(aTime.DateTime());
 		endYear++;
 		}
 	const TTime KStart(TDateTime(startYear, EJanuary, 0, 0, 0, 0, 0));
 	const TTime KEnd(TDateTime(endYear, EJanuary, 0, 0, 0, 0, 0));
+	OstTraceDef0( OST_TRACE_CATEGORY_DEBUG,TRACE_FLOW_PARAM, CTZRULESCACHE_RULEAPPLIES_EXIT, "CTZRulesCache::RuleApplies Exit" );
 	return ((aTime >= KStart) && (aTime < KEnd));
 	}
 //------------------------------------------------------------------------------------
 //

changeset 81	676b6116ca93
parent 77	b01c07dfcf84