/*

* 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 "tsysinfoprovidergeneraltests.h"

#include "watchtimer.h"

#include "entitykeys.h"

#include "sysinfoaiwparams.hrh"

using namespace LIW ;

using namespace SysInfo;

using namespace sysinfoaiwparams;

_LIT(KDriveSeperator,":\\");

const TInt KMaxDriveLength = 5;

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

	{

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

	self->ConstructL();

	return self;

	}

CTCriticalMemNotification::~CTCriticalMemNotification()

	{

	Cancel();

	if(iWaitSchedular->IsStarted())

		iWaitSchedular->AsyncStop();

	delete	iTimer;

	iInParamList->Reset();

	iOutParamList->Reset();

	iInterface->Close();

	delete iServiceHandler;

	delete iWaitSchedular;

	}

void CTCriticalMemNotification::ConstructL()

	{

	iWaitSchedular  = new(ELeave) CActiveSchedulerWait();

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

	CreateInterfaceL();

	CActiveScheduler::Add(this);

	}

CTCriticalMemNotification::CTCriticalMemNotification(CStifLogger* aLog,TInt aDrvNo) :

				CActive(EPriorityStandard),iLog(aLog),iDrvNo(aDrvNo)

	{

	}

void CTCriticalMemNotification::DoCancel()

	{

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

	}

void CTCriticalMemNotification::RunL()

	{

	TestFuncL();

	}

void CTCriticalMemNotification::Start()

	{

	SetActive();

	TRequestStatus* temp = &iStatus;

	User::RequestComplete(temp, KErrNone);

	iWaitSchedular->Start();	

	}

TInt CTCriticalMemNotification::Result()

	{

	return iResult;

	}

void CTCriticalMemNotification::TestFuncL()

	{

	TInt criticalspace(0);

	TInt32 Err(PASS);

	TInt RetVal(PASS);

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

	{

	CLiwMap* inputmap = CLiwDefaultMap::NewL();

	TBuf<KMaxDriveLength> drive;

	drive.FillZ();

	drive.Append('A'+iDrvNo);

	drive.Append(KDriveSeperator);

	inputmap->InsertL(KDriveNo,TLiwVariant(drive));

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

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

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

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

		if (outmap->FindL(KFreeSpace,info))

			{

			TLex freespace(info.AsDes());

			TInt64 freespaceval;

			if ( KErrNone != freespace.Val(freespaceval) )

				{

				iLog->Log( _L("Invalid free space string") );

				User::Leave(FAIL);

				}

			iLog->Log( _L("Free Space: %s"),info.AsDes().Ptr() );

			criticalspace = freespaceval/2;

			}

		info.Reset();

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

		}

	inputmap->DecRef();

	}

	iInParamList->Reset();

	iOutParamList->Reset();

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

	{

	CLiwMap* inputmap = CLiwDefaultMap::NewL();

	inputmap->InsertL(KCriticalSpace,TLiwVariant((TInt32)criticalspace));

	TBuf<KMaxDriveLength> drive;

	drive.FillZ();

	drive.Append('A'+iDrvNo);

	drive.Append(KDriveSeperator);

	inputmap->InsertL(KDriveNo,TLiwVariant(drive));

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

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

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

	iLog->Log( _L("Critical Free Space Set to: %d"),criticalspace );

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

		}

	inputmap->DecRef();

	}

	iInParamList->Reset();

	iOutParamList->Reset();	

	const TTimeIntervalMicroSeconds32 OneMinute(120000000);

	iTimer->After(OneMinute);

	return ;

	}

TInt CTCriticalMemNotification::HandleNotifyL( TInt aTransID, TInt aEventId,

            CLiwGenericParamList& aEventParamList,

            const CLiwGenericParamList& /*aInParamList*/)

	{

	aEventId=aEventId;

	delete iTimer;

	iTimer = NULL;

	{

	TInt index=0;

	TPtrC entity,key;

	TPtrC drive;

	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(KStringData,vstatus) )

			{

			iLog->Log( _L("Drive not found"));

			User::Leave(FAIL);

			}

		ventity.Get(entity);

		vkey.Get(key);

		if ( !vstatus.Get(drive) )

			{

			iLog->Log( _L("Drive not found"));

			User::Leave(FAIL);

			}

		if( !(entity.Compare(KMemory) || key.Compare(KCriticalMemory)) )

			{

			if(!(aTransID == iTransID))

				{

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

				iResult |= FAIL;

				}

			iLog->Log(_L("CRITICAL MEMORY Notification.."));

			iLog->Log(_L("LOW MEMORY DETECTED ON DRIVE %s"),drive.Ptr());

			iResult |= PASS;		

			}

		ventity.Reset();

		vkey.Reset();

		}

	}

	iResult |= PASS;

	iWaitSchedular->AsyncStop();

	return KErrNone;

	}

void CTCriticalMemNotification::HandleTimeOut()

{

	iLog->Log(_L("TimeOut reached. LOW MEMORY Notification not detected.."));

//	iSysInfoService->Cancel(1);

	iResult = FAIL;

	iWaitSchedular->AsyncStop();

}

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