// 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 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:

 // e32test\power\d_lddpowerseqtest.cpp

 // LDD for testing the power up and down sequence

 // 

 //

 #include <kernel/kernel.h>

 #include <kernel/kpower.h>

 #include "d_lddpowerseqtest.h"

 _LIT(KLitPower1,"PowerSeqTest1");

 _LIT(KLitPower2,"PowerSeqTest2");

 //

 // Variables to store asynchronous status request and time count user variables address.

 //

 TRequestStatus *aStatus_up1;

 TRequestStatus *aStatus_up2;

 TRequestStatus *aStatus_down1;

 TRequestStatus *aStatus_down2;

 TUint *time_power1down;

 TUint *time_power2down;

 TUint *time_power1up;

 TUint *time_power2up;

 TUint sleepTime;

 class DTest1;

 //

 // Power handler1

 //

 class DTest1PowerHandler : public DPowerHandler

 	{

 public:

 	DTest1PowerHandler();

 	void PowerUp();

 	void PowerDown(TPowerState);

 	};

 //

 // Power handler2

 //

 class DTest2PowerHandler : public DPowerHandler

 	{

 public:

 	DTest2PowerHandler();

 	void PowerUp();

 	void PowerDown(TPowerState);

 	};

 class DTestFactory : public DLogicalDevice

 //

 // Test LDD factory

 //

 	{

 public:

 	DTestFactory();

 	virtual TInt Install(); 					//overriding pure virtual

 	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual

 	virtual TInt Create(DLogicalChannelBase*& aChannel); 	//overriding pure virtual

 	};

 class DTest1 : public DLogicalChannelBase

 //

 // Test logical channel

 //

 	{

 public:

 	virtual ~DTest1();

 protected:

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

 	DTest1PowerHandler power1;

 	DTest2PowerHandler power2;

 	};

 DECLARE_STANDARD_LDD()

 	{

 	return new DTestFactory;

 	}

 //

 // Constructor

 //

 DTestFactory::DTestFactory()

 	{

 	}

 TInt DTestFactory::Create(DLogicalChannelBase*& aChannel)

 	{

 //

 // Create new channel

 //

 	aChannel=new DTest1;

 	return aChannel?KErrNone:KErrNoMemory;

 	}

 TInt DTestFactory::Install()

 //

 // Install the LDD - overriding pure virtual

 //

 	{

 	return SetName(&KLddName);

 	}

 void DTestFactory::GetCaps(TDes8& /*aDes*/) const

 //

 // Get capabilities - overriding pure virtual

 //

 	{

 	}

 TInt DTest1::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

 //

 // Create channel

 //

 	{

 	//try to remove a handler that hasn't been added yet - should not cause any problems

 	power1.Remove();

 	//Add power handlers

 	power2.Add();

 	power1.Add();

 	return KErrNone;

 	}

 DTest1::~DTest1()

 //

 // Destructor

 //

 	{

 	power1.Remove();

 	power2.Remove();

 	//try to remove a handler twice - should not cause any problems

 	power2.Remove();

 	}

 TInt DTest1::Request(TInt aReqNo, TAny* a1, TAny* a2)

 	{

 //

 // Store status requests and time stamp variable for each power up and power down

 //

 	if(aReqNo<0)

 		{

 		// 'Request' functions...

 		TRequestStatus* s = (TRequestStatus*)a1;

 		TAny* args[2];

 		kumemget32(args,a2,sizeof(args)); // get user side arguments

 		switch(~aReqNo)

 			{

 			case RLddTest1::EPOWERDOWN_POWER1:

 				aStatus_down1 = s;

 				time_power1down = (TUint*)args[0];

 				break;

 			case RLddTest1::EPOWERDOWN_POWER2:

 				aStatus_down2 = s;

 				time_power2down = (TUint*)args[0];

 				break;

 			case RLddTest1::EPOWERUP_POWER1:

 				aStatus_up1 = s;

 				time_power1up = (TUint*)args[0];

 				break;

 			case RLddTest1::EPOWERUP_POWER2:

 				aStatus_up2 = s;

 				time_power2up = (TUint*)args[0];

 				break;

 			}

 		}

 	else

 		{

 		// 'Control' functions...

 		switch(aReqNo)

 			{

 			// DoControl

 			case RLddTest1::ESET_SLEEPTIME:

 				sleepTime = (TUint)a1;

 				break;

 			}

 		}

 	return KErrNone;

 	}

 DTest1PowerHandler::DTest1PowerHandler():DPowerHandler(KLitPower1)

 	{

 //

 // Power handler1 constructor

 //

 	}

 DTest2PowerHandler::DTest2PowerHandler():DPowerHandler(KLitPower2)

 	{

 //

 // Power handler2 constructor

 //

 	}

 void DTest1PowerHandler::PowerUp()

 	{

 //

 // Sleep for sometime to get different tick counts for comparision.

 // Copy the tick count to user variable and complete the request

 //

 	NKern::Sleep(sleepTime);

 	TUint temp = NKern::TickCount();

 	kumemput(time_power1up, (const TUint *)&temp, sizeof(temp));

 	Kern::RequestComplete(aStatus_up1, KErrNone);

 	PowerUpDone();

 	}

 void DTest2PowerHandler::PowerUp()

 	{

 //

 // Copy the tick count to user variable and complete the request

 //

 	TUint temp = NKern::TickCount();

 	kumemput(time_power2up, (const TUint *)&temp, sizeof(temp));

 	Kern::RequestComplete(aStatus_up2, KErrNone);

 	PowerUpDone();

 	}

 void DTest1PowerHandler::PowerDown(TPowerState /*aState*/)

 	{

 //

 // Copy the tick count to user variable and complete the request

 //

 	TUint temp = NKern::TickCount();

 	kumemput(time_power1down, (const TUint *)&temp, sizeof(temp));

 	Kern::RequestComplete(aStatus_down1, KErrNone);

 	PowerDownDone();

 	}

 void DTest2PowerHandler::PowerDown(TPowerState /*aState*/)

 	{

 //

 // Sleep for sometime to get different tick counts for comparision.

 // Copy the tick count to user variable and complete the request

 //

 	NKern::Sleep(sleepTime);

 	TUint temp = NKern::TickCount();

 	kumemput(time_power2down, (const TUint *)&temp, sizeof(temp));

 	Kern::RequestComplete(aStatus_down2, KErrNone);

 	PowerDownDone();

 	}