// Copyright (c) 2008-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\digitiser\d_ldddigitisertest.cpp
// LDD for testing the Digitiser  Hal Calls.
// 
//

#include <kernel/kernel.h>

#include "d_ldddigitisertest.h"

const TUint KMaxDeviceNumber=10;

TUint 	gDeviceNumber=1;					// Device Number
TUint	gRegisteredDeviceNumber;			// Represents the registered Hal Entry
TBool	gHalEntryRegistered; 				// States HAL Entry Successfully registered or not
static	TDigitiserInfoV02 gDigitserHalData;	// Buffer to  hold the HAL data; 
static	TUint gPointer3DSupported;			// States whether the pointing device supports 3rd dimension.

class DDigitiserLDDTestFactory : public DLogicalDevice
//
// Test LDD factory
//
	{
public:
	DDigitiserLDDTestFactory();
	virtual TInt Install(); 								//overriding pure virtual
	virtual void GetCaps(TDes8& aDes) const;				//overriding pure virtual
	virtual TInt Create(DLogicalChannelBase*& aChannel); 	//overriding pure virtual
	};

class DDigitiserLDDTestChannel : public DLogicalChannelBase
//
// Test logical channel
//
	{
public:
	virtual ~DDigitiserLDDTestChannel();
protected:
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
	};

// Initialise Digitiser HAL Data
void initialiseDigitiserHalData()
	{
//  TDigitiserInfoV02 Class Data layout
  
//class TDigitiserInfoV02 : public TDigitiserInfoV01
//	{	
//public :
//	TInt iZRange;				/**< The maximum distance to screen a pointing device will be detected (settable).*/
//	TUint8 iThetaSupported;		/**< A Boolean value that indicates if Theta polar angle detection (tilt) is supported.*/
//	TUint8 iPhiSupported;		/**< A Boolean value that indicates if Phi polar angle detection (tilt) is supported.*/
//	TUint8 iAlphaSupported;		/**< A Boolean value that indicates if rotation of the pointing device along its main axis is supported.*/
//	TUint8 iPressureSupported; 	/**< A Boolean value that indicates if pressure applied on screen is supported.*/
//	TInt iProximityStep;    	/**<proximity resolution, e.g. proximity readings change in steps of 1, 5, 10, ... */
//	TInt iMaxPressure;      	/**< maximum pressure reading*/
//	TInt iPressureStep;     	/**< pressure resolution, */	
//	TUint8 iMaxPointers;    	/**< max number of multi-touch pointers supported by hardware/driver.*/ 
//	TUint8 iNumberOfPointers;	/**< Number of pointers it supports (settable).*/
//	};

    gPointer3DSupported=1;
    gDigitserHalData.iZRange=100;
	gDigitserHalData.iThetaSupported=1;
	gDigitserHalData.iPhiSupported=1;
	gDigitserHalData.iPressureSupported=1;
	gDigitserHalData.iAlphaSupported=1;
	gDigitserHalData.iProximityStep=5;
	gDigitserHalData.iMaxPointers=2;
	gDigitserHalData.iNumberOfPointers=2;
	gDigitserHalData.iMaxPressure=5000;
	gDigitserHalData.iPressureStep=500;
	}

LOCAL_C TInt halFunction(TAny* /*aPtr*/, TInt aFunction, TAny* a1, TAny* /*a2*/)
	{
	TInt r=KErrNone;
	TPckgBuf<TDigitiserInfoV02> vPckg(gDigitserHalData);
	switch(aFunction)
		{
		case EDigitiserHal3DInfo:
			// Get Request for all but EPointer3D. Copy the TDigitiserInfoV02 object to a1
			Kern::InfoCopy(*(TDes8*)a1,vPckg);
			break;
		case EDigitiserHal3DPointer:
			// Get request EPointer3D
			kumemput32(a1,&gPointer3DSupported,sizeof(gPointer3DSupported));
			break;
		case EDigitiserHalSetZRange:
			// Set requeest for EPointer3DMaxProximity (iZRange)
			gDigitserHalData.iZRange=(TInt)a1;
			break;
		case EDigitiserHalSetNumberOfPointers:
			// Set request for EPointerNumberOfPointers
			gDigitserHalData.iNumberOfPointers=static_cast<TUint8>((TInt)a1);
			break;
		default:
			r=KErrNotSupported;
			break;
		}
	return r;
	}

#ifdef GRAPHICS_VERSION
DECLARE_EXTENSION_LDD()
	{
	return new DDigitiserLDDTestFactory;
	}
DECLARE_STANDARD_EXTENSION()
	{
	TInt r;
	// Initialise Digitiser HAL Data first.
	initialiseDigitiserHalData();
	// Find device number
	do
		{
		r=Kern::AddHalEntry(EHalGroupDigitiser,halFunction,NULL,gDeviceNumber);
		}
	while((r==KErrInUse) && (++gDeviceNumber < KMaxDeviceNumber));
		
	if((gDeviceNumber < KMaxDeviceNumber) && (r==KErrNone))
		{
		gHalEntryRegistered = ETrue;
		gRegisteredDeviceNumber = gDeviceNumber;
		}
	else
		{
		gHalEntryRegistered = EFalse;
		r=KErrInUse;
		}
	return r;
	}
#else
DECLARE_STANDARD_LDD()
	{
	return new DDigitiserLDDTestFactory;
	}
#endif

//
// Constructor
//
DDigitiserLDDTestFactory::DDigitiserLDDTestFactory()
	{
	}

TInt DDigitiserLDDTestFactory::Create(DLogicalChannelBase*& aChannel)
	{
//
// Create new channel
//  
	aChannel=new DDigitiserLDDTestChannel;
	return aChannel?KErrNone:KErrNoMemory;
	}

TInt DDigitiserLDDTestFactory::Install()
//
// Install the LDD - overriding pure virtual
	{
	return SetName(&KLddName);
	}

void DDigitiserLDDTestFactory::GetCaps(TDes8& /*aDes*/) const
//
// Get capabilities - overriding pure virtual
//
	{
	}

TInt DDigitiserLDDTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
//
// Create channel
//
	{
	return KErrNone;
	}

DDigitiserLDDTestChannel::~DDigitiserLDDTestChannel()
//
// Destructor
//
	{
	}

TInt DDigitiserLDDTestChannel::Request(TInt aReqNo, TAny* a1, TAny* /*a2*/)
	{
	TInt r=KErrNone;
	switch(aReqNo)
		{
		case (RLddDigitiserTest::EADDHALENTRY):
#ifndef GRAPHICS_VERSION
            NKern::ThreadEnterCS();
			do
			{
		    r=Kern::AddHalEntry(EHalGroupDigitiser,halFunction,this,gDeviceNumber);
			}
            while((r==KErrInUse) && (++gDeviceNumber < KMaxDeviceNumber));
			NKern::ThreadLeaveCS();

			if((gDeviceNumber < KMaxDeviceNumber) && (r==KErrNone))
				{
				gHalEntryRegistered=ETrue;
				gRegisteredDeviceNumber=gDeviceNumber;
				}
			else
				{
				gHalEntryRegistered=EFalse;
				r=KErrInUse;
				}
#else
			r=KErrNotSupported;
#endif
			break;
		case (RLddDigitiserTest::EREMOVEHALENTRY):
			if(gHalEntryRegistered)
				{
				r=Kern::RemoveHalEntry(EHalGroupDigitiser,gRegisteredDeviceNumber);
				}
		break;
		case (RLddDigitiserTest::EGETREGISTEREDDEVICENUMBER):
			if(gHalEntryRegistered)
				{
				r=gRegisteredDeviceNumber;
				}
			else
				{
				r=KErrNotFound;
				}
			break;
		case (RLddDigitiserTest::EINITIALISEHALDATA):
#ifndef GRAPHICS_VERSION
			initialiseDigitiserHalData();
#else
			r=KErrNone;
#endif
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3D):
			r=gPointer3DSupported;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3D):
			gPointer3DSupported=(TUint32)a1;
			break;
		case (RLddDigitiserTest::EGET_EPOINTERMAXPROXIMITY):
			r=gDigitserHalData.iZRange;
			break;
		case (RLddDigitiserTest::ESET_EPOINTERMAXPROXIMITY):
			gDigitserHalData.iZRange=(TInt)a1;
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DTHETASUPPORTED):
			r=gDigitserHalData.iThetaSupported;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DTHETASUPPORTED):
			gDigitserHalData.iThetaSupported=static_cast<TUint8>((TInt)a1);
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DPHISUPPORTED):
			r=gDigitserHalData.iPhiSupported;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DPHISUPPORTED):
			gDigitserHalData.iPhiSupported=static_cast<TUint8>((TInt)a1);
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DROTATIONSUPPORTED):
			r=gDigitserHalData.iAlphaSupported;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DROTATIONSUPPORTED):
			gDigitserHalData.iAlphaSupported=static_cast<TUint8>((TInt)a1);
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DPRESSURESUPPORTED):
			r=gDigitserHalData.iPressureSupported;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DPRESSURESUPPORTED):
			gDigitserHalData.iPressureSupported=static_cast<TUint8>((TInt)a1);
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DPROXIMITYSTEP):
			r=gDigitserHalData.iProximityStep;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DPROXIMITYSTEP):
			gDigitserHalData.iProximityStep=(TInt)a1;
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DMAXPOINTERS):
			r=gDigitserHalData.iMaxPointers;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DMAXPOINTERS):
			gDigitserHalData.iMaxPointers=static_cast<TUint8>((TInt)a1);
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DNUMBEROFPOINTERS):
			r=gDigitserHalData.iNumberOfPointers;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DNUMBEROFPOINTERS):
			gDigitserHalData.iNumberOfPointers=static_cast<TUint8>((TInt)a1);
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DMAXPRESSURE):
			r=gDigitserHalData.iMaxPressure;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DMAXPRESSURE):
			gDigitserHalData.iMaxPressure=(TInt)a1;
			break;
		case (RLddDigitiserTest::EGET_EPOINTER3DPRESSURESTEP):
			r=gDigitserHalData.iPressureStep;
			break;
		case (RLddDigitiserTest::ESET_EPOINTER3DPRESSURESTEP):
			gDigitserHalData.iPressureStep=(TInt)a1;
			break;
		default:
			r=KErrNotSupported;
			break;
		} 
	return r;
	}