/*
* Copyright (c) 2006-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:  Harvester audio plugin
*
*/


#include <e32base.h>
#include <apgcli.h>  // for RApaLsSession

#include "harvesteraudiopluginutils.h"

#include "mdsutils.h"
#include "harvesterlog.h"

_LIT( KMimeTypeMpeg,   "audio/mpeg" );
_LIT( KMimeTypeAac,    "audio/aac" );
_LIT( KMimeTypeAmr,    "audio/amr" );
_LIT( KMimeTypeAwb,    "audio/amr-wb" );
_LIT( KMimeTypeMidi,   "audio/midi" );
_LIT( KMimeTypeSpMidi, "audio/sp-midi" );
_LIT( KMimeTypeRng,    "application/vnd.nokia.ringing-tone" );
_LIT( KMimeTypeMxmf,   "audio/vnd.nokia.mobile-xmf" );
_LIT( KMimeTypeWav,    "audio/wav" );
_LIT( KMimeTypeAu,     "audio/au" );
_LIT( KMimeTypeWma,    "audio/x-ms-wma");
_LIT( KMimeTypeAudioMatroska, "audio/x-matroska");

_LIT( KExtensionMp3,    "mp3" );
_LIT( KExtensionAac,    "aac" );
_LIT( KExtensionAmr,    "amr" );
_LIT( KExtensionAwb,    "awb" );
_LIT( KExtensionMid,    "mid" );
_LIT( KExtensionMidi,   "midi" );
_LIT( KExtensionSpMid,  "spmid" );
_LIT( KExtensionRng,    "rng" );
_LIT( KExtensionMxmf,   "mxmf" );
_LIT( KExtensionWav,    "wav" );
_LIT( KExtensionAu,     "au" );
_LIT( KExtensionWma,    "wma" );
_LIT( KExtensionNrt,    "nrt" );
_LIT( KExtensionMka,    "mka" );

// -----------------------------------------------------------------------------
// CAudioMDParser::NewL
// 
// -----------------------------------------------------------------------------
//
CAudioMDParser* CAudioMDParser::NewL( const TBool aAlbumArt )
    {
    CAudioMDParser* self = new ( ELeave ) CAudioMDParser();
	CleanupStack::PushL( self );
	self->ConstructL( aAlbumArt );
	CleanupStack::Pop( self );

	return self;
    }


// -----------------------------------------------------------------------------
// Destructor
// 
// -----------------------------------------------------------------------------
//
CAudioMDParser::~CAudioMDParser()
    {
    delete iMetaDataUtility;
    
    iMimeTypeMappings.Close();
    iWantedMetadataFields.Close();
    }


// -----------------------------------------------------------------------------
// CAudioMDParser::CAudioMDParser
// 
// -----------------------------------------------------------------------------
//
CAudioMDParser::CAudioMDParser() :
	iMetaDataUtility( NULL ), iLastParsedFileMimeType( 0 )
    {
    }


// -----------------------------------------------------------------------------
// CAudioMDParser::ConstructL
// 
// -----------------------------------------------------------------------------
//
void CAudioMDParser::ConstructL( const TBool aAlbumArt )
    {
    iMetaDataUtility = CMetaDataUtility::NewL();

    // initialize metadata field list for CMetaDataUtility (iMetaDataUtility)
    iWantedMetadataFields.AppendL( EMetaDataSongTitle );
    iWantedMetadataFields.AppendL( EMetaDataArtist );
    iWantedMetadataFields.AppendL( EMetaDataAlbum );
    iWantedMetadataFields.AppendL( EMetaDataGenre );
    iWantedMetadataFields.AppendL( EMetaDataComposer );
    iWantedMetadataFields.AppendL( EMetaDataRating );
    iWantedMetadataFields.AppendL( EMetaDataAlbumTrack );
    iWantedMetadataFields.AppendL( EMetaDataOriginalArtist );
    iWantedMetadataFields.AppendL( EMetaDataDuration );
    iWantedMetadataFields.AppendL( EMetaDataCopyright );
    iWantedMetadataFields.AppendL( EMetaDataDate );
    
    if( aAlbumArt )
        {
        iWantedMetadataFields.AppendL( EMetaDataJpeg );
        }
    
    TLinearOrder< TMimeTypeMapping<TAudioMetadataHandling> > cmp(
    		TMimeTypeMapping<TAudioMetadataHandling>::CompareFunction);

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionMp3(), KMimeTypeMpeg(), 
    		EMetaDataUtilityHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionAac(), KMimeTypeAac(), 
    		EMetaDataUtilityHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionAmr(), KMimeTypeAmr(), 
    		EMetaDataUtilityHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionAwb(), KMimeTypeAwb(), 
    		EMetaDataUtilityHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
        	KExtensionWma(), KMimeTypeWma(), 
        	EMetaDataUtilityHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionMid(), KMimeTypeMidi(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionMidi(), KMimeTypeMidi(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionSpMid(), KMimeTypeSpMidi(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionRng(), KMimeTypeRng(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionMxmf(), KMimeTypeMxmf(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionWav(), KMimeTypeWav(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionAu(), KMimeTypeAu(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
    		KExtensionNrt(), KMimeTypeRng(), 
    		EFileSystemHandling ), cmp ) );
    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TAudioMetadataHandling>(
            KExtensionMka(), KMimeTypeAudioMatroska(), 
            EMetaDataUtilityHandling ), cmp ) );

    }


// -----------------------------------------------------------------------------
// CAudioMDParser::ParseMimeType
// 
// -----------------------------------------------------------------------------
//
const TMimeTypeMapping<TAudioMetadataHandling>* CAudioMDParser::ParseMimeType( 
		const TDesC& aFileName )
    {
    TPtrC ext;
    if( MdsUtils::GetExt( aFileName, ext ) )
    	{
    	TMimeTypeMapping<TAudioMetadataHandling> finder(ext);
    	
    	TLinearOrder< TMimeTypeMapping<TAudioMetadataHandling> > cmp(
    			TMimeTypeMapping<TAudioMetadataHandling>::CompareFunction);
    	
    	TInt pos = iMimeTypeMappings.FindInOrder( finder, cmp );
    	
    	if( KErrNotFound != pos )
    		{
    		iLastParsedFileMimeType = pos;
    		return &iMimeTypeMappings[ pos ];
    		}
    	}

    return NULL;
    }


// -----------------------------------------------------------------------------
// CAudioMDParser::ParseL
// 
// -----------------------------------------------------------------------------
//
TBool CAudioMDParser::ParseL( const TDesC& aFileName )
    {
    TBuf8<KMaxDataTypeLength> mime;
    mime.Copy( iMimeTypeMappings[ iLastParsedFileMimeType ].iMimeType );
    iMetaDataUtility->OpenFileL( aFileName, iWantedMetadataFields, mime );
    
    return iMetaDataUtility->MetaDataCount() > 0;
    }


// -----------------------------------------------------------------------------
// CAudioMDParser::MetaDataFieldL
// 
// -----------------------------------------------------------------------------
//
TPtrC CAudioMDParser::MetaDataFieldL( TInt aFieldId )
    {
    const CMetaDataFieldContainer& metaCont = iMetaDataUtility->MetaDataFieldsL();
    
    TMetaDataFieldId id = MapFieldId( aFieldId );
    return metaCont.Field( id );  // returns KNullDesC if not found
    }

// -----------------------------------------------------------------------------
// CAudioMDParser::MetaDataFieldL
// 
// -----------------------------------------------------------------------------
//
TPtrC8 CAudioMDParser::MetaDataField8L( TInt aFieldId )
    {
    const CMetaDataFieldContainer& metaCont = iMetaDataUtility->MetaDataFieldsL();
    
    TMetaDataFieldId id = MapFieldId( aFieldId );
    return metaCont.Field8( id );  // returns KNullDesC if not found
    }

// -----------------------------------------------------------------------------
// CAudioMDParser::ResetL
// 
// -----------------------------------------------------------------------------
//
void CAudioMDParser::ResetL()
    {
    iMetaDataUtility->ResetL();
    }

// -----------------------------------------------------------------------------
// CAudioMDParser::MapFieldId
// 
// -----------------------------------------------------------------------------
//
TMetaDataFieldId CAudioMDParser::MapFieldId( TInt aFieldId )
    {
    TMetaDataFieldId id = EMetaDataSongTitle;
    
    switch ( aFieldId )
        {
        case EAudioMDFieldSong:
            {
            id = EMetaDataSongTitle;
            break;
            }
        case EAudioMDFieldArtist:
            {
            id = EMetaDataArtist;
            break;
            }
        case EAudioMDFieldAlbum:
            {
            id = EMetaDataAlbum;
            break;
            }
        case EAudioMDFieldGenre:
            {
            id = EMetaDataGenre;
            break;
            }
        case EAudioMDFieldComposer:
            {
            id = EMetaDataComposer;
            break;
            }
        case EAudioMDFieldRating:
            {
            id = EMetaDataRating;
            break;
            }
        case EAudioMDFieldTrack:
            {
            id = EMetaDataAlbumTrack;
            break;
            }
        case EAudioMDFieldOriginalArtist:
            {
            id = EMetaDataOriginalArtist;
            break;
            }
        case EAudioMDFieldDuration:
            {
            id = EMetaDataDuration;
            break;
            }
        case EAudioMDFieldCopyright:
            {
            id = EMetaDataCopyright;
            break;
            }
        case EAudioMDFieldDate:
            {
            id = EMetaDataDate;
            break;
            }
        case EAudioMDFieldJpeg:
            {
            id = EMetaDataJpeg;
            break;
            }

        default:
            {
#ifdef _DEBUG
            _LIT( KPanicCategory,"HarvesterAudioPlugin" );
            __ASSERT_DEBUG( EFalse, User::Panic( KPanicCategory,  KErrArgument ) );
#endif
            break;
            }
        }
        
    return id;
    }