/*

* 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 "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 ),

    {

    }

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

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

    }

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

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

//

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

                                                   CMPXMedia*& aNewProperty,

                                                   TBool aMetadataOnly )

    {

        {

            {

                }

            }

        }

    }

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

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

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

//

    {

    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 )

           {

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

           if ( KErrNone != err )

               {

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

               continue;

               }     

           }

        switch( fieldType )

            {

            case EMetaDataSongTitle:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    }

                break;

                }

            case EMetaDataArtist:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    }

                break;

                }

            case EMetaDataAlbum:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    }

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

                                                 time.Int64() );

                break;

                }

            case EMetaDataComment:

                {

                                      *value );

                break;

                }

            case EMetaDataAlbumTrack:

                {

                                      *value );

                break;

                }

            case EMetaDataGenre:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    }

                break;

                }

            case EMetaDataComposer:

                {

                TPtr valptr = value->Des();

                valptr.Trim();

                TInt vallen = value->Length();

                if (vallen>0)

                    {

                    FindAndReplaceForbiddenChars(valptr, vallen);

                    }

                break;

                }

            case EMetaDataUrl:

            case EMetaDataUserUrl:  // fall through

                {

                                      *value );

                break;

                }

            case EMetaDataJpeg:

                {

                break;

                }

            case EMetaDataCopyright:

                {

                                      *value );

                break;

                }

            case EMetaDataDuration:     

                {                  

                MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, 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]

                                                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

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

//

    {

    // DB Flags to set

    //

    TUint dbFlags(KMPXMediaGeneralFlagsSetOrUnsetBit);

    // File Path

    //

    // DRM Rights

    //

    CMPXMedia* drm = NULL;

         );

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

            }

        TMPXMediaDrmRightsStatus status(EMPXDrmRightsFull);

        if( drm->IsSupported( KMPXMediaDrmRightsStatus ) )

            {

            status = drm->ValueTObjectL<TMPXMediaDrmRightsStatus>(KMPXMediaDrmRightsStatus);

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

            }

        // Set DB flags

        dbFlags |= KMPXMediaGeneralFlagsIsDrmProtected;

        if( status != EMPXDrmRightsFull && status != EMPXDrmRightsRestricted && status != EMPXDrmRightsPreview )

            {

            dbFlags |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid;

            }

        CleanupStack::PopAndDestroy( drm );

        }

    // Trapped PV DRM error. If -46, we know the file has no rights

    //

    if( drmError == KErrPermissionDenied )

        {

        dbFlags |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid;

        }

    else

        {

        User::LeaveIfError( drmError );

        }

    iDrmMediaUtility->Close();