/*

* 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

*  Version     : %version: da1mmcf#38.1.4.2.6.1.5 % << Don't touch! Updated by Synergy at check-out.

*

*/

#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 "mpxmetadataextractor.h"

#include "mpxfileinfoutility.h"

#ifdef RD_MPX_TNM_INTEGRATION

_LIT( KImageFileType, "image/jpeg" );

const TInt KMPXTimeoutTimer = 3000000; // 3 seconds

const TInt KMPXMaxThumbnailRequest = 5; 

#endif //RD_MPX_TNM_INTEGRATION

//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 ),

                                    iOutstandingThumbnailRequest(0),

                                    iTNMBlockCount(0)

    {

    }

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

// 2nd Phase Constructor

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

//

void CMPXMetadataExtractor::ConstructL()

    {

    iMetadataUtility = CMetaDataUtility::NewL();

    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    iFileInfoUtil    = CMPXFileInfoUtility::NewL();

#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 );

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

#ifdef RD_MPX_TNM_INTEGRATION

    delete iTNManager;

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

        {

        iTNSyncWait->AsyncStop();

        }

    delete iTNSyncWait;

    delete iTimer;

#endif //RD_MPX_TNM_INTEGRATION

    MPX_DEBUG2("CMPXMetadataExtractor: TNM Block Count: %d ", iTNMBlockCount );

    }

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

// Constructs a media properties object

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

//

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

                                                   CMPXMedia*& aNewProperty,

                                                   TBool aMetadataOnly )

    {

    // make a copy of aFile

    HBufC* fileName = HBufC::NewL(KMaxFileName);

    CleanupStack::PushL( fileName );

    fileName->Des().Append( aFile );

    MPX_DEBUG2("CMPXMetadataExtractor::CreateMediaL %S <---", fileName );

    RArray<TInt> contentIDs;

    contentIDs.AppendL( KMPXMediaIdGeneral );

    contentIDs.AppendL( KMPXMediaIdAudio );

    contentIDs.AppendL( KMPXMediaIdMusic );

    contentIDs.AppendL( KMPXMediaIdDrm );

    contentIDs.AppendL( KMPXMediaIdMTP );

    aNewProperty = NULL;

    CMPXMedia* media = CMPXMedia::NewL( contentIDs.Array() );

    CleanupStack::PushL( media );

    contentIDs.Close();

    // CMPXMedia default types

    media->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType,

                                              EMPXItem );

    media->SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory,

                                                  EMPXSong );

    TParsePtrC parse( *fileName );

    // Title, default is file name

    media->SetTextValueL( KMPXMediaGeneralTitle,

                          parse.Name() );

    // Default album track

    media->SetTextValueL( KMPXMediaMusicAlbumTrack,

                          KNullDesC );

    // Set the Mime Type and collection UID

    //

    if( !aMetadataOnly )

        {

        TInt index(KErrNotFound);

        TInt count( iSupportedTypes.Count() );

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

            {

            TInt index2(KErrNotFound);

            const CDesCArray& exts = iSupportedTypes[i]->Extensions();

            const TDesC& ext = parse.Ext();

            if (!exts.FindIsq(ext, index2))

                { // found

                index = i;

                break;

                }

            }

        if( KErrNotFound != index )

            {

            MPX_DEBUG1("CMPXMetadataExtractor::CreateMediaPropertiesL apparc <---" );

            TInt mimeIndex = SupportedContainerTypeL( *fileName, index );

            User::LeaveIfError( mimeIndex );

            MPX_DEBUG1("CMPXMetadataExtractor::CreateMediaPropertiesL apparc --->" );

            media->SetTextValueL( KMPXMediaGeneralMimeType,

                                  iSupportedTypes[index]->Mimetypes()[mimeIndex] );

            media->SetTObjectValueL( KMPXMediaGeneralCollectionId,

                                     iSupportedTypes[index]->Uid() );

            }

        else

            {

            User::Leave(KErrNotSupported);

            }

        }

    else // other case use apparc to fetch and set mimetype

        {

        TDataType dataType;

        TUid dummyUid(KNullUid);

        iAppArc.AppForDocument(*fileName, dummyUid, dataType);

        media->SetTextValueL( KMPXMediaGeneralMimeType,dataType.Des() );

        }

    // Use file handle here

    //

    RFile file;

    TInt err = file.Open( iFs, *fileName, EFileRead | EFileShareReadersOrWriters );

    CleanupClosePushL(file);

    // Metadata related

    //

    if( err == KErrNone )

        {

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

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

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

        TRAPD( metadataerror, iMetadataUtility->OpenFileL( file, *mimeType8 ) );

        CleanupStack::PopAndDestroy( mimeType8 );

        // No problem

        if( KErrNone == metadataerror )

            {

            // Add TRAPD to capture exception KErrNoMemory.

            //If album art size is too large, trap this exception and SetDefaultL.

            //Fix EYLU-7ESE5L

            TRAPD( err, SetMediaPropertiesL( *media, *fileName ) );

            if ( KErrNoMemory == err )

                {

                SetDefaultL( *media );

                }

            }

        else  // Error, Set defaults

            {

            SetDefaultL( *media );

            }

        // Reset the utility

        iMetadataUtility->ResetL();

        }

    else // Error, Set defaults

        {

        SetDefaultL( *media );

        }

    // Common properties that we can extract

    //

    SetExtMediaPropertiesL( *media, *fileName, aMetadataOnly, file, err );

    CleanupStack::PopAndDestroy(&file);

    // Set the pointers now that the object is ready

    //

    CleanupStack::Pop( media );

    aNewProperty = media;

    CleanupStack::PopAndDestroy( fileName );

    MPX_DEBUG1("CMPXMetadataExtractor::CreateMediaPropertiesL --->");

    }

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

// Sets all of the default media properties

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

//

void CMPXMetadataExtractor::SetDefaultL( CMPXMedia& aMediaProp )

    {

    // 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( CMPXMedia& aMedia,

                                                 const TDesC& aFile )

    {

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

    const CMetaDataFieldContainer& metaCont =

                                          iMetadataUtility->MetaDataFieldsL();

    TInt count( metaCont.Count() );

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

        {

        TMetaDataFieldId fieldType;

        HBufC* value = NULL;

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

        CleanupStack::PushL(value);

        if ( KErrNone != err )

        {

            CleanupStack::PopAndDestroy(value);

            continue;

        }

        switch( fieldType )

            {

            case EMetaDataSongTitle:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    aMedia.SetTextValueL(KMPXMediaGeneralTitle, *value);

                    }

                break;

                }

            case EMetaDataArtist:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    aMedia.SetTextValueL(KMPXMediaMusicArtist, *value);

                    }

                break;

                }

            case EMetaDataAlbum:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    aMedia.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 );

                aMedia.SetTObjectValueL<TInt64>( KMPXMediaMusicYear,

                                                 time.Int64() );

                break;

                }

            case EMetaDataComment:

                {

                aMedia.SetTextValueL( KMPXMediaGeneralComment,

                                      *value );

                break;

                }

            case EMetaDataAlbumTrack:

                {

                aMedia.SetTextValueL( KMPXMediaMusicAlbumTrack,

                                      *value );

                break;

                }

            case EMetaDataGenre:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    aMedia.SetTextValueL(KMPXMediaMusicGenre, *value);

                    }

                break;

                }

            case EMetaDataComposer:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    aMedia.SetTextValueL(KMPXMediaMusicComposer, *value);

                    }

                break;

                }

            case EMetaDataUrl:

            case EMetaDataUserUrl:  // fall through

                {

                aMedia.SetTextValueL( KMPXMediaMusicURL,

                                      *value );

                break;

                }

            case EMetaDataJpeg:

                {

#ifdef RD_MPX_TNM_INTEGRATION

                MPX_PERF_START(CMPXMetadataExtractor_SetMediaPropertiesL_JPEG_TNM);

                HBufC8* value8 = MPXUser::Alloc8L(metaCont.At( i, fieldType ));

                CleanupStack::PushL( value8 );

                AddMediaAlbumArtL( aMedia, aFile, *value8 );

                CleanupStack::Pop(value8);

                MPX_PERF_END(CMPXMetadataExtractor_SetMediaPropertiesL_JPEG_TNM);

#else //RD_MPX_TNM_INTEGRATION

                aMedia.SetTextValueL( KMPXMediaMusicAlbumArtFileName,

                                      aFile );

#endif //RD_MPX_TNM_INTEGRATION

                break;

                }

            case EMetaDataCopyright:

                {

                aMedia.SetTextValueL( KMPXMediaGeneralCopyright,

                                      *value );

                break;

                }

            case EMetaDataOriginalArtist:  // fall through

            case EMetaDataVendor:          // fall through

            case EMetaDataRating:          // fall through

            case EMetaDataUniqueFileIdentifier:  // fall through

            case EMetaDataDuration:        // fall through

            case EMetaDataDate:            // fall through

                {

                // not used

                break;

                }

            default:

                {

                //ASSERT(0);

                break;

                }

            }

        CleanupStack::PopAndDestroy(value);

        }

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

    }

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

// Sets extra media properties not returned by metadata utilities

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

//

void CMPXMetadataExtractor::SetExtMediaPropertiesL( CMPXMedia& aProp, 

                                                    const TDesC& aFile,

                                                    TBool aMetadataOnly,

                                                    RFile& aFileHandle,

                                                    TInt aFileErr )

    {

    MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL <---");

    // DB Flags to set

    //

    TUint dbFlags(KMPXMediaGeneralFlagsSetOrUnsetBit);

    // File Path

    //

    TParsePtrC parse( aFile );

    aProp.SetTextValueL( KMPXMediaGeneralUri,

                         aFile );

    aProp.SetTextValueL( KMPXMediaGeneralDrive,

                         parse.Drive() );

    // DRM Rights

    //

    CMPXMedia* drm = NULL;

    TRAPD( drmError, iDrmMediaUtility->InitL( aFile );

                     drm = CMPXMedia::NewL( *iDrmMediaUtility->GetMediaL( KMPXMediaDrmProtected.iAttributeId |

                                                                          KMPXMediaDrmRightsStatus.iAttributeId ) );

         );

    TBool prot(EFalse);

    if( drm )

        {

        CleanupStack::PushL( drm );

        MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL -- is a drm file");

        if( drm->IsSupported( KMPXMediaDrmProtected ) )

            {

            prot = drm->ValueTObjectL<TBool>( KMPXMediaDrmProtected );

            MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL protected %i", prot);

            }