// 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 <bacntf.h>             // CEnvironmentChangeNotifier.

#include <centralrepository.h>  // CRepository.

#include "tzconfigagent.h"

#include "dataprovider.h"

#include <tzupdate.h>   // auto-update notification constants.

#include <vtzrules.h>

#include "tzpersisted.h"

#include "tzlocalizationdb.h"

#include <bautils.h>

#include "CBackupRestoreNotification.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzuserdefineddata.h>

#endif

_LIT8(KUnknownTZName, "Unknown/Zone");

const TUint32 KUnknownTZId = 0x0ffffff0;

const TInt KSecondsPerMinute = 60;

_LIT(KTimeStamps, "c:\\private\\1020383e\\timestamps");

_LIT(KTzDbFileNameFlash,"c:\\private\\1020383e\\TZDB.DBZ");

_LIT(KUserDatabaseName, "c:\\private\\1020383e\\SQLite__tzuserdata.db");

_LIT(KResourceDir, "c:\\resource\\timezonelocalization\\");

// specifies the limits for rules caching.

// (year - KRuleCacheLowerLimit) , (year + KRuleCacheUpperLimit)

// the actual cache includes one more year at year - (KRuleCacheLowerLimit + 1)

// required to provide the offset used at the start of the search 

const TUint KRuleCacheLowerLimit = 2;

const TUint KRuleCacheUpperLimit = 3;

// Security policy for the Publish and Subscribe auto-update notification property.

const TInt KServerUid = 0x1020383E;

const TInt KNextDSTChangePropertyKey(0x10285B32);

_LIT_SECURITY_POLICY_PASS(KReadPolicy);

_LIT_SECURITY_POLICY_S0(KWritePolicy, KServerUid);

CTzConfigAgent::~CTzConfigAgent()

	{

	// Flag that the server is shutting down so that we don't try and set 

	// a new DST Change Timer when the current one is cancelled.

	iShuttingDown = ETrue;

	delete iTzDataProvider;

    // Cancel any exitsing timer.

    if (iDstTimer)

        {

        iDstTimer->Cancel();

        delete iDstTimer;

        }

	delete iSystemTzCache;

	delete iOtherTzCache;

	delete iRepository;

	delete iChangeNotifier;

	delete iBackupNotifier;

	iTzSwiObserver.RemoveObserver(this);

	iChangeObservers.Close();

	iFs.Close();

	}

/*

*/

CTzConfigAgent::CTzConfigAgent(MTZCfgAgentObserver& aServer, CTzUserDataDb& aTzUserDataDb,

		CTzSwiObserver& aTzSwiObserver) 

	: iTzServer(aServer),

	iEnabled(RTz::ETZAutoDSTUpdateOn),

	iTzSwiObserver(aTzSwiObserver), 

	iShuttingDown(EFalse), 

	iTzUserDataDb(aTzUserDataDb)

	{

	}

/*

*/

void CTzConfigAgent::ConstructL()

	{

	User::LeaveIfError(iFs.Connect());

	// Define a property using Publish and Subscribe.

	// ** Note that the value of this property is unimportant - setting it

	// (to any value) counts as a notification, so we do not set it here.

    TInt err = RProperty::Define(

        NTzUpdate::EUtcOffsetChangeNotification,

        RProperty::EInt,

	    KReadPolicy,

	    KWritePolicy);

	if (err != KErrAlreadyExists)

	    {

	    User::LeaveIfError(err);

	    }

    err = RProperty::Define(

        NTzUpdate::ECurrentTimeZoneId,

        RProperty::EByteArray,

	    KReadPolicy,

	    KWritePolicy);

	if (err != KErrAlreadyExists)

	    {

	    User::LeaveIfError(err);

	    }

    err = RProperty::Define(

        NTzUpdate::EHomeTimeZoneId,

        RProperty::EByteArray,

	    KReadPolicy,

	    KWritePolicy);

	if (err != KErrAlreadyExists)

	    {

	    User::LeaveIfError(err);

	    }

	err = RProperty::Define(

        NTzUpdate::ETzRulesChange,

        RProperty::EByteArray,

	    KReadPolicy,

	    KWritePolicy);

	if (err != KErrAlreadyExists)

	    {

	    User::LeaveIfError(err);

	    }

    err = RProperty::Define(

        NTzUpdate::ETzNamesChange,

        RProperty::EByteArray,

	    KReadPolicy,

	    KWritePolicy);

	if (err != KErrAlreadyExists)

	    {

	    User::LeaveIfError(err);

	    }

	iTzDataProvider = CTzDataProvider::NewL(iFs, iTzSwiObserver, iTzUserDataDb,

		*this);

	iDstTimer = CDstEventNotifier::NewL(*this);

    iRepository = CRepository::NewL(NTzUpdate::KPropertyCategory);

	// Get the DST auto-update configuration value from the repository.

    User::LeaveIfError(iRepository->Get(EConfigurationKey, iEnabled));

	// Get the current time zone from the repository.

	TInt timeZoneIdentity(0);

    User::LeaveIfError(iRepository->Get(ETimeZoneKey, timeZoneIdentity));

	// Extract the current time zone identifier.  This is stored in the bits

	// not occupied by the old TLocale DST settings.

	TUint localeZone = timeZoneIdentity & ~(EDstHome | EDstEuropean |

		EDstNorthern | EDstSouthern);

	// If the current time zone identifier is set (non-zero) then check that

	// this zone exists. 

    TBool timeZoneExists = EFalse;

    if (localeZone > 0)

    	{

    	timeZoneExists = iTzDataProvider->IsIdInDbL(localeZone);

    	}

    CTzId* timeZoneId = NULL;

    if(timeZoneExists)

    	{

    	// Use the current time zone identifier obtained from the repository.

    	timeZoneId = CTzId::NewL(localeZone);

    	}

    else 

		{

		// Either the current time zone is not set in the repository or it is

		// and the time zone does not exist.  In either case we need to use the

		// default time zone identifier.

        timeZoneId = iTzDataProvider->GetDefaultTimeZoneIdL();

        if (!timeZoneId)

            {

            // If we cannot obtain the default time zone identifier then use the

            // "unknown" time zone identifier as a fallback solution.

		    timeZoneId = CTzId::NewL(KUnknownTZId);

            }  

  		}

    CleanupStack::PushL(timeZoneId);

	// Setting the time zone updates the UTC offset and sets a new DST change

	// timer if required.

	SetTimeZoneL(*timeZoneId, static_cast<TAny*>(this), ETrue);

	CleanupStack::PopAndDestroy(timeZoneId);

	// Create and start the environment change notifier.

	iChangeNotifier = CEnvironmentChangeNotifier::NewL(CActive::EPriorityIdle, TCallBack(EnvironmentChangeCallBackL, this));

	iChangeNotifier->Start();

	TRAP_IGNORE(PublishNewDstChangeInfoL());

	iTzSwiObserver.AddObserverL(this);

	// Create backup notifier.  Note that file name argument is unimportant.

	iBackupNotifier = CBackupRestoreNotification::NewL(KTzDbFileNameFlash(),*this);

	// Publish any changes that may have happened to TZ databases or resources

	// while the TZ Server was not running.

	PublishTzDbChangeInfoL();

	}

void CTzConfigAgent::PublishTzDbChangeInfoL()

	{

	RFile file;

	CleanupClosePushL(file);

	TTime tzDbModified = Time::NullTTime();

	TTime userDbModified = Time::NullTTime();

	TTime resourceFileModified = Time::NullTTime();

	TInt err = file.Open(iFs, KTimeStamps, EFileRead | EFileWrite);

	if(err == KErrNone || err == KErrNotFound)

		{

		//Read time stamps

		TInt err1 = iFs.Modified(KTzDbFileNameFlash, tzDbModified);

		if(err1 != KErrNone && err1 != KErrNotFound)

			{

			User::Leave(err1);

			}

		err1 = iFs.Modified(KUserDatabaseName, userDbModified);

		if(err1 != KErrNone && err1 != KErrNotFound)

			{

			User::Leave(err1);

			}

		resourceFileModified = GetResourceFileTimeStampsL();

		}

	else

		{

		User::Leave(err);

		}

	TBool tzRuleChanged = EFalse;

	TBool tzNameChanged = EFalse;

	TTime tzDbSaved = Time::NullTTime();

	TTime userDbSaved  = Time::NullTTime();

	TTime resourceFileSaved  = Time::NullTTime();

	if (err == KErrNone)

		{

		ReadTimeStampsL(file, tzDbSaved, userDbSaved, resourceFileSaved);

		if(tzDbModified != tzDbSaved)

			{

			tzRuleChanged = ETrue;		

			}

		if(userDbModified != userDbSaved)

			{

			tzRuleChanged = ETrue;

			tzNameChanged = ETrue;

			}

		if(resourceFileModified != resourceFileSaved)

			{

			tzNameChanged = ETrue;		

			}

		}

	else//err == KErrNotFound

		{//Always publish the changes if the time stamps file is not there

		tzRuleChanged = ETrue;

		tzNameChanged = ETrue;

		}

	if(tzRuleChanged || tzNameChanged)

		{//Rewrite all three times

		User::LeaveIfError(file.Replace(iFs, KTimeStamps, EFileRead | EFileWrite));

		WriteTimeStampsL(file, tzDbModified, userDbModified, resourceFileModified);

		}

	CleanupStack::PopAndDestroy(&file); // file.Close()

	if (tzRuleChanged || tzNameChanged)

		{

		iTzDbHasChanged = ETrue;

		if (tzRuleChanged)

			{

			//Publish the tz rules change

			NTzUpdate::TTzRulesChange rulesChange;

			rulesChange.iUTCTimeOfRulesChange.UniversalTime();

			TPckgBuf<NTzUpdate::TTzRulesChange> bufRules(rulesChange);

			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);

			RProperty::Set(NTzUpdate::KPropertyCategory, NTzUpdate::ETzNamesChange, bufNames);	

			}

		}

	}

void CTzConfigAgent::ReadTimeStampsL(RFile& aFile, TTime& aTzdbSaved, TTime& aUserDbSaved, TTime& aResourceFileSaved)

	{

	RFileReadStream readStream(aFile);

	CleanupClosePushL(readStream);

	TUint32 low = readStream.ReadUint32L();

	TUint32 high = readStream.ReadUint32L();

	aTzdbSaved = TTime(MAKE_TINT64(high, low));

	low = readStream.ReadUint32L();

	high = readStream.ReadUint32L();

	aUserDbSaved = TTime(MAKE_TINT64(high, low));

	low = readStream.ReadUint32L();

	high = readStream.ReadUint32L();

	aResourceFileSaved = TTime(MAKE_TINT64(high, low));

	CleanupStack::PopAndDestroy(&readStream);

	}

void CTzConfigAgent::WriteTimeStampsL(RFile& aFile, const TTime& aTzdbModified, const TTime& aUserDbModified, const TTime& aResourceFileModified)

	{

	RFileWriteStream writeStream(aFile);

	CleanupClosePushL(writeStream);

	writeStream << I64LOW(aTzdbModified.Int64());

	writeStream << I64HIGH(aTzdbModified.Int64());

	writeStream << I64LOW(aUserDbModified.Int64());

	writeStream << I64HIGH(aUserDbModified.Int64());

	writeStream << I64LOW(aResourceFileModified.Int64());

	writeStream << I64HIGH(aResourceFileModified.Int64());

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	}

/* 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()

	{

	CDir* files = NULL;

	TInt err = iFs.GetDir(KResourceDir, KEntryAttNormal, ESortNone, files);

	CleanupStack::PushL(files);

	TInt64 sum = 0;

	if(err != KErrNone && err != KErrNotFound && err != KErrPathNotFound)

		{

		User::Leave(err);

		}

	if(files)

		{

		TInt count = files->Count();

		for(TInt ii = 0; ii < count; ++ii)

			{

			const TEntry& entry = (*files)[ii];

			sum = sum + entry.iModified.Int64();

			}

		}

	CleanupStack::PopAndDestroy(files);

	if(sum==0)

		{

		return Time::NullTTime();

		}

	return TTime(sum);

	}

void CTzConfigAgent::PublishNewDstChangeInfoL()

	{

    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

		User::LeaveIfError(propertyDefineError);

		}

    // create the next DST change and set some default values

    NTzUpdate::TDSTChangeInfo newDSTChangeInfo;

    newDSTChangeInfo.iVersion = 2;

	if ( CalculateNextDstChangeL(newDSTChangeInfo.iNextDSTChangeUTC, newDSTChangeInfo.iPreviousDSTChangeUTC) 

		&& (iEnabled == RTz::ETZAutoDSTUpdateOn) )

		{

		// There is a future DST change in this time zone and auto DST updates are on

		CVTzActualisedRules& actualisedRules = GetTimeZoneRulesL(newDSTChangeInfo.iNextDSTChangeUTC, ETzUtcTimeReference);

		newDSTChangeInfo.iNextUTCOffset = actualisedRules.GetOffsetFromRuleL(newDSTChangeInfo.iNextDSTChangeUTC, ETzUtcTimeReference);

		newDSTChangeInfo.iPreviousUTCOffset = actualisedRules.GetOffsetFromRuleL(newDSTChangeInfo.iPreviousDSTChangeUTC-TTimeIntervalMinutes(1), ETzUtcTimeReference);

		}

	else

		{

		newDSTChangeInfo.iNextDSTChangeUTC = Time::NullTTime();

		newDSTChangeInfo.iNextUTCOffset = 0;

		newDSTChangeInfo.iPreviousDSTChangeUTC = Time::NullTTime();

		newDSTChangeInfo.iPreviousUTCOffset = 0;

		}

	// get the current value that is published

	TPckgBuf<NTzUpdate::TDSTChangeInfo> currentNextDSTChangeBuf;

	User::LeaveIfError(RProperty::Get(KUidSystemCategory, KNextDSTChangePropertyKey, currentNextDSTChangeBuf));

	// Publish if the next DST change is different from the previous version

	if ((currentNextDSTChangeBuf().iNextUTCOffset != newDSTChangeInfo.iNextUTCOffset)

		|| (currentNextDSTChangeBuf().iNextDSTChangeUTC != newDSTChangeInfo.iNextDSTChangeUTC)

		|| (currentNextDSTChangeBuf().iPreviousUTCOffset != newDSTChangeInfo.iPreviousUTCOffset)

		|| (currentNextDSTChangeBuf().iPreviousDSTChangeUTC != newDSTChangeInfo.iPreviousDSTChangeUTC)

		|| (propertyDefineError != KErrAlreadyExists))

		{

		// package the data and set the property value 

		TPckgBuf<NTzUpdate::TDSTChangeInfo> newDSTChangeInfoBuf(newDSTChangeInfo);

	    User::LeaveIfError(RProperty::Set(KUidSystemCategory, KNextDSTChangePropertyKey, newDSTChangeInfoBuf));

		}

	}

/*

*/

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;

	}

const CTzId& CTzConfigAgent::GetTimeZoneIdL() const

	{

	if (!iSystemTzCache)

		{

		User::Leave(KErrNotFound);

		}

	return iSystemTzCache->TimeZoneId();

	}

const CTzId& CTzConfigAgent::SetTimeZoneL(const CTzId& aZoneId, const TAny* aRequester, TBool aUpdateCentralRepository, TBool aForceCacheUpdate)

	{

	TInt oldTzId = 0;

	TBool zoneChanged = EFalse;

	TTime now;

	now.UniversalTime();

	if (!iSystemTzCache)

		{

		iSystemTzCache = CSystemTzRulesCache::NewL(aZoneId, *this, now);

		}

	else if (iSystemTzCache->TimeZoneId() == aZoneId && !aForceCacheUpdate)

		{

		return (iSystemTzCache->TimeZoneId());

		}

	else

		{

		oldTzId = iSystemTzCache->TimeZoneId().TimeZoneNumericID();

		// replace the rule. create new before deleting old

		CSystemTzRulesCache* newZone = CSystemTzRulesCache::NewL(aZoneId, *this, now);

		CleanupStack::PushL(newZone);

		//For Invalid Timezone, rules doesnot exist 

		CTzRules& newZoneRules =  newZone->GetEncodedTimeZoneRulesL();

		if (newZoneRules.Count() == 0)

		    {

		    User::Leave(KErrNotFound);

		    }

		delete iSystemTzCache;

		iSystemTzCache = newZone;