/*

* 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:  Meta data Mpx access

*

*/

// from Symbian MTP

#include <mtp/tmtptypeuint8.h>

#include <mtp/tmtptypeuint16.h>

#include <mtp/tmtptypeuint32.h>

#include <mtp/tmtptypeuint64.h>

#include <mtp/tmtptypeuint128.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtptypearray.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mtpprotocolconstants.h>

// from MPX

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediamtpdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionhelper.h>

#include <pathinfo.h>

#include "cmmmtpdpmetadatampxaccess.h"

#include "mmmtpdplogger.h"

#include "mmmtpdputility.h"

#include "tmmmtpdppanic.h"

#include "tobjectdescription.h"

static const TInt KMtpInvalidSongID = 0x1FFFFFFF;

static const TInt KMtpChannelMono = 1;

static const TInt KMtpChannelStereo = 2;

_LIT( KMtpDateTimeConnector, "T" );

_LIT( KEmptyText, "" );

#if defined(_DEBUG) || defined(MMMTPDP_PERFLOG)

_LIT( KMpxCollectionNewL, "MpxCollectionNewL" );

_LIT( KMpxCollectionAddL, "MpxCollectionAddL" );

_LIT( KMpxCollectionGetL, "MpxCollectionGetL" );

_LIT( KMpxCollectionSetL, "MpxCollectionSetL" );

_LIT( KMpxCollectionSetReferenceL, "MpxCollectionSetReferenceL" );

_LIT( KMpxCollectionGetAbstractMedia, "MpxCollectionGetAbstractMedia" );

_LIT( KMpxCollectionGetReference, "MpxCollectionGetReference" );

_LIT( KMpxCollectionFindAllLValidate, "MpxCollectionValidate" );

_LIT( KMpxCollectionFindAllLBeforeAdd, "MpxCollectionFindAllLBeforeAdd" );

_LIT( KMpxCollectionFindAllLModified, "MpxCollectionFindAllLModified" );

_LIT( KMpxCollectionCleanupDeletedMediasL, "KMpxCollectionCleanupDeletedMediasL" );

_LIT( KSetMetadataValue, "SetMetadataValueL" );

#endif

CMmMtpDpMetadataMpxAccess* CMmMtpDpMetadataMpxAccess::NewL( RFs& aRfs )

    {

    CMmMtpDpMetadataMpxAccess* self = new( ELeave ) CMmMtpDpMetadataMpxAccess( aRfs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CMmMtpDpMetadataMpxAccess::CMmMtpDpMetadataMpxAccess( RFs& aRfs ) :

    iRfs( aRfs ),

    iSampleData( NULL ),

    iHasCleanUp( EFalse )

    {

    // Do nothing

    }

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

// CMmMtpDpMetadataMpxAccess::ConstructL

// Second-phase

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

//

void CMmMtpDpMetadataMpxAccess::ConstructL()

    {

    // for performance measurement purpose

#if defined(_DEBUG) || defined(MMMTPDP_PERFLOG)

    iPerfLog = CMmMtpDpPerfLog::NewL( _L( "CMmMtpDpMetadataMpxAccess" ) );

#endif

    }

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

// CMmMtpDpMetadataMpxAccess::~CMmMtpDpMetadataMpxAccess

// Destructor

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

//

CMmMtpDpMetadataMpxAccess::~CMmMtpDpMetadataMpxAccess()

    {

    if ( iCollectionHelper != NULL )

        {

        iCollectionHelper->Close();

        iCollectionHelper = NULL;

        }

    delete iSampleData;

    // for performance measurement purpose

#if defined(_DEBUG) || defined(MMMTPDP_PERFLOG)

    delete iPerfLog;

#endif

    }

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

// CMmMtpDpMetadataMpxAccess::OpenSession

// This is introduced to fix CollectionHelper Flush problem

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

//

void CMmMtpDpMetadataMpxAccess::OpenSession()

    {

    // do nothing

    }

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

// CMmMtpDpMetadataMpxAccess::CloseSession

// This is introduced to fix CollectionHelper Flush problem

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

//

void CMmMtpDpMetadataMpxAccess::CloseSession()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::CloseSession" ) );

    // flush cache

    if ( iCollectionHelper != NULL )

        {

        PRINT( _L( "MM MTP <> Delete & Close CollectionHelper" ) );

        iCollectionHelper->Close();

        iCollectionHelper = NULL;

        }

    iHasCleanUp = EFalse;  // must reset, as class is not always destoryed

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataMpxAccess::CloseSession" ) );

    }

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

// CMmMtpDpMetadataMpxAccess::GetObjectMetadataValueL

// Gets a piece of metadata from the collection

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

//

void CMmMtpDpMetadataMpxAccess::GetObjectMetadataValueL( const TUint16 aPropCode,

    MMTPType& aNewData,

    const TDesC& aFullFileName,

    TMPXGeneralCategory aCategory )

    {

    PRINT1( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::GetObjectMetadataValueL aPropCode = 0x%x" ), aPropCode );

    PERFLOGSTART( KMpxCollectionGetL );

    const CMPXMedia& media = CollectionHelperL()->GetL( aFullFileName, aCategory );

    PERFLOGSTOP( KMpxCollectionGetL );

    TMPXAttributeData attrib( MpxAttribFromPropL( aPropCode ) );

    TBool isSupported = media.IsSupported( attrib );

    PRINT1(_L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValueL isSupported = %d" ), isSupported );

    if ( aPropCode != EMTPObjectPropCodeOriginalReleaseDate

        && aPropCode != EMTPObjectPropCodeDRMStatus

        && !isSupported )

        {

        User::Leave( KErrNotSupported );

        }

    switch ( aPropCode )

        {

        case EMTPObjectPropCodeName:

        case EMTPObjectPropCodeArtist:

        case EMTPObjectPropCodeAlbumName:

        case EMTPObjectPropCodeComposer:

        case EMTPObjectPropCodeGenre:

        case EMTPObjectPropCodeAlbumArtist:

            {

            if ( EMTPTypeString == aNewData.Type() )

                {

                ( ( CMTPTypeString& ) aNewData ).SetL( media.ValueText( attrib ) );

                }

            else

                {

                User::Leave( KErrArgument );

                }

            }

            break;

        case EMTPObjectPropCodeDescription:

            {

            HBufC* data;

            data = media.ValueText( KMPXMediaGeneralComment ).AllocLC(); // + data

            PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue data = %S" ), data );

            if ( EMTPTypeAUINT16 == aNewData.Type() )

                {

                TInt len = data->Length();

                PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue len = %d" ),len );

                if( len != 0 )

                    {

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

                        ( ( CMTPTypeArray& ) aNewData ).AppendUintL( (*data)[i] );

                    }

                }

            else

                {

                User::Leave( KErrArgument );

                }

            CleanupStack::PopAndDestroy( data ); // - data

            }

            break;

        case EMTPObjectPropCodeDateModified:

        case EMTPObjectPropCodeDateAdded:

        case EMTPObjectPropCodeDateCreated:

            {

            TTime time( *media.Value<TInt64> ( attrib ) );

            TBuf<KMtpMaxDateTimeStringLength> timeStr;

            time.FormatL( timeStr, KMtpDateTimeFormat );

            if ( EMTPTypeString == aNewData.Type() )

                {

                ( ( CMTPTypeString & ) aNewData ).SetL( timeStr );

                }

            else

                {

                User::Leave( KErrArgument );

                }

            PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue - get DC4E DateAdded = %Ld" ), time.Int64() );

            }

            break;

        case EMTPObjectPropCodeDuration:

        case EMTPObjectPropCodeAudioBitRate:

        case EMTPObjectPropCodeSampleRate:

        case EMTPObjectPropCodeAudioWAVECodec:

            {

            if ( EMTPTypeUINT32 == aNewData.Type() )

                {

                ( ( TMTPTypeUint32& ) aNewData ).Set( *media.Value<TUint32>( attrib ) );

                }

            else

                {

                User::Leave( KErrArgument );

                }

            }

            break;

        case EMTPObjectPropCodeTrack:

            {

            TLex lex( media.ValueText( attrib ) );

            TUint16 uint16( 0 );

            lex.Val( uint16, EDecimal );

            if ( EMTPTypeUINT16 == aNewData.Type() )

                {

                ( ( TMTPTypeUint16 & ) aNewData ).Set( uint16 );

                }

            else

                {

                User::Leave( KErrArgument );

                }

            PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue - get DC8B Track = %d" ), uint16 );

            }

            break;

        case EMTPObjectPropCodeOriginalReleaseDate:

            {

            // Compose DateTime string in format YYYYMMDDTHHMMSS

            TBuf<KMtpMaxDateTimeStringLength> dateTime;

            dateTime.Zero();

            // NOTE: Handled specially, shouldn't leave like other property, following S60

            if ( !isSupported )

                {

                PRINT( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue 0xDC99 date hasn't been set before" ) );

                dateTime.Copy( KEmptyText );

                }

            else

                {

                TTime time = *media.Value<TInt64> ( attrib );

#ifdef _DEBUG

                RDebug::Print( _L( "MM MTP <> GetObjectMetadataValue 0xDC99 time = %Ld, Year = %d, Month = %d, Day = %d, Hour = %d, Minute = %d, Second = %d" ),

                    time.Int64(),

                    time.DateTime().Year(),

                    time.DateTime().Month(),

                    time.DateTime().Day(),

                    time.DateTime().Hour(),

                    time.DateTime().Minute(),

                    time.DateTime().Second() );

#endif  // _DEBUG

                // Compose DateTime string in format YYYYMMDDTHHMMSS

                dateTime.AppendNumFixedWidth( time.DateTime().Year(),

                    EDecimal,

                    4 );

                dateTime.AppendNumFixedWidth( time.DateTime().Month() + 1,

                    EDecimal,

                    2 );

                dateTime.AppendNumFixedWidth( time.DateTime().Day() + 1,

                    EDecimal,

                    2 );

                dateTime.Append( KMtpDateTimeConnector );

                dateTime.AppendNumFixedWidth( time.DateTime().Hour(),

                    EDecimal,

                    2 );

                dateTime.AppendNumFixedWidth( time.DateTime().Minute(),

                    EDecimal, 2 );

                dateTime.AppendNumFixedWidth( time.DateTime().Second(),

                    EDecimal, 2 );

                PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue 0xDC99 dateString = %S" ), &dateTime );

                }

            if ( EMTPTypeString == aNewData.Type() )

                {

                ( ( CMTPTypeString & ) aNewData ).SetL( dateTime );

                }

            else

                {

                User::Leave( KErrArgument );

                }

            }

            break;

        case EMTPObjectPropCodeNumberOfChannels:

        case EMTPObjectPropCodeDRMStatus:

            if ( !isSupported)

                {

                PRINT( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::GetObjectMetadataValue 0xDC9D date hasn't been set before" ) );

                TInt16 zeroValue = 0x0;

                ( ( TMTPTypeUint16 & ) aNewData ).Set( zeroValue );

                }

            else

                {

                if (EMTPTypeUINT16 == aNewData.Type() )

                    {

                    ( ( TMTPTypeUint16 & ) aNewData ).Set( *media.Value<TUint16>(attrib) );

                    }

                else

                    {

                    User::Leave(KErrArgument);

                    }

                }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataMpxAccess::GetObjectMetadataValueL" ) );

    }

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

// CMmMtpDpMetadataMpxAccess::CollectionHelperL

// Returns the collection helper

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

//

MMPXCollectionHelper* CMmMtpDpMetadataMpxAccess::CollectionHelperL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::CollectionHelperL()" ) );

    // This is for the case when drive is completely full but Music DB is not

    // yet created. NewCollectionCachedHelperL() will attempt to create a

    // DB file on the spot when MPX Collection helper is accessed. For the

    // case of Music DB creation failure, it will be handled by MTP server

    // as a General Error

    if ( iCollectionHelper == NULL )

        {

        PERFLOGSTART( KMpxCollectionNewL );

        iCollectionHelper = CMPXCollectionHelperFactory::NewCollectionCachedHelperL();

        PERFLOGSTOP( KMpxCollectionNewL );

        // Do a search for a song ID that does not exist

        // This is to validate the presence of the media database.

        RArray<TInt> contentIDs;

        CleanupClosePushL( contentIDs ); // + contentIDs

        contentIDs.AppendL( KMPXMediaIdGeneral );

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

        CleanupStack::PopAndDestroy( &contentIDs ); // - contentIDs

        CleanupStack::PushL( searchMedia ); // + searchMedia

        searchMedia->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem );

        searchMedia->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );

        searchMedia->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId,

            KMtpInvalidSongID );

        if ( iStoreRoot.Length() > 0 )

            {

            searchMedia->SetTextValueL( KMPXMediaGeneralDrive, iStoreRoot );

            }

        RArray<TMPXAttribute> songAttributes;

        CleanupClosePushL( songAttributes ); // + songAttributes

        songAttributes.AppendL( KMPXMediaGeneralId );

        CMPXMedia* foundMedia = NULL;

        PERFLOGSTART( KMpxCollectionFindAllLValidate );

        TRAPD( err, foundMedia = iCollectionHelper->FindAllL(

            *searchMedia,

            songAttributes.Array() ) );

        PERFLOGSTOP( KMpxCollectionFindAllLValidate );

        CleanupStack::PopAndDestroy( &songAttributes ); // - songAttributes

        CleanupStack::PopAndDestroy( searchMedia ); // - searchMedia

        CleanupStack::PushL( foundMedia ); // + foundMedia

        if ( err != KErrNone )

            {

            PRINT1( _L("MM MTP <> CMmMtpDpMetadataMpxAccess::CollectionHelperL() Had err (%d) accessing the Music Database!!!"), err );

            // Delete the collection helper for now

            iCollectionHelper->Close();

            iCollectionHelper = NULL;

            User::Leave( KErrGeneral );

            }

        else

            {

            PRINT( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::CollectionHelperL() Music Database successfully created and validated!!!" ) );

            }

        CleanupStack::PopAndDestroy( foundMedia ); // - foundMedia

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataMpxAccess::CollectionHelperL()" ) );

    return iCollectionHelper;

    }

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

// CMmMtpDpMetadataMpxAccess::FindWMPMediaLC

// Finds Media with specific WMP values

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

//

CMPXMedia* CMmMtpDpMetadataMpxAccess::FindWMPMediaLC( TMPXAttributeData aWMPMediaID,

    TBool aFlag )

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::FindWMPMediaLC" ) );

    CMPXMedia* searchMedia = CMPXMedia::NewL();

    CleanupStack::PushL( searchMedia ); // + searchMeida

    searchMedia->SetTObjectValueL( KMPXMediaGeneralType, EMPXGroup );

    searchMedia->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );

    searchMedia->SetTObjectValueL<TBool>( aWMPMediaID, aFlag );

    searchMedia->SetTextValueL( KMPXMediaGeneralDrive, iStoreRoot );

    RArray<TMPXAttribute> songAttributes;

    CleanupClosePushL( songAttributes ); // + songAttributes

    songAttributes.AppendL( KMPXMediaGeneralUri );

    PRINT( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::FindWMPMediaLC searchMedia setup with no problems" ) );

    PERFLOGSTART(KMpxCollectionFindAllLModified);

    CMPXMedia* foundMedia = CollectionHelperL()->FindAllL( *searchMedia,

        songAttributes.Array() );

    PERFLOGSTOP(KMpxCollectionFindAllLModified);

    PRINT( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::FindWMPMediaLC foundMedia assigned from FindAllL" ) );

    CleanupStack::PopAndDestroy( &songAttributes ); // - songAttributes

    CleanupStack::PopAndDestroy( searchMedia ); // - searchMedia

    CleanupStack::PushL( foundMedia ); // + foundMedia

    if ( !foundMedia->IsSupported( KMPXMediaArrayCount ) )

        {

        User::Leave( KErrNotSupported );

        }

#ifdef _DEBUG

    TInt foundItemCount = *foundMedia->Value<TInt>( KMPXMediaArrayCount );

    PRINT1( _L( "MM MTP <> %d Media Objects found in the WMP search" ), foundItemCount );

#endif

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataMpxAccess::FindWMPMediaLC" ) );

    return foundMedia;

    }

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

// Update the Sync flag for those not synchronized, Update the Modified flag for those have been modified, and delete the stale

// records for files that have been deleted.

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

//

void CMmMtpDpMetadataMpxAccess::UpdateMusicCollectionL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataMpxAccess::UpdateMusicCollectionL" ) );

    CMPXMedia* foundMedia= NULL;

    TInt foundItemCount( 0 );

    // We Should Consider this!!!

    //        if (iWmpRoundTripUsed)  // Only update values if they've been read by the PC...

    //            {

    // Change flag on acquired content so they won't be reported twice

    //when thousands of the file are being copied in with mass storage, and MTP is connected/disconnected for the first time

    //updateing the sync bit cause a serious performance issue issue

    //since our DP is not presistent, and we are not depedns on KMPXMediaGeneralSynchronized flag to tell whether a file is newly added or not

    //reseting this flag is not needed in reality, comment out for now

    /*foundMedia = FindWMPMediaLC( KMPXMediaGeneralSynchronized, EFalse );// + foundMedia

    if ( !foundMedia->IsSupported( KMPXMediaArrayCount ) )

        {

        User::Leave( KErrNotSupported );

        }

    foundItemCount = *foundMedia->Value<TInt>( KMPXMediaArrayCount );

    PRINT1( _L( "MM MTP <> CMmMtpDpMetadataMpxAccess::UpdateMusicCollectionL found %d Media Objects" ), foundItemCount );

    if ( foundItemCount )

        {