/*

* 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 <StifLogger.h>

#include "tsysinfoprovidertests.h"

#include "tuseractivitynotifier.h"

#include "watchtimer.h"

#include "entitykeys.h"

#include "sysinfoaiwparams.hrh"

using namespace LIW ;

using namespace SysInfo;

using namespace sysinfoaiwparams;

CTestUserActivity* CTestUserActivity::NewL(CStifLogger* aLog,TInt aTimeOut,Test_Type aType)

	{

	CTestUserActivity* self = new(ELeave) CTestUserActivity(aLog,aTimeOut,aType);

	self->ConstructL();

	return self;

	}

CTestUserActivity::~CTestUserActivity()

	{

	Cancel();

	if(iWaitSchedular->IsStarted())

		iWaitSchedular->AsyncStop();

	delete iTimer;

	iInParamList->Reset();

	iOutParamList->Reset();

	iInterface->Close();

	delete iServiceHandler;

	delete iWaitSchedular;

	}

void CTestUserActivity::ConstructL()

	{

	iWaitSchedular  = new(ELeave) CActiveSchedulerWait();

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

	CreateInterfaceL();

	CActiveScheduler::Add(this);

	}

CTestUserActivity::CTestUserActivity(CStifLogger* aLog,TInt aTimeOut,

									Test_Type aType) :

								CActive(EPriorityStandard),

								iInactivityTimeOut(aTimeOut),

								iLog(aLog),

								iTestType(aType)

	{

	}

void CTestUserActivity::DoCancel()

	{

	}

void CTestUserActivity::RunL()

	{

	TestFuncL();

	}

void CTestUserActivity::Start()

	{

	SetActive();

	TRequestStatus* temp = &iStatus;

	User::RequestComplete(temp, KErrNone);

	iWaitSchedular->Start();	

	}

TInt CTestUserActivity::Result()

	{

	return iResult;

	}

void CTestUserActivity::TestFuncL()

	{

	const TInt OneSec(1000000);

	iTimer->After(OneSec*iInactivityTimeOut*30);

//	REGISTER FOR NOTIFICATION.

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

	{

	iLog->Log( _L("Issueing Notification request .. InactivityTimeOut: %d"),iInactivityTimeOut);

	TInt RetVal(PASS);

	TInt32 Err;

	iOutParamList->Reset();

	iInParamList->Reset();

	CLiwMap* inmap = CLiwDefaultMap::NewL();

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

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

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

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

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

		}

	inmap->DecRef();

	}

	iOutParamList->Reset();

	iInParamList->Reset();

	}

TInt CTestUserActivity::HandleNotifyL( TInt aTransID, TInt aEventId,

            CLiwGenericParamList& aEventParamList,

            const CLiwGenericParamList& /*aInParamList*/)

	{

	aEventId=aEventId;

	delete iTimer;

	iTimer = NULL;

	{

	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("Key parameter not found"));

			User::Leave(FAIL);

			}

		ventity.Get(entity);

		vkey.Get(key);

		status = vstatus.AsTInt32();

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

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

			{

			if(!(aTransID == iTransID))

				{

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

				iResult |= FAIL;

				}

			iLog->Log(_L("UserActivity/Inactivity Notification.."));

			if(status)

				iLog->Log(_L("User Inactivity Detected.."));

			else

				iLog->Log(_L("User Activity Detected.."));

			iResult |= PASS;		

			}

		ventity.Reset();

		vkey.Reset();

		if (ETESTACTIVITY == iTestType)

			{

			if(status)

				{

				iLog->Log(_L("Waiting for user activity"));

				return KErrNone;

				}

			else

				{

				iLog->Log(_L("User Activity Detected.."));

				}

			iResult |= PASS;

			}

		}

	}

	iResult |= PASS;

	iWaitSchedular->AsyncStop();

	return KErrNone;

	}

void CTestUserActivity::HandleTimeOut()

{

	iLog->Log(_L("TimeOut reached. Inactivity not detected.."));

/*	iSysInfoService->Cancel(1);

*/

	iResult = FAIL;

	iWaitSchedular->AsyncStop();

}

void CTestUserActivity::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 CTestUserActivity::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.