localconnectivityservice/generichid/inc/hidparser.h
changeset 0 c3e98f10fcf4
child 44 7a45d2ea2f56
equal deleted inserted replaced
-1:000000000000 0:c3e98f10fcf4
       
     1 /*
       
     2 * Copyright (c) 2005-2007 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  BTHid item
       
    15 *
       
    16 */
       
    17 
       
    18 #ifndef C_PARSER_H
       
    19 #define C_PARSER_H
       
    20 
       
    21 #include "hidreportroot.h"
       
    22 
       
    23 class TItem;
       
    24 
       
    25 /**
       
    26  * HID Parser error codes.  For a description of the error code
       
    27  * format, see "HID Parser Error Codes", Revision 1.2, USB
       
    28  * Implementers' Forum, February 2000.
       
    29  */
       
    30 enum THidParserError
       
    31     {
       
    32     // General:
       
    33     //
       
    34     EUnknownItem                    = 0xbf00,
       
    35     ELongItemDefined                = 0x3e00,
       
    36     //
       
    37     // Global:
       
    38     //
       
    39     EZeroUsagePage                  = 0x8004,
       
    40     EUsagePageOutOfRange            = 0x8104,
       
    41     ELogicalMinInvalidForArray      = 0x8214,
       
    42     ELogicalMaxInvalidForArray      = 0x8224,
       
    43     ELonelyPhysicalMin              = 0x8034,
       
    44     ELonelyPhysicalMax              = 0x8044,
       
    45     EZeroReportId                   = 0x8084,
       
    46     EReportIdTooBig                 = 0x8184,
       
    47     ELateReportId                   = 0x8284,
       
    48     EReportIdOutsideTopLevel        = 0x8484,
       
    49     EZeroReportCount                = 0x8094,
       
    50     EPushWithoutPop                 = 0x80a4,
       
    51     EPushHasData                    = 0x81a4,
       
    52     EPopWithoutPush                 = 0x80b4,
       
    53     EPopHasData                     = 0x81b4,
       
    54     ERedundantGlobalItem            = 0x80f4,
       
    55     EReservedUsagePage              = 0x0004,
       
    56     ELogicalMinExceedsMax           = 0x0014,
       
    57     EPhysicalMinExceedsMax          = 0x0034,
       
    58     EExponentReservedBitsNonZero    = 0x0054,
       
    59     EUnitReservedBitsNonZero        = 0x0064,
       
    60     //
       
    61     // Local:
       
    62     //
       
    63     ELonelyUsageMin                 = 0x8018,
       
    64     EUsageMinExceedsMax             = 0x8118,
       
    65     EUsagePageMismatchMin           = 0x8318,
       
    66     ELonelyUsageMax                 = 0x8028,
       
    67     EUsagePageMismatchMax           = 0x8228,
       
    68     ELonelyDesignatorMin            = 0x8048,
       
    69     EDesignatorMinExceedsMax        = 0x8148,
       
    70     ELonelyDesignatorMax            = 0x8058,
       
    71     ELonelyStringMin                = 0x8088,
       
    72     EStringMinExceedsMax            = 0x8188,
       
    73     ELonelyStringMax                = 0x8098,
       
    74     EUnknownDelimiter               = 0x80a8,
       
    75     ENestedDelimiter                = 0x81a8,
       
    76     ELonelyDelimiter                = 0x82a8,
       
    77     EInvalidItemWithinDelimiter     = 0x83a8,
       
    78     EDelimiterAtTopLevel            = 0x84a8,
       
    79     EZeroUsage                      = 0x0008,
       
    80     //
       
    81     // Main:
       
    82     //
       
    83     EInputMissingItems              = 0x8080,
       
    84     EInputItemWithinDelimiter       = 0x8180,
       
    85     EInputReportSize                = 0x8280,
       
    86     EInputMinExceedsMax             = 0x8380,
       
    87     EOutputMissingItems             = 0x8090,
       
    88     EOutputItemWithinDelimiter      = 0x8190,
       
    89     EOutputReportSize               = 0x8290,
       
    90     EOutputMinExceedsMax            = 0x8390,
       
    91     EFeatureMissingItems            = 0x80b0,
       
    92     EFeatureItemWithinDelimiter     = 0x81b0,
       
    93     EFeatureReportSize              = 0x82b0,
       
    94     EFeatureMinExceedsMax           = 0x83b0,
       
    95     ENoMatchingBeginCollection      = 0x80c0,
       
    96     EEndCollectionWithinDelimiter   = 0x81c0,
       
    97     EReportMustBeEightBitMultiple   = 0x82c0,
       
    98     ENoMatchingEndCollection        = 0x80a0,
       
    99     EBeginCollectionWithinDelimiter = 0x81a0,
       
   100     EApplicationCollectionLevel     = 0x82a0,
       
   101     EInputReservedBitsNonZero       = 0x0080,
       
   102     EInputLocalMultipleUse          = 0x0280,
       
   103     EOutputReservedBitsNonZero      = 0x0090,
       
   104     EOutputLocalMultipleUse         = 0x0290,
       
   105     EFeatureReservedBitsNonZero     = 0x00b0,
       
   106     EFeatureLocalMultipleUse        = 0x02b0,
       
   107     ECollectionLocalUnused          = 0x00a0,
       
   108     ECollectionTypeUnknownReserved  = 0x01a0,
       
   109     EEndCollectionLocalUnused       = 0x00c0,
       
   110     EEndCollectionHasData           = 0x01c0,
       
   111     //
       
   112     // Our ("vendor specific") codes:
       
   113     //
       
   114     EInvalidItemLength              = 0xC000,
       
   115     EApplicationHasDelimiter        = 0x40a0,
       
   116     EDelimiterWithinNamedArray      = 0x40a8,
       
   117     ECollectionHasNoUsage           = 0x40c0,
       
   118     ECollectionHasNoUsagePage       = 0x41c0
       
   119     };
       
   120 
       
   121 /**
       
   122  * HID parser panics
       
   123  */
       
   124 enum THidParsingError
       
   125     {
       
   126     // ASSERT_ALWAYS:
       
   127     //
       
   128     EZeroLengthItem = 1,       //!< Zero descriptor length in TItem constructor
       
   129     ENoReportRoot = 2,         //!< iReportRoot is 0 in CreateFieldL()
       
   130     ENoCurrentCollection = 3,  //!< No current collection in Collection()
       
   131     //
       
   132     // ASSERT_DEBUG:
       
   133     //
       
   134     ENoCollectionToCheck = 10, //!< No collection in CheckForCollectionErrors()
       
   135     EPopFailed = 11,           //!< Empty collection stack in PopCollection()
       
   136     EIndexOutOfRange = 12,     //!< Index out of range in TItem::operator[]
       
   137     EItemTooLong = 13          //!< Data() called for item with size > 4
       
   138     };
       
   139 
       
   140 
       
   141 /**
       
   142  *  Parser global states
       
   143  *
       
   144  *  CParser uses TParserGlobalState objects to store the global item
       
   145  *  state during parsing. The global state can be saved and restored
       
   146  *  using the HID descriptor POP and PUSH tags, therefore CParser
       
   147  *  incorporates a stack of TParserGlobalState objects.
       
   148  *
       
   149  *
       
   150  *  @lib  generichid.lib
       
   151  *  @since S60 v5.0
       
   152  */
       
   153 class TParserGlobalState
       
   154     {
       
   155     friend class CParser;
       
   156 
       
   157 public:
       
   158 
       
   159     TParserGlobalState();
       
   160 
       
   161     /**
       
   162      * Copies all data members into a CField object. The other
       
   163      * members of the CField object (those corresponding to local
       
   164      * HID descriptor tags) are unaffected.
       
   165      *
       
   166      * @since S60 v5.0
       
   167      * @param aField Pointer to the field object to populate.
       
   168      * @return None.
       
   169      */
       
   170     void Populate(CField *aField) const;
       
   171 
       
   172 private:
       
   173     /**
       
   174      * Usage page
       
   175      */
       
   176     TInt iUsagePage;
       
   177 
       
   178     /**
       
   179      * Logical minimum
       
   180      */
       
   181     TInt iLogicalMin;
       
   182 
       
   183     /**
       
   184      * Logical maximum
       
   185      */
       
   186     TInt iLogicalMax;
       
   187 
       
   188     /**
       
   189      * Physical minimum
       
   190      */
       
   191     TInt iPhysicalMin;
       
   192 
       
   193     /**
       
   194      * Physical maximum
       
   195      */
       
   196     TInt iPhysicalMax;
       
   197 
       
   198     /**
       
   199      * Unit type
       
   200      */
       
   201     TInt iUnit;
       
   202 
       
   203     /**
       
   204      *  Unit exponent
       
   205      */
       
   206     TInt iUnitExponent;
       
   207 
       
   208     /**
       
   209      * Associated report ID
       
   210      */
       
   211     TInt iReportId;
       
   212 
       
   213     /**
       
   214      * Report size
       
   215      */
       
   216     TInt iSize;
       
   217 
       
   218     /**
       
   219      * Report count
       
   220      */
       
   221     TInt iCount;
       
   222     };
       
   223 
       
   224 
       
   225 /**
       
   226  *
       
   227  * HID parser
       
   228  * CParser parses a HID report descriptor.  It outputs a CReportRoot
       
   229  * containing a tree of CCollection and CField objects representing
       
   230  * the descriptor information.  A HID device driver can then use this,
       
   231  * in conjunction with TReportTranslator and CReportGenerator objects,
       
   232  * to facilitate communication with a HID device.
       
   233  *
       
   234  * The parsing process conforms to the HID class specification
       
   235  * document: "USB Device Class Definition for Human Interface Devices
       
   236  * (HID)", Firmware Specification, Version 1.11, USB Implementers' Forum,
       
   237  * June 2001.
       
   238  *
       
   239  *
       
   240  *  @lib generichid.lib
       
   241  *  @since S60 v5.0
       
   242  */
       
   243 class CParser : public CBase
       
   244     {
       
   245 public:
       
   246     IMPORT_C static CParser* NewL();
       
   247     IMPORT_C static CParser* NewLC();
       
   248 
       
   249     virtual ~CParser();
       
   250 
       
   251     /**
       
   252      * ParseL() parses a string of bytes representing a HID report
       
   253      * descriptor. It returns a tree of collection and field objects (a
       
   254      * CReportRoot). Ownership of the CReportRoot is transferred to the
       
   255      * caller.
       
   256      *
       
   257      * Warning messages produced during the parse process are added to
       
   258      * a list which the driver can retrieve using the Warnings()
       
   259      * function. Note that the list will be overwritten by the next
       
   260      * ParseL() operation.
       
   261      *
       
   262      * Errors and warnings are represented using the format described
       
   263      * in "HID Parser Error Codes", Revision 1.2, USB Implementers'
       
   264      * Forum, February 2000.
       
   265      *
       
   266      * @since S60 v5.0
       
   267      * @param aRawData The report descriptor data to be processed
       
   268      * @return The root collection, a tree of CCollection and CField objects
       
   269      */
       
   270     IMPORT_C CReportRoot* ParseL(const TDesC8& aRawData);
       
   271 
       
   272     /**
       
   273      * Return field count
       
   274      *
       
   275      * @since S60 v5.0
       
   276      * @return field count
       
   277      */
       
   278     TInt FieldCount();
       
   279      
       
   280   
       
   281 
       
   282         
       
   283 
       
   284 private:
       
   285     CParser();
       
   286     void ConstructL();
       
   287 
       
   288     /**
       
   289      * Handle a HID descriptor main item.  This includes the creation
       
   290      * of new field objects in the current collection and management of
       
   291      * the global item state stack.
       
   292      *
       
   293      * @since S60 v5.0
       
   294      * @param aItem The current report descriptor tag and its associated data
       
   295      * @return KErrNone (0) on success, otherwise a critical error code in
       
   296      *         the standard HID format.
       
   297      */
       
   298     TInt MainItemL(const TItem& aItem);
       
   299 
       
   300     /**
       
   301      * Handle a HID descriptor local item.  Stores the data in the
       
   302      * appropriate member of the local state object, *iLocal.
       
   303      *
       
   304      * @since S60 v5.0
       
   305      * @param aItem The current report descriptor tag and its associated data
       
   306      * @return KErrNone (0) on success, otherwise a critical error code in
       
   307      *         the standard HID format.
       
   308      */
       
   309     TInt LocalItemL(const TItem& aItem);
       
   310 
       
   311     /**
       
   312      * Handle a HID descriptor global item. Stores the data in the
       
   313      * appropriate member of the current global state object, iGlobal.
       
   314      *
       
   315      * @since S60 v5.0
       
   316      * @param aItem The current report descriptor tag and its associated data
       
   317      * @return KErrNone (0) on success, otherwise a critical error code in
       
   318      *         the standard HID format.
       
   319      */
       
   320     TInt GlobalItemL(const TItem& aItem);
       
   321 
       
   322     /**
       
   323      * Used to access the current collection object, i.e. the object
       
   324      * at the top of the collection stack (iCollectionStack).
       
   325      *     
       
   326      *
       
   327      * @since S60 v5.0
       
   328      * @return A pointer to the current collection object.
       
   329      *
       
   330      */
       
   331     CCollection* Collection();
       
   332 
       
   333     /**
       
   334      * Pushes a pointer to the current collection object on to the
       
   335      * collection stack.
       
   336      *
       
   337      * Note that the collection stack is used to create the tree of
       
   338      * collections. It should not be confused with the global state
       
   339      * stack, iGlobalStack.
       
   340      *
       
   341      * @since S60 v5.0
       
   342      * @param aCollection The collection to be pushed onto the stack
       
   343      * @return None.
       
   344      *
       
   345      */
       
   346     void PushCollectionL(const CCollection* aCollection);
       
   347 
       
   348     /**
       
   349      * Pushes a pointer to the current collection object on to the
       
   350      * collection stack.
       
   351      *
       
   352      * Note that the collection stack is used to create the tree of
       
   353      * collections. It should not be confused with the global state
       
   354      * stack, iGlobalStack.
       
   355      *
       
   356      * @since  S60 v5.0
       
   357      * @return None.
       
   358      *
       
   359      */
       
   360     void PopCollection();
       
   361 
       
   362     /**
       
   363      * CreateFieldL() is called to instantiate a new CField object
       
   364      * when an input, output or feature item is encountered in the
       
   365      * report descriptor.
       
   366      *
       
   367      * The current local and global states extracted from the report
       
   368      * descriptor are copied to the CField, which is placed into the
       
   369      * current CCollection.
       
   370      *
       
   371      * @since S60 v5.0
       
   372      * @param aType The type of field: input, output or feature
       
   373      * @param aAttributes The attributes for the field (e.g. Data, Array,
       
   374      *                    Absolute.)
       
   375      * @return KErrNone (0) on success, otherwise a critical error code
       
   376      *                  in the standard HID format.
       
   377      *
       
   378      */
       
   379     TInt CreateFieldL(CField::TType aType, TUint32 aAttributes);
       
   380 
       
   381     /**
       
   382      * ClearLocalState() clears the appropriate fields in the CField
       
   383      * object that represents the current local item state.
       
   384      *
       
   385      * @since S60 v5.0
       
   386      * @return None
       
   387      *
       
   388      */
       
   389     void ClearLocalState();
       
   390 
       
   391     /**
       
   392      * DumpStateTableL() copies the current local and global item state
       
   393      * into a CField object.
       
   394      *
       
   395      * @since S60 v5.0
       
   396      * @param aField The field object to receive the data
       
   397      * @return None
       
   398      *
       
   399      */
       
   400     void DumpStateTableL(CField *aField) const;
       
   401 
       
   402     /**
       
   403      * CreateCollectionL() is called to instantiate a new CCollection
       
   404      * object when a "begin collection" item is encountered in the
       
   405      * report descriptor.
       
   406      *
       
   407      * @since S60 v5.0
       
   408      * @param aType The type of the collection. This can be one of the
       
   409      *              seven standard types defined in CCollection::TType,
       
   410      *              or a vendor defined value.
       
   411      * @return KErrNone (0) on success, otherwise a critical error code in
       
   412      *         the standard HID format.
       
   413      */
       
   414     TInt CreateCollectionL(TUint32 aType);
       
   415 
       
   416     /**
       
   417      * CheckForCollectionErrors() validates the current collection
       
   418      * object. It adds non-critical errors to the warnings list. It
       
   419      * returns an error code if a critical error is encountered.
       
   420      *
       
   421      * @since S60 v5.0
       
   422      * @param aType The type of the collection (one of the CCollection::TType
       
   423      *              values, or vendor defined).
       
   424      * @return KErrNone (0) if there was no error, otherwise a critical
       
   425      *         error code in the standard HID format.
       
   426      */
       
   427     TInt CheckForCollectionErrors(TUint32 aType);
       
   428 
       
   429     /**
       
   430      * CheckForFieldErrors() validates the current global and local
       
   431      * item state in preparation for creating a CField object.  It adds
       
   432      * non-critical errors to the warnings list. It returns an error
       
   433      * code if a critical error is encountered.
       
   434      *
       
   435      * @since S60 v5.0
       
   436      * @param @param aType The type of the field (input, output or feature).
       
   437      * @param aAttributes The attributes for the field (e.g. Data, Array,
       
   438      *                    Absolute.)
       
   439      * @return KErrNone (0) if there was no error, otherwise a critical
       
   440      *                   error code in the standard HID format.
       
   441      */
       
   442     TInt CheckForFieldErrors(CField::TType aType, TUint32 aAttributes);
       
   443 
       
   444     /**
       
   445      * CheckForMainErrors() performs error checking common to
       
   446      * CheckForCollectionErrors() and CheckForFieldErrors(). It adds
       
   447      * non-critical errors to the warnings list. It returns an error
       
   448      * code if a critical error is encountered.
       
   449      *
       
   450      * @since S60 v5.0
       
   451      * @return KErrNone (0) if there was no error, otherwise a critical
       
   452      *                  error code in the standard HID format.
       
   453      */
       
   454     TInt CheckForMainErrors();
       
   455 
       
   456     /**
       
   457      * CheckAllReportSizes() checks if all report sizes are integral
       
   458      * multiples of 8 bits.
       
   459      *
       
   460      * @since S60 v5.0
       
   461      * @return ETrue if all report sizes are integral multiples of
       
   462      *         8 bits.
       
   463      */
       
   464     TBool CheckAllReportSizes() const;
       
   465 
       
   466     /**
       
   467      * BitsToRepresentRange() returns the number of bits required to
       
   468      * represent all values in a given range. It is used to check
       
   469      * that the report field size is appropriate for the given
       
   470      * logical minimum and maximum.
       
   471      *
       
   472      * If the range is all positive then it is assumed that there is no
       
   473      * sign bit, otherwise twos complement format is assumed, as per
       
   474      * the HID class specification, v1.11, Section 6.2.2.7.
       
   475      *
       
   476      * @since S60 v5.0
       
   477      * @param aMin Logical minimum
       
   478      * @param aMax Logical maximum
       
   479      * @return The number of bits required to represent the range aMin
       
   480      *         to aMax (inclusive).
       
   481      */
       
   482     static TInt BitsToRepresentRange(TInt aMin, TInt aMax);
       
   483 
       
   484     /**
       
   485      * NumberOfLeadingZeros() is used by BitsToRepresentRange(). It
       
   486      * returns the number of leading zeros in the binary representation
       
   487      * of a number, effectively performing a log_2 operation.
       
   488      *
       
   489      * @since S60 v5.0
       
   490      * @param aValue Unsigned 32-bit value
       
   491      * @return Number of leading zeros in the binary representation of aValue
       
   492      */
       
   493     static TInt NumberOfLeadingZeros(TUint32 aValue);
       
   494 
       
   495     /**
       
   496      * IssueWarning() adds a TParserWarning to the warning list.
       
   497      *
       
   498      * @since S60 v5.0
       
   499      * @param aHidWarningCode The error or warning code, which should
       
   500      *                        be in the standard HID format.
       
   501      * @return None
       
   502      */
       
   503     void IssueWarning(TInt aHidWarningCode);
       
   504 
       
   505     /**
       
   506      * IsReservedUsagePage() checks if the given HID usage page is
       
   507      * listed as reserved according to the HID clas specification,
       
   508      * v1.11.
       
   509      *
       
   510      * @since S60 v5.0
       
   511      * @param aUsagePage The usage page to check.
       
   512      * @result ETrue if the usage page is listed as reserved.
       
   513      */
       
   514     static TBool IsReservedUsagePage(TInt aUsagePage);
       
   515 
       
   516 
       
   517     /**
       
   518      * HandleMainInputTagL
       
   519      *
       
   520      * @since S60 v5.0
       
   521      * @param aItem a Hid field item
       
   522      * @result error code
       
   523      */
       
   524     TInt HandleMainInputTagL(const TItem& aItem);
       
   525 
       
   526 
       
   527     /**
       
   528      * HandleMainOutputTag
       
   529      *
       
   530      * @since S60 v5.0
       
   531      * @param aItem a Hid field item
       
   532      * @result error code
       
   533      */
       
   534     TInt HandleMainOutputTagL(const TItem& aItem);
       
   535 
       
   536     /**
       
   537      * HandleMainFeature
       
   538      *
       
   539      * @since S60 v5.0
       
   540      * @param aItem a Hid field item
       
   541      * @result error code
       
   542      */
       
   543     TInt HandleMainFeatureL( const TItem& aItem );
       
   544 
       
   545     /**
       
   546      * HandleMainCollection
       
   547      *
       
   548      * @since S60 v5.0
       
   549      * @param aItem a Hid field item
       
   550      * @result error code
       
   551      */
       
   552     TInt HandleMainCollectionL( const TItem& aItem );
       
   553 
       
   554 
       
   555     /**
       
   556      * MainEndCollection
       
   557      *
       
   558      * @since S60 v5.0
       
   559      * @param aItem a Hid field item
       
   560      * @result error code
       
   561      */
       
   562     TInt HandleMainEndCollection( const TItem& aItem);
       
   563 
       
   564     /**
       
   565      * HandleGlobalReportId
       
   566      *
       
   567      * @since S60 v5.0
       
   568      * @param aItem a Hid field item
       
   569      * @result error code
       
   570      */
       
   571     TInt HandleGlobalReportId( const TItem& aItem );
       
   572 
       
   573     /**
       
   574      * HandleGlobalUsagePage
       
   575      *
       
   576      * @since S60 v5.0
       
   577      * @param aItem a Hid field item
       
   578      * @result error code
       
   579      */
       
   580     TInt HandleGlobalUsagePage( const TItem& aItem );
       
   581 
       
   582     /**
       
   583      * HandleGlobalLogicalMinimum
       
   584      *
       
   585      * @since S60 v5.0
       
   586      * @param aItem a Hid field item
       
   587      * @result error code
       
   588      */
       
   589     TInt HandleGlobalLogicalMinimum( const TItem& aItem );
       
   590 
       
   591     /**
       
   592      * HandleGlobalLogicalMaximum
       
   593      *
       
   594      * @since S60 ?S60_version *** for example, S60 v3.0
       
   595      * @param aItem a Hid field item
       
   596      * @result error code
       
   597      */
       
   598     TInt HandleGlobalLogicalMaximum( const TItem& aItem );
       
   599 
       
   600     /**
       
   601      * HandleGlobalPhysicalMinimum
       
   602      *
       
   603      * @since S60 v5.0
       
   604      * @param aItem a Hid field item
       
   605      * @result error code
       
   606      */
       
   607     TInt HandleGlobalPhysicalMinimum( const TItem& aItem );
       
   608 
       
   609     /**
       
   610      * HandleGlobalPhysicalMinimum
       
   611      *
       
   612      * @since S60 v5.0
       
   613      * @param aItem a Hid field item
       
   614      * @result error code
       
   615      */
       
   616     TInt HandleGlobalPhysicalMaximum( const TItem& aItem );
       
   617 
       
   618     /**
       
   619      * HandleGlobalUnit
       
   620      *
       
   621      * @since S60 v5.0
       
   622      * @param aItem a Hid field item
       
   623      * @result error code
       
   624      */
       
   625     TInt HandleGlobalUnit( const TItem& aItem );
       
   626 
       
   627     /**
       
   628      * HandleGlobalUnitExponent
       
   629      *
       
   630      * @since S60 v5.0
       
   631      * @param aItem a Hid field item
       
   632      * @result error code
       
   633      */
       
   634     TInt HandleGlobalUnitExponent( const TItem& aItem );
       
   635 
       
   636     /**
       
   637      * HandleGlobalReportSize
       
   638      *
       
   639      * @since S60 v5.0
       
   640      * @param aItem a Hid field item
       
   641      * @result error code
       
   642      */
       
   643     TInt HandleGlobalReportSize( const TItem& aItem );
       
   644 
       
   645     /**
       
   646      * HandleGlobalReportSize
       
   647      *
       
   648      * @since S60 v5.0
       
   649      * @param aItem a Hid field item
       
   650      * @result error code
       
   651      */
       
   652     TInt HandleGlobalReportCount( const TItem& aItem );
       
   653 
       
   654     /**
       
   655      * HandleGlobalPush
       
   656      *
       
   657      * @since S60 v5.0
       
   658      * @param aItem a Hid field item
       
   659      * @result error code
       
   660      */
       
   661     TInt HandleGlobalPushL( const TItem& aItem );
       
   662 
       
   663     /**
       
   664      * HandleGlobalPop
       
   665      *
       
   666      * @since S60 v5.0
       
   667      * @param aItem a Hid field item
       
   668      * @result error code
       
   669      */
       
   670     TInt HandleGlobalPop( const TItem& aItem );
       
   671 
       
   672     /**
       
   673      * HandleLocalUsage
       
   674      *
       
   675      * @since S60 v5.0
       
   676      * @param aItem a Hid field item
       
   677      * @result error code
       
   678      */
       
   679     TInt HandleLocalUsageL( const TItem& aItem );
       
   680 
       
   681     /**
       
   682      * HandleLocalUsageMinimum
       
   683      *
       
   684      * @since S60 v5.0
       
   685      * @param aItem a Hid field item
       
   686      * @result error code
       
   687      */
       
   688     TInt HandleLocalUsageMinimum( const TItem& aItem );
       
   689 
       
   690     /**
       
   691      * HandleLocalUsageMinimum
       
   692      *
       
   693      * @since S60 v5.0
       
   694      * @param aItem a Hid field item
       
   695      * @result error code
       
   696      */
       
   697     TInt HandleLocalUsageMaximum( const TItem& aItem );
       
   698 
       
   699     /**
       
   700      * HandleLocalDesignatorIndex
       
   701      *
       
   702      * @since S60 v5.0
       
   703      * @param aItem a Hid field item
       
   704      * @result error code
       
   705      */
       
   706     TInt HandleLocalDesignatorIndex( const TItem& aItem );
       
   707 
       
   708     /**
       
   709      * HandleLocalDesignatorMinimum
       
   710      *
       
   711      * @since S60 v5.0
       
   712      * @param aItem a Hid field item
       
   713      * @result error code
       
   714      */
       
   715     TInt HandleLocalDesignatorMinimum( const TItem& aItem );
       
   716 
       
   717     /**
       
   718      * HandleLocalDesignatorMaximum
       
   719      *
       
   720      * @since S60 v5.0
       
   721      * @param aItem a Hid field item
       
   722      * @result error code
       
   723      */
       
   724     TInt HandleLocalDesignatorMaximum( const TItem& aItem );
       
   725 
       
   726     /**
       
   727      * HandleLocalStringIndex
       
   728      *
       
   729      * @since S60 v5.0
       
   730      * @param aItem a Hid field item
       
   731      * @result error code
       
   732      */
       
   733     TInt HandleLocalStringIndex( const TItem& aItem );
       
   734 
       
   735     /**
       
   736      * HandleLocalStringMinimum
       
   737      *
       
   738      * @since S60 v5.0
       
   739      * @param aItem a Hid field item
       
   740      * @result error code
       
   741      */
       
   742     TInt HandleLocalStringMinimum( const TItem& aItem );
       
   743 
       
   744     /**
       
   745      * HandleLocalStringMaximum
       
   746      *
       
   747      * @since S60 v5.0
       
   748      * @param aItem a Hid field item
       
   749      * @result error code
       
   750      */
       
   751     TInt HandleLocalStringMaximum( const TItem& aItem );
       
   752 
       
   753     /**
       
   754      * HandleLocalDelimiter
       
   755      *
       
   756      * @since S60 v5.0
       
   757      * @param aItem a Hid field item
       
   758      * @result error code
       
   759      */
       
   760     TInt HandleLocalDelimiter( const TItem& aItem );
       
   761     
       
   762     /**
       
   763      * CheckMandatoryFieldError
       
   764      *
       
   765      * @since S60 v5.0
       
   766      * @param aType a field type
       
   767      * @param aAttributes attributes
       
   768      * @result error code
       
   769      */
       
   770     TInt CheckMandatoryFieldExistence( CField::TType aType, TUint32 aAttributes );
       
   771     
       
   772     /**
       
   773      * CheckUsageMinAndMaxErrors
       
   774      *
       
   775      * @since S60 v5.0     
       
   776      * @result error code
       
   777      */
       
   778     TInt CheckUsageMinAndMaxErrors();
       
   779     
       
   780     /**
       
   781      * CheckDesignatorMinAndMaxErrors
       
   782      *
       
   783      * @since S60 v5.0     
       
   784      * @result error code
       
   785      */
       
   786     TInt CheckDesignatorMinAndMaxErrors();
       
   787     
       
   788     /**
       
   789      * CheckStringMinAndMaxErrors
       
   790      *
       
   791      * @since S60 v5.0     
       
   792      * @result error code
       
   793      */
       
   794     TInt CheckStringMinAndMaxErrors();
       
   795     
       
   796     /**
       
   797      * CheckMandatoryFieldError
       
   798      *
       
   799      * @since S60 v5.0
       
   800      * @param aType a field type
       
   801      * @param aAttributes attributes
       
   802      * @result error code
       
   803      */
       
   804     TInt CheckMandatoryFieldErrors( CField::TType aType, TUint32 aAttributes );
       
   805     
       
   806     /**
       
   807      * CheckLogicalMinAndMax
       
   808      * Check if logical minimum and maximum must match the number of usage
       
   809      * values 
       
   810      *
       
   811      * @since S60 v5.0     
       
   812      * @param aAttributes attributes
       
   813      * @result error code
       
   814      */
       
   815     void CheckLogicalMinAndMax( TUint32 aAttributes );
       
   816     
       
   817     /**
       
   818      * CheckMandatoryFieldError
       
   819      *
       
   820      * @since S60 v5.0
       
   821      * @param aType a field type
       
   822      * @param aAttributes attributes
       
   823      * @result error code
       
   824      */
       
   825     void CheckFieldBitNeeded( CField::TType aType, TUint32 aAttributes );
       
   826     
       
   827     /**
       
   828      * HandleItem
       
   829      *
       
   830      * @since S60 v5.0     
       
   831      * @result error code
       
   832      */
       
   833     void HandleItemL(TItem& aItem);
       
   834     
       
   835     /**
       
   836      * CheckParseErrors
       
   837      *
       
   838      * @since S60 v5.0     
       
   839      * @result error code
       
   840      */
       
   841     void CheckParseErrors();
       
   842     
       
   843     /**
       
   844      * ResetParser
       
   845      *
       
   846      * @since S60 v5.0     
       
   847      * @result error code
       
   848      */
       
   849     void ResetParserL();
       
   850 
       
   851 private:
       
   852     /**
       
   853      * A bitmask containing the THidItem flags which represent local
       
   854      * (as opposed to main or global) items.
       
   855      */
       
   856     static const TUint32 KLocalItemMask;
       
   857     
       
   858     /**
       
   859      * A bitmask containing the THidItem flags which represent local
       
   860      * unused items.
       
   861      */
       
   862     static const TUint32 KUnusedLocalItemsMask;
       
   863     
       
   864     /**
       
   865      * A bitmask containing the THidItem flags which represent mandatory
       
   866      * items.
       
   867      */
       
   868     static const TUint32 KMandatoryItemMask;
       
   869     
       
   870     /**
       
   871      * A bitmask containing the THidItem flags which represent report
       
   872      * items.
       
   873      */
       
   874     static const TUint32 KReportItemMask;
       
   875 
       
   876 private:
       
   877 
       
   878     /**
       
   879      * THidItem defineds a set of flags used for keeping track of
       
   880      * which items have been encountered in the report descriptor for
       
   881      * the current report field. The flags are used with the
       
   882      * iItemsDefined and iGlobalItemsDefined data members.
       
   883      */
       
   884     enum THidItem
       
   885         {
       
   886         EUsagePage       = 1<<0,
       
   887         ELogicalMin      = 1<<1,
       
   888         ELogicalMax      = 1<<2,
       
   889         EReportSize      = 1<<3,
       
   890         EReportCount     = 1<<4,
       
   891         EReportId        = 1<<5,
       
   892         EUsageMin        = 1<<6,
       
   893         EUsageMax        = 1<<7,
       
   894         EPhysicalMin     = 1<<8,
       
   895         EPhysicalMax     = 1<<9,
       
   896         EUnit            = 1<<10,
       
   897         EUnitExponent    = 1<<11,
       
   898         EDesignatorIndex = 1<<12,
       
   899         EDesignatorMin   = 1<<13,
       
   900         EDesignatorMax   = 1<<14,
       
   901         EStringIndex     = 1<<15,
       
   902         EStringMin       = 1<<16,
       
   903         EStringMax       = 1<<17,
       
   904         EInputReport     = 1<<18,
       
   905         EOutputReport    = 1<<19,
       
   906         EFeatureReport   = 1<<20,
       
   907         EDelimiter       = 1<<21,
       
   908         EUsageId         = 1<<22
       
   909        };
       
   910 
       
   911     /**
       
   912      * HID local tags
       
   913      */
       
   914     enum THidLocalTags
       
   915         {
       
   916         ELocalUsage             = 0x00,
       
   917         ELocalUsageMinimum      = 0x01,
       
   918         ELocalUsageMaximum      = 0x02,
       
   919         ELocalDesignatorIndex   = 0x03,
       
   920         ELocalDesignatorMinimum = 0x04,
       
   921         ELocalDesignatorMaximum = 0x05,
       
   922         ELocalStringIndex       = 0x07,
       
   923         ELocalStringMinimum     = 0x08,
       
   924         ELocalStringMaximum     = 0x09,
       
   925         ELocalDelimiter         = 0x0a
       
   926         };
       
   927 
       
   928     /**
       
   929      *  HID global tags
       
   930      */
       
   931     enum THidGlobalTags
       
   932         {
       
   933         EGlobalUsagePage       = 0x00,
       
   934         EGlobalLogicalMinimum  = 0x01,
       
   935         EGlobalLogicalMaximum  = 0x02,
       
   936         EGlobalPhysicalMinimum = 0x03,
       
   937         EGlobalPhysicalMaximum = 0x04,
       
   938         EGlobalUnitExponent    = 0x05,
       
   939         EGlobalUnit            = 0x06,
       
   940         EGlobalReportSize      = 0x07,
       
   941         EGlobalReportId        = 0x08,
       
   942         EGlobalReportCount     = 0x09,
       
   943         EGlobalPush            = 0x0a,
       
   944         EGlobalPop             = 0x0b
       
   945         };
       
   946 
       
   947     /**
       
   948      * HID main tags
       
   949      */
       
   950     enum THidMainTags
       
   951         {
       
   952         EMainInput         = 0x08,
       
   953         EMainOutput        = 0x09,
       
   954         EMainFeature       = 0x0b,
       
   955         EMainCollection    = 0x0a,
       
   956         EMainEndCollection = 0x0c
       
   957         };
       
   958 
       
   959     /**
       
   960      * The local state, cleared after each "Main" item
       
   961      * Own.
       
   962      */
       
   963     CField* iLocal;
       
   964 
       
   965     /**
       
   966      * Current global state
       
   967      */
       
   968     TParserGlobalState iGlobal;
       
   969 
       
   970     /**
       
   971      * Global state stack, to allow HID descriptor PUSH and POP commands
       
   972      */
       
   973     RArray<TParserGlobalState> iGlobalStack;
       
   974 
       
   975     // For delimiter handling:
       
   976     //
       
   977     /**
       
   978      *  ETrue if currently within a delimiter pair
       
   979      */
       
   980     TBool iWithinDelimiter;
       
   981 
       
   982     /**
       
   983      *  Count of alternate USAGE declarations so far
       
   984      */
       
   985     TInt iAliasCount;
       
   986 
       
   987     /**
       
   988      *  Count of alternate USAGE_MIN declarations
       
   989      */
       
   990     TInt iAliasCountMin;
       
   991 
       
   992     /**
       
   993      *  Count of alternate USAGE_MAX declarations
       
   994      */
       
   995     TInt iAliasCountMax;
       
   996 
       
   997     /**
       
   998      * The root node of the collection tree
       
   999      * Own.
       
  1000      */
       
  1001     CReportRoot* iReportRoot;
       
  1002 
       
  1003     /**
       
  1004      * Stack used to create the collection tree
       
  1005      */
       
  1006     RPointerArray<CCollection> iCollectionStack;
       
  1007 
       
  1008     // Keep track of which items have been seen in the descriptor:
       
  1009     //
       
  1010     /**
       
  1011      * All items forming the current item state
       
  1012      */
       
  1013     TUint32 iItemsDefined;
       
  1014 
       
  1015     /**
       
  1016      * Global items seen since the last main tag
       
  1017      */
       
  1018     TUint32 iGlobalItemsDefined;
       
  1019 
       
  1020     /**
       
  1021      * ETrue if a redundant local item is seen
       
  1022      */
       
  1023     TBool iLocalMultipleUse;
       
  1024 
       
  1025     /**
       
  1026      * Number of the item we're currently processing
       
  1027      */
       
  1028     TInt iItemNumber;
       
  1029 
       
  1030     /**
       
  1031      * Record of any critical error encountered
       
  1032      */
       
  1033     TInt iErrorCode;
       
  1034     
       
  1035     /**
       
  1036      * Field count
       
  1037      */
       
  1038     TInt iFieldCount;
       
  1039     };
       
  1040 
       
  1041 #endif