/*

 * 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

                        }