// 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