/*
* 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:  Generic hid implementation
*
*/

#include <e32std.h>

#include "debug.h"
#include "hidgeneric.h"
#include "hidreportroot.h"
#include "hidparser.h"
#include "hiddriveritem.h"
#include "hidconnectioninfo.h"

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

// ---------------------------------------------------------------------------
// NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CGenericHid* CGenericHid::NewLC(MTransportLayer* aTransportLayer)
    {
    TRACE_INFO((_L("[HID]\tCGenericHid::NewLC(0x%08x)"), aTransportLayer));
    CGenericHid* self = new (ELeave) CGenericHid(aTransportLayer);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CGenericHid* CGenericHid::NewL(MTransportLayer* aTransportLayer)
    {
    TRACE_INFO((_L("[HID]\tCGenericHid::NewL(0x%08x)"), aTransportLayer));
	CGenericHid* self = NewLC(aTransportLayer);
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------------------------
// ConstructL()
// ---------------------------------------------------------------------------
//
void CGenericHid::ConstructL()
    {
    TRACE_INFO(_L("[HID]\tCGenericHid::ConstructL()"));
    TRACE_INFO(_L("[HID]\tCGenericHid::ConstructL(): Creating Parser..."));
    iParser = CParser::NewL();
    iInputHandlingReg = CHidInputDataHandlingReg::NewL();
    }

// ---------------------------------------------------------------------------
// CGenericHid()
// ---------------------------------------------------------------------------
//
CGenericHid::CGenericHid(MTransportLayer* aTransportLayer) :
    iDriverList(_FOFF(CDriverListItem, iSlink)),
    iTransportLayer(aTransportLayer)
    {
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CGenericHid::~CGenericHid()
    {
    TRACE_FUNC_ENTRY
    RemoveDrivers();
    iConnectionInfo.ResetAndDestroy();
    iConnectionInfo.Close();
    delete iInputHandlingReg;
    delete iParser;
    REComSession::FinalClose();
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// CountryCodeL
// ---------------------------------------------------------------------------
//
TUint CGenericHid::CountryCodeL(TInt aConnID)
    {
    // Pass the request through to the transport layer.
    return (iTransportLayer->CountryCodeL(aConnID));
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// VendorIdL
// ---------------------------------------------------------------------------
//
TUint CGenericHid::VendorIdL(TInt aConnID)
    {
    // Pass the request through to the transport layer.
    return (iTransportLayer->VendorIdL(aConnID));
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// ProductIdL()
// ---------------------------------------------------------------------------
//
TUint CGenericHid::ProductIdL(TInt aConnID)
    {
    // Pass the request through to the transport layer.
    return iTransportLayer->ProductIdL(aConnID);
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// SetProtocol
// ---------------------------------------------------------------------------
//
void CGenericHid::SetProtocolL(TInt aConnectionId, TUint16 aInterface,
                              MDriverAccess::TProtocols aProtocol, 
                              CHidDriver* aDriver)
    {
    iTransportLayer->SetProtocolL(aConnectionId, static_cast<TUint16>(aProtocol), 
            aInterface);    
    CConnectionInfo* conninfo = SeekConnectionInfo( aConnectionId );
        if ( conninfo )
            {
            conninfo->SetLastCommandHandler(aDriver);
            }          
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// GetProtocol
// ---------------------------------------------------------------------------
//
void CGenericHid::GetProtocolL(TInt aConnectionId,TUint16 aInterface)
    {
    iTransportLayer->GetProtocolL(aConnectionId, aInterface);    
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// GetReport
// ---------------------------------------------------------------------------
//
void CGenericHid::GetReportL(TInt aConnectionId,
    TUint8 aReportId, TUint16 aInterface, TUint16 aLength)
    {
    iTransportLayer->GetReportL(aConnectionId, MDriverAccess::EInput, aReportId, 
            aInterface, aLength);    
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// SetReport()
// ---------------------------------------------------------------------------
//
void CGenericHid::SetReportL(TInt aConnectionId, TUint8 aReportId,
    MDriverAccess::TReportType aReportType, const TDesC8& aPayload,
    TUint16 aInterface, CHidDriver* aDriver)
    {
    iTransportLayer->SetReportL(aConnectionId, static_cast<TUint8>(aReportType),
        aReportId, aInterface, aPayload);    
    CConnectionInfo* conninfo = SeekConnectionInfo( aConnectionId );
        if ( conninfo )
            {
            conninfo->SetLastCommandHandler(aDriver);
            }          
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// DataOut()
// ---------------------------------------------------------------------------
//
void CGenericHid::DataOutL(TInt aConnectionId, TUint8 aReportId,
                          const TDesC8& aPayload,
                          TUint16 aInterface)
    {
    iTransportLayer->DataOutL(aConnectionId, aReportId, aInterface, aPayload);    
    }


// ---------------------------------------------------------------------------
// From MDriverAccess
// GetIdle()
// ---------------------------------------------------------------------------
//
void CGenericHid::GetIdleL(TInt aConnectionId, TUint8 aReportId,
    TUint16 aInterface )
    {
    iTransportLayer->GetIdleL(aConnectionId, aReportId, aInterface);    
    }

// ---------------------------------------------------------------------------
// From MDriverAccess
// SetIdle()
// ---------------------------------------------------------------------------
//
void CGenericHid::SetIdleL(TInt aConnectionId, TUint8 aDuration,
    TUint8 aReportId, TUint16 aInterface, CHidDriver* aDriver)
    {
    iTransportLayer->SetIdleL(aConnectionId, aDuration, aReportId, aInterface);
    CConnectionInfo* conninfo = SeekConnectionInfo( aConnectionId );
    if ( conninfo )
        {
        conninfo->SetLastCommandHandler(aDriver);
        }          
                       
    }

// ---------------------------------------------------------------------------
// RemoveDrivers()
// ---------------------------------------------------------------------------
//
void CGenericHid::RemoveDrivers()
    {
    TRACE_FUNC
    // Driver instances
    CDriverListItem* driverItem;
    while ( !iDriverList.IsEmpty() )
        {
        driverItem = iDriverList.Last();
        iDriverList.Remove( *driverItem );
        delete driverItem;
        }
    }

// ---------------------------------------------------------------------------
// From CHidTransport
// Disconnected()
// ---------------------------------------------------------------------------
//
TInt CGenericHid::Disconnected( TInt aConnectionId )
    {
    TRACE_FUNC_ENTRY
    TInt retVal = KErrNone;
    
    TSglQueIter<CDriverListItem> driverIter( iDriverList );
    driverIter.SetToFirst();    

    CDriverListItem* driverItem = driverIter;    
    while ( driverItem )
        {            
        driverIter++;    
        if ( driverItem->ConnectionId() == aConnectionId )
            {
            TRACE_INFO(_L("[HID]\tCGenericHid::Disconnected driver"));
            if (driverItem->Driver())
                {
                driverItem->Driver()->Disconnected(0);
                }
            // Remove it from the list of driver instances           
            
            iDriverList.Remove(*driverItem);
            delete driverItem;
            driverItem = NULL;
            retVal = KErrNone;
            }                                  
        driverItem = driverIter;
        
        TRACE_INFO(_L("[HID]\tCGenericHid::Disconnected next driver"));
        }
    TRACE_INFO(_L("[HID]\tCGenericHid::Disconnected remove connection info"));
    TInt count = iConnectionInfo.Count();
    for (TInt i = count-1 ; i>=0; i--)
        {
        TRACE_INFO((_L("[HID]\tCGenericHid::Disconnected remove connection info %d"),i));
        CConnectionInfo* conninfo = iConnectionInfo[i];
        TRACE_INFO((_L("[HID]\tCGenericHid::Disconnected remove connection info %d"),i));
        if ( conninfo->ConnectionID() == aConnectionId )                
            {
            iConnectionInfo.Remove(i);
            delete conninfo;
            TRACE_INFO((_L("[HID]\tCGenericHid::Disconnected remove connection info %d removed"),i));
            }
        }     
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// From CHidTransport
// ConnectedL
// HID device has been connected.  Attempt to find a driver that can
// handle reports in the format specified by the report descriptor.
// ---------------------------------------------------------------------------
//
TInt CGenericHid::ConnectedL( TInt aConnectionId, const TDesC8& aDescriptor )
    {
    TRACE_INFO((_L("[HID]\tCGenericHid::ConnectedL(%d, ...)"), aConnectionId))    
    
    // Place the parsed report descriptor in the driver list item:
    
    TBool found = EFalse;
    CConnectionInfo* conninfo = SeekConnectionInfo( aConnectionId );
    if ( conninfo )
        {
        return KErrInUse;    
        }
    
    CReportRoot* reportRoot = iParser->ParseL( aDescriptor );
    CleanupStack::PushL(reportRoot);
        
    TRACE_INFO(_L("[HID]\tCGenericHid::ConnectedL: evaluate driver array"));
    // Implementation info array
    RImplInfoPtrArray implInfoArray;
    REComSession::ListImplementationsL( KHidDriverPluginInterfaceUid, implInfoArray );
    CleanupClosePushL(implInfoArray);    
    
    TRACE_INFO((_L("[HID]\tCGenericHid::ConnectedL: %d implementations found"), implInfoArray.Count()));
    TInt index = 0;
    TInt retVal = KErrHidNoDriver;
    TInt supportedfields = 0;
    CHidDriver* driver = NULL;
    for ( index  = 0; index < implInfoArray.Count(); index++ )
        {
        // parse implementation UID
        CImplementationInformation* info = implInfoArray[ index  ];
        TUid implUid = info->ImplementationUid();
        TRACE_INFO((_L("[HID]\tCGenericHid::ConnectedL: load plugin 0x%08x"),implUid ));
        // load driver
        // Trap so other drivers will be enumerated even if
        // this fails:

        TRAPD(retTrap, driver = CHidDriver::NewL( implUid, this ));
        if ( retTrap != KErrNone)
            {
            continue;    
            }
        CleanupStack::PushL(driver);
        TRACE_INFO((_L("[HID]\tCGenericHid::ConnectedL: init plugin 0x%08x"),implUid ));
        driver->InitialiseL( aConnectionId );
        TInt ret = driver->CanHandleReportL( reportRoot );
        if (ret == KErrNone)
            {
            TRACE_INFO(_L("[HID]\tCGenericHid::ConnectedL(): found driver"));            
	        
	        // Make a new driver list item:
	        CDriverListItem* driverItem = new ( ELeave ) CDriverListItem( aConnectionId );	        
	        CleanupStack::PushL( driverItem );	                
	        driver->SetInputHandlingReg( iInputHandlingReg );
	        supportedfields += driver->SupportedFieldCount();	        
            iDriverList.AddLast( *driverItem );
            CleanupStack::Pop( driverItem );
            driverItem->SetDriver( driver );    
            CleanupStack::Pop( driver );
            retVal = KErrNone;
            found = ETrue;
            }
        else
        	{
 	        CleanupStack::PopAndDestroy( driver );
        	}
        }
    TRACE_INFO((_L("[HID]\tCGenericHid::ConnectedL Partial supported hid device supported %d in report %d&"),supportedfields,iParser->FieldCount()));
    if (supportedfields < iParser->FieldCount() && found )
        {
        TRACE_INFO(_L("[HID]\tCGenericHid::ConnectedL Partial supported hid device"));
        }
    implInfoArray.ResetAndDestroy();     
    CleanupStack::PopAndDestroy();  // info
    if ( found )
        {   
        TRACE_INFO(_L("[HID]\tCGenericHid::ConnectedL append connection info"));    
        conninfo = CConnectionInfo::NewL(aConnectionId, reportRoot);
        CleanupStack::Pop(reportRoot); // ownership transfered to conninfo        
        CleanupStack::PushL(conninfo);
        iConnectionInfo.AppendL(conninfo);
        CleanupStack::Pop(conninfo);
        }         
    else
        {
        CleanupStack::PopAndDestroy(reportRoot);     
        }
    
    return retVal;
    }

// ---------------------------------------------------------------------------
// From CHidTransport
// DataIn
// Determine which driver is handling this connection ID and pass the payload
// reference to it
// ---------------------------------------------------------------------------
//
TInt CGenericHid::DataIn(TInt aConnectionId,
    CHidTransport::THidChannelType aChannel, const TDesC8& aPayload)
    {
    TRACE_FUNC_ENTRY
    TInt retVal = KErrHidNoDriver;
    TInt ret = KErrNone;
    
    TSglQueIter<CDriverListItem> driverIter( iDriverList );
    driverIter.SetToFirst();    

    CDriverListItem* item = driverIter;
    TBool found = EFalse; 
    while ( item )
        {            
        if ( item->ConnectionId() == aConnectionId )
                {                
                ret = item->Driver()->DataIn( aChannel, aPayload );
                if (ret == KErrNone)
                    {
                    TRACE_INFO(_L("[HID]\tCGenericHid::DataIn command handled"));
                    found = ETrue;
                    retVal = KErrNone;
                    }
                }
         TRACE_INFO(_L("[HID]\tCGenericHid::DataIn next driver"));
         driverIter++;
         item = driverIter;
         }
    if ( !found && aChannel == CHidTransport::EHidChannelCtrl )
        {
        retVal = KErrNone;
        }
    iInputHandlingReg->Reset();    
    TRACE_FUNC_EXIT    
    return retVal;
    }


// ---------------------------------------------------------------------------
// ReportDescriptor
// Provides access to the parsed results to the factory
// ---------------------------------------------------------------------------
//
CReportRoot* CGenericHid::ReportDescriptor(TInt aConnectionId)
    {
    CConnectionInfo* conninfo = SeekConnectionInfo( aConnectionId );
    if ( conninfo )
        {
        return conninfo->ReportRoot();
        }
    return NULL;
    }

// ---------------------------------------------------------------------------
// From CHidTransport
// DriverActive()
// ---------------------------------------------------------------------------
//
TInt CGenericHid::DriverActive(TInt aConnectionId,
    CHidTransport::TDriverState aActive)
    {
    TRACE_FUNC_ENTRY
    TInt retVal = KErrHidNoDriver;    
    // Find the driver handling the connection and stop it    
    TSglQueIter<CDriverListItem> driverIter( iDriverList );
    driverIter.SetToFirst();  
    CDriverListItem* item = driverIter;
    
    while ( item )
        {
        TRACE_INFO(_L("[HID]\tCGenericHid::DriverActive"));        
        if ( item->ConnectionId() == aConnectionId && item->Driver() )
            {
            TRACE_INFO(_L("[HID]\tCGenericHid::DriverActive driver found"));
            if ( aActive == CHidTransport::EActive )
                {
                TRAP(retVal, item->Driver()->StartL( aConnectionId ));
                if (retVal != KErrNone)
                    {
                    break;
                    }
                }
            else if ( aActive == CHidTransport::ESuspend)
                {
                item->Driver()->Stop();
                retVal = KErrNone;
                }            
            }   
         driverIter++;
         item = driverIter;
         }
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// CommandResult()
// ---------------------------------------------------------------------------
//
void CGenericHid::CommandResult(TInt aConnectionId, TInt aCmdAck)
    {
    // Get the driver handling this connection    
    CConnectionInfo* conninfo = SeekConnectionInfo( aConnectionId );
    if ( conninfo )
        {
        CHidDriver*  hiddriver = conninfo->ReturnLastCommandHandler();
        if (hiddriver)
            {
            hiddriver->CommandResult(aCmdAck);
            }
        }    
    }

// ---------------------------------------------------------------------------
// SeekConnectionInfo()
// ---------------------------------------------------------------------------
//
CConnectionInfo* CGenericHid::SeekConnectionInfo(TInt aConnectionId)
    {
    TRACE_FUNC    
    CConnectionInfo* conninfo = NULL;
    TInt count = iConnectionInfo.Count();
    TRACE_INFO((_L("[HID]\tCGenericHid::SeekConnectionInfo count %d"), count));   
    for (TInt i = 0 ; i < count; i++)
        {
        conninfo = iConnectionInfo[i];
        TRACE_INFO((_L("[HID]\tCGenericHid::SeekConnectionInfo connection info check %d %d"),aConnectionId, conninfo->ConnectionID()));    
        if ( conninfo->ConnectionID() == aConnectionId)                
            {
            TRACE_INFO(_L("[HID]\tCGenericHid::SeekConnectionInfo connection info found"));    
            return conninfo;
            }
        }
    return NULL;
    }