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


// References:
//
// [1] USB Device Class Definition for Human Interface Devices (HID),
//     Firmware Specification, Version 1.11, USB Implementers' Forum,
//     June 2001
//
// ----------------------------------------------------------------------

#include <e32std.h>

#include "hiditem.h"
#include "hidparser.h"

const TInt KSizeMask        = 0x03;
const TInt KTypeMask        = 0x03;
const TInt KTypePosn        = 2;
const TInt KTagMask         = 0x0F;
const TInt KTagPosn         = 4;
const TInt KLongItemId      = 0xfe;
const TInt KMaxItemlength   = 4;
const TInt KSizeThree       = 3;
const TInt KSizeFour        = 4;
const TInt KLongItemMin     = 3;


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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
TItem::TItem(const TDesC8& aRawData)
    : iRawData(aRawData)
    {    
    if (aRawData.Length() < 1)
        {
        return;
        }
    TBool isShortItem = (aRawData[0] != KLongItemId);

    if (isShortItem)
        {
        //  +----+----+----+----+----+----+----+----+
        //  |        Tag        |   Type  |  Size   |    [data...]
        //  |    .    .    .    |    .    |    .    |
        //  +----+----+----+----+----+----+----+----+
        //    7    6    5    4    3    2    1     0
        //
        // A short item is followed by 0, 1, 2 or 4 bytes of data, as
        // specified in the size field. See [1], Section 6.2.2.2.        
        iSize = aRawData[0] & KSizeMask;
        if (iSize == KSizeThree)
            {
            iSize = KSizeFour;
            }        
        iType = static_cast<TItemType>((aRawData[0] >> KTypePosn) & KTypeMask);
        iTag = (aRawData[0] >> KTagPosn) & KTagMask;
        iDataOffset = 1;
        }
    else
        {
        //        Byte 0               Byte 1          Byte 2
        // +------+------+------+   +-----------+   +-----------+
        // | Tag  | Type | Size |   | Data size |   | Long item |   [data...]
        // | 1111 |  11  |  10  |   |  (0-255)  |   |    tag    |
        // +------+------+------+   +-----------+   +-----------+
        //   7654    32     10
        //
        // A long item is followed by 0-255 bytes of data, as specified
        // in the data size byte. See [1], Section 6.2.2.3.

        iType = EReserved;

        if (aRawData.Length() > KLongItemMin)
            {
            iSize = aRawData[1];
            iTag = aRawData[2];
            iDataOffset = KLongItemMin;
            }
        else
            {
            iSize = 0;
            iTag = 0;
            iDataOffset = 0;
            }
        }

#ifdef DBG_ACTIVE
    for (TInt i=0; (i<aRawData.Length()) && (i<(iSize+iDataOffset)); ++i)
        {
        RDebug::Print(_L("aRawData[%d] = 0x%02x"), i, aRawData[i]);
        }
#endif
    }

// ---------------------------------------------------------------------------
// DataSize()
// ---------------------------------------------------------------------------
//
TInt TItem::DataSize() const
    {
    return iSize;
    }

// ---------------------------------------------------------------------------
// Tag()
// ---------------------------------------------------------------------------
//
TInt TItem::Tag() const
    {
    return iTag;
    }

// ---------------------------------------------------------------------------
// Data()
// ---------------------------------------------------------------------------
//
TUint32 TItem::Data() const
    {
    TInt size = DataSize();

    // Calling Data() makes no sense for long items that have a data
    // size over 4 bytes, as it only returns a TUint32:
    //
    if (size > KMaxItemlength)
        {
        size = KMaxItemlength;
        }

    // Ensure we don't overrun the source buffer:
    //
    if (size > (iRawData.Length() - 1))
        {
        size = iRawData.Length() - 1;
        }

    // Concatenate each byte into a TUint32.  Note that this function must
    // return zero if the data size is zero (see Parser.cpp, MainItemL()).
    //
    TUint32 tagData = 0;
    for (TInt i=0; i<size; ++i)
        {
        tagData |= (iRawData[1 + i] << (KSizeOfByte*i));
        }

    return tagData;
    }

// ---------------------------------------------------------------------------
// SignedData()
// ---------------------------------------------------------------------------
//
TInt32 TItem::SignedData() const
    {
    TUint32 data = Data();

    // For 8 and 16 bit negative values, we need to
    // sign extend to 32-bits:
    //
    if ((DataSize() == 1) && (data & 0x80))
        {
        data |= 0xffffff00;
        }
    if ((DataSize() == 2) && (data & 0x8000))
        {
        data |= 0xffff0000;
        }

    // Note that this assumes that the machine uses 2s complement
    // representation internally.  All current Symbian devices do,
    // including ARM devices and the WINS emulator. This is almost
    // certain to remain the case in the future.
    //
    return static_cast<TInt32>(data);
    }

// ---------------------------------------------------------------------------
// Operator []
// ---------------------------------------------------------------------------
//
TUint8 TItem::operator[](TInt aIndex) const
    {    

    TUint8 value = 0;
    if ((aIndex >= 0) && (aIndex < iSize))
        {
        value = iRawData[iDataOffset + aIndex];
        }
    return value;
    }

// ---------------------------------------------------------------------------
// Type()
// ---------------------------------------------------------------------------
//
TItem::TItemType TItem::Type() const
    {
    return iType;
    }

// ---------------------------------------------------------------------------
// IsMain()
// ---------------------------------------------------------------------------
//
TBool TItem::IsMain() const
    {
    return iType == TItem::EMain;
    }

// ---------------------------------------------------------------------------
// IsLocal()
// ---------------------------------------------------------------------------
//
TBool TItem::IsLocal() const
    {
    return iType == TItem::ELocal;
    }

// ---------------------------------------------------------------------------
// IsGlobal()
// ---------------------------------------------------------------------------
//
TBool TItem::IsGlobal() const
    {
    return iType == TItem::EGlobal;
    }

// ---------------------------------------------------------------------------
// IsLong()
// ---------------------------------------------------------------------------
//
TBool TItem::IsLong() const
    {
    return iType == TItem::EReserved;
    }

// ---------------------------------------------------------------------------
// ItemSize()
// ---------------------------------------------------------------------------
//
TInt TItem::ItemSize() const
    {
    return iSize + iDataOffset;
    }