/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:   ?Description

*

*/

#include <e32std.h>

#include <liwservicehandler.h>

#include "tsysinfoprovidertests.h"

#include "tautolocknotifier.h"

#include "watchtimer.h"

#include "entitykeys.h"

#include "sysinfoaiwparams.hrh"

using namespace LIW ;

using namespace SysInfo;

using namespace sysinfoaiwparams;

CAutoLockNotifier* CAutoLockNotifier::NewL(CStifLogger* aLog,TInt aDrvNo)

	{

	CAutoLockNotifier* self = new(ELeave) CAutoLockNotifier(aLog,aDrvNo);

	self->ConstructL();

	return self;

	}

CAutoLockNotifier::~CAutoLockNotifier()

	{

	Cancel();

	if(iWaitSchedular->IsStarted())

		iWaitSchedular->AsyncStop();

	delete iTimer;

	iInParamList->Reset();

	iOutParamList->Reset();

	iInterface->Close();

	delete iServiceHandler;

	delete iWaitSchedular;

	}

void CAutoLockNotifier::ConstructL()

	{

	iWaitSchedular  = new(ELeave) CActiveSchedulerWait();

	iTimer			= CWatchTimer::NewL(EPriorityNormal,this);

	CreateInterfaceL();

	CActiveScheduler::Add(this);

	}

CAutoLockNotifier::CAutoLockNotifier(CStifLogger* aLog,TInt aAutoLockTime) :

				CActive(EPriorityStandard),

				iAutoLockTime(aAutoLockTime),

				iRestoreAutoLockTime(15),

				iLog(aLog)

	{

	}

void CAutoLockNotifier::DoCancel()

	{

	//TRAPD(err1,iSysInfoService->GetInfoL(req1));

	}

void CAutoLockNotifier::RunL()

	{

	TestFuncL();

	}

void CAutoLockNotifier::Start()

	{

	SetActive();

	TRequestStatus* temp = &iStatus;

	User::RequestComplete(temp, KErrNone);

	iWaitSchedular->Start();	

	}

TInt CAutoLockNotifier::Result()

	{

	return iResult;

	}

void CAutoLockNotifier::TestFuncL()

	{

	TInt RetVal(PASS);

	TInt32 Err;

//	Get autolocktime val

//-------------------------------------------------------------------------

	{

	iLog->Log( _L("Reading initial autolocktime value .."));

	iOutParamList->Reset();

	iInParamList->Reset();

	iInParamList->AppendL(TLiwGenericParam(KEntity,TLiwVariant(KDisplay)));

	iInParamList->AppendL(TLiwGenericParam(KKey,TLiwVariant(KAutoLockTime)));

	iInterface->ExecuteCmdL(KGetInfo,*iInParamList,*iOutParamList);	

	RetVal |= CheckErrorCode(*iOutParamList,Err);

	if ( Err )

		{

		iLog->Log( _L("GetInfo retured error : %d"),Err );

		User::Leave(Err);

		} 

	TInt index=0;

	const TLiwGenericParam* ret_val = iOutParamList->FindFirst(index,KReturnValue);

	if(!ret_val)

		{

		iLog->Log( _L("Return value parameter not found"));

		User::Leave(FAIL);

		}

	else

		{

		const CLiwMap* outmap = ret_val->Value().AsMap();

		TLiwVariant autolocktime;

		if( outmap->FindL(KStatus,autolocktime) )

			iRestoreAutoLockTime = autolocktime.AsTInt32();

		((CLiwMap*)outmap)->DecRef();

		}

	iLog->Log( _L("Inital autolocktime to be restored to: %d"),iRestoreAutoLockTime);

	}

//	SET AUTOLOCK TIME.

//-------------------------------------------------------------------------

	{

	CLiwMap* inmap = CLiwDefaultMap::NewL();

	iLog->Log( _L("Seting Autolock time .."));

	iOutParamList->Reset();

	iInParamList->Reset();

	iInParamList->AppendL(TLiwGenericParam(KEntity,TLiwVariant(KDisplay)));

	iInParamList->AppendL(TLiwGenericParam(KKey,TLiwVariant(KAutoLockTime)));

	inmap->InsertL(KStatus,TLiwVariant((TInt32)iAutoLockTime));

	iInParamList->AppendL(TLiwGenericParam(KSysData,TLiwVariant(inmap)));

	iInterface->ExecuteCmdL(KSetInfo,*iInParamList,*iOutParamList);	

	inmap->Remove(KStatus);	

	RetVal |= CheckErrorCode(*iOutParamList,Err);

	if ( Err )

		{

		iLog->Log( _L("SetInfo retured error : %d"),Err );

		User::Leave(Err);

		} 

	inmap->DecRef();

	}

//	REGISTER FOR NOTIFICATION.

//-------------------------------------------------------------------------

	{

	iLog->Log( _L("Issueing Notification request .."));

	TInt RetVal(PASS);

	TInt32 Err;

	iOutParamList->Reset();

	iInParamList->Reset();

	iInParamList->AppendL(TLiwGenericParam(KEntity,TLiwVariant(KDisplay)));

	iInParamList->AppendL(TLiwGenericParam(KKey,TLiwVariant(KAutoLockStatus)));

	iInterface->ExecuteCmdL(KGetNotification,*iInParamList,*iOutParamList,KLiwOptASyncronous,this);	

	RetVal |= CheckErrorCode(*iOutParamList,Err);

	if ( Err )

		{

		iLog->Log( _L("GetNotification retured error : %d"),Err );

		User::Leave(Err);

		} 

	TInt index=0;

	const TLiwGenericParam* ret_val = iOutParamList->FindFirst(index,KTransactionId);

	if(!ret_val)

		{

		iLog->Log( _L("Transaction ID not found"));

		User::Leave(FAIL);

		}

	else

		{

		iTransID = ret_val->Value().AsTInt32();

		iLog->Log( _L("TRANSACTION ID : %d"),iTransID );

		}

	}

	iOutParamList->Reset();

	iInParamList->Reset();

	const TInt OneMin(60000000);

	iTimer->After(OneMin*iAutoLockTime*2);

	}

TInt CAutoLockNotifier::HandleNotifyL( TInt aTransID, TInt aEventId,

            CLiwGenericParamList& aEventParamList,

            const CLiwGenericParamList& )

	{

	aEventId=aEventId;

	delete iTimer;

	iTimer = NULL;

//	RESTORE AUTOLOCK TIME.

//-------------------------------------------------------------------------

	{

	TInt RetVal(PASS);

	TInt32 Err(PASS);

	CLiwMap* inmap = CLiwDefaultMap::NewL();

	iLog->Log( _L("Restoring Autolock time to %d"),iRestoreAutoLockTime);

	iOutParamList->Reset();

	iInParamList->Reset();

	iInParamList->AppendL(TLiwGenericParam(KEntity,TLiwVariant(KDisplay)));

	iInParamList->AppendL(TLiwGenericParam(KKey,TLiwVariant(KAutoLockTime)));

	inmap->InsertL(KStatus,TLiwVariant((TInt32)iRestoreAutoLockTime));

	iInParamList->AppendL(TLiwGenericParam(KSysData,TLiwVariant(inmap)));

	iInterface->ExecuteCmdL(KSetInfo,*iInParamList,*iOutParamList);	

	inmap->Remove(KStatus);	

	RetVal |= CheckErrorCode(*iOutParamList,Err);

	if ( Err )

		{

		iLog->Log( _L("SetInfo retured error : %d"),Err );

		User::Leave(Err);

		} 

	inmap->DecRef();

	}

//	CHECK AUTOLOCK NOTIFICATION.

//-------------------------------------------------------------------------

	{

	TInt index=0;

	TPtrC entity,key;

	TInt32 status;

	const TLiwGenericParam* ret_val = aEventParamList.FindFirst(index,KReturnValue);

	if(!ret_val)

		{

		iLog->Log( _L("Return value parameter not found"));

		User::Leave(FAIL);

		}

	else

		{

		const CLiwMap* outmap = ret_val->Value().AsMap();

		TLiwVariant ventity,vkey,vstatus;

		if( !outmap->FindL(KEntity,ventity) )

			{

			iLog->Log( _L("Entity parameter not found"));

			User::Leave(FAIL);

			}

		if( !outmap->FindL(KKey,vkey) )

			{

			iLog->Log( _L("Key parameter not found"));

			User::Leave(FAIL);

			}

		if( !outmap->FindL(KStatus,vstatus) )

			{

			iLog->Log( _L("Status parameter not found"));

			User::Leave(FAIL);

			}

		ventity.Get(entity);

		vkey.Get(key);

		status = vstatus.AsTInt32();

//		((CLiwMap)outmap)->DecRef();	

		if( !(entity.Compare(KDisplay) || key.Compare(KAutoLockStatus)) )

			{

			if(!(aTransID == iTransID))

				{

				iLog->Log(_L("Incorrect TransactionID: %d"),aTransID);				

				iResult |= FAIL;

				}

			iLog->Log(_L("Autolock Notification.."));

			if(status)

				iLog->Log(_L("AutoLock ENABLED"));

			else

				iLog->Log(_L("AutoLock DISABLED"));

			iResult |= PASS;		

			}

		ventity.Reset();

		vkey.Reset();

		}

	}

	iWaitSchedular->AsyncStop();

	return KErrNone;

	}

void CAutoLockNotifier::HandleTimeOut()

{

	iLog->Log(_L("TimeOut reached. Auto Lock Not Enabled.."));

//	iSysInfoService->Cancel(1);

//	RESTORE AUTOLOCK TIME.

//-------------------------------------------------------------------------

	{

	TInt RetVal(PASS);

	TInt32 Err(PASS);

	CLiwMap* inmap = CLiwDefaultMap::NewL();

	iLog->Log( _L("Restoring Autolock time to %d"),iRestoreAutoLockTime);

	iOutParamList->Reset();

	iInParamList->Reset();

	iInParamList->AppendL(TLiwGenericParam(KEntity,TLiwVariant(KDisplay)));

	iInParamList->AppendL(TLiwGenericParam(KKey,TLiwVariant(KAutoLockTime)));

	inmap->InsertL(KStatus,TLiwVariant((TInt32)iRestoreAutoLockTime));

	iInParamList->AppendL(TLiwGenericParam(KSysData,TLiwVariant(inmap)));

	iInterface->ExecuteCmdL(KSetInfo,*iInParamList,*iOutParamList);	

	inmap->Remove(KStatus);	

	RetVal |= CheckErrorCode(*iOutParamList,Err);

	if ( Err )

		{

		iLog->Log( _L("SetInfo retured error : %d"),Err );

		User::Leave(Err);

		} 

	inmap->DecRef();

	}

	iResult = FAIL;

	iWaitSchedular->AsyncStop();

}

void CAutoLockNotifier::CreateInterfaceL() 

	{

    iServiceHandler = CLiwServiceHandler::NewL();

    CleanupStack::PushL(iServiceHandler);

    iInParamList = &(iServiceHandler->InParamListL());

    iOutParamList = &(iServiceHandler->OutParamListL());

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1,KIDataSource,KService);

	CleanupStack::PushL(crit);

	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;

	CleanupClosePushL(a);

	a.AppendL(crit);

	iServiceHandler->AttachL(a);

	iServiceHandler->ExecuteServiceCmdL(*crit,*iInParamList,*iOutParamList);

	TInt Index = 0;

	const TLiwGenericParam* param = iOutParamList->FindFirst(Index,KIDataSource);

	if(!param)

		{

		iLog->Log( _L("Interface Not found "));

		User::Leave(KErrGeneral);

		}

	iInterface = param->Value().AsInterface();

	CleanupStack::PopAndDestroy(&a);	

	CleanupStack::PopAndDestroy (crit);

  	CleanupStack::Pop (iServiceHandler); 

  	}	

TInt CAutoLockNotifier::CheckErrorCode( const CLiwGenericParamList& aOutList, TInt32 &aError )

	{

	TInt Index = 0;

	const TLiwGenericParam* errcode = aOutList.FindFirst(Index,KErrorCode);

	if ( KErrNotFound == Index )

		{

		iLog->Log( _L("ErrorCode not found in output ArgList") );

		return FAIL;

		}

	else

		errcode->Value().Get(aError);

	return PASS;

	}

//End of file.