// 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 "timezoneserver.h"

#include <tzdefines.h>

#include <tz.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzusernames.h> //new file added for CTzUserNames which is publishedPartner

#endif

#include <tzlocalizedcityrecord.h>

#include <tzlocalizedtimezonerecord.h>

#include "tzrules.h"

#include <s32mem.h>

#include <vtzrules.h>

#include <tzupdate.h>

#include "tzruleholder.h"

const TInt KNumConnectRetries = 5;

// Define server name

_LIT(KServerCode,"TZSERVER");

// Return the client side version no.

TVersion RTz::Version() const

	{

	return (TVersion(KTimeZoneServerMajorVersion,

			KTimeZoneServerMinorVersion,

			KTimeZoneServerBuildVersion));

	}

// 

//Start the server process/thread which lives in an EPOCEXE object

//

TInt RTz::StartServer()

	{

	const TInt KIntServerType = 0x10004019;

	const TUidType serverUid(KNullUid,TUid::Uid(KIntServerType));

	TRequestStatus started(KRequestPending);

	TRendezvous rendezvous;

	rendezvous.iId = RThread().Id();		// id of this thread

	rendezvous.iStatus = &started;

	RProcess server;

	TInt err = server.Create(KServerCode,

						TPtrC(reinterpret_cast<TText*>(&rendezvous),

						sizeof(rendezvous)/sizeof(TText)),serverUid);

	if (err != KErrNone)

		{

		return err;

		}

	server.SetPriority(EPriorityHigh);

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat != KRequestPending)

		{

		server.Kill(0);		// abort startup

		}

	else

		{

		server.Resume();	// logon OK - start the server

		}

	User::WaitForRequest(stat);		// wait for start or death

	server.Close();

	return stat.Int();

	}

/**

Retrieves the time zone rules for the current home time zone.

@param aStartTime The start date to generate the time zone rules from.

@param aEndTime The end date to generate the time zone rules to.

@param aTimeRef Whether to generate the rules relative to UTC or local time. Use 

ETzUtcTimeReference to generate from UTC, ETzWallTimeReference to generate from local time.

@return Pointer to the time zone rules generated.

*/

EXPORT_C CTzRules* RTz::GetTimeZoneRulesL(const TTime& aStartTime, const TTime& aEndTime, TTzTimeReference aTimeRef) const

	{

	TInt rulesSize = 0;

	TPckg<TTime> startTimeBuffer(aStartTime);

	TPckg<TTime> endTimeBuffer(aEndTime);

	TPckg<TTzTimeReference> timeRefBuffer(aTimeRef);

	TPckg<TInt> rulesSizeBuffer(rulesSize);

	TIpcArgs args(&startTimeBuffer, &endTimeBuffer, &timeRefBuffer, &rulesSizeBuffer);

	const TInt result = SendReceive(CTzServer::EGetLocalEncodedTimeZoneRulesSize, args);

	User::LeaveIfError(result);

	// prepare buffer for tz rules	

	CBufFlat* inBuffer = CBufFlat::NewL(rulesSize);

	CleanupStack::PushL(inBuffer);  // push #1

	inBuffer->ExpandL(0, rulesSize);

	TPtr8 inPtr(inBuffer->Ptr(0) );

	// get the rules

	TIpcArgs args2(&rulesSizeBuffer,&inPtr);

	const TInt result2 = SendReceive(CTzServer::EGetLocalEncodedTimeZoneRules, args2);

	User::LeaveIfError(result2);

	RBufReadStream readStream;

	readStream.Open(*inBuffer);

	CTzRules* rules = CTzRules::NewL(readStream);

	CleanupStack::PopAndDestroy(inBuffer); // pop #1

	return rules;

	}

/**

Retrieves the time zone rules for a specified time zone.

@param aZone The time zone to generate the rules for.

@param aStartTime The start date to generate the time zone rules from.

@param aEndTime The end date to generate the time zone rules to.

@param aTimeRef Whether to generate the rules relative to UTC or local time. Use 

ETzUtcTimeReference to generate from UTC, ETzWallTimeReference to generate from local time.

@return Pointer to the time zone rules generated.

*/

EXPORT_C CTzRules* RTz::GetTimeZoneRulesL(const CTzId& aZone, const TTime& aStartTime, const TTime& aEndTime, TTzTimeReference aTimeRef) const

	{

	TInt rulesSize = 0;

	TPckg<TTime> startTimeBuffer(aStartTime);

	TPckg<TTime> endTimeBuffer(aEndTime);

	TPckg<TInt> rulesSizeBuffer(rulesSize);

	// prepare out buffer for zoneid and timeref

	CBufFlat* outBuffer = CBufFlat::NewL(KMaxTimeZoneIdSize + sizeof(TTzTimeReference)); 

	CleanupStack::PushL(outBuffer); // push #1

	RBufWriteStream writeStream;

	writeStream.Open(*outBuffer);

	aZone.ExternalizeL(writeStream);

	writeStream.WriteInt8L(aTimeRef);

	TPtr8 outPtr(outBuffer->Ptr(0) );

	TIpcArgs args(&startTimeBuffer, &endTimeBuffer, &outPtr, &rulesSizeBuffer);

	const TInt result = SendReceive(CTzServer::EGetForeignEncodedTimeZoneRulesSize, args);

	User::LeaveIfError(result);

	CleanupStack::PopAndDestroy(outBuffer); // pop #1

	// prepare in rules buffer

	CBufFlat* inBuffer = CBufFlat::NewL(rulesSize);

	CleanupStack::PushL(inBuffer); // push #1

	inBuffer->ExpandL(0, rulesSize);

	TPtr8 inPtr(inBuffer->Ptr(0) );

	TIpcArgs args2(&rulesSizeBuffer, &inPtr);

	const TInt result2 = SendReceive(CTzServer::EGetForeignEncodedTimeZoneRules, args2);

	User::LeaveIfError(result2);

	RBufReadStream readStream;

	readStream.Open(*inBuffer);

	CTzRules* rules = CTzRules::NewL(readStream);

	CleanupStack::PopAndDestroy(inBuffer); // pop #1

	return rules;

	}

// Registers to receive notification to time and zone changes in the

// Server

void RTz::RegisterTzChangeNotifier(TRequestStatus& aStatus) const

	{

	SendReceive(CTzServer::ERegisterTimeChangeNotifier, aStatus);

	}

// Cancels a previous request for notification of time zone changes

TInt RTz::CancelRequestForNotice() const

	{

	return (SendReceive(CTzServer::ECancelRequestforNotice));

	}

// Converts time between UTC and Local for the current selected system time zone

void RTz::doConvertL(TTime& aTime, TTzTimeReference aTimerRef) const

	{

	TPckg<TTime> timeBuffer(aTime);

	TPckg<TTime> timeInBuffer(aTime);

	TPckg<TTzTimeReference> timerRefBuffer(aTimerRef);

	TIpcArgs args(&timeBuffer, &timerRefBuffer, &timeInBuffer);

	const TInt result = SendReceive(CTzServer::EConvertLocalZoneTime, args);

	User::LeaveIfError(result);

	aTime = timeInBuffer();

	}

// Converts time between UTC and Local for a foreing time zone

void RTz::doConvertL(const CTzId& aZone,

								TTime& aTime,

								TTzTimeReference aTimerRef) const

	{

	// prepare out zoneid buffer

	CBufFlat* outBuffer = CBufFlat::NewL(KMaxTimeZoneIdSize);

	CleanupStack::PushL(outBuffer);

	RBufWriteStream writeStream;

	writeStream.Open(*outBuffer);

	aZone.ExternalizeL(writeStream);

	TPtr8 outPtr(outBuffer->Ptr(0) );

	TPckg<TTime> timeBuffer(aTime);

	TPckg<TTime> timeInBuffer(aTime);

	TPckg<TTzTimeReference> timerRefBuffer(aTimerRef);

	TIpcArgs args(&timeBuffer, &timerRefBuffer, &outPtr, &timeInBuffer);

	const TInt result = SendReceive(CTzServer::EConvertForeignZoneTime, args);

	CleanupStack::PopAndDestroy(outBuffer);

	User::LeaveIfError(result);

	aTime = timeInBuffer();

	}

/**

Constructor.

*/

EXPORT_C RTz::RTz() :

    iRulesHolder (NULL)

	{

	}

/**

Destructor. Calls Close().

*/

EXPORT_C RTz::~RTz()

	{

	Close();

	}

/** 

Connects to the time zone server, attempting to start it if necessary.

@return KErrNone if successful, otherwise a system error code.

@panic TzServer 1 The attempt to connect to the server failed with an error 

code other than KErrNotFound.

*/

EXPORT_C TInt RTz::Connect()

	{

	// The number of message slots in the RSessionBase::CreateSession() 

	// call are delibrately unspecified so the kernel will take messages 

	// from a global pool as and when required (the session is allowed

	// a maximum of 255 outstanding asynchronous messages)

	TInt retry = KNumConnectRetries;

	FOREVER

		{

		TInt err = CreateSession(KTimeZoneServerName,Version());

		if (err != KErrNotFound && err!=KErrServerTerminated)

			{

			return err;

			}

		// need to restart server

		if (--retry == 0)

			{

			return err;

			}

		err = StartServer();

		if (err != KErrNone && err != KErrAlreadyExists)

			{

			// Time Zone Server is configurable, so it is possible not to find it

			if (err != KErrNotFound)

				{

				return err;

				}

			Panic(EPanicServerNotFound);

			}

		}

	}

/**

Closes the connection to the time zone server.

*/

EXPORT_C void RTz::Close()

	{

	// Destroy rules before closing session.

    delete iRulesHolder;

    iRulesHolder = NULL;

	if (Handle())

		{

		RSessionBase::Close();

		}

	}

/** 

Converts a time from UTC to local (wall-clock) time for the current system 

time zone. If caching has been enabled by the CTzConverter class, then the 

conversion will be done using the cache instead of issuing a request to the 

server.

@return KErrNone if successful, otherwise another system error code.

@param aTime On entry, contains the UTC time to be converted,

and the converted value on exit. 

*/

EXPORT_C TInt RTz::ConvertToLocalTime(TTime& aTime) const

	{

    // Use cached method for conversion if caching enabled, otherwise request 

    // server to do the conversion.

    TInt result = KErrNone;

	if (iRulesHolder)

    	{

        TRAP( result, iRulesHolder->DoConvertL( aTime, ETzUtcTimeReference ) );

    	}

    else

        {

    	TRAP(result, doConvertL(aTime, ETzUtcTimeReference));

        }

	return result;

	}

/** 

Converts a time from UTC to the local (wall-clock) time 

for the specified time zone.

@return KErrNone if successful, otherwise another system error code.

@param aTime On entry, contains the UTC time to be converted,

and the converted value on exit.

@param aZone Time zone ID.

*/

EXPORT_C TInt RTz::ConvertToLocalTime(TTime& aTime, const CTzId& aZone) const

	{

	TRAPD(result, doConvertL(aZone, aTime, ETzUtcTimeReference));

	return result;

	}

/** 

Converts a local (wall-clock) time for the current system time zone, to UTC.

If caching has been enabled by the CTzConverter class, then the conversion will

be done using the cache instead of issuing a request to the server.

@param aTime On entry, contains the local time to be converted, and 

the converted value on exit. 

@return KErrNone if successful, otherwise another system error code.

*/

EXPORT_C TInt RTz::ConvertToUniversalTime(TTime& aTime) const

	{

    // Use cached method for conversion if caching enabled, otherwise request 

    // server to do the conversion.

    TInt result = KErrNone;

	if (iRulesHolder)

    	{

        TRAP( result, iRulesHolder->DoConvertL( aTime, ETzWallTimeReference ) );

        }

    else

        {

    	TRAP(result, doConvertL(aTime, ETzWallTimeReference));

        }

	return result;

	}

/** 

Converts a local (wall-clock) time for the specified time zone, to UTC.

@param aTime On entry, contains the local time to be converted, and 

the converted value on exit. 

@param aZone The time zone ID of interest.

@return KErrNone if successful, otherwise another system error code.

*/

EXPORT_C TInt RTz::ConvertToUniversalTime(TTime& aTime, const CTzId& aZone) const

	{

	TRAPD(result, doConvertL(aZone, aTime, ETzWallTimeReference));

	return result;

	}

/**

Retrieves the UTC offset for an array of numeric time zone ids.

The offset is written back into aOffsets.

@param aTzNumericIds An array of numeric time zone IDs for which the current

UTC offset is required.

@param aOffsets An array that, on return, will contain the UTC offsets

corresponding to the the time zone IDs in aTzNumericIds.

*/

EXPORT_C void RTz::GetOffsetsForTimeZoneIdsL(const RArray<TInt>& aTzNumericIds, RArray<TInt>& aOffsets) const

	{

	TInt count 			= aTzNumericIds.Count();

	TInt tintSize 		= sizeof(TInt);

	TInt idBufLength	= count * tintSize;

	TInt pos 			= 0;

	idBufLength += tintSize;

	TInt x;

	//Write the number of elements in the array, followed by

	//the time zone id of each element into idBuf.

	CBufFlat* idBuf = CBufFlat::NewL(idBufLength);

	CleanupStack::PushL(idBuf);

	idBuf->ExpandL(pos,idBufLength);

	idBuf->Write(pos,&count,tintSize);

	pos += tintSize;

	for (x = 0; x < count; ++x)

		{

		TInt id = aTzNumericIds[x];

		idBuf->Write(pos,&id,tintSize);

		pos += tintSize ;

		}

	TInt size = idBuf->Size();

	TPtr8 outPtr(idBuf->Ptr(0) );

	TIpcArgs args(size,&outPtr);

	const TInt result = SendReceive(CTzServer::EGetOffsetsForTimeZoneIds, args);	

	User::LeaveIfError(result);

	// idBuf now contains the offsets INSTEAD of the timezone Ids

	pos = 0;

	count = 0;

	TInt offset = 0;

	idBuf->Read(pos,&count,tintSize);

	pos += tintSize;

	//Loop through aArray again, setting the offsets from idBuf

	for (x = 0; x < count; ++x)

		{

		idBuf->Read(pos,&offset,tintSize);

		aOffsets.AppendL(offset);

		pos += tintSize;

		}

	CleanupStack::PopAndDestroy(idBuf);

	}

/** 

Retrieves the time zone ID for the current system time zone.

@return Time zone ID. The client takes ownership of the object.

@leave KErrNoMemory or another system leave code.

@internalTechnology

*/

EXPORT_C CTzId* RTz::GetTimeZoneIdL() const

	{

	CBufFlat* inBuffer = CBufFlat::NewL(KMaxTimeZoneIdSize);

	CleanupStack::PushL(inBuffer);

	// reserve the full space

	inBuffer->ExpandL(0, KMaxTimeZoneIdSize);

	TPtr8 ptr(inBuffer->Ptr(0) );

	TIpcArgs args(&ptr);

	const TInt result = SendReceive(CTzServer::EGetLocalTimeZoneId, args);

	User::LeaveIfError(result);

	RBufReadStream readStream;

	readStream.Open(*inBuffer);

	CTzId* zone = CTzId::NewL(readStream);

	CleanupStack::PopAndDestroy(inBuffer);

	return zone;

	}

/** 

Sets the current system time zone information to that corresponding to the 

supplied time zone ID.

@param aZone The time zone ID.

@capability WRITE_DEVICE_DATA

@internalTechnology

*/

EXPORT_C void RTz::SetTimeZoneL(CTzId& aZone) const