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: 

    15 *

    16 */

    17 #include "cmetadatautilityitf.h"

    18 #include <OpenMAXAL.h>

    19 #include <string.h>

    20 #include <ctype.h>

    21 #include <uri8.h>

    22 #include "profileutilmacro.h"

    23 

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

    25 {

    26 }

    27 

    28 CMetadataUtilityItf::~CMetadataUtilityItf()

    29 {

    30 	if(m_pS60Util)

    31 	{

    32 		delete m_pS60Util;

    33 	}

    34 

    35 	if(m_pHXUtil)

    36 	{

    37 		delete m_pHXUtil;

    38 	}

    39 }

    40 

    41 

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

    43 {

    44 	CMetadataUtilityItf* p_mdutilitf = new CMetadataUtilityItf;

    45 	

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

    47 

    48 	if(ret == KErrNone)

    49 	{

    50 		return p_mdutilitf; 

    51 	}

    52 

    53 	delete p_mdutilitf;

    54 	return NULL;

    55 }

    56 

    57 TInt CMetadataUtilityItf::OpenSource(char* pOrigUri)

    58 {

    59     //Make a local copy for uri

    60     if ( !pOrigUri )

    61         return XA_RESULT_PARAMETER_INVALID;

    62     

    63     int uriLen = strlen(pOrigUri);

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

    65     if (! uri )

    66         {

    67         return XA_RESULT_MEMORY_FAILURE;

    68         }

    69     strncpy(uri, pOrigUri, uriLen);

    70     uri[uriLen] = '\0';

    71     //

    72 

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

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

    75 

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

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

    78  

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

    80     if(pos != KErrNotFound)

    81     {

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

    83     }

    84 

    85     TUriParser8 localfileUri;

    86     TInt ret = localfileUri.Parse(fileuri);

    87     if(ret == KErrNone)

    88     {    

    89         HBufC* file = NULL;

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

    91         if(ret == KErrNone)

    92         {

    93         	if(m_pS60Util)

    94         	{

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

    96         	}

    97 			else if(m_pHXUtil)

    98 			{

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

   100 			}

   101 			else

   102 			{

   103 				ret = KErrNotFound;

   104 			}

   105         }

   106         

   107         delete file;

   108     }

   109     

   110     if(uri)

   111     {

   112         delete []uri;

   113     }

   114     

   115 	return ret;

   116 }

   117 

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

   119 {

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

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

   122 	

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

   124 	outDes.Copy(tempPtr);

   125 	outDes.ZeroTerminate();

   126 

   127 	return outLen * 2; //return size

   128 }

   129 

   130 TInt CMetadataUtilityItf::CalculateNumMetadataItems(TUint*numItems)

   131 {

   132 	if(m_pS60Util)

   133 	{

   134 		return m_pS60Util->CalculateNumMetadataItems(numItems);

   135 	}

   136 	else

   137 	{

   138 		return m_pHXUtil->CalculateNumMetadataItems(numItems);

   139 	}

   140 }

   141 

   142 char* CMetadataUtilityItf::GetKey(TInt index)

   143 {

   144 	if(m_pS60Util)

   145 	{

   146 		return m_pS60Util->GetKey(index);

   147 	}

   148 	else

   149 	{

   150 		return m_pHXUtil->GetKey(index);

   151 	}

   152 }

   153 

   154 TInt CMetadataUtilityItf::GetValueSize(TInt index)

   155 {

   156 	if(m_pS60Util)

   157 	{

   158 		return m_pS60Util->GetValueSize(index);

   159 	}

   160 	else

   161 	{

   162 		return m_pHXUtil->GetValueSize(index);

   163 	}

   164 }

   165 

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

   167 {

   168 	if(m_pS60Util)

   169 	{

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

   171 	}

   172 	else

   173 	{

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

   175 	}

   176 }

   177 

   178 TInt CMetadataUtilityItf::ParseSource(char* uri)

   179 {

   180 	char* tempPtr = NULL;

   181  	char extension[MAX_EXTENSION_SIZE] = { 0 };

   182   

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

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

   185 	

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

   187   	{

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

   189   	}

   190 

   191 	//if s60 util in use

   192 	if(m_pS60Util)

   193 	{

   194 		//reset existing instace

   195 		TInt ret = m_pS60Util->Reset();

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

   197 		{

   198 			delete m_pS60Util;

   199 			m_pS60Util = NULL;

   200 		}

   201 	}

   202 

   203 	if(m_pHXUtil)

   204 	{

   205 		//reset existing instace

   206 		TInt ret = m_pHXUtil->Reset();

   207 		if(CS60MetadataUtilityItf::IsSupportedExtension(extension))

   208 		{

   209 			delete m_pHXUtil;

   210 			m_pHXUtil = NULL;

   211 		}

   212 	}

   213 

   214 	if(!m_pS60Util && !m_pHXUtil)

   215 	{

   216 		

   217 		if(CS60MetadataUtilityItf::IsSupportedExtension(extension))

   218 		{

   219 			m_pS60Util = CS60MetadataUtilityItf::New(); 

   220 		}

   221 		else

   222 		{

   223 			m_pHXUtil = CHXMetadataUtilityItf::New();

   224 		}

   225 	}

   226 

   227 	return OpenSource(uri);

   228 }

   229 

   230 

   231 bool CS60MetadataUtilityItf::IsSupportedExtension(char *extn)

   232 {

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

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

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

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

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

   238 	{

   239 		return true;

   240 	}

   241 

   242 	return false;

   243 }

   244 

   245 CS60MetadataUtilityItf* CS60MetadataUtilityItf::New()

   246 {

   247 	CS60MetadataUtilityItf* self = new CS60MetadataUtilityItf();

   248 	

   249 	TInt err = KErrGeneral;

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

   251 

   252 	if(err == KErrNone)

   253 	{

   254 		return self;

   255 	}

   256 

   257 	delete self;

   258 	return NULL;

   259 }

   260 

   261 CS60MetadataUtilityItf::CS60MetadataUtilityItf():pMetaDataUtility(NULL)

   262 {

   263 }

   264 

   265 void CS60MetadataUtilityItf::ConstructL()

   266 {

   267 	TAG_TIME_PROFILING_BEGIN;

   268 	pMetaDataUtility = CMetaDataUtility::NewL();

   269 	TAG_TIME_PROFILING_END;

   270 	PRINT_TO_CONSOLE_TIME_DIFF;

   271 }

   272     

   273 CS60MetadataUtilityItf::~CS60MetadataUtilityItf()

   274 {

   275 	if(pMetaDataUtility)

   276 	{		

   277 		TInt err = KErrGeneral;

   278 		

   279 		TAG_TIME_PROFILING_BEGIN;

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

   281 		delete pMetaDataUtility;

   282 		TAG_TIME_PROFILING_END;

   283 		PRINT_TO_CONSOLE_TIME_DIFF;

   284 	}

   285 

   286 	pMetaDataUtility = NULL;

   287 }

   288 

   289 TInt CS60MetadataUtilityItf::ParseSource(TDesC& fileName)

   290 {

   291 	TInt err = KErrGeneral;

   292 

   293 	if(pMetaDataUtility)

   294 	{

   295 	

   296 		TAG_TIME_PROFILING_BEGIN;

   297 		//open with the file handle

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

   299 		TAG_TIME_PROFILING_END;

   300 		PRINT_TO_CONSOLE_TIME_DIFF;

   301 

   302 		if(err == KErrNone)

   303 		{

   304 			uNumMetadataItems = pMetaDataUtility->MetaDataCount();

   305 		}

   306 	}

   307 

   308 	return err;

   309 }

   310 

   311 TInt CS60MetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)

   312 {

   313 	TInt err = KErrGeneral;

   314 

   315 	if(pMetaDataUtility && numItems)

   316 	{

   317 		*numItems = uNumMetadataItems;

   318 		err = KErrNone;

   319 	}

   320 

   321 	return err;

   322 }

   323 

   324 char* CS60MetadataUtilityItf::KeyMapping(TMetaDataFieldId fldID)

   325 {

   326 	switch(fldID)

   327 	{

   328 	

   329 		case EMetaDataSongTitle:

   330 		{

   331 			return "KhronosTitle";

   332 		}

   333 		case EMetaDataArtist:

   334 		{

   335 			return "KhronosArtist";

   336 		}

   337 		case EMetaDataAlbum:

   338 		{

   339 			return "KhronosAlbum";

   340 		}

   341 		case EMetaDataYear:

   342 		{

   343 			return "KhronosYear";

   344 		}

   345 		case EMetaDataComment:

   346 		{

   347 			return "KhronosComment";

   348 		}

   349 		case EMetaDataAlbumTrack:

   350 		{

   351 			return "KhronosTrackNumber";

   352 		}

   353 		case EMetaDataGenre:

   354 		{

   355 			return "KhronosGenre";

   356 		}

   357 		case EMetaDataComposer:

   358 		{

   359 			return "Composer"; //Non Standard

   360 		}

   361 		case EMetaDataCopyright:

   362 		{

   363 			return "KhronosCopyright";

   364 		}

   365 		case EMetaDataOriginalArtist:

   366 		{

   367 			return "Original Artist"; //Non Standard

   368 		}

   369 		case EMetaDataUserUrl:

   370 		case EMetaDataUrl:	   

   371 		{

   372 			return "KhronosContentURL";

   373 		}

   374 		case EMetaDataJpeg:

   375 		{

   376 			return "attachedpicture";//"KhronosAlbumArtJPEG";

   377 		}

   378 		case EMetaDataVendor:

   379 		{

   380 			return "Vendor"; //Non Standard

   381 		}

   382 		case EMetaDataRating:

   383 		{

   384 			return "KhronosRating";			

   385 		}

   386 		case EMetaDataDuration:

   387 		{

   388 			return "Duration"; //Non Standard

   389 		}

   390 		default:

   391 		{

   392 		}

   393 	} 

   394 

   395 	return NULL;

   396 }

   397 

   398 TInt CS60MetadataUtilityItf::ValueEncoding(TMetaDataFieldId fldID)

   399 {

   400 	switch(fldID)

   401 	{

   402 		case EMetaDataJpeg:

   403 		{

   404 			return CMetadataUtilityItf::EBinaryEncoding;

   405 		}

   406 		

   407 		case EMetaDataSongTitle:

   408 		case EMetaDataArtist:

   409 		case EMetaDataAlbum:

   410 		case EMetaDataYear:

   411 		case EMetaDataComment:

   412 		case EMetaDataAlbumTrack:

   413 		case EMetaDataGenre:

   414 		case EMetaDataComposer:

   415 		case EMetaDataCopyright:

   416 		case EMetaDataOriginalArtist:

   417 		case EMetaDataUserUrl:

   418 		case EMetaDataUrl:

   419 		case EMetaDataVendor:

   420 		case EMetaDataRating:

   421 		case EMetaDataDuration:

   422 		default:

   423 		{

   424 			return CMetadataUtilityItf::EUnicodeEncoding;

   425 		}

   426 	}

   427 	

   428 }

   429 char* CS60MetadataUtilityItf::GetKey(TInt index)

   430 {

   431 

   432 	if(pMetaDataUtility && index < uNumMetadataItems)

   433 	{

   434 		

   435         TMetaDataFieldId fieldId; 

   436 		

   437 		TAG_TIME_PROFILING_BEGIN;

   438 		TInt err = KErrGeneral;

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

   440 		TAG_TIME_PROFILING_END;

   441 		PRINT_TO_CONSOLE_TIME_DIFF;

   442 		

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

   444 		{

   445 			return KeyMapping(fieldId);

   446 		}

   447 	}

   448 	return NULL;

   449 }

   450 

   451 TInt CS60MetadataUtilityItf::GetValueSize(TInt index)

   452 {

   453 	if(pMetaDataUtility && index < uNumMetadataItems)

   454 	{

   455 		

   456         TMetaDataFieldId fieldId; 

   457 		TInt err = KErrGeneral;

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

   459 

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

   461 		{

   462 			const CMetaDataFieldContainer* iContainer = NULL;

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

   464 			if(err == KErrNone)

   465 			{

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

   467 				{

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

   469 					if(field != KNullDesC)

   470 					{

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

   472 					}

   473 				}	

   474 				else //Binary

   475 				{

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

   477 					if(field8 != KNullDesC8)

   478 					{

   479 						return field8.Size();

   480 					}

   481 		        }

   482 			}

   483 		}

   484 	}

   485 

   486 	return 0;

   487 }

   488 	

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

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

   491 {

   492 

   493 	TInt retValueSize = 0;

   494 	*encodingType= CMetadataUtilityItf::EUnknownEncoding;

   495 

   496 	if(pMetaDataUtility && index < uNumMetadataItems)

   497 	{

   498 		

   499         TMetaDataFieldId fieldId; 

   500 		TInt err = KErrGeneral;

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

   502 		

   503 		

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

   505 		{

   506 		

   507 			const CMetaDataFieldContainer* iContainer = NULL;

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

   509 			if(err == KErrNone)

   510 			{

   511 				*encodingType = ValueEncoding(fieldId);

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

   513 				{

   514 				

   515 					

   516 					TAG_TIME_PROFILING_BEGIN;

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

   518 					TAG_TIME_PROFILING_END;

   519 					PRINT_TO_CONSOLE_TIME_DIFF;

   520 					if(field != KNullDesC)

   521 					{

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

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

   524 					}

   525 				}	

   526 				else //Binary

   527 				{

   528 					

   529 					TAG_TIME_PROFILING_BEGIN;

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

   531 					TAG_TIME_PROFILING_END;

   532 					PRINT_TO_CONSOLE_TIME_DIFF;

   533 					if(field8 != KNullDesC8)

   534 					{

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

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

   537 						retValueSize = field8.Size();					

   538 					}

   539 				}

   540 			}

   541 		}

   542 	}

   543 

   544 	return	 retValueSize;

   545 }

   546 

   547 TInt CS60MetadataUtilityItf::Reset()

   548 {

   549 	TInt err = KErrNone;	

   550 	if(pMetaDataUtility)

   551 	{		

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

   553 	}

   554 

   555 	return err;

   556 }

   557 

   558 

   559 CHXMetadataUtilityItf::CHXMetadataUtilityItf():pHXMetaDataUtility(NULL)

   560 {

   561 }

   562 

   563 void CHXMetadataUtilityItf::ConstructL()

   564 {

   565 	TAG_TIME_PROFILING_BEGIN;

   566 	pHXMetaDataUtility = CHXMetaDataUtility::NewL();

   567 	TAG_TIME_PROFILING_END;

   568 	PRINT_TO_CONSOLE_TIME_DIFF;

   569 }

   570 

   571    

   572 CHXMetadataUtilityItf* CHXMetadataUtilityItf::New()

   573 {

   574 	CHXMetadataUtilityItf* self = new CHXMetadataUtilityItf();

   575 

   576 	if(self)

   577 	{

   578 		TInt err = KErrGeneral;

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

   580    

   581 		if(err != KErrNone)

   582 		{

   583 			delete self;

   584 			self = NULL;

   585 		}

   586 	}

   587    

   588 	return self;

   589 }

   590    

   591 CHXMetadataUtilityItf::~CHXMetadataUtilityItf()

   592 {

   593 	if(pHXMetaDataUtility)

   594 	{		

   595 		TInt err = KErrGeneral;

   596 		

   597 		TAG_TIME_PROFILING_BEGIN;

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

   599 		delete pHXMetaDataUtility;

   600 		TAG_TIME_PROFILING_END;

   601 		PRINT_TO_CONSOLE_TIME_DIFF;

   602 	}

   603 

   604 	pHXMetaDataUtility = NULL;

   605 }

   606 

   607 TInt CHXMetadataUtilityItf::Reset()

   608 {

   609 	TInt err = KErrNone;	

   610 	if(pHXMetaDataUtility)

   611 	{		

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

   613 	}

   614 

   615 	return err;

   616 }

   617 

   618 

   619 

   620 TInt CHXMetadataUtilityItf::ParseSource(TDesC& fileName)

   621 {

   622 	TInt err = KErrGeneral;

   623 

   624 	if(pHXMetaDataUtility)

   625 	{

   626 		//open with the file handle

   627 		TAG_TIME_PROFILING_BEGIN;

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

   629 		TAG_TIME_PROFILING_END;

   630 		PRINT_TO_CONSOLE_TIME_DIFF;

   631 

   632 		if(err == KErrNone)

   633 		{

   634 			 return pHXMetaDataUtility->GetMetaDataCount(uNumMetadataItems);

   635 		}

   636 	}

   637 

   638 	return err;

   639 }

   640 

   641 TInt CHXMetadataUtilityItf::CalculateNumMetadataItems(TUint* numItems)

   642 {

   643 	TInt err = KErrGeneral;

   644 

   645 	if(pHXMetaDataUtility && numItems)

   646 	{

   647 		*numItems = uNumMetadataItems;

   648 		err = KErrNone;

   649 	}

   650 

   651 	return err;

   652 }

   653 

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

   655 {

   656         

   657 	switch(fldID)

   658 	{

   659 	

   660 		case HXMetaDataKeys::EHXTitle:

   661 		{

   662 			return "KhronosTitle";

   663 		}

   664 		case HXMetaDataKeys::EHXPerformer:

   665 		{

   666 			return "KhronosArtist";

   667 		}

   668 		case HXMetaDataKeys::EHXDescription:

   669 		{

   670 			return "KhronosComment";

   671 		}

   672 		case HXMetaDataKeys::EHXGenre:

   673 		{

   674 			return "KhronosGenre";

   675 		}

   676 		case HXMetaDataKeys::EHXAuthor:

   677 		{

   678 			return "Composer"; //Non Standard

   679 		}

   680 		case HXMetaDataKeys::EHXCopyright:

   681 		{

   682 			return "KhronosCopyright";

   683 		}

   684 		case HXMetaDataKeys::EHXContentURI:	   

   685 		{

   686 			return "KhronosContentURL";

   687 		}

   688 		case HXMetaDataKeys::EHXDuration:

   689 		{

   690 			return "Duration"; //Non Standard

   691 		}

   692 		case HXMetaDataKeys::EHXClipBitRate:

   693 		{

   694 			return "ClipBitRate"; //non-standard

   695 		}

   696 		case HXMetaDataKeys::EHXVideoBitRate:

   697 		{

   698 			return "VideoBitRate"; // non-standard

   699 		}

   700 		case HXMetaDataKeys::EHXAudioBitRate:

   701 		{

   702 			return "AudioBitRate";

   703 		}

   704 		case HXMetaDataKeys::EHXCodec:

   705 		{

   706 			return "Codec";

   707 		}

   708 		case HXMetaDataKeys::EHXFrameSize:

   709 		{

   710 			return "Resolution";

   711 		}

   712 		case HXMetaDataKeys::EHXFramesPerSecond:

   713 		{

   714 			return "FrameRate";

   715 		}

   716 		case HXMetaDataKeys::EHXStreamCount:

   717 		{

   718 			return "Stream Count";

   719 		}

   720 		case HXMetaDataKeys::EHXLiveStream:

   721 		{

   722 			return "Live Stream";

   723 		}

   724         case HXMetaDataKeys::EHXSeekable:

   725 		{

   726 			return "Seekable";

   727 		}

   728         case HXMetaDataKeys::EHXContentType:

   729   		{

   730 			return "Content Type";

   731 		}

   732 		case HXMetaDataKeys::EHXFormat:

   733 		{

   734 			return "Format";

   735 		}

   736         case HXMetaDataKeys::EHXQuality:

   737 		{

   738 			return "Quality";

   739 		}

   740         case HXMetaDataKeys::EHXAbstract:

   741 		{

   742 			return "Abstract";

   743 		}

   744 		case HXMetaDataKeys::EHXMimeType:

   745 		{

   746 			return "MimeType";

   747 		}

   748 		case HXMetaDataKeys::EHXIconURI:

   749 		{

   750 			return "Icon URI";

   751 		}

   752         case HXMetaDataKeys::EHXEPreviewURI:

   753 		{

   754 			return "Preview URI";

   755 		}

   756         case HXMetaDataKeys::EHXContentID:

   757 		{

   758 			return "Content ID";

   759 		}

   760         case HXMetaDataKeys::EHXInfoURL:

   761 		{

   762 			return "Info URL";

   763 		}

   764 		default:

   765 		{

   766 		}

   767 	} 

   768 

   769 	return NULL;

   770 }

   771 

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

   773 {

   774 	switch(fldID)

   775 	{

   776 		default:

   777 		{

   778 			return CMetadataUtilityItf::EUnicodeEncoding;

   779 		}

   780 	}

   781 	

   782 }

   783 char* CHXMetadataUtilityItf::GetKey(TInt index)

   784 {

   785 

   786 	if(pHXMetaDataUtility && index < uNumMetadataItems)

   787 	{

   788 		HXMetaDataKeys::EHXMetaDataId id;

   789 		HBufC* pDes;

   790 		

   791 		TAG_TIME_PROFILING_BEGIN;

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

   793 		TAG_TIME_PROFILING_END;

   794 		PRINT_TO_CONSOLE_TIME_DIFF;

   795 		

   796 		if(err == KErrNone)

   797 		{

   798 			return KeyMapping(id);

   799 		}

   800 	}

   801 	return NULL;

   802 }

   803 

   804 TInt CHXMetadataUtilityItf::GetValueSize(TInt index)

   805 {

   806 	if(pHXMetaDataUtility && index < uNumMetadataItems)

   807 	{

   808 		HXMetaDataKeys::EHXMetaDataId id;

   809 		HBufC* pDes;

   810 		

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

   812 		

   813 		if(err == KErrNone)

   814 		{

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

   816 			{

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

   818 			}	

   819 			else //Binary

   820 			{

   821 				//no support

   822 	        }

   823 		}

   824 	}

   825 

   826 	return 0;

   827 }

   828 	

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

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

   831 {

   832 

   833 	TInt retValueSize = 0;

   834 	*encodingType= CMetadataUtilityItf::EUnknownEncoding;

   835 

   836 	if(pHXMetaDataUtility && index < uNumMetadataItems)

   837 	{

   838 		HXMetaDataKeys::EHXMetaDataId id;

   839 		HBufC* pDes;

   840 

   841 		

   842 		TAG_TIME_PROFILING_BEGIN;

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

   844 		TAG_TIME_PROFILING_END;

   845 		PRINT_TO_CONSOLE_TIME_DIFF;

   846 		

   847 		*encodingType = ValueEncoding(id);

   848 		

   849 		if(err == KErrNone)

   850 		{

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

   852 			{

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

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

   855 			}	

   856 			else //Binary

   857 			{

   858 				//no support

   859 			}

   860 		}

   861 	}

   862 

   863 	return	 retValueSize;

   864 }

   865 

   866 

   867 extern "C" {

   868 

   869     void* mmf_metadata_utility_init(char* uri)

   870 	{

   871 		return CMetadataUtilityItf::New(uri);

   872 	}

   873 

   874     void mmf_metadata_utility_destroy(void* context)

   875 	{

   876 		delete ((CMetadataUtilityItf*)context);

   877 	}

   878 

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

   880 	{

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

   882 		

   883 		if(err == KErrNone)

   884 		{

   885 			return XA_RESULT_SUCCESS;

   886 		}

   887 		

   888 		return XA_RESULT_PARAMETER_INVALID;

   889 	}

   890 

   891 

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

   893 	{

   894 		if(itemCount)

   895 		{

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

   897 			if(err == KErrNone)

   898 			{

   899 				return XA_RESULT_SUCCESS;

   900 			}

   901 		}

   902 

   903 		return XA_RESULT_PARAMETER_INVALID;

   904 	}

   905 	

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

   907 	{

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

   909 		if(key && keySize)

   910 		{

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

   912 			

   913 			return XA_RESULT_SUCCESS;

   914 		}

   915 		

   916 		return XA_RESULT_PARAMETER_INVALID;		

   917 	}

   918 	

   919 

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

   921 	{

   922 		XAresult ret = XA_RESULT_PARAMETER_INVALID;

   923 		

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

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

   926 

   927 		if(ascKey && keyDataSize)

   928 		{

   929 			TInt ascKeySize = strlen(ascKey);

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

   931 			

   932 			pKey->size = outSize + 1;

   933 			pKey->encoding = XA_CHARACTERENCODING_ASCII;

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

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

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

   937 

   938 			if(ascKeySize >= keyDataSize)

   939 			{

   940 				ret = XA_RESULT_BUFFER_INSUFFICIENT;

   941 			}

   942 			else

   943 			{

   944 				ret = XA_RESULT_SUCCESS;

   945 			}

   946 		}

   947 

   948 		ret = XA_RESULT_SUCCESS;

   949 		return ret;		

   950 	}

   951 

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

   953 	{

   954 		if(pValueSize)

   955 		{

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

   957 			

   958 			return XA_RESULT_SUCCESS;

   959 		}

   960 

   961 		return XA_RESULT_PARAMETER_INVALID;		

   962 	}

   963 

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

   965 	{

   966 		XAresult ret = XA_RESULT_PARAMETER_INVALID;

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

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

   969 

   970 		if(dataSize > 0)

   971 		{

   972 		

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

   974 

   975 			pValue->size = outLen;

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

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

   978 

   979 			if(!actualDataSize)

   980 			{

   981 				return XA_RESULT_INTERNAL_ERROR;

   982 			}

   983 			if(actualDataSize > dataSize)

   984 			{

   985 				ret = XA_RESULT_BUFFER_INSUFFICIENT;

   986 			}

   987 			else

   988 			{

   989 				ret = XA_RESULT_SUCCESS;

   990 			}

   991 		}

   992 			

   993 		return ret; 

   994 	}

   995 }

   996