// Copyright (c) 2006-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:

//

// System

#include <e32std.h>

#include <ecom/ecom.h>

#include <centralrepository.h>

// Lbs

#include <lbs.h>

#include <lbs/lbsadmin.h>

#include <lbssatellite.h>

#include "lbsprocessuiddefs.h"

#include "lbsdevloggermacros.h"

// Component

#include "lbsautoclockadjust.h"

#include "lbsagpsmanagerconfigkeys.h"

CAutoClockAdjust* CAutoClockAdjust::NewL()

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::NewL()\n");

	CAutoClockAdjust* self = new(ELeave) CAutoClockAdjust();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CAutoClockAdjust::ConstructL()

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::ConstructL()\n");

	// Config

	// Dynamic Set Clock module selection is not supported.

	iAdmin = CLbsAdmin::NewL(*this, KLbsSettingClockAdjustInterval | KLbsSettingClockAdjustThreshold |

									KLbsSettingClockAdjust);

	ReadAdminSettingsL();

	iCenRep = CRepository::NewL(KLbsGpsLocManagerUid);

	ReadLocalSettingsL();

	// Load a plug-in or the default impl

	LBSLOG(ELogP9, "->S CGpsSetClockBase::NewL() ClockModule\n");

	LBSLOG2(ELogP9, "  > TPositionModuleId iSetClockModuleId  = 0x%08X\n", iSetClockModuleId.iUid);

	iSetClockImpl = CGPSSetClockBase::NewL(iSetClockModuleId);

	}

CAutoClockAdjust::CAutoClockAdjust():

iClockAdjustSetting(CLbsAdmin::EClockAdjustUnknown),

iSetClockModuleId(KLbsSetClockNullModuleId),

iAdjustInterval(0),

iAdjustThreshold(0),

iLastAdjustment(0),

iAdmin(0),

iSetClockImpl(0)

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::CAutoClockAdjust()\n");

	}

CAutoClockAdjust::~CAutoClockAdjust()

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::~CAutoClockAdjust()\n");

	delete iAdmin;

	iAdmin = NULL;

	if (iCenRep != NULL)

		{

		WriteLastAutoAdjustTime();

		}

	delete iCenRep;

	iCenRep = NULL;

	LBSLOG(ELogP9, "->S CGpsSetClockBase::~CGpsSetClockBase() ClockModule\n");

	delete iSetClockImpl;

	iSetClockImpl = NULL;

	REComSession::FinalClose();	

	}

/** Adjusts system time if required. The decision whether the adjustment is needed or not

is based on the following criterias:

 - satellite time must be present in the location update

 - time threshold must be exceeded

 - time from a last adjustment is greater than a defined interval.

@param aStatus An error code.

@param TPositionSatelliteInfo Position and time information. 

							  If clock adjustment takes place the TPosition::iTime is 

							  re-set to the satellite time.

@see CLbsAdmin

@see TPositionSatelliteInfo

*/

void CAutoClockAdjust::LocationUpdate(TInt aStatus, TPositionSatelliteInfo& aPosInfo)

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::LocationUpdate()\n");

	TTimeIntervalMicroSeconds timeCorr;

	TTime sysTime;

	TInt err;

	// If adjustment on, no error, and satellite information present

	if ((iClockAdjustSetting == CLbsAdmin::EClockAdjustOn) && (aStatus == KErrNone) &&

	    ((aPosInfo.PositionClassType() & EPositionSatelliteInfoClass) == EPositionSatelliteInfoClass))

		{

		// Is is time do do another time adjustment?

		sysTime.UniversalTime();

		if (Abs(sysTime.MicroSecondsFrom(iLastAdjustment).Int64()) > (1000*iAdjustInterval))

			{

			const TPositionSatelliteInfo& satInfo = static_cast<const TPositionSatelliteInfo&>(aPosInfo);

			err = CalculateTimeCorrection(satInfo, timeCorr);

			if (err == KErrNone)

				{

				// Is threshold exceeded? 

				if (Abs(timeCorr.Int64()) > (1000*iAdjustThreshold))

					{

					sysTime.UniversalTime();

					sysTime += timeCorr;

					LBSLOG(ELogP9, "->S CGpsSetClockBase::SetUTCTime() ClockModule\n");

					LBSLOG5(ELogP9, "  > TTime sysTime  = %02d:%02d:%02d.%06d\n", sysTime.DateTime().Hour(), 

																				sysTime.DateTime().Minute(),

																				sysTime.DateTime().Second(),

																				sysTime.DateTime().MicroSecond());

					err = iSetClockImpl->SetUTCTime(sysTime);

					LBSLOG2(ELogP9, "  Return  = %d\n", err);

					if (err == KErrNone)

						{				

						// Sync the position time with the satellite time

						// to avoid re-adjusting the system time by the manual clock adjustment component.

						TPosition pos;

						aPosInfo.GetPosition(pos);

						pos.SetTime(aPosInfo.SatelliteTime());

						aPosInfo.SetPosition(pos);

						LBSLOG2(ELogP2, "ACTION: Clock Adjusted by %ld\n", timeCorr.Int64());

						}

					}

				if (err == KErrNone)

					{				

					// Remember the current time even if threshold not exceeded

					iLastAdjustment = sysTime;

					}

				else

					{

					LBSLOG_WARN2(ELogP3, "Clock Adjustment failed. Error: %d\n", err);

					}

				}

			}

		}

	}

/** Calculates a difference between the system UTC time and the GPS based UTC time.

Accuracy of the calculations is affected by:

   - time required to process the satellite information in the GPS HW

   - time required to transfer the information over a HW link from the GPS HW to a mobile phone

   - time required to receive the information by a Symbian OS drivers and decode by the AGPS

     integration module

@param aSatInfo A satellite information with the GPS based UTC time

@param aTimeCorr A time correction that must be applied to the System UTC time. Not valid if the method returns an error.

@return KErrNone if sucedded. 

        KErrNotSupported if the satellite (GPS based UTC time) or the position 

        reception time is not present (0).

@see TPositionSatelliteInfo

@internalComponent

*/

TInt CAutoClockAdjust::CalculateTimeCorrection(const TPositionSatelliteInfo &aSatInfo, TTimeIntervalMicroSeconds &aTimeCorr)

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::CalculateTimeCorrection()\n");

	// The System UTC time when the location has been received from a GPS

	TTime recTime;

	// GPS based UTC time (satellite time)

	TTime satTime;

	TPosition pos;

	TInt err = KErrNone;

	aSatInfo.GetPosition(pos);

	recTime = pos.Time();

	satTime = aSatInfo.SatelliteTime();

	if ((recTime == 0) || (satTime == 0))

		{

		err = KErrNotSupported;

		}

	else

		{

		aTimeCorr = satTime.MicroSecondsFrom(recTime);

		}

	return err;

	}

/** Read clock configuration.

@see CLbsAdmin*/

void CAutoClockAdjust::ReadAdminSettingsL()

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::ReadAdminSettingsL()\n");

	User::LeaveIfError(iAdmin->Get(KLbsSettingClockAdjust, 			iClockAdjustSetting));

	LBSLOG2(ELogP2, "   KLbsSettingClockAdjust is: %d\n", iClockAdjustSetting);

	User::LeaveIfError(iAdmin->Get(KLbsSettingClockAdjustThreshold, iAdjustThreshold));

	LBSLOG2(ELogP2, "   KLbsSettingClockAdjustThreshold is: %d\n", iAdjustThreshold);

	User::LeaveIfError(iAdmin->Get(KLbsSettingClockAdjustInterval, 	iAdjustInterval));

	LBSLOG2(ELogP2, "   KLbsSettingClockAdjustInterval is: %d\n", iAdjustInterval);

	User::LeaveIfError(iAdmin->Get(KLbsSettingSetClockModule, 		iSetClockModuleId));

	LBSLOG2(ELogP2, "   KLbsSettingSetClockModule is: 0x%X\n", iSetClockModuleId);

	}

/** Read local clock configuration. */

void CAutoClockAdjust::ReadLocalSettingsL()

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::ReadLocalSettingsL()\n");

	TInt   valHi;

	TInt   valLo;

	TInt   err;

	TInt64 val;

	err = iCenRep->Get(KLastAutoClockAdjustmentHi, valHi);

	ASSERT(err == KErrNone);

	if (err != KErrNone)

		{

		// Retry

		err = iCenRep->Reset();

		ASSERT(err == KErrNone);

		User::LeaveIfError(iCenRep->Get(KLastAutoClockAdjustmentHi, valHi));

		}

	User::LeaveIfError(iCenRep->Get(KLastAutoClockAdjustmentLo, valLo));

	val = MAKE_TINT64(valHi, valLo);

	iLastAdjustment = val;

	}

/** Write local clock configuration. 

On UREL the method does not return and error/leave even if writing the

time fails. */

void CAutoClockAdjust::WriteLastAutoAdjustTime()

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::WriteLastAutoAdjustTime()\n");

	TInt   valHi = I64HIGH(iLastAdjustment.Int64());

	TInt   valLo = I64LOW(iLastAdjustment.Int64());

	TInt   err;

	err = iCenRep->Set(KLastAutoClockAdjustmentHi, valHi);

	// For OOM tests also KErrNoMemory is fine

	ASSERT((err == KErrNone) || (err == KErrNoMemory));

	if (err != KErrNone)

		{

		err = iCenRep->Set(KLastAutoClockAdjustmentLo, valLo);

		ASSERT((err == KErrNone) || (err == KErrNoMemory));

		}

	}

/** Config settings observer call-back.

@see CLbsAdmin */

/*virtual*/ void CAutoClockAdjust::OnSettingUpdateEvent(TInt aError, const TLbsAdminSetting& aSetting)

	{

	LBSLOG(ELogP1, "CAutoClockAdjust::OnSettingUpdateEvent()\n");

	LBSLOG4(ELogP3, "NEW EVENT: Setting: 0x%08X%08X changed. err: %d", I64HIGH(aSetting), I64LOW(aSetting), aError); 

	if (aError == KErrNone)

		{

		// switch/case not used because of RVCT compiler problem (aSetting is TUint64)

		if (aSetting == KLbsSettingClockAdjust)

			{

			aError = iAdmin->Get(KLbsSettingClockAdjust, iClockAdjustSetting);

			LBSLOG2(ELogP2, "NEW EVENT: KLbsSettingClockAdjust changed to: %d\n", iClockAdjustSetting);

			}

		else if (aSetting == KLbsSettingClockAdjustThreshold)

			{

			aError = iAdmin->Get(KLbsSettingClockAdjustThreshold, iAdjustThreshold);

			LBSLOG2(ELogP2, "NEW EVENT: KLbsSettingClockAdjustThreshold changed to: %d\n", iAdjustThreshold);

			}

		else if (aSetting == KLbsSettingClockAdjustInterval)

			{

			aError = iAdmin->Get(KLbsSettingClockAdjustInterval, 	iAdjustInterval);

			LBSLOG2(ELogP2, "NEW EVENT: KLbsSettingClockAdjustInterval changed to: %d\n", iAdjustInterval);

			}

		else

			{

			ASSERT(EFalse);

			}

		}

		// Ignored on UREL

		ASSERT(aError == KErrNone);

	}