khronosfws/openmax_al/src/mmf_adaptation/cmetadatautilityitf.h
changeset 25 6f7ceef7b1d1
parent 20 b67dd1fc57c5
child 33 5e8b14bae8c3
equal deleted inserted replaced
21:2ed61feeead6 25:6f7ceef7b1d1
       
     1 /*
       
     2  * Copyright (c) 2009 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: Metadata backend engine
       
    15  *
       
    16  */
       
    17 
     1 #ifndef CMETADATA_UTILITY_ITF_H
    18 #ifndef CMETADATA_UTILITY_ITF_H
     2 #define CMETADATA_UTILITY_ITF_H
    19 #define CMETADATA_UTILITY_ITF_H
     3 
       
     4 
    20 
     5 #ifdef __cplusplus
    21 #ifdef __cplusplus
     6 
    22 
     7 #include <e32base.h>
    23 #include <e32base.h>
     8 #include <e32std.h>
    24 #include <e32std.h>
    12 #include <hxmetadatautil.h>
    28 #include <hxmetadatautil.h>
    13 #include <MetaDataUtility.h>
    29 #include <MetaDataUtility.h>
    14 #include <MetaDataFieldContainer.h>
    30 #include <MetaDataFieldContainer.h>
    15 #include <MetaDataField.hrh>
    31 #include <MetaDataField.hrh>
    16 
    32 
    17 
       
    18 #define MAX_EXTENSION_SIZE 10
    33 #define MAX_EXTENSION_SIZE 10
    19 #define uint32 unsigned int
    34 #define uint32 unsigned int
    20 
    35 
    21 class CS60MetadataUtilityItf;
    36 class CS60MetadataUtilityItf;
    22 class CHXMetadataUtilityItf;
    37 class CHXMetadataUtilityItf;
    23 
    38 
    24 NONSHARABLE_CLASS(CMetadataUtilityItf)
    39 NONSHARABLE_CLASS(CMetadataUtilityItf)
    25 {
    40     {
    26 public:
    41 public:
    27 
    42 
    28 	enum TValueEncodingType
    43     enum TValueEncodingType
    29 	{
    44         {
    30 		EUnknownEncoding,
    45         EUnknownEncoding, EAsciiEncoding, EUnicodeEncoding, EBinaryEncoding,
    31 		EAsciiEncoding,
    46         };
    32 		EUnicodeEncoding,
       
    33 		EBinaryEncoding,	
       
    34 	};
       
    35 	
       
    36 	static CMetadataUtilityItf* New(char* uri);
       
    37 
    47 
    38 	CMetadataUtilityItf();
    48     static CMetadataUtilityItf* New(char* uri);
    39 	virtual ~CMetadataUtilityItf();
       
    40 	TInt ParseSource(char* uri);
       
    41 	TInt OpenSource(char* uri);	
       
    42 	TInt CalculateNumMetadataItems(TUint*);
       
    43 	char* GetKey(TInt index);
       
    44 	TInt GetValueSize(TInt index);
       
    45 	TInt GetValue(TInt index, char* data, TInt maxLength, TInt* outSize, TInt* encodingType);
       
    46 
    49 
    47 	//helper function
    50     CMetadataUtilityItf();
    48 	//extracts left part of input descriptor upto (maxLen-1) and copies content in outPtr
    51     virtual ~CMetadataUtilityItf();
    49 	//append a null terminator
    52     TInt ParseSource(char* uri);
    50 	static TInt ExtractUCS2(TDesC& inDes, char* outPtr,TInt maxLen);
    53     TInt OpenSource(char* uri);
       
    54     TInt CalculateNumMetadataItems(TUint*);
       
    55     char* GetKey(TInt index);
       
    56     TInt GetValueSize(TInt index);
       
    57     TInt GetValue(TInt index, char* data, TInt maxLength, TInt* outSize,
       
    58             TInt* encodingType);
       
    59 
       
    60     //helper function
       
    61     //extracts left part of input descriptor upto (maxLen-1) and copies content in outPtr
       
    62     //append a null terminator
       
    63     static TInt ExtractUCS2(TDesC& inDes, char* outPtr, TInt maxLen);
    51 
    64 
    52 private:
    65 private:
    53 	CS60MetadataUtilityItf* m_pS60Util;
    66     CS60MetadataUtilityItf* m_pS60Util;
    54 	CHXMetadataUtilityItf*  m_pHXUtil;
    67     CHXMetadataUtilityItf* m_pHXUtil;
    55 };
    68     };
    56 
       
    57 
    69 
    58 NONSHARABLE_CLASS(CS60MetadataUtilityItf)
    70 NONSHARABLE_CLASS(CS60MetadataUtilityItf)
    59 {
    71     {
    60 public:
    72 public:
    61 
    73 
    62 	static CS60MetadataUtilityItf* New();
    74     static CS60MetadataUtilityItf* New();
    63   	~CS60MetadataUtilityItf();
    75     ~CS60MetadataUtilityItf();
    64 
    76 
    65 	TInt CalculateNumMetadataItems(TUint*);
    77     TInt CalculateNumMetadataItems(TUint*);
    66 	
       
    67 	char* GetKey(TInt index);
       
    68 	TInt  GetValueSize(TInt index);
       
    69 	TInt  GetValue(TInt index, char* data, TInt maxLength, TInt* outSize, TInt* encodingType);
       
    70 
    78 
    71 	TInt 	ParseSource(TDesC&);
    79     char* GetKey(TInt index);
       
    80     TInt GetValueSize(TInt index);
       
    81     TInt GetValue(TInt index, char* data, TInt maxLength, TInt* outSize,
       
    82             TInt* encodingType);
    72 
    83 
    73 	char* KeyMapping(TMetaDataFieldId);
    84     TInt ParseSource(TDesC&);
    74 	TInt  ValueEncoding(TMetaDataFieldId);
       
    75 
    85 
    76 	static bool IsSupportedExtension(char* extn);
    86     char* KeyMapping(TMetaDataFieldId);
       
    87     TInt ValueEncoding(TMetaDataFieldId);
    77 
    88 
    78 	TInt Reset();
    89     static bool IsSupportedExtension(char* extn);
       
    90 
       
    91     TInt Reset();
    79 
    92 
    80 private:
    93 private:
    81 	
    94 
    82     CS60MetadataUtilityItf();
    95     CS60MetadataUtilityItf();
    83     void ConstructL();
    96     void ConstructL();
    84 	
    97 
    85    	CMetaDataUtility* pMetaDataUtility; //S60MetadataUtility
    98     CMetaDataUtility* pMetaDataUtility; //S60MetadataUtility
    86    	
    99 
    87 	TUint 		uNumMetadataItems;		
   100     TUint uNumMetadataItems;
    88 		
   101 
    89 };
   102     };
    90 
   103 
    91 NONSHARABLE_CLASS(CHXMetadataUtilityItf)
   104 NONSHARABLE_CLASS(CHXMetadataUtilityItf)
    92 {
   105     {
    93 public:
   106 public:
    94 
   107 
    95 	static CHXMetadataUtilityItf* New();
   108     static CHXMetadataUtilityItf* New();
    96   ~CHXMetadataUtilityItf();
   109     ~CHXMetadataUtilityItf();
    97 
   110 
    98 	TInt CalculateNumMetadataItems(TUint*);
   111     TInt CalculateNumMetadataItems(TUint*);
    99 	
   112 
   100 	char* GetKey(TInt index);
   113     char* GetKey(TInt index);
   101 	
   114 
   102 	TInt ValueEncoding(HXMetaDataKeys::EHXMetaDataId fldID);
   115     TInt ValueEncoding(HXMetaDataKeys::EHXMetaDataId fldID);
   103 	TInt  GetValueSize(TInt index);
   116     TInt GetValueSize(TInt index);
   104 	TInt  GetValue(TInt index, char* data, TInt maxLength, TInt* outSize, TInt* encodingType);
   117     TInt GetValue(TInt index, char* data, TInt maxLength, TInt* outSize,
   105 	
   118             TInt* encodingType);
   106 	TInt 	ParseSource(TDesC&);
   119 
   107 	char* KeyMapping(HXMetaDataKeys::EHXMetaDataId);
   120     TInt ParseSource(TDesC&);
   108 	
   121     char* KeyMapping(HXMetaDataKeys::EHXMetaDataId);
   109 	TInt Reset();
   122 
       
   123     TInt Reset();
   110 
   124 
   111 private:
   125 private:
   112 	CHXMetadataUtilityItf();
   126     CHXMetadataUtilityItf();
   113     void ConstructL();
   127     void ConstructL();
   114    	
       
   115   CHXMetaDataUtility *pHXMetaDataUtility;
       
   116   
       
   117   TUint 	  uNumMetadataItems;	  
       
   118 };
       
   119 
   128 
       
   129     CHXMetaDataUtility *pHXMetaDataUtility;
       
   130 
       
   131     TUint uNumMetadataItems;
       
   132     };
   120 
   133 
   121 #else
   134 #else
   122 
   135 
   123 extern void* mmf_metadata_utility_init(char*);
   136 extern void* mmf_metadata_utility_init(char*);
   124 extern void  mmf_metadata_utility_destroy(void* context);
   137 extern void mmf_metadata_utility_destroy(void* context);
   125 extern XAresult mmf_metadata_utility_parse_source(void* , char*);
   138 extern XAresult mmf_metadata_utility_parse_source(void* , char*);
   126 extern XAresult  mmf_get_item_count(void* context, XAuint32* itemCount);
   139 extern XAresult mmf_get_item_count(void* context, XAuint32* itemCount);
   127 extern XAresult  mmf_get_key_size(void* context, XAuint32 keyIndex, XAuint32* keySize);
   140 extern XAresult mmf_get_key_size(void* context, XAuint32 keyIndex, XAuint32* keySize);
   128 extern XAresult  mmf_get_key(void* context, XAuint32 index,XAuint32 keySize, XAMetadataInfo *pKey);
   141 extern XAresult mmf_get_key(void* context, XAuint32 index,XAuint32 keySize, XAMetadataInfo *pKey);
   129 extern XAresult  mmf_get_value_size(void* context, XAuint32 index, XAuint32 *pValueSize);
   142 extern XAresult mmf_get_value_size(void* context, XAuint32 index, XAuint32 *pValueSize);
   130 extern XAresult  mmf_get_value(void* context, XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue);
   143 extern XAresult mmf_get_value(void* context, XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue);
   131 #endif //__cplusplus
   144 #endif //__cplusplus
   132 
       
   133 #endif
   145 #endif