--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/mmf_adaptation/cmetadatautilityitf.cpp Tue Aug 31 15:43:02 2010 +0300
@@ -0,0 +1,1029 @@
+/*
+ * Copyright (c) 2009 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: Metadata backend engine
+ *
+ */
+
+#include <string.h>
+#include <ctype.h>
+#include <uri8.h>
+#include "cmetadatautilityitf.h"
+#include "profileutilmacro.h"
+
+CMetadataUtilityItf::CMetadataUtilityItf() :
+ m_pS60Util(NULL), m_pHXUtil(NULL)
+ {
+ }
+
+CMetadataUtilityItf::~CMetadataUtilityItf()
+ {
+ if (m_pS60Util)
+ {
+ delete m_pS60Util;
+ }
+
+ if (m_pHXUtil)
+ {
+ delete m_pHXUtil;
+ }
+ }
+
+CMetadataUtilityItf* CMetadataUtilityItf::New(char* uri)
+ {
+ CMetadataUtilityItf* p_mdutilitf = new CMetadataUtilityItf;
+
+ p_mdutilitf->ParseSource(uri); //ignore error
+
+ return p_mdutilitf;
+ }
+
+TInt CMetadataUtilityItf::OpenSource(char* pOrigUri)
+ {
+ //Make a local copy for uri
+ if (!pOrigUri)
+ return XA_RESULT_PARAMETER_INVALID;
+
+ int uriLen = strlen(pOrigUri);
+ char* uri = new char[uriLen + 1];
+ if (!uri)
+ {
+ return XA_RESULT_MEMORY_FAILURE;
+ }
+ strncpy(uri, pOrigUri, uriLen);
+ uri[uriLen] = '\0';
+ ////////////////////////////////////////////
+ _LIT8(KFileSlash,"file:///");
+ TInt fileslashlen = KFileSlash().Length();
+
+ TPtr8 fileuri((TUint8*) uri, strlen(uri), strlen(uri));
+ TPtr8 filepath = fileuri.RightTPtr(strlen(uri) - fileslashlen);
+
+ TInt pos = filepath.LocateReverse(':');
+ if (pos != KErrNotFound)
+ {
+ fileuri.Delete(fileslashlen + pos, 1);
+ }
+
+ TUriParser8 localfileUri;
+ TInt ret = localfileUri.Parse(fileuri);
+ if (ret == KErrNone)
+ {
+ HBufC* file = NULL;
+ TRAP(ret,file = localfileUri.GetFileNameL());
+ if (ret == KErrNone)
+ {
+ if (m_pS60Util)
+ {
+ ret = m_pS60Util->ParseSource(*file);
+ }
+ else if (m_pHXUtil)
+ {
+ ret = m_pHXUtil->ParseSource(*file);
+ }
+ else
+ {
+ ret = KErrNotFound;
+ }
+ }
+
+ delete file;
+ }
+
+ if (uri)
+ {
+ delete[] uri;
+ }
+
+ if (ret != KErrNone)
+ {
+ //delete the utilities
+ if (m_pS60Util)
+ {
+ delete m_pS60Util;
+ m_pS60Util = NULL;
+ }
+
+ if (m_pHXUtil)
+ {
+ delete m_pHXUtil;
+ m_pHXUtil = NULL;
+ }
+
+ }
+ return ret;
+ }
+
+TInt CMetadataUtilityItf::ExtractUCS2(TDesC& inDes, char* outPtr, TInt maxLen)
+ {
+ TPtrC tempPtr = inDes.Left((maxLen / 2) - 1); //save last one for null terminator
+ TInt outLen = tempPtr.Length() + 1;
+
+ TPtr16 outDes((unsigned short*) outPtr, outLen);
+ outDes.Copy(tempPtr);
+ outDes.ZeroTerminate();
+
+ return outLen * 2; //return size
+ }
+
+TInt CMetadataUtilityItf::CalculateNumMetadataItems(TUint*numItems)
+ {
+ *numItems = 0;
+
+ if (m_pS60Util)
+ {
+ return m_pS60Util->CalculateNumMetadataItems(numItems);
+ }
+ else if (m_pHXUtil)
+ {
+ return m_pHXUtil->CalculateNumMetadataItems(numItems);
+ }
+
+ return KErrNone;
+ }
+
+char* CMetadataUtilityItf::GetKey(TInt index)
+ {
+ if (m_pS60Util)
+ {
+ return m_pS60Util->GetKey(index);
+ }
+ else if (m_pHXUtil)
+ {
+ return m_pHXUtil->GetKey(index);
+ }
+
+ return NULL;
+ }
+
+TInt CMetadataUtilityItf::GetValueSize(TInt index)
+ {
+ if (m_pS60Util)
+ {
+ return m_pS60Util->GetValueSize(index);
+ }
+ else if (m_pHXUtil)
+ {
+ return m_pHXUtil->GetValueSize(index);
+ }
+
+ return 0;
+ }
+
+TInt CMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength,
+ TInt* outSize, TInt* encodingType)
+ {
+ if (m_pS60Util)
+ {
+ return m_pS60Util->GetValue(index, data, maxLength, outSize,
+ encodingType);
+ }
+ else if (m_pHXUtil)
+ {
+ return m_pHXUtil->GetValue(index, data, maxLength, outSize,
+ encodingType);
+ }
+
+ return 0;
+ }
+
+TInt CMetadataUtilityItf::ParseSource(char* uri)
+ {
+ char* tempPtr = NULL;
+ char extension[MAX_EXTENSION_SIZE] =
+ {
+ 0
+ };
+
+ tempPtr = strchr(uri, (int) '.');
+ strncpy(extension, tempPtr, sizeof(tempPtr));
+
+ for (unsigned int i = 0; i < sizeof(extension); i++)
+ {
+ extension[i] = tolower(extension[i]);
+ }
+
+ //if s60 util in use
+ if (m_pS60Util)
+ {
+ //reset existing instace
+ TInt ret = m_pS60Util->Reset();
+ if (!CS60MetadataUtilityItf::IsSupportedExtension(extension))
+ {
+ delete m_pS60Util;
+ m_pS60Util = NULL;
+ }
+ }
+
+ if (m_pHXUtil)
+ {
+ //reset existing instace
+ TInt ret = m_pHXUtil->Reset();
+ if (CS60MetadataUtilityItf::IsSupportedExtension(extension))
+ {
+ delete m_pHXUtil;
+ m_pHXUtil = NULL;
+ }
+ }
+
+ if (!m_pS60Util && !m_pHXUtil)
+ {
+
+ if (CS60MetadataUtilityItf::IsSupportedExtension(extension))
+ {
+ m_pS60Util = CS60MetadataUtilityItf::New();
+ }
+ else
+ {
+ m_pHXUtil = CHXMetadataUtilityItf::New();
+ }
+ }
+
+ return OpenSource(uri);
+ }
+
+bool CS60MetadataUtilityItf::IsSupportedExtension(char *extn)
+ {
+ if ((!strcasecmp(extn, ".mp3")) || (!strcasecmp(extn, ".wma"))
+ || (!strcasecmp(extn, ".aac")) || (!strcasecmp(extn, ".wav"))
+ || (!strcasecmp(extn, ".m4a")))
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+CS60MetadataUtilityItf* CS60MetadataUtilityItf::New()
+ {
+ CS60MetadataUtilityItf* self = new CS60MetadataUtilityItf();
+
+ TInt err = KErrGeneral;
+ TRAP(err, self->ConstructL());
+
+ if (err == KErrNone)
+ {
+ return self;
+ }
+
+ delete self;
+ return NULL;
+ }
+
+CS60MetadataUtilityItf::CS60MetadataUtilityItf() :
+ pMetaDataUtility(NULL)
+ {
+ }
+
+void CS60MetadataUtilityItf::ConstructL()
+ {
+ TAG_TIME_PROFILING_BEGIN;
+ pMetaDataUtility = CMetaDataUtility::NewL();
+ TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;
+ }
+
+CS60MetadataUtilityItf::~CS60MetadataUtilityItf()
+ {
+ if (pMetaDataUtility)
+ {
+ TInt err = KErrGeneral;
+
+ TAG_TIME_PROFILING_BEGIN;
+ TRAP(err, pMetaDataUtility->ResetL());
+ delete pMetaDataUtility;
+ TAG_TIME_PROFILING_END; PRINT_TO_CONSOLE_TIME_DIFF;
+ }
+
+ pMetaDataUtility = NULL;
+ }
+
+TInt CS60MetadataUtilityItf::ParseSource(TDesC& fileName)
+ {
+ TInt err = KErrGeneral;
+
+ if (pMetaDataUtility)
+ {
+
+ TAG_TIME_PROFILING_BEGIN;
+ //open with the file handle
+ TRAP(err, pMetaDataUtility->OpenFileL(fileName));
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+
+ if (err == KErrNone)
+ {
+ uNumMetadataItems = pMetaDataUtility->MetaDataCount();
+ }
+ }
+
+ return err;
+ }
+
+TInt CS60MetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)
+ {
+ TInt err = KErrGeneral;
+
+ if (pMetaDataUtility && numItems)
+ {
+ *numItems = uNumMetadataItems;
+ err = KErrNone;
+ }
+
+ return err;
+ }
+
+char* CS60MetadataUtilityItf::KeyMapping(TMetaDataFieldId fldID)
+ {
+ switch (fldID)
+ {
+
+ case EMetaDataSongTitle:
+ {
+ return "KhronosTitle";
+ }
+ case EMetaDataArtist:
+ {
+ return "KhronosArtist";
+ }
+ case EMetaDataAlbum:
+ {
+ return "KhronosAlbum";
+ }
+ case EMetaDataYear:
+ {
+ return "KhronosYear";
+ }
+ case EMetaDataComment:
+ {
+ return "KhronosComment";
+ }
+ case EMetaDataAlbumTrack:
+ {
+ return "KhronosTrackNumber";
+ }
+ case EMetaDataGenre:
+ {
+ return "KhronosGenre";
+ }
+ case EMetaDataComposer:
+ {
+ return "Composer"; //Non Standard
+ }
+ case EMetaDataCopyright:
+ {
+ return "KhronosCopyright";
+ }
+ case EMetaDataOriginalArtist:
+ {
+ return "Original Artist"; //Non Standard
+ }
+ case EMetaDataUserUrl:
+ case EMetaDataUrl:
+ {
+ return "KhronosContentURL";
+ }
+ case EMetaDataJpeg:
+ {
+ return "attachedpicture";//"KhronosAlbumArtJPEG";
+ }
+ case EMetaDataVendor:
+ {
+ return "Vendor"; //Non Standard
+ }
+ case EMetaDataRating:
+ {
+ return "KhronosRating";
+ }
+ case EMetaDataDuration:
+ {
+ return "Duration"; //Non Standard
+ }
+ default:
+ {
+ }
+ }
+
+ return "UnSupported";
+ }
+
+TInt CS60MetadataUtilityItf::ValueEncoding(TMetaDataFieldId fldID)
+ {
+ switch (fldID)
+ {
+ case EMetaDataJpeg:
+ {
+ return CMetadataUtilityItf::EBinaryEncoding;
+ }
+
+ case EMetaDataSongTitle:
+ case EMetaDataArtist:
+ case EMetaDataAlbum:
+ case EMetaDataYear:
+ case EMetaDataComment:
+ case EMetaDataAlbumTrack:
+ case EMetaDataGenre:
+ case EMetaDataComposer:
+ case EMetaDataCopyright:
+ case EMetaDataOriginalArtist:
+ case EMetaDataUserUrl:
+ case EMetaDataUrl:
+ case EMetaDataVendor:
+ case EMetaDataRating:
+ case EMetaDataDuration:
+ default:
+ {
+ return CMetadataUtilityItf::EUnicodeEncoding;
+ }
+ }
+
+ }
+char* CS60MetadataUtilityItf::GetKey(TInt index)
+ {
+
+ if (pMetaDataUtility && index < uNumMetadataItems)
+ {
+
+ TMetaDataFieldId fieldId;
+
+ TAG_TIME_PROFILING_BEGIN;
+ TInt err = KErrGeneral;
+ TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+
+ if ((err == KErrNone) && (fieldId != EUnknownMetaDataField))
+ {
+ return KeyMapping(fieldId);
+ }
+ }
+ return NULL;
+ }
+
+TInt CS60MetadataUtilityItf::GetValueSize(TInt index)
+ {
+ if (pMetaDataUtility && index < uNumMetadataItems)
+ {
+
+ TMetaDataFieldId fieldId;
+ TInt err = KErrGeneral;
+ TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
+
+ if ((err == KErrNone) && (fieldId != EUnknownMetaDataField))
+ {
+ const CMetaDataFieldContainer* iContainer = NULL;
+ TRAP(err, iContainer = &pMetaDataUtility->MetaDataFieldsL());
+ if (err == KErrNone)
+ {
+ if (ValueEncoding(fieldId)
+ == CMetadataUtilityItf::EUnicodeEncoding)
+ {
+ TPtrC field = iContainer->Field(fieldId);
+ if (field != KNullDesC)
+ {
+ return field.Size() + 2; //additional character (two bytes) for null terminator
+ }
+ }
+ else //Binary
+ {
+ TPtrC8 field8 = iContainer->Field8(fieldId);
+ if (field8 != KNullDesC8)
+ {
+ return field8.Size();
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+ }
+
+TInt CS60MetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, //in params
+ TInt* outSize, TInt* encodingType) //out params
+ {
+
+ TInt retValueSize = 0;
+ *encodingType = CMetadataUtilityItf::EUnknownEncoding;
+
+ if (pMetaDataUtility && index < uNumMetadataItems)
+ {
+
+ TMetaDataFieldId fieldId;
+ TInt err = KErrGeneral;
+ TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));
+
+ if ((err == KErrNone) && (fieldId != EUnknownMetaDataField))
+ {
+
+ const CMetaDataFieldContainer* iContainer = NULL;
+ TRAP(err, iContainer = &pMetaDataUtility->MetaDataFieldsL());
+ if (err == KErrNone)
+ {
+ *encodingType = ValueEncoding(fieldId);
+ if (*encodingType == CMetadataUtilityItf::EUnicodeEncoding)
+ {
+
+ TAG_TIME_PROFILING_BEGIN;
+ TPtrC field = iContainer->Field(fieldId);
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+ if (field != KNullDesC)
+ {
+ *outSize = CMetadataUtilityItf::ExtractUCS2(field,
+ data, maxLength);
+ retValueSize = field.Size() + 2; //actual size
+ }
+ }
+ else //Binary
+ {
+
+ TAG_TIME_PROFILING_BEGIN;
+ TPtrC8 field8 = iContainer->Field8(fieldId);
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+ if (field8 != KNullDesC8)
+ {
+ *outSize
+ = (maxLength > field8.Size())
+ ? field8.Size()
+ : maxLength;
+ memcpy(data, field8.Ptr(), *outSize);
+ retValueSize = field8.Size();
+ }
+ }
+ }
+ }
+ }
+
+ return retValueSize;
+ }
+
+TInt CS60MetadataUtilityItf::Reset()
+ {
+ TInt err = KErrNone;
+ if (pMetaDataUtility)
+ {
+ TRAP(err, pMetaDataUtility->ResetL());
+ }
+
+ return err;
+ }
+
+CHXMetadataUtilityItf::CHXMetadataUtilityItf() :
+ pHXMetaDataUtility(NULL)
+ {
+ }
+
+void CHXMetadataUtilityItf::ConstructL()
+ {
+ TAG_TIME_PROFILING_BEGIN;
+ pHXMetaDataUtility = CHXMetaDataUtility::NewL();
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+ }
+
+CHXMetadataUtilityItf* CHXMetadataUtilityItf::New()
+ {
+ CHXMetadataUtilityItf* self = new CHXMetadataUtilityItf();
+
+ if (self)
+ {
+ TInt err = KErrGeneral;
+ TRAP(err, self->ConstructL());
+
+ if (err != KErrNone)
+ {
+ delete self;
+ self = NULL;
+ }
+ }
+
+ return self;
+ }
+
+CHXMetadataUtilityItf::~CHXMetadataUtilityItf()
+ {
+ if (pHXMetaDataUtility)
+ {
+ TInt err = KErrGeneral;
+
+ TAG_TIME_PROFILING_BEGIN;
+ TRAP(err, pHXMetaDataUtility->ResetL());
+ delete pHXMetaDataUtility;
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+ }
+
+ pHXMetaDataUtility = NULL;
+ }
+
+TInt CHXMetadataUtilityItf::Reset()
+ {
+ TInt err = KErrNone;
+ if (pHXMetaDataUtility)
+ {
+ TRAP(err, pHXMetaDataUtility->ResetL());
+ }
+
+ return err;
+ }
+
+TInt CHXMetadataUtilityItf::ParseSource(TDesC& fileName)
+ {
+ TInt err = KErrGeneral;
+
+ if (pHXMetaDataUtility)
+ {
+ //open with the file handle
+ TAG_TIME_PROFILING_BEGIN;
+ TRAP(err, pHXMetaDataUtility->OpenFileL(fileName));
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+
+ if (err == KErrNone)
+ {
+ return pHXMetaDataUtility->GetMetaDataCount(uNumMetadataItems);
+ }
+ }
+
+ return err;
+ }
+
+TInt CHXMetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)
+ {
+ TInt err = KErrGeneral;
+
+ if (pHXMetaDataUtility && numItems)
+ {
+ *numItems = uNumMetadataItems;
+ err = KErrNone;
+ }
+
+ return err;
+ }
+
+char* CHXMetadataUtilityItf::KeyMapping(HXMetaDataKeys::EHXMetaDataId fldID)
+ {
+
+ switch (fldID)
+ {
+
+ case HXMetaDataKeys::EHXTitle:
+ {
+ return "KhronosTitle";
+ }
+ case HXMetaDataKeys::EHXPerformer:
+ {
+ return "KhronosArtist";
+ }
+ case HXMetaDataKeys::EHXDescription:
+ {
+ return "KhronosComment";
+ }
+ case HXMetaDataKeys::EHXGenre:
+ {
+ return "KhronosGenre";
+ }
+ case HXMetaDataKeys::EHXAuthor:
+ {
+ return "Composer"; //Non Standard
+ }
+ case HXMetaDataKeys::EHXCopyright:
+ {
+ return "KhronosCopyright";
+ }
+ case HXMetaDataKeys::EHXContentURI:
+ {
+ return "KhronosContentURL";
+ }
+ case HXMetaDataKeys::EHXDuration:
+ {
+ return "Duration"; //Non Standard
+ }
+ case HXMetaDataKeys::EHXClipBitRate:
+ {
+ return "ClipBitRate"; //non-standard
+ }
+ case HXMetaDataKeys::EHXVideoBitRate:
+ {
+ return "VideoBitRate"; // non-standard
+ }
+ case HXMetaDataKeys::EHXAudioBitRate:
+ {
+ return "AudioBitRate";
+ }
+ case HXMetaDataKeys::EHXCodec:
+ {
+ return "Codec";
+ }
+ case HXMetaDataKeys::EHXFrameSize:
+ {
+ return "Resolution";
+ }
+ case HXMetaDataKeys::EHXFramesPerSecond:
+ {
+ return "FrameRate";
+ }
+ case HXMetaDataKeys::EHXStreamCount:
+ {
+ return "Stream Count";
+ }
+ case HXMetaDataKeys::EHXLiveStream:
+ {
+ return "Live Stream";
+ }
+ case HXMetaDataKeys::EHXSeekable:
+ {
+ return "Seekable";
+ }
+ case HXMetaDataKeys::EHXContentType:
+ {
+ return "Content Type";
+ }
+ case HXMetaDataKeys::EHXFormat:
+ {
+ return "Format";
+ }
+ case HXMetaDataKeys::EHXQuality:
+ {
+ return "Quality";
+ }
+ case HXMetaDataKeys::EHXAbstract:
+ {
+ return "Abstract";
+ }
+ case HXMetaDataKeys::EHXMimeType:
+ {
+ return "MimeType";
+ }
+ case HXMetaDataKeys::EHXIconURI:
+ {
+ return "Icon URI";
+ }
+ case HXMetaDataKeys::EHXEPreviewURI:
+ {
+ return "Preview URI";
+ }
+ case HXMetaDataKeys::EHXContentID:
+ {
+ return "Content ID";
+ }
+ case HXMetaDataKeys::EHXInfoURL:
+ {
+ return "Info URL";
+ }
+ default:
+ {
+ }
+ }
+
+ return "UnSupported";
+ }
+
+TInt CHXMetadataUtilityItf::ValueEncoding(HXMetaDataKeys::EHXMetaDataId fldID)
+ {
+ switch (fldID)
+ {
+ default:
+ {
+ return CMetadataUtilityItf::EUnicodeEncoding;
+ }
+ }
+
+ }
+char* CHXMetadataUtilityItf::GetKey(TInt index)
+ {
+
+ if (pHXMetaDataUtility && index < uNumMetadataItems)
+ {
+ HXMetaDataKeys::EHXMetaDataId id;
+ HBufC* pDes;
+
+ TAG_TIME_PROFILING_BEGIN;
+ TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes);
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+
+ if (err == KErrNone)
+ {
+ return KeyMapping(id);
+ }
+ }
+ return NULL;
+ }
+
+TInt CHXMetadataUtilityItf::GetValueSize(TInt index)
+ {
+ if (pHXMetaDataUtility && index < uNumMetadataItems)
+ {
+ HXMetaDataKeys::EHXMetaDataId id;
+ HBufC* pDes;
+
+ TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes);
+
+ if (err == KErrNone)
+ {
+ if (ValueEncoding(id) == CMetadataUtilityItf::EUnicodeEncoding)
+ {
+ return pDes->Size() + 2; //additional character (two bytes) for null terminator
+ }
+ else //Binary
+ {
+ //no support
+ }
+ }
+ }
+
+ return 0;
+ }
+
+TInt CHXMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, //in params
+ TInt* outSize, TInt* encodingType) //out params
+ {
+
+ TInt retValueSize = 0;
+ *encodingType = CMetadataUtilityItf::EUnknownEncoding;
+
+ if (pHXMetaDataUtility && index < uNumMetadataItems)
+ {
+ HXMetaDataKeys::EHXMetaDataId id;
+ HBufC* pDes;
+
+ TAG_TIME_PROFILING_BEGIN;
+ TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes);
+ TAG_TIME_PROFILING_END;
+ PRINT_TO_CONSOLE_TIME_DIFF;
+
+ *encodingType = ValueEncoding(id);
+
+ if (err == KErrNone)
+ {
+ if (*encodingType == CMetadataUtilityItf::EUnicodeEncoding)
+ {
+ *outSize = CMetadataUtilityItf::ExtractUCS2(*pDes, data,
+ maxLength);
+ retValueSize = pDes->Size() + 2; //actual Size
+ }
+ else //Binary
+ {
+ //no support
+ }
+ }
+ }
+
+ return retValueSize;
+ }
+
+extern "C"
+ {
+
+ void* mmf_metadata_utility_init(char* uri)
+ {
+ return CMetadataUtilityItf::New(uri);
+ }
+
+ void mmf_metadata_utility_destroy(void* context)
+ {
+ delete ((CMetadataUtilityItf*) context);
+ }
+
+ XAresult mmf_metadata_utility_parse_source(void* context, char* uri)
+ {
+ TInt err = ((CMetadataUtilityItf*) context)->ParseSource(uri);
+
+ if (err == KErrNone)
+ {
+ return XA_RESULT_SUCCESS;
+ }
+
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ XAresult mmf_get_item_count(void* context, XAuint32* itemCount)
+ {
+ if (itemCount)
+ {
+ TInt err =((CMetadataUtilityItf*) (context))->CalculateNumMetadataItems(
+ (TUint *) itemCount);
+ if (err == KErrNone)
+ {
+ return XA_RESULT_SUCCESS;
+ }
+ }
+
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ XAresult mmf_get_key_size(void* context, XAuint32 keyIndex,
+ XAuint32* keySize)
+ {
+ char* key = ((CMetadataUtilityItf*) (context))->GetKey(keyIndex);
+ if (key && keySize)
+ {
+ *keySize = (strlen(key) + sizeof(XAMetadataInfo));
+
+ return XA_RESULT_SUCCESS;
+ }
+
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ XAresult mmf_get_key(void* context, XAuint32 index, XAuint32 keySize,
+ XAMetadataInfo *pKey)
+ {
+ XAresult ret = XA_RESULT_PARAMETER_INVALID;
+
+ TInt keyDataSize = keySize - sizeof(XAMetadataInfo) + 1;
+ char* ascKey = ((CMetadataUtilityItf*) (context))->GetKey(index);
+
+ if (ascKey && keyDataSize)
+ {
+ TInt ascKeySize = strlen(ascKey);
+ TInt outSize = (ascKeySize >= keyDataSize)
+ ? (keyDataSize - 1)
+ : ascKeySize;
+
+ pKey->size = outSize + 1;
+ pKey->encoding = XA_CHARACTERENCODING_ASCII;
+ strcpy((char *) (pKey->langCountry), "en-us");
+ strncpy((char *) (pKey->data), ascKey, outSize);
+ pKey->data[outSize] = '\0';
+
+ if (ascKeySize >= keyDataSize)
+ {
+ ret = XA_RESULT_BUFFER_INSUFFICIENT;
+ }
+ else
+ {
+ ret = XA_RESULT_SUCCESS;
+ }
+ }
+
+ ret = XA_RESULT_SUCCESS;
+ return ret;
+ }
+
+ XAresult mmf_get_value_size(void* context, XAuint32 index,
+ XAuint32 *pValueSize)
+ {
+ if (pValueSize)
+ {
+ *pValueSize = ((CMetadataUtilityItf*) (context))->GetValueSize(
+ index) + sizeof(XAMetadataInfo) - 1;
+ //XAMetadataInfo already includes one byte for Data
+
+ return XA_RESULT_SUCCESS;
+ }
+
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ XAresult mmf_get_value(void* context, XAuint32 index, XAuint32 valueSize,
+ XAMetadataInfo *pValue)
+ {
+ XAresult ret = XA_RESULT_PARAMETER_INVALID;
+ TInt dataSize = valueSize - sizeof(XAMetadataInfo) + 1;
+ TInt outLen = 0, encodingType = CMetadataUtilityItf::EUnknownEncoding;
+
+ if (dataSize > 0)
+ {
+
+ TInt actualDataSize =
+ ((CMetadataUtilityItf*) (context))->GetValue(index,
+ (char*) pValue->data, dataSize, &outLen,
+ &encodingType);
+
+ pValue->size = outLen;
+ pValue->encoding
+ = (encodingType == CMetadataUtilityItf::EUnicodeEncoding)
+ ? XA_CHARACTERENCODING_UTF16LE : XA_CHARACTERENCODING_BINARY;
+ strcpy((char *) (pValue->langCountry), "en-us");
+
+ if (!actualDataSize)
+ {
+ return XA_RESULT_INTERNAL_ERROR;
+ }
+ if (actualDataSize > dataSize)
+ {
+ ret = XA_RESULT_BUFFER_INSUFFICIENT;
+ }
+ else
+ {
+ ret = XA_RESULT_SUCCESS;
+ }
+ }
+
+ return ret;
+ }
+ }
+