FCL/sf/app/organizer: comparison clock/clockmw/clocktimezone/src/timezoneclient.cpp

equal deleted inserted replaced

-:579cc610882e
+:ef813d54df51
 // User includes
 #include "timezoneclient.h"
 #include "clockcommon.h"
 #include "clockserverclt.h"
 #include "clockprivatecrkeys.h"
+#include "environmentchangenotifier.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "timezoneclientTraces.h"
+#endif
 const int KDaysInWeek(7);
 const int KZerothRule(0);
 const int KOneHour(1);
 const int KNoDifference(0);
 /*!
 	Call this funtion to instantiate the TimezoneClient class.
 */
 TimezoneClient* TimezoneClient::getInstance()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETINSTANCE_ENTRY );
 	if (!mTimezoneClient) {
 		mTimezoneClient = new TimezoneClient();
 		mReferenceCount = true;
 	}
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETINSTANCE_EXIT );
 	return mTimezoneClient;
 }
 /*!
 	Call this function to clean up the instance of TimezoneClient class.
 */
 void TimezoneClient::deleteInstance()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_DELETEINSTANCE_ENTRY );
 	if (mReferenceCount) {
 		delete mTimezoneClient;
 		mTimezoneClient = 0;
-	}
+		mReferenceCount = false;
+	}
+	OstTraceFunctionExit0( TIMEZONECLIENT_DELETEINSTANCE_EXIT );
 }
 /*!
 	Call this function to check if the object is NULL.
 */
 bool TimezoneClient::isNull()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_ISNULL_ENTRY );
+	OstTraceFunctionExit0( TIMEZONECLIENT_ISNULL_EXIT );
 	return !mReferenceCount;
 }
 /*!
 	The constructor.
 */
 TimezoneClient::TimezoneClient()
 {
-	TCallBack callback(environmentCallback, this);
+	OstTraceFunctionEntry0( TIMEZONECLIENT_TIMEZONECLIENT_ENTRY );
+	mNotifier = new EnvironmentChangeNotifier(this);
-	mNotifier = CEnvironmentChangeNotifier::NewL(
-			CActive::EPriorityStandard, callback);
-	mNotifier->Start();
 	mTzLocalizer = CTzLocalizer::NewL();
 	// Create the settings manager.
 	mSettingsManager = new XQSettingsManager(this);
 	// Listen to the key value changes.
 	connect(
 			mSettingsManager, SIGNAL(valueChanged(XQSettingsKey, QVariant)),
 			this, SLOT(eventMonitor(XQSettingsKey, QVariant)));
+	OstTraceFunctionExit0( TIMEZONECLIENT_TIMEZONECLIENT_EXIT );
 }
 /*!
 	Destructor.
 */
 TimezoneClient::~TimezoneClient()
 {
+	OstTraceFunctionEntry0( DUP1_TIMEZONECLIENT_TIMEZONECLIENT_ENTRY );
 	if (mNotifier) {
-		mNotifier->Cancel();
 		delete mNotifier;
-		mNotifier = 0;
 	}
 	if (mWorldClockModel) {
 		mWorldClockModel->clear();
 	}
 	if (mTzLocalizer) {
 	}
 	// Clear the locations if exist.
 	if (mAllLocations.count()) {
 		mAllLocations.clear();
 	}
+	OstTraceFunctionExit0( DUP1_TIMEZONECLIENT_TIMEZONECLIENT_EXIT );
 }
 /*!
 	This functions returns a QList of location info which represent all the
 	cities preset in the device returned by the tz server.
 			valid cityName, countryName, tz id and city group id. None of the other
 			data is filled.
 */
 QList<LocationInfo>& TimezoneClient::getLocations()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETLOCATIONS_ENTRY );
 	if (mAllLocations.count()) {
 		mAllLocations.clear();
 	}
 	// Get the cities, in alphabetical-ascending sorted order.
 		mAllLocations.append(cityInfo);
 	}
 	// Cleanup.
 	CleanupStack::PopAndDestroy(cityArray);
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETLOCATIONS_EXIT );
 	return mAllLocations;
 }
 bool TimezoneClient::getUtcDstOffsetL(int& dstOffset, const CTzId& timezoneId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETUTCDSTOFFSETL_ENTRY );
 	RTz tzHandle;
 	User::LeaveIfError(tzHandle.Connect());
 	CleanupClosePushL(tzHandle);
 	// Local time.
 		if (initialTimeZoneOffset != tVTzactRule.iNewOffset) {
 			dstOffset = tVTzactRule.iNewOffset;
 			CleanupStack::PopAndDestroy(actualizedRules);
 			CleanupStack::PopAndDestroy(timezoneRules);
 			CleanupStack::PopAndDestroy(&tzHandle);
+			OstTraceFunctionExit0( TIMEZONECLIENT_GETUTCDSTOFFSETL_EXIT );
 			return true;
 		} else {
 			dstOffset = initialTimeZoneOffset;
 		}
 	}
 	CleanupStack::PopAndDestroy(actualizedRules);
 	CleanupStack::PopAndDestroy(timezoneRules);
 	CleanupStack::PopAndDestroy(&tzHandle);
+	OstTraceFunctionExit0( DUP1_TIMEZONECLIENT_GETUTCDSTOFFSETL_EXIT );
 	return false;
 }
 LocationInfo TimezoneClient::getCurrentZoneInfoL()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETCURRENTZONEINFOL_ENTRY );
 	// Current zone info.
 	LocationInfo currentLocation;
 	int timezoneId(0);
 	int utcOffset(0);
 	}
 	// Cleanup.
 	CleanupStack::PopAndDestroy( tzId );
 	CleanupStack::PopAndDestroy( &tzHandle );
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETCURRENTZONEINFOL_EXIT );
 	return currentLocation;
 }
 void TimezoneClient::setAsCurrentLocationL(LocationInfo &location)
 {
-/*	Debug::writeDebugMsg(
+	OstTraceFunctionEntry0( TIMEZONECLIENT_SETASCURRENTLOCATIONL_ENTRY );
-			"In time zone client setAsCurrentLocationL " + location.cityName +
-			" " +
-			location.countryName +
-			" " +
-			QString::number(location.zoneOffset));*/
 	LocationInfo prevLocationInfo ;
 	prevLocationInfo = getCurrentZoneInfoL();
+	QTime prevLocationTime = QTime::currentTime();
 	mTzLocalizer->SetTimeZoneL( location.timezoneId );
 	TPtrC ptrCityName(
 			reinterpret_cast<const TText*>(location.cityName.constData()));
 	CTzLocalizedCity* localizedCity =
 	CleanupStack::PopAndDestroy( localizedCity );
 	if(prevLocationInfo.timezoneId == location.timezoneId) {
 		emit cityUpdated();
 	}
+	QTime newTime = QTime::currentTime();
+	if ((prevLocationTime.hour() == newTime.hour())
+			&& (prevLocationTime.minute() == newTime.minute())
+			&& (prevLocationInfo.timezoneId != location.timezoneId)) {
+	    emit cityUpdated();
+}
+	OstTraceFunctionExit0( TIMEZONECLIENT_SETASCURRENTLOCATIONL_EXIT );
 }
 bool TimezoneClient::isDSTOnL(int timezoneId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_ISDSTONL_ENTRY );
 	bool returnVal( false );
 	CTzId* tzId = CTzId::NewL( timezoneId );
 	CleanupStack::PushL( tzId );
 	RTz tzHandle;
 	tzHandle.Close();
 	CleanupStack::PopAndDestroy( &tzHandle );
 	CleanupStack::PopAndDestroy( tzId );
+	OstTraceFunctionExit0( TIMEZONECLIENT_ISDSTONL_EXIT );
 	return returnVal;
 }
 int TimezoneClient::getStandardOffset(int timezoneId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETSTANDARDOFFSET_ENTRY );
 	RTz tzHandle;
 	User::LeaveIfError(tzHandle.Connect());
 	CleanupClosePushL(tzHandle);
 	RArray<int> idArray;
 	RArray<int> offsetArray;
 	idArray.Append(timezoneId);
 	tzHandle.GetOffsetsForTimeZoneIdsL(idArray, offsetArray);
 	int stdOffset = offsetArray[0];
+	if (isDSTOnL(timezoneId)) {
+		CTzId* tzId = CTzId::NewL( timezoneId );
+		CleanupStack::PushL( tzId );
+		// Get the offset with DST enabled.
+		getUtcDstOffsetL(stdOffset, *tzId);
+		CleanupStack::PopAndDestroy(tzId);
+}
 	offsetArray.Close();
 	idArray.Close();
 	// Cleanup.
 	CleanupStack::PopAndDestroy(&tzHandle);
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETSTANDARDOFFSET_EXIT );
 	return stdOffset;
 }
 void TimezoneClient::getDstRulesL(
 		QDateTime &startTime, QDateTime &endTime, int timezoneId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETDSTRULESL_ENTRY );
 	RTz tzHandle;
 	User::LeaveIfError(tzHandle.Connect());
 	CleanupClosePushL(tzHandle);
 	// Local time.
 	}
 	CleanupStack::PopAndDestroy(actualizedRules);
 	CleanupStack::PopAndDestroy(timezoneRules);
 	CleanupStack::PopAndDestroy(tzId);
 	CleanupStack::PopAndDestroy(&tzHandle);
+OstTraceFunctionExit0( TIMEZONECLIENT_GETDSTRULESL_EXIT );
 }
 QList<LocationInfo> TimezoneClient::getSavedLocations()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETSAVEDLOCATIONS_ENTRY );
 	QList<LocationInfo> locationList;
 	QString fileName(CITY_INFO_DB_PATH);
 	fileName.append(CITY_INFO_DB);
 	if (cityInfoFile.open(QIODevice::ReadOnly)) {
 		QDataStream writeStream(&cityInfoFile);
 		writeStream >> locationList;
 		cityInfoFile.close();
 	}
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETSAVEDLOCATIONS_EXIT );
 	return locationList;
 }
 void TimezoneClient::saveLocations(const QList<LocationInfo> &locationList)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_SAVELOCATIONS_ENTRY );
 	QDir cityDbDir;
 	cityDbDir.mkpath(CITY_INFO_DB_PATH);
 	QString fileName(CITY_INFO_DB_PATH);
 	fileName.append(CITY_INFO_DB);
 	QFile cityInfoFile(fileName);
 	if (!cityInfoFile.open(QIODevice::WriteOnly)) {
 		// Error opening or creating file.
+		OstTraceFunctionExit0( TIMEZONECLIENT_SAVELOCATIONS_EXIT );
 		return;
 	}
 	QDataStream writeStream(&cityInfoFile);
 	writeStream << locationList;
 	cityInfoFile.close();
 	emit listUpdated();
-}
+OstTraceFunctionExit0( DUP1_TIMEZONECLIENT_SAVELOCATIONS_EXIT );
-void TimezoneClient::getCountries(QMap<QString, int>& countries)
-{
-	// Get all the city groups(countries).
-	QTime t;
-	t.start();
-	CTzLocalizedCityGroupArray* cityGroupArray =
-			mTzLocalizer->GetAllCityGroupsL(CTzLocalizer::ETzAlphaNameAscending);
-	CleanupStack::PushL(cityGroupArray);
-	t.restart();
-	// Iterate through each of the city groups.
-	for (int i = 0; i < cityGroupArray->Count(); i++) {
-		CTzLocalizedCityGroup& cityGroup(cityGroupArray->At(i));
-		TPtrC countryName(cityGroup.Name());
-		// Get the QString of country name
-		QString qCountryName = QString::fromUtf16(
-				countryName.Ptr(),countryName.Length());
-	    countries[qCountryName] = cityGroup.Id();
-	}
-	// Cleanup.
-	CleanupStack::PopAndDestroy(cityGroupArray);
 }
 void TimezoneClient::getCitiesForCountry(int id, QMap<QString, int>& cities)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETCITIESFORCOUNTRY_ENTRY );
 	// Get the city group for the given id.
 	CTzLocalizedCityArray* cityArray = mTzLocalizer->GetCitiesInGroupL(id,
 			CTzLocalizer::ETzAlphaNameAscending);
 	CleanupStack::PushL(cityArray);
 	CTzLocalizedCityArray* unsortedArray = mTzLocalizer->GetCitiesInGroupL(id,
 	}
 	// Cleanup.
 	CleanupStack::PopAndDestroy(unsortedArray);
 	CleanupStack::PopAndDestroy(cityArray);
+OstTraceFunctionExit0( TIMEZONECLIENT_GETCITIESFORCOUNTRY_EXIT );
 }
 void TimezoneClient::getLocationInfo(
 		int groupId, int cityIndex, LocationInfo& cityInfo)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETLOCATIONINFO_ENTRY );
 	TRAPD(
 			error,
 			// Get the localized city group.
 			CTzLocalizedCityGroup* cityGroup = mTzLocalizer->GetCityGroupL(groupId);
 			// Cleanup.
 			CleanupStack::PopAndDestroy(cityArray);
 			CleanupStack::PopAndDestroy(cityGroup);
 	)
 	Q_UNUSED(error)
+OstTraceFunctionExit0( TIMEZONECLIENT_GETLOCATIONINFO_EXIT );
 }
 QDataStream &operator<<(
 		QDataStream &writeStream, const LocationInfo& locationInfo)
 {
+	OstTraceFunctionEntry0( _OPERATOR_ENTRY );
 	writeStream << locationInfo.cityName
 			<< locationInfo.countryName
 			<< locationInfo.listImageName
 			<< locationInfo.dstOn
 			<< locationInfo.timezoneId
 			<< locationInfo.zoneOffset;
+	OstTraceFunctionExit0( _OPERATOR_EXIT );
 	return writeStream;
 }
 QDataStream &operator>>(
 		QDataStream &readStream, LocationInfo &locationInfo)
 {
+	OstTraceFunctionEntry0( DUP1__OPERATOR_ENTRY );
 	readStream >> locationInfo.cityName
 	>> locationInfo.countryName
 	>> locationInfo.listImageName
 	>> locationInfo.dstOn
 	>> locationInfo.timezoneId
 	>> locationInfo.zoneOffset;
+	OstTraceFunctionExit0( DUP1__OPERATOR_EXIT );
 	return readStream;
 }
-int TimezoneClient::environmentCallback(TAny* obj)
-{
-	TimezoneClient* self = static_cast<TimezoneClient *> (obj);
-	int changes = KInitialEvent;
-	if (self->mNotifier) {
-		changes = self->mNotifier->Change();
-	}
-	if (KInitialEvent <= changes) {
-		// We're not concerned about handling environment changes in that range.
-		return 0;
-	}
-	if (changes & (EChangesMidnightCrossover |
-			EChangesLocale |
-			EChangesSystemTime)) {
-		emit self->timechanged();
-	} else {
-		// Nothing to do.
-	}
-	return 0;
-}
 int TimezoneClient::getDstZoneOffset(int tzId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETDSTZONEOFFSET_ENTRY );
 	// Connect to the timezone server.
 	RTz client;
 	User::LeaveIfError(client.Connect());
 	CleanupClosePushL(client);
 	client.GetOffsetsForTimeZoneIdsL(zoneIds, zoneOffsets);
 	// Cleanup.
 	CleanupStack::PopAndDestroy(&client);
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETDSTZONEOFFSET_EXIT );
 	return zoneOffsets[0];
 }
 bool TimezoneClient::dstOn(int tzId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_DSTON_ENTRY );
 	// Connect to the timezone server.
 	RTz client;
 	User::LeaveIfError(client.Connect());
 	CleanupClosePushL(client);
 	// Cleanup.
 	CleanupStack::PopAndDestroy(zoneId);
 	CleanupStack::PopAndDestroy(&client);
+	OstTraceFunctionExit0( TIMEZONECLIENT_DSTON_EXIT );
 	return returnVal;
 }
 int TimezoneClient::getCityGroupIdByName(const QString& name)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETCITYGROUPIDBYNAME_ENTRY );
 	TPtrC namePtr;
 	namePtr.Set(name.utf16(), name.length());
 	// Get the citygroup matching the name.
 	CTzLocalizedCityGroup *cityGroup = mTzLocalizer->FindCityGroupByNameL(namePtr);
 	int id = cityGroup->Id();
 	// Cleanup.
 	CleanupStack::PopAndDestroy(cityGroup);
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETCITYGROUPIDBYNAME_EXIT );
 	return id;
 }
 int TimezoneClient::getCityOffsetByNameAndId(const QString& name, int tzId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETCITYOFFSETBYNAMEANDID_ENTRY );
 	TPtrC namePtr;
 	namePtr.Set(name.utf16(), name.length());
 	// Get the citygroup matching the name.
 	CTzLocalizedCityArray *cityArray = mTzLocalizer->GetCitiesL(tzId);
 	}
 	// Cleanup.
 	CleanupStack::PopAndDestroy(cityArray);
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETCITYOFFSETBYNAMEANDID_EXIT );
 	return id;
 }
 void TimezoneClient::setDateTime(QDateTime dateTime)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_SETDATETIME_ENTRY );
 	TMonth month = intToMonth(dateTime.date().month());
 	TTime current(TDateTime(
 			dateTime.date().year(), month, dateTime.date().day() - 1,
 			dateTime.time().hour(), dateTime.time().minute(),
 			dateTime.time().second(), dateTime.time().msec() * 1000));
 	RTz tz;
 	User::LeaveIfError(tz.Connect());
 	CleanupClosePushL(tz);
 	TInt ret(tz.SetHomeTime(current));
 	CleanupStack::PopAndDestroy(&tz);
+OstTraceFunctionExit0( TIMEZONECLIENT_SETDATETIME_EXIT );
 }
 void TimezoneClient::setTimeUpdateOn(bool timeUpdate)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_SETTIMEUPDATEON_ENTRY );
 	RClkSrvInterface clkSrvInterface;
 	User::LeaveIfError(clkSrvInterface.Connect());
 	if (timeUpdate) {
 		clkSrvInterface.ActivateAllProtocols();
 	}
 	else {
 		clkSrvInterface.DeActivateAllProtocols();
 	}
 	clkSrvInterface.Close();
+OstTraceFunctionExit0( TIMEZONECLIENT_SETTIMEUPDATEON_EXIT );
 }
 bool TimezoneClient::timeUpdateOn()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_TIMEUPDATEON_ENTRY );
 	TBool autoTimeUpdateOn;
 	RClkSrvInterface clkSrvInterface;
 	User::LeaveIfError(clkSrvInterface.Connect());
 	clkSrvInterface.IsAutoTimeUpdateOn(autoTimeUpdateOn);
 	clkSrvInterface.Close();
+	OstTraceFunctionExit0( TIMEZONECLIENT_TIMEUPDATEON_EXIT );
 	return autoTimeUpdateOn;
 }
-QStandardItemModel *TimezoneClient::locationSelectorModel()
-{
-	if (!mWorldClockModel) {
-		createWorldClockModel();
-	}
-	return mWorldClockModel;
-}
 TMonth TimezoneClient::intToMonth(int month)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_INTTOMONTH_ENTRY );
 	switch (month) {
 		case 1:
 			return EJanuary;
 		case 2:
 			return EFebruary;
 			break;
 	}
 	return (TMonth) -1;
 }
-void TimezoneClient::createWorldClockModel()
-{
-	// Construct the model if its not yet done
-	if (!mWorldClockModel) {
-		// Create the model
-		mWorldClockModel = new QStandardItemModel(this);
-		getCountries(mAllCountries);
-		mCountryCount = mAllCountries.count();
-		// Construct the model in asynchronously
-		QTimer::singleShot(2000, this, SLOT(populateCities()));
-	}
-}
 void TimezoneClient::populateCities()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_POPULATECITIES_ENTRY );
 	// First iterate over all the counties
 	QMapIterator<QString, int> countryIter(mAllCountries);
 	while (countryIter.hasNext()) {
 		countryIter.next();
 		// Create an item for each country and append it to the model
 			// TODO: Define and use proper role
 			city->setData(cityIter.value(), Qt::UserRole + 200);
 			country->appendRow(city);
 		}
 	}
+OstTraceFunctionExit0( TIMEZONECLIENT_POPULATECITIES_EXIT );
 }
 /*!
 	 Checks if DST changes will be applied in the next 24 hours.
 	 \param alarmInfo reference to alarm info
 	 \return true if there is DST change otherwise false
 */
 bool TimezoneClient::checkForDstChange(AlarmInfo& alarmInfo)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_CHECKFORDSTCHANGE_ENTRY );
 	// User to be notified whether DST rollover happens in a day or
 	// has happen within a day if he tries to change the time.
 	bool returnValue( EFalse );
 	// Establish connection with RTz to get the timezone ID
 	CleanupStack::PopAndDestroy( vActualisedRules);
 	CleanupStack::PopAndDestroy( currentRules );
 	CleanupStack::PopAndDestroy( currentTZId );
 	CleanupStack::PopAndDestroy( &tzHandle );
+	OstTraceFunctionExit0( TIMEZONECLIENT_CHECKFORDSTCHANGE_EXIT );
 	return returnValue;
 }
 /*!
 	Get all time zone ids
 	\return list of time zone ids
 */
 QList<int> TimezoneClient::getAllTimeZoneIds()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETALLTIMEZONEIDS_ENTRY );
 	if (mTimeZoneIds.count()) {
+		OstTraceFunctionExit0( TIMEZONECLIENT_GETALLTIMEZONEIDS_EXIT );
 		return mTimeZoneIds;
 	} else {
 		// This list will contain the info of the cities fetched from tz server.
 		QList<LocationInfo> infoList;
 				mTimeZoneIds.append(tzId);
 			}
 		}
 		CleanupStack::PopAndDestroy(cityArray);
+		OstTraceFunctionExit0( DUP1_TIMEZONECLIENT_GETALLTIMEZONEIDS_EXIT );
 		return mTimeZoneIds;
 	}
 }
 /*!
 	\return list of time zone ids
 */
 QList<int> TimezoneClient::getAllTimeZoneOffsets()
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETALLTIMEZONEOFFSETS_ENTRY );
 	QList<int> timeZoneOffsetList;
 	QList<int> timeZoneIdList;
 	if (mTimeZoneIds.count()) {
 		timeZoneIdList = mTimeZoneIds;
 	} else {
 	tzHandle.Close();
 	CleanupStack::PopAndDestroy( &tzHandle );
 	// Sort the offset list
 	qSort(timeZoneOffsetList.begin(),timeZoneOffsetList.end());
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETALLTIMEZONEOFFSETS_EXIT );
 	return timeZoneOffsetList;
 }
 /*!
 	\param list of countries infomation having the same UTC offsets
 */
 QList<LocationInfo> TimezoneClient::getCountriesForUTCOffset(int utcOffset)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_GETCOUNTRIESFORUTCOFFSET_ENTRY );
 	// This list will contain the info of the countries.
 	QList<LocationInfo> countryList;
 	QList<int> cityGroupIdList;
 	// Get all cities for the UTC offset.
 			delete country;
 		}
 	}
 	cityGroupIdList.clear();
 	CleanupStack::PopAndDestroy(cityList);
+	OstTraceFunctionExit0( TIMEZONECLIENT_GETCOUNTRIESFORUTCOFFSET_EXIT );
 	return countryList;
 }
 /*!
 	Add a new city to the city list using the
 	\cityGroupId Group Id of the country
 */
 LocationInfo TimezoneClient::addCity(
 		int timeZoneId,QString &cityName,int cityGroupId)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_ADDCITY_ENTRY );
 	TPtrC namePtr;
 	namePtr.Set(cityName.utf16(), cityName.length());
 	// Add a new city using the localizer
 	CTzLocalizedCity* newCity =
 	info.cityName = QString::fromUtf16(
 			newCityName.Ptr(), newCityName.Length());
 	CleanupStack::PopAndDestroy(newCity);
+	OstTraceFunctionExit0( TIMEZONECLIENT_ADDCITY_EXIT );
 	return info;
 }
 /*!
 	Slot which is called when the value changes in cevrep.
 	\param key The key which got changed in cenrep.
 	\param value The new value of that key.
 */
 void TimezoneClient::eventMonitor(const XQSettingsKey& key, const QVariant& value)
 {
+	OstTraceFunctionEntry0( TIMEZONECLIENT_EVENTMONITOR_ENTRY );
 	if (key.uid() == KCRUidNitz && key.key() == KActiveProtocol) {
 		if (mSettingsManager->error() == XQSettingsManager::NoError) {
 			// New value of auto time update.
 			int autoTimeUpdate = value.toInt();
 				mAutoTimeUpdateValue = autoTimeUpdate;
 				emit autoTimeUpdateChanged(mAutoTimeUpdateValue);
 			}
 		}
 	}
+OstTraceFunctionExit0( TIMEZONECLIENT_EVENTMONITOR_EXIT );
+}
+void TimezoneClient::notifyTimeChange()
+{
+	OstTraceFunctionEntry0( TIMEZONECLIENT_NOTIFYTIMECHANGE_ENTRY );
+	emit timechanged();
+OstTraceFunctionExit0( TIMEZONECLIENT_NOTIFYTIMECHANGE_EXIT );
 }
 // End of file	--Don't remove this.

changeset 58	ef813d54df51
parent 50	579cc610882e