--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tzservices/tzserver/Server/Source/timezonesession.cpp Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,1204 @@
+// Copyright (c) 1997-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 <s32mem.h>
+#include <vtzrules.h>
+#include <tzupdate.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <tzusernames.h>//new file added for CTzUserNames which is publishedPartner
+#include <tzuserdefineddata.h> //new file added for CTzUserData which is publishedPartner
+#endif
+#include <tzlocalizedcityrecord.h>
+#include <tzlocalizedtimezonerecord.h>
+#include "timezonesession.h"
+#include "timezoneserver.h"
+
+CTzServerSession* CTzServerSession::NewL()
+ {
+ CTzServerSession* self = new (ELeave) CTzServerSession();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+CTzServerSession::~CTzServerSession()
+ {
+ if (iPendingRequest)
+ {
+ iClientMessage.Complete(KErrCancel);
+ iPendingRequest = EFalse;
+ }
+
+ TzServer()->SessionClosed();
+
+ delete iTzUserDataCache;
+
+ iCitiesResultCache.ResetAndDestroy();
+ iCitiesResultCache.Close();
+ delete iTimeZoneResultCache;
+ delete iCityResultCache;
+ }
+
+CTzServerSession::CTzServerSession()
+ {
+ }
+
+void CTzServerSession::ConstructL()
+ {
+ iTzUserDataCache = CTzUserDataCache::NewL();
+ }
+
+// completes a pending client notifier
+void CTzServerSession::NotifyTZStatusChange(RTz::TTzChanges aChange, const TAny* aRequester)
+ {
+ if (static_cast<const CTzServerSession*>(aRequester) == this)
+ {
+ // no need informing the client making the change
+ // he should look after him self
+ return;
+ }
+
+ if (iPendingRequest)
+ {
+ iClientMessage.Complete(aChange);
+ iPendingRequest = EFalse;
+ }
+ }
+
+//
+// Registers to receive notification to time and zone changes in the
+// Server
+TInt CTzServerSession::doRegisterTzChangeNotifier(const RMessage2& aMessage)
+ {
+ if (!iPendingRequest)
+ {
+ iClientMessage = aMessage;
+ iPendingRequest = ETrue;
+ }
+ else
+ {
+ // the same client already requested such notice
+ // Panic the client
+ iPendingRequest = EFalse;
+ aMessage.Panic(KTimeZoneServerName, RTz::EPanicNotificationRequestPending);
+
+ return (KErrCancel);
+ }
+
+ return KRequestPending;
+ }
+
+//
+// Cancels request to receive notification to time and zone changes in the
+// Server
+TInt CTzServerSession::doCancelRequestForTzChangeNoticeL(const RMessage2& /* aMessage */)
+ {
+ if (iPendingRequest)
+ {
+ iPendingRequest = EFalse;
+ iClientMessage.Complete(KErrCancel);
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ return KErrNone;
+ }
+
+
+TInt CTzServerSession::doSetTimeZoneL(const RMessage2& aMessage)
+ {
+ CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize);
+ CleanupStack::PushL(buffer);
+
+ // Read from client message buffer
+ // reserve the full space
+ buffer->ExpandL(0, KMaxTimeZoneIdSize);
+ TPtr8 bufferPtr(buffer->Ptr(0) );
+ aMessage.ReadL(0, bufferPtr);
+
+ RBufReadStream readStream;
+ readStream.Open(*buffer);
+
+ CTzId* zoneId = NULL;
+ TRAPD(err, zoneId = CTzId::NewL(readStream));
+
+ // Panic the client if it sent invalid data that would cause the server to panic.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument);
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ CleanupStack::PushL(zoneId);
+ const CTzId& KInZoneId = TzServer()->TimeZoneManager().SetTimeZoneL(*zoneId, this, ETrue);
+ CleanupStack::PopAndDestroy(zoneId);
+
+ // return the new setting
+ buffer->Reset();
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+ KInZoneId.ExternalizeL(writeStream);
+ writeStream.CommitL();
+ writeStream.Close();
+
+ // Write to client message buffer
+ aMessage.WriteL(1, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+
+ return (KErrNone);
+ }
+
+TInt CTzServerSession::doIsDaylightSavingOnL(const RMessage2& aMessage)
+{
+ CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize);
+ CleanupStack::PushL(buffer);
+ // Read from client message buffer
+ // reserve the full space
+ buffer->ExpandL(0, KMaxTimeZoneIdSize);
+ TPtr8 bufferPtr(buffer->Ptr(0) );
+ aMessage.ReadL(0, bufferPtr);
+
+ TPckgBuf<TTime> timeBuffer;
+ aMessage.ReadL(1, timeBuffer);
+
+ TTime time(timeBuffer());
+
+ RBufReadStream readStream;
+ readStream.Open(*buffer);
+
+ CTzId* zoneId = NULL;
+ TRAPD(err, zoneId = CTzId::NewL(readStream));
+
+ // Panic the client if it sent invalid data that would cause the server to panic.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ CleanupStack::PushL(zoneId);
+
+ if( time == Time::NullTTime())
+ {
+ time.UniversalTime();
+ }
+
+ TInt isDaylightSavingOn = TzServer()->TimeZoneManager().IsDaylightSavingOnL(*zoneId, time);
+ CleanupStack::PopAndDestroy(zoneId);
+ // Write to client message buffer
+ TPckg<TInt> response(isDaylightSavingOn);
+ aMessage.WriteL(2, response);
+ CleanupStack::PopAndDestroy(buffer);
+ return (KErrNone);
+}
+
+TInt CTzServerSession::doGetLocalTimeZoneIdL(const RMessage2& aMessage)
+ {
+ const CTzId& KZoneId = TzServer()->TimeZoneManager().GetTimeZoneIdL();
+
+ CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize);
+ CleanupStack::PushL(buffer);
+
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+
+ KZoneId.ExternalizeL(writeStream);
+
+ writeStream.CommitL();
+ writeStream.Close();
+
+ // Write to client message buffer
+ aMessage.WriteL(0, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+ return (KErrNone);
+
+ }
+
+TInt CTzServerSession::doGetLocalEncodedTimeZoneRulesL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TInt> rulesSizeBuffer;
+ aMessage.ReadL(0, rulesSizeBuffer);
+
+ // Check if rules size buffer is valid. Panic the client if it sent
+ // invalid data that would cause the server to panic.
+ TInt size = rulesSizeBuffer();
+ const TInt KMaxSize = KMaxTInt / 2;
+ if (size <= 0 || size >= KMaxSize)
+ {
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+
+ CBufFlat* buffer = CBufFlat::NewL(rulesSizeBuffer());
+ CleanupStack::PushL(buffer);
+
+ const CTzRules& KRules = TzServer()->TimeZoneManager().GetEncodedTimeZoneRulesL();
+
+ // Externalise rules
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+
+ TRAPD(err, KRules.ExternalizeL(writeStream));
+ // If the stream contains invalid data that would cause the server to panic
+ // then panic the client.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ writeStream.CommitL();
+ writeStream.Close();
+
+ // Write to client message buffer
+ aMessage.WriteL(1, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doGetLocalEncodedTimeZoneRulesSizeL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TTime> startTimeBuffer;
+ aMessage.ReadL(0, startTimeBuffer);
+
+ TPckgBuf<TTime> endTimeBuffer;
+ aMessage.ReadL(1, endTimeBuffer);
+
+ TPckgBuf<TTzTimeReference> timeRefBuffer;
+ aMessage.ReadL(2, timeRefBuffer);
+
+ TInt rulesSize = TzServer()->TimeZoneManager().GetEncodedTimeZoneRulesSizeL(startTimeBuffer(), endTimeBuffer(),
+ timeRefBuffer());
+
+ // Write to client message buffer
+ TPckgBuf<TInt> rulesSizeBuffer(rulesSize);
+ aMessage.WriteL(3, rulesSizeBuffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doGetForeignEncodedTimeZoneRulesL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TInt> rulesSizeBuffer;
+ aMessage.ReadL(0, rulesSizeBuffer);
+
+ // Check if rules size buffer is invalid. Panic the client if it sent
+ // invalid data that would cause the server to panic.
+ TInt size = rulesSizeBuffer();
+ const TInt KMaxSize = KMaxTInt/2;
+ if (size <= 0 || size >= KMaxSize)
+ {
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+
+ CBufFlat* buffer = CBufFlat::NewL(rulesSizeBuffer());
+ CleanupStack::PushL(buffer);
+
+ const CTzRules& KRules = TzServer()->TimeZoneManager().GetForeignEncodedTimeZoneRulesL();
+
+ // Externalise rules
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+ // If the stream contains invalid data that would cause the server to panic
+ // then panic the client.
+ TRAPD(err, KRules.ExternalizeL(writeStream));
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ writeStream.CommitL();
+ writeStream.Close();
+
+ // Write to client message buffer
+ aMessage.WriteL(1, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doGetForeignEncodedTimeZoneRulesSizeL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TTime> startTimeBuffer;
+ aMessage.ReadL(0, startTimeBuffer);
+
+ TPckgBuf<TTime> endTimeBuffer;
+ aMessage.ReadL(1, endTimeBuffer);
+
+ // Read from client message buffer
+ // reserve the full space
+ CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize + sizeof(TTzTimeReference));
+ CleanupStack::PushL(buffer);
+
+ buffer->ExpandL(0, KMaxTimeZoneIdSize + sizeof(TTzTimeReference));
+ TPtr8 bufferPtr(buffer->Ptr(0) );
+ aMessage.ReadL(2, bufferPtr);
+
+ RBufReadStream readStream;
+ readStream.Open(*buffer);
+
+ CTzId* zoneId = NULL;
+ TRAPD(err, zoneId = CTzId::NewL(readStream));
+ // If the stream contains invalid data that would cause the server to panic
+ // then panic the client.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ CleanupStack::PushL(zoneId);
+
+ TTzTimeReference timeRef(static_cast<TTzTimeReference>(readStream.ReadInt8L() ) );
+ TPckgBuf<TTzTimeReference> timeRefBuffer(timeRef);
+
+ TInt rulesSize = TzServer()->TimeZoneManager().GetForeignEncodedTimeZoneRulesSizeL(*zoneId, startTimeBuffer(),
+ endTimeBuffer(), timeRefBuffer());
+
+
+ // Write to client message buffer
+ TPckgBuf<TInt> rulesSizeBuffer(rulesSize);
+ aMessage.WriteL(3, rulesSizeBuffer);
+
+ CleanupStack::PopAndDestroy(2,buffer);
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doConvertLocalZoneTimeL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TTime> timeBuffer;
+ aMessage.ReadL(0, timeBuffer);
+
+ TPckgBuf<TTzTimeReference> timerRefBuffer;
+ aMessage.ReadL(1, timerRefBuffer);
+
+ TTime time(timeBuffer());
+ TzServer()->TimeZoneManager().ConvertL(time, timerRefBuffer());
+
+ // Write to client message buffer
+ TPckg<TTime> timeInBuffer(time);
+ aMessage.WriteL(2, timeInBuffer);
+
+ return (KErrNone);
+ }
+
+
+TInt CTzServerSession::doConvertForeignZoneTimeL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TTime> timeBuffer;
+ aMessage.ReadL(0, timeBuffer);
+
+ TPckgBuf<TTzTimeReference> timerRefBuffer;
+ aMessage.ReadL(1, timerRefBuffer);
+
+ // Read from client message buffer
+ // reserve the full space
+ CBufFlat* buffer = CBufFlat::NewL(KMaxTimeZoneIdSize);
+ CleanupStack::PushL(buffer);
+
+ buffer->ExpandL(0, KMaxTimeZoneIdSize);
+ TPtr8 bufferPtr(buffer->Ptr(0) );
+ aMessage.ReadL(2, bufferPtr);
+
+ RBufReadStream readStream;
+ readStream.Open(*buffer);
+
+ CTzId* zoneId = NULL;
+ TRAPD(err, zoneId = CTzId::NewL(readStream));
+ // If the stream contains invalid data that would cause the server to panic
+ // then panic the client.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(buffer);
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ CleanupStack::PushL(zoneId);
+
+ TTime time(timeBuffer() );
+ TzServer()->TimeZoneManager().ConvertL(*zoneId, time, timerRefBuffer());
+
+ // Write to client message buffer
+ TPckg<TTime> timeInBuffer(time);
+ aMessage.WriteL(3, timeInBuffer);
+
+ CleanupStack::PopAndDestroy(2);
+ return (KErrNone);
+ }
+
+/**
+Retrieves UTC offset for a number of time zone ids
+*/
+TInt CTzServerSession::doGetOffsetsForTimeZoneIdsL(const RMessage2& aMessage) const
+ {
+ TInt bufferSize = aMessage.Int0();
+
+ // If buffer size invalid then panic client.
+ const TInt KMaxSize = KMaxTInt / 4;
+ if (bufferSize <= 0 || bufferSize > KMaxSize)
+ {
+ aMessage.Panic( KTimeZoneServerName, RTz::EPanicInvalidArgument );
+ return KRequestPending;
+ }
+
+ CBufFlat* idBuf = CBufFlat::NewL(bufferSize);
+ CleanupStack::PushL(idBuf);
+ idBuf->ExpandL(0,bufferSize);
+ TPtr8 bufferPtr = idBuf->Ptr(0);
+ aMessage.ReadL(1, bufferPtr);
+
+ CTzConfigAgent& configAgent = TzServer()->TimeZoneManager();
+ configAgent.GetOffsetsForTimeZoneIdsL(*idBuf);
+
+ // Write to client message buffer
+ aMessage.WriteL(1, idBuf->Ptr(0));
+
+ CleanupStack::PopAndDestroy(idBuf);
+
+ return KErrNone;
+ }
+
+/**
+Sets the configuration of the UTC Offset auto-update functionality.
+
+@param aMessage The client-server message parameter.
+@return An error code.
+@internalComponent
+@capability ECapabilityWriteDeviceData Write Device Data capability is needed
+to be able to set the UTC Offset auto-update configuration. This prevents
+non-system applications from altering the settings.
+*/
+TInt CTzServerSession::doSetAutoUpdateBehaviorL(const RMessage2& aMessage)
+ {
+ // Configuration value is stored in message slot zero.
+ TzServer()->TimeZoneManager().SetAutoUpdateBehaviorL(aMessage.Int0());
+ return KErrNone;
+ }
+/**
+Retrieves the auto update value
+*/
+TInt CTzServerSession::doAutoUpdateSettingL(const RMessage2& aMessage)
+ {
+ TInt autoUpdate = TzServer()->TimeZoneManager().AutoUpdateSetting();
+ // Write to client message buffer
+ TPckg<TInt> response(autoUpdate);
+ aMessage.WriteL(0, response);
+ return (KErrNone);
+ }
+
+TInt CTzServerSession::doNotifyHomeTimeZoneChanged(const RMessage2& aMessage)
+ {
+ NTzUpdate::TTimeZoneChange change;
+ change.iNewTimeZoneId = aMessage.Int0();
+ change.iOldTimeZoneId = aMessage.Int1();
+
+ TPckgBuf<NTzUpdate::TTimeZoneChange> changeBuf(change);
+ return RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::EHomeTimeZoneId, changeBuf);
+ }
+
+TInt CTzServerSession::doSetHomeTimeL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TTime> homeTimeBuffer;
+ aMessage.ReadL(0, homeTimeBuffer);
+ return TzServer()->TimeZoneManager().SetHomeTimeL(homeTimeBuffer());
+ }
+
+TInt CTzServerSession::doSetUnknownZoneTimeL(const RMessage2& aMessage)
+ {
+ TPckgBuf<TTime> utcTimeBuffer;
+ TPckgBuf<TInt> utcOffset;
+ TPckgBuf<TBool> persist;
+ aMessage.ReadL(0, utcTimeBuffer);
+ aMessage.ReadL(1, utcOffset);
+ aMessage.ReadL(2, persist);
+
+ return TzServer()->TimeZoneManager().SetUnknownTimeZoneTimeL(utcTimeBuffer(),utcOffset(),persist());
+ }
+
+/**
+ * Creates user defined time zone
+ * Arguments: 0 : Input - Buffer Size
+ * 1 : Input - Data Buffer contains time zone info
+ * 2 : Output - ID of the time zone created
+ */
+TInt CTzServerSession::doCreateUserTimeZoneL(const RMessage2& aMessage)
+ {
+ const TInt buffersize = aMessage.Int0();
+
+ CBufFlat* buffer = CBufFlat::NewL(buffersize);
+ CleanupStack::PushL(buffer);
+
+ buffer->ExpandL(0, buffersize);
+ TPtr8 bufferPtr(buffer->Ptr(0) );
+ aMessage.ReadL(1, bufferPtr);
+
+ RBufReadStream readStream;
+ CleanupClosePushL(readStream);
+ readStream.Open(*buffer);
+
+ CTzRules* rules = NULL;
+ TRAPD(err, rules = CTzRules::NewL(readStream));
+
+ // Panic the client if it sent invalid data that would cause the server to panic.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(2, buffer);
+ aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument);
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ CleanupStack::PushL(rules);
+
+ CTzUserNames* names = CTzUserNames::NewL(readStream);
+ CleanupStack::PushL(names);
+ TInt id = TzServer()->UserTimeZoneDb().CreateTzL(*rules, *names);
+ CleanupStack::PopAndDestroy(4, buffer);
+ TPckgBuf<TInt> idBuffer(id);
+ aMessage.WriteL(2, idBuffer);
+ return KErrNone;
+ }
+
+/**
+ * Update a user defined time zone
+ * Arguments: 0 : Input - Size of data buffer
+ * 1 : Input - Data buffer contained time zone info
+ * 2 : Input - ID of thetTime zone to be updated
+ */
+TInt CTzServerSession::doUpdateUserTimeZoneL(const RMessage2& aMessage)
+ {
+ const TInt buffersize = aMessage.Int0();
+
+ CBufFlat* buffer = CBufFlat::NewL(buffersize);
+ CleanupStack::PushL(buffer);
+
+ buffer->ExpandL(0, buffersize);
+ TPtr8 bufferPtr(buffer->Ptr(0) );
+ aMessage.ReadL(1, bufferPtr);
+
+ RBufReadStream readStream;
+ CleanupClosePushL(readStream);
+ readStream.Open(*buffer);
+
+ CTzRules* rules = NULL;
+ TRAPD(err, rules = CTzRules::NewL(readStream));
+
+ // Panic the client if it sent invalid data that would cause the server to panic.
+ if (err == KErrArgument)
+ {
+ CleanupStack::PopAndDestroy(2, buffer);
+ aMessage.Panic(KTimeZoneServerName, RTz::EPanicInvalidArgument);
+ return KRequestPending;
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+
+ CleanupStack::PushL(rules);
+
+ CTzUserNames* names = CTzUserNames::NewL(readStream);;
+ CleanupStack::PushL(names);
+
+ const TInt id = aMessage.Int2();
+
+ TzServer()->UserTimeZoneDb().UpdateTzL(id, *rules, *names);
+ CleanupStack::PopAndDestroy(4, buffer);
+ return KErrNone;
+ }
+
+/**
+ * Delete a user defined time zone
+ * Arguments: 0 : Input - Time Zone ID
+ */
+TInt CTzServerSession::doDeleteUserTimeZoneL(const RMessage2& aMessage)
+ {
+ const TInt id = aMessage.Int0();
+ TzServer()->UserTimeZoneDb().DeleteTzL(id);
+ return KErrNone;
+ }
+
+/**
+ * Gets the size of user defined time zone names
+ * Arguments: 0 : Input - Time Zone ID
+ * 1 : Output - size of time zone names
+ */
+TInt CTzServerSession::doGetUserTimeZoneNamesSizeL(const RMessage2& aMessage)
+ {
+ const TInt id = aMessage.Int0();
+ TInt sizeOfNames = 0;
+ //ReadTzNamesL leaves if there is not a names found
+ CTzUserNames* names = TzServer()->UserTimeZoneDb().ReadTzNamesL(id);
+ iTzUserDataCache->SetNames(names);
+ sizeOfNames = iTzUserDataCache->SizeOfNames();
+ // Write to client message buffer
+ TPckgBuf<TInt> nameSizeBuffer(sizeOfNames);
+ aMessage.WriteL(1, nameSizeBuffer);
+
+ return KErrNone;
+ }
+
+/**
+ * Gets user defined time zone names
+ * Arguments: 0 : Output - Data buffer contained time zone name
+*/
+ TInt CTzServerSession::doGetUserTimeZoneNamesL(const RMessage2& aMessage)
+ {
+ TInt size = iTzUserDataCache->SizeOfNames();
+ CBufFlat* buffer = CBufFlat::NewL(size);
+ CleanupStack::PushL(buffer);
+ buffer->ExpandL(0,size);
+
+ RBufWriteStream writeStream;
+ CleanupClosePushL(writeStream);
+ writeStream.Open(*buffer);
+ const CTzUserNames& names = iTzUserDataCache->GetNames();
+ writeStream << names;
+ writeStream.CommitL();
+ aMessage.WriteL(0, buffer->Ptr(0));
+ CleanupStack::PopAndDestroy(2, buffer);
+ return KErrNone;
+ }
+
+/**
+ * Gets the size of user defined time zone Ids
+ * Arguments: 0 : Output - Size of time zone IDs
+ */
+TInt CTzServerSession::doGetUserTimeZoneIdsSizeL(const RMessage2& aMessage)
+ {
+ RArray<TUint32> ids;
+ CleanupClosePushL(ids);
+ TzServer()->UserTimeZoneDb().ReadTzIdsL(ids);
+ iTzUserDataCache->SetIdsL(ids);
+ CleanupStack::PopAndDestroy(&ids);
+
+ TInt idsSize = iTzUserDataCache->SizeOfIds();
+ // Write to client message buffer
+ TPckgBuf<TInt> idsSizeBuffer(idsSize);
+ aMessage.WriteL(0, idsSizeBuffer);
+ return KErrNone;
+ }
+
+/**
+ * Gets the user defined time zone Ids
+ * Arguments: 0 : Output - Data buffer contained time zone IDs
+ */
+TInt CTzServerSession::doGetUserTimeZoneIdsL(const RMessage2& aMessage)
+ {
+ CBufFlat* buffer = CBufFlat::NewL(iTzUserDataCache->SizeOfIds());
+ CleanupStack::PushL(buffer);
+ buffer->ExpandL(0,iTzUserDataCache->SizeOfIds());
+
+ RBufWriteStream writeStream;
+ CleanupClosePushL(writeStream);
+ writeStream.Open(*buffer);
+ TArray<TUint32> ids = iTzUserDataCache->GetIds();
+ TInt count = ids.Count();
+ writeStream.WriteInt16L(count);
+ for (TInt ii=0; ii<count; ++ii)
+ {
+ writeStream.WriteUint32L((ids)[ii]);
+ }
+ writeStream.CommitL();
+ aMessage.WriteL(0, buffer->Ptr(0));
+ CleanupStack::PopAndDestroy(2, buffer);
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doGetHeapSizeL(const RMessage2& aMessage)
+ {
+ TInt reply = User::Heap().Count();
+ TInt sizeInBytes;
+ reply = User::AllocSize(sizeInBytes);
+ TPckg<TInt> heapCellsBuffer(reply);
+ TPckg<TInt> heapsizeBuffer(sizeInBytes);
+ aMessage.WriteL(0, heapCellsBuffer);
+ aMessage.WriteL(1, heapsizeBuffer);
+ return reply;
+ }
+
+TInt CTzServerSession::doLocalizationReadCitiesSizeL(const RMessage2& aMessage)
+ {
+ iCitiesResultCache.ResetAndDestroy();
+ TzServer()->LocalizationDb().ReadCitiesL(iCitiesResultCache);
+ TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache);
+
+ // Write to client message buffer
+ TPckgBuf<TInt> resultSizeBuffer(resultSize);
+ aMessage.WriteL(0, resultSizeBuffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadCitiesTzIdSizeL(const RMessage2& aMessage)
+ {
+ iCitiesResultCache.ResetAndDestroy();
+ TzServer()->LocalizationDb().ReadCitiesL(iCitiesResultCache, aMessage.Int1());
+ TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache);
+
+ // Write to client message buffer
+ TPckgBuf<TInt> resultSizeBuffer(resultSize);
+ aMessage.WriteL(0, resultSizeBuffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadCitiesInGroupSizeL(const RMessage2& aMessage)
+ {
+ iCitiesResultCache.ResetAndDestroy();
+ TzServer()->LocalizationDb().ReadCitiesInGroupL(iCitiesResultCache, aMessage.Int1());
+ TInt resultSize = CTzLocalizedCityRecord::ExternalizeSize(iCitiesResultCache);
+
+ // Write to client message buffer
+ TPckgBuf<TInt> resultSizeBuffer(resultSize);
+ aMessage.WriteL(0, resultSizeBuffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadCitiesL(const RMessage2& aMessage)
+ {
+ TInt maxSize = aMessage.GetDesLengthL(0);
+ CBufFlat* buffer = CBufFlat::NewL(maxSize);
+ CleanupStack::PushL(buffer);
+
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+ CleanupClosePushL(writeStream);
+ CTzLocalizedCityRecord::ExternalizeL(iCitiesResultCache, writeStream);
+ writeStream.CommitL();
+ iCitiesResultCache.ResetAndDestroy();
+ CleanupStack::PopAndDestroy(&writeStream);
+
+ // Write to client message buffer
+ aMessage.WriteL(0, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadFrequentlyUsedZoneSizeL(const RMessage2& aMessage)
+ {
+ delete iTimeZoneResultCache;
+ iTimeZoneResultCache = 0;
+ iTimeZoneResultCache = TzServer()->LocalizationDb().ReadFrequentlyUsedZoneL(aMessage.Int1());
+ TInt resultSize = iTimeZoneResultCache->ExternalizeSize();
+
+ // Write to client message buffer
+ TPckgBuf<TInt> resultSizeBuffer(resultSize);
+ aMessage.WriteL(0, resultSizeBuffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadFrequentlyUsedZoneL(const RMessage2& aMessage)
+ {
+ TInt maxSize = aMessage.GetDesLengthL(0);
+ CBufFlat* buffer = CBufFlat::NewL(maxSize);
+ CleanupStack::PushL(buffer);
+
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+ CleanupClosePushL(writeStream);
+ iTimeZoneResultCache->ExternalizeL(writeStream);
+ writeStream.CommitL();
+ delete iTimeZoneResultCache;
+ iTimeZoneResultCache = 0;
+ CleanupStack::PopAndDestroy(&writeStream);
+
+ // Write to client message buffer
+ aMessage.WriteL(0, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadCachedTimeZoneCitySizeL(const RMessage2& aMessage)
+ {
+ delete iCityResultCache;
+ iCityResultCache = 0;
+ iCityResultCache = TzServer()->LocalizationDb().ReadCachedTimeZoneCityL(aMessage.Int1());
+ TInt resultSize = iCityResultCache->ExternalizeSize();
+
+ // Write to client message buffer
+ TPckgBuf<TInt> resultSizeBuffer(resultSize);
+ aMessage.WriteL(0, resultSizeBuffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationReadCachedTimeZoneCityL(const RMessage2& aMessage)
+ {
+ TInt maxSize = aMessage.GetDesLengthL(0);
+ CBufFlat* buffer = CBufFlat::NewL(maxSize);
+ CleanupStack::PushL(buffer);
+
+ RBufWriteStream writeStream;
+ writeStream.Open(*buffer);
+ CleanupClosePushL(writeStream);
+ iCityResultCache->ExternalizeL(writeStream);
+ writeStream.CommitL();
+ delete iCityResultCache;
+ iCityResultCache = 0;
+ CleanupStack::PopAndDestroy(&writeStream);
+
+ // Write to client message buffer
+ aMessage.WriteL(0, buffer->Ptr(0));
+
+ CleanupStack::PopAndDestroy(buffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationOpenDbL()
+ {
+ TzServer()->LocalizationDb().OpenDbL();
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationCloseDb()
+ {
+ TzServer()->LocalizationDb().CloseDb();
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationWriteCityL(const RMessage2& aMessage)
+ {
+ TInt length=aMessage.GetDesLengthL(0);
+ HBufC* const cityName=HBufC::NewLC(length);
+ TPtr cityNamePtr(cityName->Des());
+ aMessage.ReadL(0, cityNamePtr);
+
+ TzServer()->LocalizationDb().WriteCityL(*cityName, (TUint16)aMessage.Int1(), aMessage.Int2(), aMessage.Int3());
+
+ CleanupStack::PopAndDestroy(cityName);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationDeleteCityL(const RMessage2& aMessage)
+ {
+ TInt length=aMessage.GetDesLengthL(0);
+ HBufC* const cityName=HBufC::NewLC(length);
+ TPtr cityNamePtr(cityName->Des());
+ aMessage.ReadL(0, cityNamePtr);
+
+ TzServer()->LocalizationDb().DeleteCityL(*cityName, (TUint16)aMessage.Int1());
+
+ CleanupStack::PopAndDestroy(cityName);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationWriteFrequentlyUsedZoneL(const RMessage2& aMessage)
+ {
+ TInt length=aMessage.GetDesLengthL(0);
+ CBufFlat* buffer = CBufFlat::NewL(length);
+ CleanupStack::PushL(buffer);
+ buffer->ExpandL(0,length);
+ TPtr8 des(buffer->Ptr(0));
+ aMessage.ReadL(0,des);
+ RBufReadStream readStream;
+ readStream.Open(*buffer);
+ CleanupClosePushL(readStream);
+ CTzLocalizedTimeZoneRecord* timeZone = CTzLocalizedTimeZoneRecord::NewLC(readStream);
+ CTzLocalizedCityRecord* city = CTzLocalizedCityRecord::NewLC(readStream);
+ TInt frequentlyUsedZone = readStream.ReadInt32L();
+
+ TzServer()->LocalizationDb().WriteFrequentlyUsedZoneL(*timeZone, *city, frequentlyUsedZone);
+
+ CleanupStack::PopAndDestroy(city);
+ CleanupStack::PopAndDestroy(timeZone);
+ CleanupStack::PopAndDestroy(&readStream);
+ CleanupStack::PopAndDestroy(buffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doLocalizationWriteAllFrequentlyUsedZonesL(const RMessage2& aMessage)
+ {
+ TInt length=aMessage.GetDesLengthL(0);
+ CBufFlat* buffer = CBufFlat::NewL(length);
+ CleanupStack::PushL(buffer);
+ buffer->ExpandL(0,length);
+ TPtr8 des(buffer->Ptr(0));
+ aMessage.ReadL(0,des);
+ RBufReadStream readStream;
+ readStream.Open(*buffer);
+ CleanupClosePushL(readStream);
+ RPointerArray<CTzLocalizedTimeZoneRecord> timeZones;
+ CleanupStack::PushL(TCleanupItem(CleanupTimeZonePointerArray,&timeZones));
+ CTzLocalizedTimeZoneRecord::InternalizeL(readStream, timeZones);
+ RPointerArray<CTzLocalizedCityRecord> cities;
+ CleanupStack::PushL(TCleanupItem(CleanupCityPointerArray,&cities));
+ CTzLocalizedCityRecord::InternalizeL(readStream, cities);
+
+ TzServer()->LocalizationDb().WriteAllFrequentlyUsedZonesL(timeZones, cities);
+
+ CleanupStack::PopAndDestroy(); // cities
+ CleanupStack::PopAndDestroy(); // timeZones
+ CleanupStack::PopAndDestroy(&readStream);
+ CleanupStack::PopAndDestroy(buffer);
+
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doSwiObsBeginL(const RMessage2& /*aMessage*/)
+ {
+ TzServer()->SwiObserver().BeginL();
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doSwiObsFileChangedL(const RMessage2& aMessage)
+ {
+ TzServer()->SwiObserver().FileChangedL((RTz::TSWIObserverFilterIndex)aMessage.Int0());
+ return KErrNone;
+ }
+
+TInt CTzServerSession::doSwiObsEndL(const RMessage2& /*aMessage*/)
+ {
+ TzServer()->SwiObserver().EndL();
+ return KErrNone;
+ }
+
+void CTzServerSession::ServiceL(const RMessage2& aMessage)
+ {
+ TInt reply = KErrNone;
+ switch(aMessage.Function())
+ {
+#if defined(_DEBUG)
+ case CTzServer::ESrvOpcodeResourceCount:
+ reply = doGetHeapSizeL(aMessage);
+ break;
+ case CTzServer::ESrvOpcodeSetHeapFailure:
+ User::__DbgSetAllocFail(RHeap::EUser,(RAllocator::TAllocFail)aMessage.Int0(),aMessage.Int1());
+ break;
+ case CTzServer::ESrvOpcodeResetHeap:
+ User::__DbgSetAllocFail(FALSE,RAllocator::ENone,1);
+ iTzUserDataCache->Reset();
+ TzServer()->TimeZoneManager().ResetForeignTimeZoneRulesCache();
+ break;
+#endif
+ case CTzServer::EConvertLocalZoneTime:
+ reply = doConvertLocalZoneTimeL(aMessage);
+ break;
+ case CTzServer::EConvertForeignZoneTime:
+ reply = doConvertForeignZoneTimeL(aMessage);
+ break;
+ case CTzServer::ESetTimeZone:
+ reply = doSetTimeZoneL(aMessage);
+ break;
+ case CTzServer::ENotifyHomeTimeZoneChanged:
+ reply = doNotifyHomeTimeZoneChanged(aMessage);
+ break;
+ case CTzServer::EGetLocalTimeZoneId:
+ reply = doGetLocalTimeZoneIdL(aMessage);
+ break;
+ case CTzServer::EGetLocalEncodedTimeZoneRules:
+ reply = doGetLocalEncodedTimeZoneRulesL(aMessage);
+ break;
+ case CTzServer::EGetLocalOlsenEncodedTimeZoneRules:
+ reply = KErrNotSupported;
+ break;
+ case CTzServer::EGetLocalEncodedTimeZoneRulesSize:
+ reply = doGetLocalEncodedTimeZoneRulesSizeL(aMessage);
+ break;
+ case CTzServer::EGetLocalOlsenEncodedTimeZoneRulesSize:
+ reply = KErrNotSupported;
+ break;
+ case CTzServer::EGetForeignEncodedTimeZoneRules:
+ reply = doGetForeignEncodedTimeZoneRulesL(aMessage);
+ break;
+ case CTzServer::EGetForeignEncodedTimeZoneRulesSize:
+ reply = doGetForeignEncodedTimeZoneRulesSizeL(aMessage);
+ break;
+ case CTzServer::ERegisterTimeChangeNotifier:
+ reply = doRegisterTzChangeNotifier(aMessage);
+ break;
+ case CTzServer::ECancelRequestforNotice:
+ reply = doCancelRequestForTzChangeNoticeL(aMessage);
+ break;
+ case CTzServer::EGetOffsetsForTimeZoneIds:
+ reply = doGetOffsetsForTimeZoneIdsL(aMessage);
+ break;
+ case CTzServer::EEnableAutoUpdate:
+ reply = doSetAutoUpdateBehaviorL(aMessage);
+ break;
+ case CTzServer::EIsDaylightSavingOn:
+ reply = doIsDaylightSavingOnL(aMessage);
+ break;
+ case CTzServer::EAutoUpdate:
+ reply = doAutoUpdateSettingL(aMessage);
+ break;
+ case CTzServer::ESetHomeTime:
+ reply = doSetHomeTimeL(aMessage);
+ break;
+ case CTzServer::ESetUnknownZoneTime:
+ reply = doSetUnknownZoneTimeL(aMessage);
+ break;
+ case CTzServer::EGetUserTimeZoneNames:
+ reply = doGetUserTimeZoneNamesL(aMessage);
+ break;
+ case CTzServer::EGetUserTimeZoneNamesSize:
+ reply = doGetUserTimeZoneNamesSizeL(aMessage);
+ break;
+ case CTzServer::EGetUserTimeZoneIds:
+ reply = doGetUserTimeZoneIdsL(aMessage);
+ break;
+ case CTzServer::EGetUserTimeZoneIdsSize:
+ reply = doGetUserTimeZoneIdsSizeL(aMessage);
+ break;
+ case CTzServer::ECreateUserTimeZone:
+ reply = doCreateUserTimeZoneL(aMessage);
+ break;
+ case CTzServer::EUpdateUserTimeZone:
+ reply = doUpdateUserTimeZoneL(aMessage);
+ break;
+ case CTzServer::EDeleteUserTimeZone:
+ reply = doDeleteUserTimeZoneL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadCitiesSize:
+ reply = doLocalizationReadCitiesSizeL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadCitiesTzIdSize:
+ reply = doLocalizationReadCitiesTzIdSizeL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadCitiesInGroupSize:
+ reply = doLocalizationReadCitiesInGroupSizeL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadCities:
+ reply = doLocalizationReadCitiesL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadFrequentlyUsedZoneSize:
+ reply = doLocalizationReadFrequentlyUsedZoneSizeL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadFrequentlyUsedZone:
+ reply = doLocalizationReadFrequentlyUsedZoneL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadCachedTimeZoneCitySize:
+ reply = doLocalizationReadCachedTimeZoneCitySizeL(aMessage);
+ break;
+ case CTzServer::ELocalizationReadCachedTimeZoneCity:
+ reply = doLocalizationReadCachedTimeZoneCityL(aMessage);
+ break;
+ case CTzServer::ELocalizationOpenDb:
+ reply = doLocalizationOpenDbL();
+ break;
+ case CTzServer::ELocalizationCloseDb:
+ reply = doLocalizationCloseDb();
+ break;
+ case CTzServer::ELocalizationWriteCity:
+ reply = doLocalizationWriteCityL(aMessage);
+ break;
+ case CTzServer::ELocalizationDeleteCity:
+ reply = doLocalizationDeleteCityL(aMessage);
+ break;
+ case CTzServer::ELocalizationWriteFrequentlyUsedZone:
+ reply = doLocalizationWriteFrequentlyUsedZoneL(aMessage);
+ break;
+ case CTzServer::ELocalizationWriteAllFrequentlyUsedZones:
+ reply = doLocalizationWriteAllFrequentlyUsedZonesL(aMessage);
+ break;
+ case CTzServer::ESwiObsBegin:
+ reply = doSwiObsBeginL(aMessage);
+ break;
+ case CTzServer::ESwiObsFileChanged:
+ reply = doSwiObsFileChangedL(aMessage);
+ break;
+ case CTzServer::ESwiObsEnd:
+ reply = doSwiObsEndL(aMessage);
+ break;
+ default:
+ reply = KErrNotFound;
+ break;
+ }
+
+ if (reply != KRequestPending)
+ {
+ aMessage.Complete(reply);
+ }
+
+#if defined(_DEBUG)
+ User::Heap().Check();
+#endif
+ }
+
+const CTzServer* CTzServerSession::TzServer() const
+ {
+ return static_cast<const CTzServer*>(Server());
+ }
+
+void CTzServerSession::CleanupTimeZonePointerArray(TAny* aArray)
+ {
+ RPointerArray<CTzLocalizedTimeZoneRecord>* array = static_cast<RPointerArray<CTzLocalizedTimeZoneRecord>* >(aArray);
+ if (array)
+ {
+ array->ResetAndDestroy();
+ array->Close();
+ }
+ }
+
+void CTzServerSession::CleanupCityPointerArray(TAny* aArray)
+ {
+ RPointerArray<CTzLocalizedCityRecord>* array = static_cast<RPointerArray<CTzLocalizedCityRecord>* >(aArray);
+ if (array)
+ {
+ array->ResetAndDestroy();
+ array->Close();
+ }
+ }