/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  HID field search

*

*/

#include <e32std.h>

#include "tGenericHIDAPI.h"

// ======== MEMBER FUNCTIONS ========

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

// NewLC

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

//

CtGenericHIDAPI* CtGenericHIDAPI::NewLC()

    {    

    CtGenericHIDAPI* self = new (ELeave) CtGenericHIDAPI();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// NewL

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

//

CtGenericHIDAPI* CtGenericHIDAPI::NewL()

    {

    CtGenericHIDAPI* self = NewLC();

    CleanupStack::Pop();

    return self;    

    }

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

// Constructor

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

//

CtGenericHIDAPI::CtGenericHIDAPI()

    {    

    }

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

// Destructor

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

//    

CtGenericHIDAPI::~CtGenericHIDAPI()

    {

    delete iHidDriver;

    iFieldList.Close();

    delete iGenHID;

    }

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

// ConstructL()

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

//

void CtGenericHIDAPI::ConstructL()

    {

    iGenHID = CGenericHid::NewL( this );

    iDriverAcces=iGenHID;

    iHidDriver = CHidDriver::NewL(TUid::Uid(0xE000B187),iGenHID);

    }

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

// ConnectL()

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

//

void CtGenericHIDAPI::ConnectL(TInt aConnectionId, const TDesC8& aDescriptor)

    {

    TInt16 ret = iGenHID->ConnectedL( aConnectionId, aDescriptor );

    ret = iGenHID->DriverActive( aConnectionId , CHidTransport::EActive);

    //todo retval

    }

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

// DisconnectL()

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

//

void CtGenericHIDAPI::DisconnectL(TInt aConnectionId )

    {    

    TInt16 ret = iGenHID->Disconnected( aConnectionId );

    //todo retval

    }

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

// DataInL()

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

//

TInt CtGenericHIDAPI::DataInL(TInt aConnectionId, const TDesC8& aDescriptor)

    {

    TInt16 ret = iGenHID->DataIn(aConnectionId, CHidTransport::EHidChannelInt, aDescriptor);

    return ret;

    }

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

// RunCountryCodeL()

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

//    

TInt CtGenericHIDAPI::RunCountryCodeL()

    {

    TInt16 countryCode = iGenHID->CountryCodeL(0);

    if(countryCode != 0)

    	return KErrNotFound;

    return KErrNone;

    }

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

// RunVendorIdL()

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

//        

TInt CtGenericHIDAPI::RunVendorIdL()

    {

    TUint vendorId = iGenHID->VendorIdL(0);

    if(vendorId != 0x0421)

    	return KErrNotFound;

    return KErrNone;

    }

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

// RunProductIdL()

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

//

TInt CtGenericHIDAPI::RunProductIdL()

    {

    TUint productId = iGenHID->ProductIdL(0);

    if(productId != 0x0083)

    	return KErrNotFound;

    return KErrNone;

    }

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

// RunSetProtocol()

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

//        

TInt CtGenericHIDAPI::RunSetProtocolL()

    {

    iGenHID->SetProtocolL(0,0,MDriverAccess::EReport,iHidDriver);

    return KErrNone;

    }

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

// RunGetProtocoL()

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

//        

TInt CtGenericHIDAPI::RunGetProtocoL()

    {

    iGenHID->GetProtocolL(0,0);    

    return KErrNone;

    }

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

// RunGetReportL()

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

//        

TInt CtGenericHIDAPI::RunGetReportL()

    {

    iGenHID->GetReportL(0, 0 ,0 , 0);    

    return KErrNone;

    }

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

// RunSetReportL()

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

//        

TInt CtGenericHIDAPI::RunSetReportL(const TDesC8& aDescriptor)

    {

    iGenHID->SetReportL(0,0, MDriverAccess::EOutput, aDescriptor,0, iHidDriver);

    return KErrNone;

    }

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

// GetDataOutL()

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

//

TInt CtGenericHIDAPI::RunDataOutL(const TDesC8& aDescriptor)

    {

    iGenHID->DataOutL( 0, 0,  aDescriptor, 0);    

    return KErrNone;

    }

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

// GetGetIdleL()

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

//        

TInt CtGenericHIDAPI::GetGetIdleL()

    {

    iGenHID->GetIdleL(0, 0, 0);

    return KErrNone;

    }

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

// RunSetIdleL()

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

//        

TInt CtGenericHIDAPI::RunSetIdleL()

    {

    iGenHID->SetIdleL(0, 10, 0, 0, iHidDriver);

    return KErrNone;

    }

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

// GetCommandResultL()

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

//

TInt CtGenericHIDAPI::GetCommandResultL()

    {

    iGenHID->CommandResult(0, 1);

    return KErrNone;

    }

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

// GetReportDescriptorL()

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

//

TInt CtGenericHIDAPI::GetReportDescriptorL()

    {

    CReportRoot* tmp=iGenHID->ReportDescriptor(0);

    if(tmp == NULL)

    	return KErrNotFound;

    return KErrNone;

    }

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

// CreateReportGeneratorL

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

//    

TInt CtGenericHIDAPI::CreateReportGeneratorL()   

    {

    CReportRoot* tmp=iGenHID->ReportDescriptor(0);

    if(tmp == NULL)

    	return KErrNotFound;

    iReportGenerator = CReportGenerator::NewL(tmp, 0, CField::EInput);

    if(iReportGenerator == NULL)

    	return KErrNotFound;

    return KErrNone;

    }

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

// DeleteReportGeneratorL()

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

//        

TInt CtGenericHIDAPI::DeleteReportGeneratorL()   

    {    

    delete iReportGenerator;

    iReportGenerator = NULL;

    return KErrNone;

    }

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

// ReportGeneratorReport()

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

//   

TInt CtGenericHIDAPI::ReportGeneratorReport()

    {

    iReportGenerator->Report();    

    //todo check return value???

    return KErrNone;

    }    

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

// ReportGeneratorReport()

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

//   

TInt CtGenericHIDAPI::ReportGeneratorSetFieldL( TBool aIsArray, TBool aOutOfRange, TBool aFieldNull, TBool aFieldCountZero, TBool aExistingUsageId, TBool aBadIndex )

    {

    CField* field = CreateCFieldL();

    TInt usageId = EConsumerUsageVolumeInc;//233;//0xE9

    TInt indexOffset = 0;

    if(aBadIndex != EFalse)

    	{

    	indexOffset = 1000;

    	}

    if(aExistingUsageId == EFalse)

    	{

    	usageId = EConsumerUsagePlayPause;//205

    	field->SetUsageRange(0,255);

    	}

    if(aIsArray == EFalse)

    	{

    	field->SetAttributes(KFieldAttributeVariable);

    	if(field->IsArray() != EFalse)

    		{

    		return KErrGeneral;

    		}

    	}

    else 

    {

		field->SetAttributes(!KFieldAttributeVariable);

		if(field->IsArray() == EFalse)

    	{

    	return KErrGeneral;

    	}

    }

    field->SetLogicalMax(10);

    if(aOutOfRange != EFalse)

    	{

    	field->SetLogicalMin(5);

    	}

    if(aFieldCountZero != EFalse)

    	{

    	field->SetCount(0);

    	}

    const CField* constField;

    if(aFieldNull == EFalse)

    	{

    	constField = (const CField*)field;

    	}

    else

    	{

    	constField = NULL;

    	}

    TInt16 ret = iReportGenerator->SetField(constField, usageId, 1, indexOffset);

    return ret;

    }    

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

// CtGenericHid::CreateReportTranslatorL

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

//   

TInt CtGenericHIDAPI::CreateReportTranslatorL( const TDesC8& aDescriptor, TBool aIsArray, TBool aFieldNull, TBool aFieldCountZero)

    {

    CField* field = CreateCFieldL();

    if(aIsArray == EFalse)

    	{

    	field->SetAttributes(KFieldAttributeVariable);

    	if(field->IsArray() != EFalse)

    		{

    		return KErrGeneral;

    		}

    	}

    else 

    {

		field->SetAttributes(!KFieldAttributeVariable);

		if(field->IsArray() == EFalse)

    	{

    	return KErrGeneral;

    	}

    }

   /* field->SetLogicalMax(10);

    if(aOutOfRange != EFalse)

    	{

    	field->SetLogicalMin(5);

    	}*/

    if(aFieldCountZero != EFalse)

    	{

    	field->SetCount(0);

    	}

    const CField* constField;

    if(aFieldNull == EFalse)

    	{

    	constField = (const CField*)field;

    	}

    else

    	{

    	constField = NULL;

    	}

    //const CField* field = CreateConstCFieldL();

    iTranslator = new (ELeave) TReportTranslator(aDescriptor, constField);

    return KErrNone;

    }

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

// CtGenericHid::CreateReportTranslator_FieldNullL

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

//   

/*TInt CtGenericHIDAPI::CreateReportTranslator_FieldNullL( const TDesC8& aDescriptor  )

    {

    const CField* field = NULL;

    iTranslator = new (ELeave) TReportTranslator(aDescriptor, field);

    return KErrNone;

    }*/

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

// CtGenericHid::DeleteReportTranslatorL

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

//   

TInt CtGenericHIDAPI::DeleteReportTranslatorL(  )

    {

    delete iTranslator;    

    iTranslator =NULL;

    return KErrNone;

    }

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

// CtGenericHid::ReportTranslatorGetValueL

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

//   

TInt CtGenericHIDAPI::ReportTranslatorGetValueL()

    {

    //todo if

    TInt value = 0;

    TInt res = iTranslator->GetValue(value,EConsumerUsageVolumeInc);

    return res;

    }

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

// CtGenericHid::ReportTranslatorValueL

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

//   

TInt CtGenericHIDAPI::ReportTranslatorValueL()

    {

    TInt value = iTranslator->ValueL(EConsumerUsageVolumeInc); 

    return KErrNone;

    }

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

// CtGenericHid::ReportTranslatorGetUsageIdL

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

//   

TInt CtGenericHIDAPI::ReportTranslatorGetUsageIdL( TBool aBadControlIndex )

    {

    TInt id;

    TInt index = 0;

    if(aBadControlIndex != EFalse)

    	{

    	index = -1;//bad index

    	}

    //todo if

    TInt ret = iTranslator->GetUsageId(id,index);

    return ret;

    }

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

// CtGenericHid::ReportTranslatorUsageIdL

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

//   

TInt CtGenericHIDAPI::ReportTranslatorUsageIdL( )

    {

    TInt value = iTranslator->UsageIdL(0);  

    return KErrNone;

    }

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

// CtGenericHid::ReportTranslatorRawValueL

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

//   

TInt CtGenericHIDAPI::ReportTranslatorRawValueL(   )

    {

    TInt value = iTranslator->RawValueL(0);  

    return KErrNone;

    }

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

// CtGenericHid::ReportTranslatorCountL

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

//   

TInt CtGenericHIDAPI::ReportTranslatorCountL( )

    {

    TInt count =iTranslator->Count();  

    //todo if, retval

    return KErrNone;

    }

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

// CtGenericHid::CollectiontypeL

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

// 

TInt CtGenericHIDAPI::CollectiontypeL( )

    {

    CReportRoot* tmp=iGenHID->ReportDescriptor(0);

    User::LeaveIfNull(tmp);

    TUint32 type=tmp->Type();

    //todo check type?

    return KErrNone;

    }

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

// CtGenericHid::CollectionIsPhysicalL

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

// 

TInt CtGenericHIDAPI::CollectionIsPhysicalL( )

    {

    CReportRoot* tmp=iGenHID->ReportDescriptor(0);

    User::LeaveIfNull(tmp);

    TBool result=tmp->IsPhysical();

    return KErrNone;

    }

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

// CtGenericHid::CollectionIsLogicalL

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

// 

TInt CtGenericHIDAPI::CollectionIsLogicalL( )

    {

    CReportRoot* tmp=iGenHID->ReportDescriptor(0);

    User::LeaveIfNull(tmp);

    TBool result=tmp->IsLogical();