/*

* Copyright (c) 2006 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:  Extracts metadata from a file

*

*/

#include <e32base.h>

#include <badesca.h>

#include <apgcli.h>

#include <MetaDataUtility.h>

#include <MetaDataFieldContainer.h>

#ifdef RD_MPX_TNM_INTEGRATION

#include <hash.h>

#include <f32file.h>

#include <sysutil.h>

#include <thumbnailmanager.h>

#endif //RD_MPX_TNM_INTEGRATION

#include <mpxlog.h>

#include <mpxmedia.h>

#include <mpxcollectionpath.h>

#include <mpxcollectiontype.h>

#include <mpxdrmmediautility.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediamtpdefs.h>

#include <mpxmetadataextractorobserver.h>

#include "mpxmetadataextractor.h"

#include "mpxfileinfoutility.h"

_LIT( KWmaMimeType, "audio/x-ms-wma" );

_LIT( KWmaCafMimeType, "x-caf-audio/x-ms-wma" );

#ifdef RD_MPX_TNM_INTEGRATION

_LIT( KImageFileType, "image/jpeg" );

const TInt KMPXTimeoutTimer = 3000000; // 3 seconds

const TInt KMPXMaxThumbnailRequest = 2; 

#endif //RD_MPX_TNM_INTEGRATION

#ifdef ABSTRACTAUDIOALBUM_INCLUDED

_LIT( KNonEmbeddedArtExt, ".alb" );

#endif

//Helper functions

static void FindAndReplaceForbiddenChars(TDes& aString, TInt aLen)

    {

    MPX_ASSERT(aLen == aString.Length());

    for (TInt i = 0; i < aLen; ++i)

        {

        if (aString[i] == TText('\t'))

            {

            aString[i] = TText(' ');

            }

        }

    }

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CMPXMetadataExtractor::CMPXMetadataExtractor(

                                  RFs& aFs,

                                  RApaLsSession& aAppArc,

                                  RPointerArray<CMPXCollectionType>& aTypes  )

                                  : iFs( aFs ),

                                    iAppArc( aAppArc ),

                                    iSupportedTypes( aTypes ),

                                    iCancelled( EFalse ),

                                    iObs( NULL ),

                                    iMedia( NULL ),

                                    iMetadataOnly( EFalse ),

                                    iFileOpenError( KErrNone )

    {

    }

// ---------------------------------------------------------------------------

// 2nd Phase Constructor

// ---------------------------------------------------------------------------

//

void CMPXMetadataExtractor::ConstructL()

    {

    iMetadataUtility = CMetaDataUtility::NewL();

    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    iFileInfoUtil    = CMPXFileInfoUtility::NewL();

    iTaskTimer = CPeriodic::NewL( CActive::EPriorityIdle );

#ifdef RD_MPX_TNM_INTEGRATION

    // Create Thumbnail Manager instance. This object is the observer.

    iTNManager = CThumbnailManager::NewL( *this );

    iTNManager->SetFlagsL( CThumbnailManager::EDefaultFlags );

    iTNManager->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQuality);

    // create wait loop

    iTNSyncWait = new (ELeave) CActiveSchedulerWait;

    iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    iArrayTNRequestId.Reset();

    iArrayTasks.Reset();

#endif //RD_MPX_TNM_INTEGRATION

    }

// ---------------------------------------------------------------------------

// Two-Phased Constructor

// ---------------------------------------------------------------------------

//

EXPORT_C CMPXMetadataExtractor* CMPXMetadataExtractor::NewL(

                                  RFs& aFs,

                                  RApaLsSession& aAppArc,

                                  RPointerArray<CMPXCollectionType>& aTypes  )

    {

    CMPXMetadataExtractor* self = new( ELeave ) CMPXMetadataExtractor( aFs,

                                                                       aAppArc,

                                                                       aTypes );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CMPXMetadataExtractor::~CMPXMetadataExtractor()

    {

    delete iMetadataUtility;

    delete iFileInfoUtil;

    delete iDrmMediaUtility;

    delete iTaskTimer;

    iFile.Close();

    if ( iMedia != NULL )

        {

        delete iMedia;

        }

#ifdef RD_MPX_TNM_INTEGRATION

    delete iTNManager;

    if (iTNSyncWait && iTNSyncWait->IsStarted() )

        {

        iTNSyncWait->AsyncStop();

        }

    delete iTNSyncWait;

    delete iTimer;

    iArrayTNRequestId.Close();

    iArrayTasks.Close();

#endif //RD_MPX_TNM_INTEGRATION

    }

// ---------------------------------------------------------------------------

// Constructs a media properties object : synchronous function

// ---------------------------------------------------------------------------

//

EXPORT_C void CMPXMetadataExtractor::CreateMediaL( const TDesC& aFile,

                                                   CMPXMedia*& aNewProperty,

                                                   TBool aMetadataOnly )

    {

    MPX_FUNC("CMPXMetadataExtractor::CreateMediaL()");

    // check if we are still processing a request.

    if ( iArrayTasks.Count() )

        {

        MPX_DEBUG1("CMPXMetadataExtractor::CreateMediaL Request ongoing. Abort!" );

        User::Leave( KErrAbort );

        }

    iCancelled = EFalse;

    iFileOpenError = KErrNone;

    iObs = NULL;

    aNewProperty = NULL;

    iFileName = aFile;

    iMetadataOnly = aMetadataOnly;

    // populate the task array

    AddTasksL();

    // execute all tasks in the array

    while ( iArrayTasks.Count() )

        {

        // execute task at index 0

        MPX_TRAPD( error, ExecuteTaskL() );

        if ( error || iCancelled )

            {

            // cleanup

            if ( iMedia != NULL )

                {

                delete iMedia;

                iMedia = NULL;

                }

            iArrayTasks.Reset();

            if ( error )

                {

                CleanUp();

                User::LeaveIfError( error );

                }

            break;

            }

        iArrayTasks.Remove( 0 );

        }

    aNewProperty = iMedia;

    iMedia = NULL;  // ownership transferred.

    CleanUp();

    }

// ---------------------------------------------------------------------------

// Sets all of the default media properties

// ---------------------------------------------------------------------------

//

void CMPXMetadataExtractor::SetDefaultL( CMPXMedia& aMediaProp )

    {

    MPX_FUNC("CMPXMetadataExtractor::SetDefaultL()");

    // Comment

    aMediaProp.SetTextValueL( KMPXMediaGeneralComment,

                              KNullDesC );

    // Artist

    aMediaProp.SetTextValueL( KMPXMediaMusicArtist,

                              KNullDesC );

    // Album

    aMediaProp.SetTextValueL( KMPXMediaMusicAlbum,

                              KNullDesC );

    // Year

    aMediaProp.SetTObjectValueL<TInt64>( KMPXMediaMusicYear,

                                         (TInt64) 0 );

    // Track

    aMediaProp.SetTextValueL( KMPXMediaMusicAlbumTrack,

                              KNullDesC );

    // Genre

    aMediaProp.SetTextValueL( KMPXMediaMusicGenre,

                              KNullDesC );

    // Composer

    aMediaProp.SetTextValueL( KMPXMediaMusicComposer,

                              KNullDesC );

    // Album artFilename

    aMediaProp.SetTextValueL( KMPXMediaMusicAlbumArtFileName,

                              KNullDesC );

    // URL

    aMediaProp.SetTextValueL( KMPXMediaMusicURL,

                              KNullDesC );

    }

// ---------------------------------------------------------------------------

// Sets media object attributes from metadata utilities

// ---------------------------------------------------------------------------

//

void CMPXMetadataExtractor::SetMediaPropertiesL()

    {

    MPX_FUNC("CMPXMetadataExtractor::SetMediaPropertiesL()");

    const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );

    HBufC8* mimeType8 = HBufC8::NewLC( mimeType.Length() );

    mimeType8->Des().Append( mimeType );

    // Continue to extract metadata even if fail.

    MPX_TRAPD( metadataerror, iMetadataUtility->OpenFileL( iFile, *mimeType8 ) );

    CleanupStack::PopAndDestroy( mimeType8 );

    // Get MetadataUtility Container

    const CMetaDataFieldContainer& metaCont = iMetadataUtility->MetaDataFieldsL();

    // Get DRM data

    // Need the protected flag from metadataUtility Container

    MPX_TRAPD( drmerror, SetDrmMediaPropertiesL( metaCont ) );

    MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, result=%d getting drm data", 

            drmerror );

    // Get metadata fields

    TInt count( metaCont.Count() );

    for( TInt i=0; i<count; ++i )

        {

        TMetaDataFieldId fieldType;

        HBufC* value = NULL;

        metaCont.FieldIdAt( i, fieldType );  // get the field type

        // get the value, except for album art

        if ( fieldType != EMetaDataJpeg )

           {

            MPX_TRAPD( err, value = metaCont.At( i, fieldType ).AllocL() );

           if ( KErrNone != err )

               {

               MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL - error = %i", err);           

               continue;

               }     

           CleanupStack::PushL( value );

           }

        switch( fieldType )

            {

            case EMetaDataSongTitle:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    iMedia->SetTextValueL(KMPXMediaGeneralTitle, *value);

                    }

                break;

                }

            case EMetaDataArtist:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    iMedia->SetTextValueL(KMPXMediaMusicArtist, *value);

                    }

                break;

                }

            case EMetaDataAlbum:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    iMedia->SetTextValueL(KMPXMediaMusicAlbum, *value );

                    }

                break;

                }

            case EMetaDataYear:

                {

                // Perform the date time conversion

                TLex lexer( *value );

                TInt year( 0 );

                lexer.Val( year );

                // Convert from TInt -> TDateTime -> TTime -> TInt64

                TDateTime dt;

                dt.SetYear( year );

                TTime time( dt );

                iMedia->SetTObjectValueL<TInt64>( KMPXMediaMusicYear,

                                                 time.Int64() );

                break;

                }

            case EMetaDataComment:

                {

                iMedia->SetTextValueL( KMPXMediaGeneralComment,

                                      *value );

                break;

                }

            case EMetaDataAlbumTrack:

                {

                iMedia->SetTextValueL( KMPXMediaMusicAlbumTrack,

                                      *value );

                break;

                }

            case EMetaDataGenre:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    iMedia->SetTextValueL(KMPXMediaMusicGenre, *value);

                    }

                break;

                }

            case EMetaDataComposer:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    iMedia->SetTextValueL(KMPXMediaMusicComposer, *value);

                    }

                break;

                }

            case EMetaDataUrl:

            case EMetaDataUserUrl:  // fall through

                {

                iMedia->SetTextValueL( KMPXMediaMusicURL,

                                      *value );

                break;

                }

            case EMetaDataJpeg:

                {

                // Album art handled in AddMediaAlbumArtL()

                break;

                }

            case EMetaDataCopyright:

                {

                iMedia->SetTextValueL( KMPXMediaGeneralCopyright,

                                      *value );

                break;

                }

            case EMetaDataDuration:     

                {                  

                const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );

                MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, mimeType = %S", &mimeType);   

                // Verify if WMA, get the duration

                if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 )

                    {

                    MPX_DEBUG1("CMPXMetadataExtractor::SetMediaPropertiesL- WMA");                         

                    // Perform the duration conversion

                    TLex lexer( *value );

                    TInt32 duration ( 0 );

                    lexer.Val( duration );   // [second]      

                    duration *= 1000;        // [msec]

                    iMedia->SetTObjectValueL<TInt32>( KMPXMediaGeneralDuration,

                                                duration );      

                    MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL- duration = %i", duration);  

                    }

                break;

                }

            case EMetaDataOriginalArtist:  // fall through

            case EMetaDataVendor:          // fall through

            case EMetaDataRating:          // fall through

            case EMetaDataUniqueFileIdentifier:  // fall through

            case EMetaDataDate:            // fall through

                {

                // not used

                break;

                }

            default:

                {

                //ASSERT(0);

                break;

                }

            }

        if (fieldType != EMetaDataJpeg)

            {

            CleanupStack::PopAndDestroy( value );       

            }

        }

    }

// ---------------------------------------------------------------------------

// Sets extra media properties not returned by metadata utilities

// ---------------------------------------------------------------------------

//

void CMPXMetadataExtractor::SetExtMediaPropertiesL()

    {

    MPX_FUNC("CMPXMetadataExtractor::SetExtMediaPropertiesL()");

    //

    // File Size --- The following needs MMF support

    //

    TInt size( 0 );

    if( iFileOpenError == KErrNone )

        {

        const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );

        MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, mimeType = %S", &mimeType);   

        iFile.Size( size );

        iMedia->SetTObjectValueL<TInt>( KMPXMediaGeneralSize, size );

        // Verify if WMA, skip getting info from MMF

        if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 )

            {

            // No need to get MMF support

            MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, skip MMF ");   

            }

        else

            {

            MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, get MMF controller");   

            // Duration, bitrate, samplerate, etc

            //

            if( !iMetadataOnly )

            {

                MPX_TRAPD(err2, iFileInfoUtil->OpenFileL(

                          iFile, 

                          iMedia->ValueText(KMPXMediaGeneralMimeType)));

                MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, file info util error %i", err2);

                if( KErrNone == err2 )

                    {

                    iMedia->SetTObjectValueL<TUint>( KMPXMediaAudioBitrate,

                                                   iFileInfoUtil->BitRate() );

                    iMedia->SetTObjectValueL<TUint>( KMPXMediaAudioSamplerate,

                                                   iFileInfoUtil->SampleRate() );

                    TInt64 duration = (TInt64) iFileInfoUtil->Duration().Int64() / 1000; // ms

                    iMedia->SetTObjectValueL<TInt32>( KMPXMediaGeneralDuration,

                                                    duration );

                    MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL -- duration %i", duration);

                    }

                iFileInfoUtil->Reset();