1 #include "cmetadatautilityitf.h"

     2 #include <OpenMAXAL.h>

     3 #include <string.h>

     4 #include <ctype.h>

     5 #include <uri8.h>

     6 #include "profileutilmacro.h"

     7 

     8 CMetadataUtilityItf::CMetadataUtilityItf():m_pS60Util(NULL), m_pHXUtil(NULL)

     9 {

    10 }

    11 

    12 CMetadataUtilityItf::~CMetadataUtilityItf()

    13 {

    14 	if(m_pS60Util)

    15 	{

    16 		delete m_pS60Util;

    17 	}

    18 

    19 	if(m_pHXUtil)

    20 	{

    21 		delete m_pHXUtil;

    22 	}

    23 }

    24 

    25 

    26 CMetadataUtilityItf* CMetadataUtilityItf::New(char* uri)

    27 {

    28 	CMetadataUtilityItf* p_mdutilitf = new CMetadataUtilityItf;

    29 	

    30 	TInt ret = p_mdutilitf->ParseSource(uri);

    31 

    32 	if(ret == KErrNone)

    33 	{

    34 		return p_mdutilitf; 

    35 	}

    36 

    37 	delete p_mdutilitf;

    38 	return NULL;

    39 }

    40 

    41 TInt CMetadataUtilityItf::OpenSource(char* pOrigUri)

    42 {

    43     //Make a local copy for uri

    44     if ( !pOrigUri )

    45         return XA_RESULT_PARAMETER_INVALID;

    46     

    47     int uriLen = strlen(pOrigUri);

    48     char* uri = new char[uriLen+1];

    49     if (! uri )

    50         {

    51         return XA_RESULT_MEMORY_FAILURE;

    52         }

    53     strncpy(uri, pOrigUri, uriLen);

    54     uri[uriLen] = '\0';

    55     ////////////////////////////////////////////

    56 

    57     _LIT8(KFileSlash,"file:///");

    58     TInt fileslashlen = KFileSlash().Length();

    59 

    60     TPtr8 fileuri((TUint8*)uri, strlen(uri),strlen(uri));

    61     TPtr8 filepath = fileuri.RightTPtr(strlen(uri)-fileslashlen);

    62  

    63     TInt pos = filepath.LocateReverse(':');

    64     if(pos != KErrNotFound)

    65     {

    66         fileuri.Delete(fileslashlen+pos,1);

    67     }

    68 

    69     TUriParser8 localfileUri;

    70     TInt ret = localfileUri.Parse(fileuri);

    71     if(ret == KErrNone)

    72     {    

    73         HBufC* file = NULL;

    74         TRAP(ret,file = localfileUri.GetFileNameL());  

    75         if(ret == KErrNone)

    76         {

    77         	if(m_pS60Util)

    78         	{

    79             	ret = m_pS60Util->ParseSource(*file);

    80         	}

    81 			else if(m_pHXUtil)

    82 			{

    83 				ret = m_pHXUtil->ParseSource(*file);

    84 			}

    85 			else

    86 			{

    87 				ret = KErrNotFound;

    88 			}

    89         }

    90         

    91         delete file;

    92     }

    93     

    94     if(uri)

    95     {

    96         delete []uri;

    97     }

    98     

    99 	return ret;

   100 }

   101 

   102 TInt CMetadataUtilityItf::ExtractUCS2(TDesC& inDes, char* outPtr,TInt maxLen)

   103 {

   104 	TPtrC tempPtr = inDes.Left((maxLen/2)-1); //save last one for null terminator

   105 	TInt outLen = tempPtr.Length() + 1;

   106 	

   107 	TPtr16 outDes((unsigned short*)outPtr, outLen);

   108 	outDes.Copy(tempPtr);

   109 	outDes.ZeroTerminate();

   110 

   111 	return outLen * 2; //return size

   112 }

   113 

   114 TInt CMetadataUtilityItf::CalculateNumMetadataItems(TUint*numItems)

   115 {

   116 	if(m_pS60Util)

   117 	{

   118 		return m_pS60Util->CalculateNumMetadataItems(numItems);

   119 	}

   120 	else

   121 	{

   122 		return m_pHXUtil->CalculateNumMetadataItems(numItems);

   123 	}

   124 }

   125 

   126 char* CMetadataUtilityItf::GetKey(TInt index)

   127 {

   128 	if(m_pS60Util)

   129 	{

   130 		return m_pS60Util->GetKey(index);

   131 	}

   132 	else

   133 	{

   134 		return m_pHXUtil->GetKey(index);

   135 	}

   136 }

   137 

   138 TInt CMetadataUtilityItf::GetValueSize(TInt index)

   139 {

   140 	if(m_pS60Util)

   141 	{

   142 		return m_pS60Util->GetValueSize(index);

   143 	}

   144 	else

   145 	{

   146 		return m_pHXUtil->GetValueSize(index);

   147 	}

   148 }

   149 

   150 TInt CMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength, TInt* outSize, TInt* encodingType)

   151 {

   152 	if(m_pS60Util)

   153 	{

   154 		return m_pS60Util->GetValue(index, data, maxLength, outSize, encodingType);

   155 	}

   156 	else

   157 	{

   158 		return m_pHXUtil->GetValue(index, data, maxLength, outSize, encodingType);

   159 	}

   160 }

   161 

   162 TInt CMetadataUtilityItf::ParseSource(char* uri)

   163 {

   164 	char* tempPtr = NULL;

   165  	char extension[MAX_EXTENSION_SIZE] = { 0 };

   166   

   167 	tempPtr = strchr(uri, (int)'.');

   168 	strncpy(extension,tempPtr,sizeof(tempPtr));

   169 	

   170   	for(unsigned int i=0;i<sizeof(extension);i++)

   171   	{

   172       	extension[i] = tolower(extension[i]);

   173   	}

   174 

   175 	//if s60 util in use

   176 	if(m_pS60Util)

   177 	{

   178 		//reset existing instace

   179 		TInt ret = m_pS60Util->Reset();

   180 		if(!CS60MetadataUtilityItf::IsSupportedExtension(extension))

   181 		{

   182 			delete m_pS60Util;

   183 			m_pS60Util = NULL;

   184 		}

   185 	}

   186 

   187 	if(m_pHXUtil)

   188 	{

   189 		//reset existing instace

   190 		TInt ret = m_pHXUtil->Reset();

   191 		if(CS60MetadataUtilityItf::IsSupportedExtension(extension))

   192 		{

   193 			delete m_pHXUtil;

   194 			m_pHXUtil = NULL;

   195 		}

   196 	}

   197 

   198 	if(!m_pS60Util && !m_pHXUtil)

   199 	{

   200 		

   201 		if(CS60MetadataUtilityItf::IsSupportedExtension(extension))

   202 		{

   203 			m_pS60Util = CS60MetadataUtilityItf::New(); 

   204 		}

   205 		else

   206 		{

   207 			m_pHXUtil = CHXMetadataUtilityItf::New();

   208 		}

   209 	}

   210 

   211 	return OpenSource(uri);

   212 }

   213 

   214 

   215 bool CS60MetadataUtilityItf::IsSupportedExtension(char *extn)

   216 {

   217 	if(	(!strcasecmp(extn, ".mp3"))	|| 

   218 		(!strcasecmp(extn, ".wma"))	|| 

   219 		(!strcasecmp(extn, ".aac")) ||

   220 		(!strcasecmp(extn, ".wav")) ||

   221 		(!strcasecmp(extn, ".m4a")))

   222 	{

   223 		return true;

   224 	}

   225 

   226 	return false;

   227 }

   228 

   229 CS60MetadataUtilityItf* CS60MetadataUtilityItf::New()

   230 {

   231 	CS60MetadataUtilityItf* self = new CS60MetadataUtilityItf();

   232 	

   233 	TInt err = KErrGeneral;

   234 	TRAP(err, self->ConstructL());

   235 

   236 	if(err == KErrNone)

   237 	{

   238 		return self;

   239 	}

   240 

   241 	delete self;

   242 	return NULL;

   243 }

   244 

   245 CS60MetadataUtilityItf::CS60MetadataUtilityItf():pMetaDataUtility(NULL)

   246 {

   247 }

   248 

   249 void CS60MetadataUtilityItf::ConstructL()

   250 {

   251 	TAG_TIME_PROFILING_BEGIN;

   252 	pMetaDataUtility = CMetaDataUtility::NewL();

   253 	TAG_TIME_PROFILING_END;

   254 	PRINT_TO_CONSOLE_TIME_DIFF;

   255 }

   256     

   257 CS60MetadataUtilityItf::~CS60MetadataUtilityItf()

   258 {

   259 	if(pMetaDataUtility)

   260 	{		

   261 		TInt err = KErrGeneral;

   262 		

   263 		TAG_TIME_PROFILING_BEGIN;

   264 		TRAP(err, pMetaDataUtility->ResetL());

   265 		delete pMetaDataUtility;

   266 		TAG_TIME_PROFILING_END;

   267 		PRINT_TO_CONSOLE_TIME_DIFF;

   268 	}

   269 

   270 	pMetaDataUtility = NULL;

   271 }

   272 

   273 TInt CS60MetadataUtilityItf::ParseSource(TDesC& fileName)

   274 {

   275 	TInt err = KErrGeneral;

   276 

   277 	if(pMetaDataUtility)

   278 	{

   279 	

   280 		TAG_TIME_PROFILING_BEGIN;

   281 		//open with the file handle

   282 		TRAP(err, pMetaDataUtility->OpenFileL(fileName));

   283 		TAG_TIME_PROFILING_END;

   284 		PRINT_TO_CONSOLE_TIME_DIFF;

   285 

   286 		if(err == KErrNone)

   287 		{

   288 			uNumMetadataItems = pMetaDataUtility->MetaDataCount();

   289 		}

   290 	}

   291 

   292 	return err;

   293 }

   294 

   295 TInt CS60MetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)

   296 {

   297 	TInt err = KErrGeneral;

   298 

   299 	if(pMetaDataUtility && numItems)

   300 	{

   301 		*numItems = uNumMetadataItems;

   302 		err = KErrNone;

   303 	}

   304 

   305 	return err;

   306 }

   307 

   308 char* CS60MetadataUtilityItf::KeyMapping(TMetaDataFieldId fldID)

   309 {

   310 	switch(fldID)

   311 	{

   312 	

   313 		case EMetaDataSongTitle:

   314 		{

   315 			return "KhronosTitle";

   316 		}

   317 		case EMetaDataArtist:

   318 		{

   319 			return "KhronosArtist";

   320 		}

   321 		case EMetaDataAlbum:

   322 		{

   323 			return "KhronosAlbum";

   324 		}

   325 		case EMetaDataYear:

   326 		{

   327 			return "KhronosYear";

   328 		}

   329 		case EMetaDataComment:

   330 		{

   331 			return "KhronosComment";

   332 		}

   333 		case EMetaDataAlbumTrack:

   334 		{

   335 			return "KhronosTrackNumber";

   336 		}

   337 		case EMetaDataGenre:

   338 		{

   339 			return "KhronosGenre";

   340 		}

   341 		case EMetaDataComposer:

   342 		{

   343 			return "Composer"; //Non Standard

   344 		}

   345 		case EMetaDataCopyright:

   346 		{

   347 			return "KhronosCopyright";

   348 		}

   349 		case EMetaDataOriginalArtist:

   350 		{

   351 			return "Original Artist"; //Non Standard

   352 		}

   353 		case EMetaDataUserUrl:

   354 		case EMetaDataUrl:	   

   355 		{

   356 			return "KhronosContentURL";

   357 		}

   358 		case EMetaDataJpeg:

   359 		{

   360 			return "attachedpicture";//"KhronosAlbumArtJPEG";

   361 		}

   362 		case EMetaDataVendor:

   363 		{

   364 			return "Vendor"; //Non Standard

   365 		}

   366 		case EMetaDataRating:

   367 		{

   368 			return "KhronosRating";			

   369 		}

   370 		case EMetaDataDuration:

   371 		{

   372 			return "Duration"; //Non Standard

   373 		}

   374 		default:

   375 		{

   376 		}

   377 	} 

   378 

   379 	return NULL;

   380 }

   381 

   382 TInt CS60MetadataUtilityItf::ValueEncoding(TMetaDataFieldId fldID)

   383 {

   384 	switch(fldID)

   385 	{

   386 		case EMetaDataJpeg:

   387 		{

   388 			return CMetadataUtilityItf::EBinaryEncoding;

   389 		}

   390 		

   391 		case EMetaDataSongTitle:

   392 		case EMetaDataArtist:

   393 		case EMetaDataAlbum:

   394 		case EMetaDataYear:

   395 		case EMetaDataComment:

   396 		case EMetaDataAlbumTrack:

   397 		case EMetaDataGenre:

   398 		case EMetaDataComposer:

   399 		case EMetaDataCopyright:

   400 		case EMetaDataOriginalArtist:

   401 		case EMetaDataUserUrl:

   402 		case EMetaDataUrl:

   403 		case EMetaDataVendor:

   404 		case EMetaDataRating:

   405 		case EMetaDataDuration:

   406 		default:

   407 		{

   408 			return CMetadataUtilityItf::EUnicodeEncoding;

   409 		}

   410 	}

   411 	

   412 }

   413 char* CS60MetadataUtilityItf::GetKey(TInt index)

   414 {

   415 

   416 	if(pMetaDataUtility && index < uNumMetadataItems)

   417 	{

   418 		

   419         TMetaDataFieldId fieldId; 

   420 		

   421 		TAG_TIME_PROFILING_BEGIN;

   422 		TInt err = KErrGeneral;

   423 		TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));

   424 		TAG_TIME_PROFILING_END;

   425 		PRINT_TO_CONSOLE_TIME_DIFF;

   426 		

   427 		if((err == KErrNone) && (fieldId != EUnknownMetaDataField))

   428 		{

   429 			return KeyMapping(fieldId);

   430 		}

   431 	}

   432 	return NULL;

   433 }

   434 

   435 TInt CS60MetadataUtilityItf::GetValueSize(TInt index)

   436 {

   437 	if(pMetaDataUtility && index < uNumMetadataItems)

   438 	{

   439 		

   440         TMetaDataFieldId fieldId; 

   441 		TInt err = KErrGeneral;

   442 		TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId ));

   443 

   444 		if((err == KErrNone) && (fieldId != EUnknownMetaDataField))

   445 		{

   446 			const CMetaDataFieldContainer* iContainer = NULL;

   447 			TRAP(err, iContainer  = &pMetaDataUtility->MetaDataFieldsL());

   448 			if(err == KErrNone)

   449 			{

   450 				if(ValueEncoding(fieldId) == CMetadataUtilityItf::EUnicodeEncoding)

   451 				{

   452 					TPtrC field = iContainer->Field( fieldId ); 

   453 					if(field != KNullDesC)

   454 					{

   455 						return field.Size() + 2; //additional character (two bytes) for null terminator

   456 					}

   457 				}	

   458 				else //Binary

   459 				{

   460 					TPtrC8 field8 = iContainer->Field8( fieldId );

   461 					if(field8 != KNullDesC8)

   462 					{

   463 						return field8.Size();

   464 					}

   465 		        }

   466 			}

   467 		}

   468 	}

   469 

   470 	return 0;

   471 }

   472 	

   473 TInt CS60MetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength,  //in params

   474 										TInt* outSize, TInt* encodingType) //out params

   475 {

   476 

   477 	TInt retValueSize = 0;

   478 	*encodingType= CMetadataUtilityItf::EUnknownEncoding;

   479 

   480 	if(pMetaDataUtility && index < uNumMetadataItems)

   481 	{

   482 		

   483         TMetaDataFieldId fieldId; 

   484 		TInt err = KErrGeneral;

   485 		TRAP(err, pMetaDataUtility->MetaDataFieldsL().FieldIdAt( index, fieldId )); 

   486 		

   487 		

   488 		if((err==KErrNone) && (fieldId != EUnknownMetaDataField))

   489 		{

   490 		

   491 			const CMetaDataFieldContainer* iContainer = NULL;

   492 			TRAP(err, iContainer  = &pMetaDataUtility->MetaDataFieldsL());

   493 			if(err == KErrNone)

   494 			{

   495 				*encodingType = ValueEncoding(fieldId);

   496 				if(*encodingType == CMetadataUtilityItf::EUnicodeEncoding)

   497 				{

   498 				

   499 					

   500 					TAG_TIME_PROFILING_BEGIN;

   501 					TPtrC field = iContainer->Field( fieldId ); 

   502 					TAG_TIME_PROFILING_END;

   503 					PRINT_TO_CONSOLE_TIME_DIFF;

   504 					if(field != KNullDesC)

   505 					{

   506 						*outSize = CMetadataUtilityItf::ExtractUCS2(field, data, maxLength);

   507 						retValueSize = field.Size() + 2; //actual size

   508 					}

   509 				}	

   510 				else //Binary

   511 				{

   512 					

   513 					TAG_TIME_PROFILING_BEGIN;

   514 					TPtrC8 field8 = iContainer->Field8( fieldId ); 

   515 					TAG_TIME_PROFILING_END;

   516 					PRINT_TO_CONSOLE_TIME_DIFF;

   517 					if(field8 != KNullDesC8)

   518 					{

   519 						*outSize = (maxLength > field8.Size())?field8.Size():maxLength;					

   520 						memcpy(data, field8.Ptr(), *outSize);

   521 						retValueSize = field8.Size();					

   522 					}

   523 				}

   524 			}

   525 		}

   526 	}

   527 

   528 	return	 retValueSize;

   529 }

   530 

   531 TInt CS60MetadataUtilityItf::Reset()

   532 {

   533 	TInt err = KErrNone;	

   534 	if(pMetaDataUtility)

   535 	{		

   536 		TRAP(err, pMetaDataUtility->ResetL());

   537 	}

   538 

   539 	return err;

   540 }

   541 

   542 

   543 CHXMetadataUtilityItf::CHXMetadataUtilityItf():pHXMetaDataUtility(NULL)

   544 {

   545 }

   546 

   547 void CHXMetadataUtilityItf::ConstructL()

   548 {

   549 	TAG_TIME_PROFILING_BEGIN;

   550 	pHXMetaDataUtility = CHXMetaDataUtility::NewL();

   551 	TAG_TIME_PROFILING_END;

   552 	PRINT_TO_CONSOLE_TIME_DIFF;

   553 }

   554 

   555    

   556 CHXMetadataUtilityItf* CHXMetadataUtilityItf::New()

   557 {

   558 	CHXMetadataUtilityItf* self = new CHXMetadataUtilityItf();

   559 

   560 	if(self)

   561 	{

   562 		TInt err = KErrGeneral;

   563 		TRAP(err, self->ConstructL());

   564    

   565 		if(err != KErrNone)

   566 		{

   567 			delete self;

   568 			self = NULL;

   569 		}

   570 	}

   571    

   572 	return self;

   573 }

   574    

   575 CHXMetadataUtilityItf::~CHXMetadataUtilityItf()

   576 {

   577 	if(pHXMetaDataUtility)

   578 	{		

   579 		TInt err = KErrGeneral;

   580 		

   581 		TAG_TIME_PROFILING_BEGIN;

   582 		TRAP(err, pHXMetaDataUtility->ResetL());

   583 		delete pHXMetaDataUtility;

   584 		TAG_TIME_PROFILING_END;

   585 		PRINT_TO_CONSOLE_TIME_DIFF;

   586 	}

   587 

   588 	pHXMetaDataUtility = NULL;

   589 }

   590 

   591 TInt CHXMetadataUtilityItf::Reset()

   592 {

   593 	TInt err = KErrNone;	

   594 	if(pHXMetaDataUtility)

   595 	{		

   596 		TRAP(err, pHXMetaDataUtility->ResetL());

   597 	}

   598 

   599 	return err;

   600 }

   601 

   602 

   603 

   604 TInt CHXMetadataUtilityItf::ParseSource(TDesC& fileName)

   605 {

   606 	TInt err = KErrGeneral;

   607 

   608 	if(pHXMetaDataUtility)

   609 	{

   610 		//open with the file handle

   611 		TAG_TIME_PROFILING_BEGIN;

   612 		TRAP(err, pHXMetaDataUtility->OpenFileL(fileName));

   613 		TAG_TIME_PROFILING_END;

   614 		PRINT_TO_CONSOLE_TIME_DIFF;

   615 

   616 		if(err == KErrNone)

   617 		{

   618 			 return pHXMetaDataUtility->GetMetaDataCount(uNumMetadataItems);

   619 		}

   620 	}

   621 

   622 	return err;

   623 }

   624 

   625 TInt CHXMetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)

   626 {

   627 	TInt err = KErrGeneral;

   628 

   629 	if(pHXMetaDataUtility && numItems)

   630 	{

   631 		*numItems = uNumMetadataItems;

   632 		err = KErrNone;

   633 	}

   634 

   635 	return err;

   636 }

   637 

   638 char* CHXMetadataUtilityItf::KeyMapping(HXMetaDataKeys::EHXMetaDataId fldID)

   639 {

   640         

   641 	switch(fldID)

   642 	{

   643 	

   644 		case HXMetaDataKeys::EHXTitle:

   645 		{

   646 			return "KhronosTitle";

   647 		}

   648 		case HXMetaDataKeys::EHXPerformer:

   649 		{

   650 			return "KhronosArtist";

   651 		}

   652 		case HXMetaDataKeys::EHXDescription:

   653 		{

   654 			return "KhronosComment";

   655 		}

   656 		case HXMetaDataKeys::EHXGenre:

   657 		{

   658 			return "KhronosGenre";

   659 		}

   660 		case HXMetaDataKeys::EHXAuthor:

   661 		{

   662 			return "Composer"; //Non Standard

   663 		}

   664 		case HXMetaDataKeys::EHXCopyright:

   665 		{

   666 			return "KhronosCopyright";

   667 		}

   668 		case HXMetaDataKeys::EHXContentURI:	   

   669 		{

   670 			return "KhronosContentURL";

   671 		}

   672 		case HXMetaDataKeys::EHXDuration:

   673 		{

   674 			return "Duration"; //Non Standard

   675 		}

   676 		case HXMetaDataKeys::EHXClipBitRate:

   677 		{

   678 			return "ClipBitRate"; //non-standard

   679 		}

   680 		case HXMetaDataKeys::EHXVideoBitRate:

   681 		{

   682 			return "VideoBitRate"; // non-standard

   683 		}

   684 		case HXMetaDataKeys::EHXAudioBitRate:

   685 		{

   686 			return "AudioBitRate";

   687 		}

   688 		case HXMetaDataKeys::EHXCodec:

   689 		{

   690 			return "Codec";

   691 		}

   692 		case HXMetaDataKeys::EHXFrameSize:

   693 		{

   694 			return "Resolution";

   695 		}

   696 		case HXMetaDataKeys::EHXFramesPerSecond:

   697 		{

   698 			return "FrameRate";

   699 		}

   700 		case HXMetaDataKeys::EHXStreamCount:

   701 		{

   702 			return "Stream Count";

   703 		}

   704 		case HXMetaDataKeys::EHXLiveStream:

   705 		{

   706 			return "Live Stream";

   707 		}

   708         case HXMetaDataKeys::EHXSeekable:

   709 		{

   710 			return "Seekable";

   711 		}

   712         case HXMetaDataKeys::EHXContentType:

   713   		{

   714 			return "Content Type";

   715 		}

   716 		case HXMetaDataKeys::EHXFormat:

   717 		{

   718 			return "Format";

   719 		}

   720         case HXMetaDataKeys::EHXQuality:

   721 		{

   722 			return "Quality";

   723 		}

   724         case HXMetaDataKeys::EHXAbstract:

   725 		{

   726 			return "Abstract";

   727 		}

   728 		case HXMetaDataKeys::EHXMimeType:

   729 		{

   730 			return "MimeType";

   731 		}

   732 		case HXMetaDataKeys::EHXIconURI:

   733 		{

   734 			return "Icon URI";

   735 		}

   736         case HXMetaDataKeys::EHXEPreviewURI:

   737 		{

   738 			return "Preview URI";

   739 		}

   740         case HXMetaDataKeys::EHXContentID:

   741 		{

   742 			return "Content ID";

   743 		}

   744         case HXMetaDataKeys::EHXInfoURL:

   745 		{

   746 			return "Info URL";

   747 		}

   748 		default:

   749 		{

   750 		}

   751 	} 

   752 

   753 	return NULL;

   754 }

   755 

   756 TInt CHXMetadataUtilityItf::ValueEncoding(HXMetaDataKeys::EHXMetaDataId fldID)

   757 {

   758 	switch(fldID)

   759 	{

   760 		default:

   761 		{

   762 			return CMetadataUtilityItf::EUnicodeEncoding;

   763 		}

   764 	}

   765 	

   766 }

   767 char* CHXMetadataUtilityItf::GetKey(TInt index)

   768 {

   769 

   770 	if(pHXMetaDataUtility && index < uNumMetadataItems)

   771 	{

   772 		HXMetaDataKeys::EHXMetaDataId id;

   773 		HBufC* pDes;

   774 		

   775 		TAG_TIME_PROFILING_BEGIN;

   776         TInt err = pHXMetaDataUtility->GetMetaDataAt(index, id, pDes); 

   777 		TAG_TIME_PROFILING_END;

   778 		PRINT_TO_CONSOLE_TIME_DIFF;

   779 		

   780 		if(err == KErrNone)

   781 		{

   782 			return KeyMapping(id);

   783 		}

   784 	}

   785 	return NULL;

   786 }

   787 

   788 TInt CHXMetadataUtilityItf::GetValueSize(TInt index)

   789 {

   790 	if(pHXMetaDataUtility && index < uNumMetadataItems)

   791 	{

   792 		HXMetaDataKeys::EHXMetaDataId id;

   793 		HBufC* pDes;

   794 		

   795         TInt err =  pHXMetaDataUtility->GetMetaDataAt(index, id, pDes); 

   796 		

   797 		if(err == KErrNone)

   798 		{

   799 			if(ValueEncoding(id) == CMetadataUtilityItf::EUnicodeEncoding)

   800 			{

   801 				return pDes->Size() + 2; //additional character (two bytes) for null terminator

   802 			}	

   803 			else //Binary

   804 			{

   805 				//no support

   806 	        }

   807 		}

   808 	}

   809 

   810 	return 0;

   811 }

   812 	

   813 TInt CHXMetadataUtilityItf::GetValue(TInt index, char* data, TInt maxLength,  //in params

   814 										TInt* outSize, TInt* encodingType) //out params

   815 {

   816 

   817 	TInt retValueSize = 0;

   818 	*encodingType= CMetadataUtilityItf::EUnknownEncoding;

   819 

   820 	if(pHXMetaDataUtility && index < uNumMetadataItems)

   821 	{

   822 		HXMetaDataKeys::EHXMetaDataId id;

   823 		HBufC* pDes;

   824 

   825 		

   826 		TAG_TIME_PROFILING_BEGIN;

   827         TInt err =  pHXMetaDataUtility->GetMetaDataAt(index, id, pDes); 

   828 		TAG_TIME_PROFILING_END;

   829 		PRINT_TO_CONSOLE_TIME_DIFF;

   830 		

   831 		*encodingType = ValueEncoding(id);

   832 		

   833 		if(err == KErrNone)

   834 		{

   835 			if(*encodingType == CMetadataUtilityItf::EUnicodeEncoding)

   836 			{

   837 				*outSize = CMetadataUtilityItf::ExtractUCS2(*pDes, data, maxLength);

   838 				retValueSize = pDes->Size() + 2; //actual Size	

   839 			}	

   840 			else //Binary

   841 			{

   842 				//no support

   843 			}

   844 		}

   845 	}

   846 

   847 	return	 retValueSize;

   848 }

   849 

   850 

   851 extern "C" {

   852 

   853     void* mmf_metadata_utility_init(char* uri)

   854 	{

   855 		return CMetadataUtilityItf::New(uri);

   856 	}

   857 

   858     void mmf_metadata_utility_destroy(void* context)

   859 	{

   860 		delete ((CMetadataUtilityItf*)context);

   861 	}

   862 

   863 	XAresult mmf_metadata_utility_parse_source(void* context, char* uri)

   864 	{

   865 		TInt err = ((CMetadataUtilityItf*)context)->ParseSource(uri);

   866 		

   867 		if(err == KErrNone)

   868 		{

   869 			return XA_RESULT_SUCCESS;

   870 		}

   871 		

   872 		return XA_RESULT_PARAMETER_INVALID;

   873 	}

   874 

   875 

   876 	XAresult  mmf_get_item_count(void* context, XAuint32* itemCount)

   877 	{

   878 		if(itemCount)

   879 		{

   880 			TInt err = ((CMetadataUtilityItf*)(context))->CalculateNumMetadataItems((TUint *)itemCount);

   881 			if(err == KErrNone)

   882 			{

   883 				return XA_RESULT_SUCCESS;

   884 			}

   885 		}

   886 

   887 		return XA_RESULT_PARAMETER_INVALID;

   888 	}

   889 	

   890 	XAresult  mmf_get_key_size(void* context, XAuint32 keyIndex, XAuint32* keySize)

   891 	{

   892 		char* key = ((CMetadataUtilityItf*)(context))->GetKey(keyIndex);

   893 		if(key && keySize)

   894 		{

   895 			*keySize = (strlen(key) + sizeof(XAMetadataInfo));

   896 			

   897 			return XA_RESULT_SUCCESS;

   898 		}

   899 		

   900 		return XA_RESULT_PARAMETER_INVALID;		

   901 	}

   902 	

   903 

   904 	XAresult  mmf_get_key(void* context, XAuint32 index,XAuint32 keySize, XAMetadataInfo *pKey)

   905 	{

   906 		XAresult ret = XA_RESULT_PARAMETER_INVALID;

   907 		

   908 		TInt keyDataSize = keySize - sizeof(XAMetadataInfo) + 1;

   909 		char* ascKey = ((CMetadataUtilityItf*)(context))->GetKey(index);

   910 

   911 		if(ascKey && keyDataSize)

   912 		{

   913 			TInt ascKeySize = strlen(ascKey);

   914 			TInt outSize = (ascKeySize >= keyDataSize) ? (keyDataSize - 1) : ascKeySize;

   915 			

   916 			pKey->size = outSize + 1;

   917 			pKey->encoding = XA_CHARACTERENCODING_ASCII;

   918 			strcpy((char *)(pKey->langCountry), "en-us");

   919 			strncpy((char *)(pKey->data), ascKey, outSize);

   920 			pKey->data[outSize] = '\0';

   921 

   922 			if(ascKeySize >= keyDataSize)

   923 			{

   924 				ret = XA_RESULT_BUFFER_INSUFFICIENT;

   925 			}

   926 			else

   927 			{

   928 				ret = XA_RESULT_SUCCESS;

   929 			}

   930 		}

   931 

   932 		ret = XA_RESULT_SUCCESS;

   933 		return ret;		

   934 	}

   935 

   936 	XAresult  mmf_get_value_size(void* context, XAuint32 index, XAuint32 *pValueSize)

   937 	{

   938 		if(pValueSize)

   939 		{

   940 			*pValueSize = ((CMetadataUtilityItf*)(context))->GetValueSize(index) + sizeof(XAMetadataInfo) - 1; //XAMetadataInfo already includes one byte for Data

   941 			

   942 			return XA_RESULT_SUCCESS;

   943 		}

   944 

   945 		return XA_RESULT_PARAMETER_INVALID;		

   946 	}

   947 

   948 	XAresult  mmf_get_value(void* context, XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue)

   949 	{

   950 		XAresult ret = XA_RESULT_PARAMETER_INVALID;

   951 		TInt dataSize = valueSize - sizeof(XAMetadataInfo) + 1;

   952 		TInt outLen = 0, encodingType = CMetadataUtilityItf::EUnknownEncoding;

   953 

   954 		if(dataSize > 0)

   955 		{

   956 		

   957 			TInt actualDataSize = ((CMetadataUtilityItf*)(context))->GetValue(index, (char*)pValue->data, dataSize, &outLen, &encodingType);

   958 

   959 			pValue->size = outLen;

   960 			pValue->encoding = (encodingType == CMetadataUtilityItf::EUnicodeEncoding) ? XA_CHARACTERENCODING_UTF16LE : XA_CHARACTERENCODING_BINARY;

   961 			strcpy((char *)(pValue->langCountry), "en-us");

   962 

   963 			if(!actualDataSize)

   964 			{

   965 				return XA_RESULT_INTERNAL_ERROR;

   966 			}

   967 			if(actualDataSize > dataSize)

   968 			{

   969 				ret = XA_RESULT_BUFFER_INSUFFICIENT;

   970 			}

   971 			else

   972 			{

   973 				ret = XA_RESULT_SUCCESS;

   974 			}

   975 		}

   976 			

   977 		return ret; 

   978 	}

   979 }

   980