/*

* 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: 

*

*/

#include "cmetadatautilityitf.h"

#include <OpenMAXAL.h>

#include <string.h>

#include <ctype.h>

#include <uri8.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;

	TInt ret = p_mdutilitf->ParseSource(uri);

	if(ret == KErrNone)

	{

		return p_mdutilitf; 

	}

	delete p_mdutilitf;

	return NULL;

}

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;

    }

	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)

{

	if(m_pS60Util)

	{

		return m_pS60Util->CalculateNumMetadataItems(numItems);

	}

	else

	{

		return m_pHXUtil->CalculateNumMetadataItems(numItems);

	}

}

char* CMetadataUtilityItf::GetKey(TInt index)

{

	if(m_pS60Util)

	{

		return m_pS60Util->GetKey(index);

	}

	else

	{

		return m_pHXUtil->GetKey(index);

	}

}

TInt CMetadataUtilityItf::GetValueSize(TInt index)

{

	if(m_pS60Util)

	{

		return m_pS60Util->GetValueSize(index);

	}

	else

	{

		return m_pHXUtil->GetValueSize(index);

	}

}

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

	{

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

	}

}

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 NULL;

}

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

				{