/*

* 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 access wrapper

*

*/

#include <bautils.h>

#include <e32math.h>

#include <mtp/mmtpdataproviderframework.h>

#include <e32property.h>

#include <MtpPrivatePSKeys.h>

#include "cmmmtpdpmetadataaccesswrapper.h"

#include "cmmmtpdpmetadatampxaccess.h"

#include "cmmmtpdpmetadatavideoaccess.h"

#include "mmmtpdputility.h"

#include "mmmtpdplogger.h"

const TInt KMMMTPDummyFileArrayGranularity = 5;

CMmMtpDpMetadataAccessWrapper* CMmMtpDpMetadataAccessWrapper::NewL( RFs& aRfs, 

    MMTPDataProviderFramework& aFramework )

    {

    CMmMtpDpMetadataAccessWrapper* me = new (ELeave) CMmMtpDpMetadataAccessWrapper( aRfs, aFramework );

    CleanupStack::PushL( me );

    me->ConstructL();

    CleanupStack::Pop( me );

    return me;

    }

CMmMtpDpMetadataAccessWrapper::CMmMtpDpMetadataAccessWrapper( RFs& aRfs, 

    MMTPDataProviderFramework& aFramework ) :

    iRfs( aRfs ),

    iFramework( aFramework )

    {

    }

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

// CMmMtpDpMetadataAccessWrapper::ConstructL

// Second-phase

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

//

void CMmMtpDpMetadataAccessWrapper::ConstructL()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::ConstructL" ) );

    iMmMtpDpMetadataMpxAccess = CMmMtpDpMetadataMpxAccess::NewL( iRfs, iFramework );

    iMmMtpDpMetadataVideoAccess = CMmMtpDpMetadataVideoAccess::NewL( iRfs );

    iPlaylistArray = new ( ELeave ) CDesCArrayFlat( KMMMTPDummyFileArrayGranularity );

    // Create the PS key to notify subscribers that MTP mode is activated

    _LIT_SECURITY_POLICY_C1(KKeyReadPolicy, ECapabilityReadUserData);

    _LIT_SECURITY_POLICY_C1(KKeyWritePolicy, ECapabilityWriteUserData);

    RProperty::Define( KMtpPSUid, 

                       KMtpPSStatus, 

                       RProperty::EInt, 

                       KKeyReadPolicy, 

                       KKeyWritePolicy);

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::ConstructL" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::~CMmMtpDpMetadataAccessWrapper

// Destructor

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

//

CMmMtpDpMetadataAccessWrapper::~CMmMtpDpMetadataAccessWrapper()

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::~CMmMtpDpMetadataAccessWrapper" ) );

    RemoveDummyFiles();

    delete iPlaylistArray;

    delete iMmMtpDpMetadataVideoAccess;

    delete iMmMtpDpMetadataMpxAccess;

    // unblock MPX

    RProperty::Set( KMtpPSUid, 

                    KMtpPSStatus, 

                    EMtpPSStatusUninitialized);

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::~CMmMtpDpMetadataAccessWrapper" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::SetPlaylist

// Set playlist to DB

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::SetPlaylistL( const TDesC& aPlaylistFileName, CDesCArray& aRefFileArray )

    {

    PRINT1( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::SetPlaylistL aPlaylistFileName = %S" ), &aPlaylistFileName );

    if ( !MmMtpDpUtility::IsVideoL( aPlaylistFileName, iFramework ) )

        {

        iMmMtpDpMetadataMpxAccess->SetPlaylistL( aPlaylistFileName, aRefFileArray );

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::SetPlaylistL" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::AddMediaL

// Gets a piece of metadata from the collection

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL( const TUint16 aPropCode,

    MMTPType& aNewData,

    const CMTPObjectMetaData& aObjectMetaData )

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::GetObjectMetadataValueL" ) );

    TPtrC fullFileName( aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ) );

    if ( !MmMtpDpUtility::IsVideoL( fullFileName, iFramework ) )

        {

        iMmMtpDpMetadataMpxAccess->GetObjectMetadataValueL( aPropCode,

            aNewData,

            aObjectMetaData );

        }

    else

        {

        iMmMtpDpMetadataVideoAccess->GetObjectMetadataValueL( aPropCode,

            aNewData,

            aObjectMetaData );

        }

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

    }

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

// CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL

// Sets a piece of metadata in the collection

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

//

void CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL( const TUint16 aPropCode,

    const MMTPType& aNewData,

    const CMTPObjectMetaData& aObjectMetaData )

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL" ) );

    TPtrC fullFileName( aObjectMetaData.DesC( CMTPObjectMetaData::ESuid ) );

    if ( MmMtpDpUtility::IsVideoL( fullFileName, iFramework ) )

        {

        iMmMtpDpMetadataVideoAccess->SetObjectMetadataValueL( aPropCode,

            aNewData,

            aObjectMetaData );

        }

    else

        {

        iMmMtpDpMetadataMpxAccess->SetObjectMetadataValueL( aPropCode,

            aNewData,

            aObjectMetaData );

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL

// Renames the file part of a record in the collection database

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::RenameObjectL( const TDesC& aOldFileName,

    const TDesC& aNewFileName )

    {

    PRINT2( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::RenameObjectL old = %S, new = %S" ),

        &aOldFileName,

        &aNewFileName );

   TMTPFormatCode formatCode = MmMtpDpUtility::FormatFromFilename( aOldFileName );

    if ( formatCode == EMTPFormatCodeWMV )

        {

        iMmMtpDpMetadataVideoAccess->RenameRecordL( aOldFileName, aNewFileName );

        }

    else

        {

        if ( !MmMtpDpUtility::IsVideoL( aNewFileName , iFramework ) )

            {

            iMmMtpDpMetadataMpxAccess->RenameObjectL( aOldFileName, aNewFileName, formatCode );

            }

        else

            {

            iMmMtpDpMetadataVideoAccess->RenameRecordL( aOldFileName, aNewFileName );

            }

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::RenameObjectL" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::SetObjectMetadataValueL

// Deletes metadata information associated with the object

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

//

void CMmMtpDpMetadataAccessWrapper::DeleteObjectL( const TDesC& aFullFileName,

    const TUint aFormatCode )

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::DeleteObjectL" ) );

    TMPXGeneralCategory category = Category( aFormatCode );

    // Have to do this.  File might not be in file system anymore, have to 

    // reply on ObjectManager

    if ( ( aFormatCode == EMTPFormatCodeMP4Container )

        || ( aFormatCode == EMTPFormatCode3GPContainer )

        || ( aFormatCode == EMTPFormatCodeASF ) )

        {

        if ( MmMtpDpUtility::IsVideoL( aFullFileName, iFramework ) )

            {

            category = EMPXVideo;

            }

        else

            {

            category = EMPXSong;

            }

        }

    switch ( category )

        {

        case EMPXPlaylist:

        case EMPXSong:

            {

            iMmMtpDpMetadataMpxAccess->DeleteObjectL( aFullFileName, category );

            }

            break;

        case EMPXVideo:

            {

            iMmMtpDpMetadataVideoAccess->DeleteRecordL( aFullFileName );

            }

            break;

        default:

            PRINT( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteObjectL default" ) );

            break;

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::DeleteObjectL" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::SetStorageRootL

// Sets current Drive info

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

//

void CMmMtpDpMetadataAccessWrapper::SetStorageRootL( const TDesC& aStorageRoot )

    {

    PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::SetStorageRootL" ) );

    iMmMtpDpMetadataVideoAccess->SetStorageRootL( aStorageRoot );

    iMmMtpDpMetadataMpxAccess->SetStorageRootL( aStorageRoot );

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::SetStorageRootL" ) );

    }

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

// CMmMtpDpMetadataMpxAccess::SetImageObjPropL

// set image specific properties specific to videos

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

//

void CMmMtpDpMetadataAccessWrapper::SetImageObjPropL( const TDesC& aFullFileName,

    const TUint32 aWidth,

    const TUint32 aHeight )

    {

    if ( MmMtpDpUtility::IsVideoL( aFullFileName, iFramework ) )

        {

        iMmMtpDpMetadataVideoAccess->SetStorageRootL( aFullFileName );

        iMmMtpDpMetadataVideoAccess->SetImageObjPropL( aFullFileName, aWidth, aHeight );

        }

    }

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

// CMmMtpDpMetadataMpxAccess::GetImageObjPropL

// get image specific properties specific to videos

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

//

void CMmMtpDpMetadataAccessWrapper::GetImageObjPropL( const TDesC& aFullFileName,

    TUint32& aWidth,

    TUint32& aHeight )

    {

    if ( MmMtpDpUtility::IsVideoL( aFullFileName, iFramework ) )

        {

        iMmMtpDpMetadataVideoAccess->SetStorageRootL( aFullFileName );

        iMmMtpDpMetadataVideoAccess->GetImageObjPropL( aFullFileName, aWidth, aHeight );

        }

    }

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

// CMmMtpDpMetadataAccessWrapper::OpenSessionL

// Called when the MTP session is initialised

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

//

void CMmMtpDpMetadataAccessWrapper::OpenSessionL()

    {

    iOpenSession = ETrue;

    }

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

// CMmMtpDpMetadataAccessWrapper::CloseSessionL

//

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

//

void CMmMtpDpMetadataAccessWrapper::CloseSessionL()

    {

    if ( iOpenSession )

        {

        PRINT( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::CloseSessionL close" ) );

        iMmMtpDpMetadataVideoAccess->CloseSessionL();

        iOpenSession = EFalse;

        }

    else

        {

        PRINT( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::CloseSessionL alreay close" ) );

        }

    }

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

// CMmMtpDpMetadataAccessWrapper::Category

// Get category according format code

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

//

TMPXGeneralCategory CMmMtpDpMetadataAccessWrapper::Category( const TUint aFormatCode )

    {

    TMPXGeneralCategory category = EMPXNoCategory;

    switch ( aFormatCode )

        {

        case EMTPFormatCodeMP3:

        case EMTPFormatCodeWAV:

        case EMTPFormatCodeWMA:

        case EMTPFormatCodeAAC:

        case EMTPFormatCodeASF:

        case EMTPFormatCodeMP4Container:

        case EMTPFormatCode3GPContainer:

            {

            category = EMPXSong;

            }

            break;

        case EMTPFormatCodeAbstractAudioVideoPlaylist:

            {

            category = EMPXPlaylist;

            }

            break;

        case EMTPFormatCodeWMV:

            {

            category = EMPXVideo;

            }

            break;

        default:

            break;

        }

    return category;

    }

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

// CMmMtpDpMetadataAccessWrapper::GetAllPlaylistL

// 

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

EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetAllPlaylistL( const TDesC& aStoreRoot, CMPXMediaArray** aPlaylists )

    {

    iMmMtpDpMetadataMpxAccess->GetAllPlaylistL( aStoreRoot, aPlaylists );

    }

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

// CMmMtpDpMetadataAccessWrapper::GetAllReferenceL

// 

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

//s

EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetAllReferenceL( CMPXMedia* aPlaylist, CDesCArray& aReferences )

    {

    iMmMtpDpMetadataMpxAccess->GetAllReferenceL( aPlaylist, aReferences );

    }

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

// CMmMtpDpMetadataAccessWrapper::GetPlaylistNameL

// 

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetPlaylistNameL( CMPXMedia* aPlaylist, TDes& aPlaylistName )

    {

    iMmMtpDpMetadataMpxAccess->GetPlaylistNameL( aPlaylist, aPlaylistName );

    }

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

// CMmMtpDpMetadataAccessWrapper::AddObjectL

// Add object (music, video and playlist) info to DB

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

//

void CMmMtpDpMetadataAccessWrapper::AddObjectL( const TDesC& aFullFileName, TBool aIsVideo /*= EFalse */ )

    {

    PRINT1( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL aFullFileName = %S" ), &aFullFileName );

    if ( aFullFileName.Length() <= 0)

        {

        User::Leave( KErrArgument );

        }

    if ( aIsVideo )

        {

        PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL Addvideo" ) );

        iMmMtpDpMetadataVideoAccess->AddVideoL( aFullFileName );

        }

    else

        {

        if ( MmMtpDpUtility::IsVideoL( aFullFileName, iFramework ) )

            {

            PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL Addvideo" ) );

            iMmMtpDpMetadataVideoAccess->AddVideoL( aFullFileName );

            }

        else

            {

            TMTPFormatCode formatCode = MmMtpDpUtility::FormatFromFilename( aFullFileName );

            if ( formatCode == EMTPFormatCodeM3UPlaylist

                || formatCode == EMTPFormatCodeMPLPlaylist

                || formatCode == EMTPFormatCodeAbstractAudioVideoPlaylist

                || formatCode == EMTPFormatCodeAbstractAudioPlaylist

                || formatCode == EMTPFormatCodeAbstractVideoPlaylist

                || formatCode == EMTPFormatCodeASXPlaylist

                || formatCode == EMTPFormatCodePLSPlaylist )

                {

                PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL AddPlaylist" ) );

                iMmMtpDpMetadataMpxAccess->AddPlaylistL( aFullFileName );

                }

            else

                {

                PRINT( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::AddObjectL AddSong" ) );

                iMmMtpDpMetadataMpxAccess->AddSongL( aFullFileName );

                }

            }

        }

    PRINT( _L( "MM MTP <= CMmMtpDpMetadataAccessWrapper::AddObjectL" ) );

    }

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

// CMmMtpDpMetadataAccessWrapper::GetModifiedContentL

// Get Modified content

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::GetModifiedContentL( const TDesC& aStorageRoot, 

    TInt& arrayCount, 

    CDesCArray& aModifiedcontent )

    {

    iMmMtpDpMetadataMpxAccess->SetStorageRootL( aStorageRoot );

    iMmMtpDpMetadataMpxAccess->GetModifiedContentL( arrayCount, aModifiedcontent );

    }

EXPORT_C void CMmMtpDpMetadataAccessWrapper::CleanupDatabaseL()

    {

    iMmMtpDpMetadataVideoAccess->CleanupDatabaseL();

    }

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

// CMmMtpDpMetadataAccessWrapper::IsExistL

// if the playlsit exist in the MPX DB

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

//

TBool CMmMtpDpMetadataAccessWrapper::IsExistL( const TDesC& aSuid )

    {

    TParsePtrC parse( aSuid );

    iMmMtpDpMetadataMpxAccess->SetStorageRootL( parse.Drive() );

    return iMmMtpDpMetadataMpxAccess->IsExistL( aSuid );

    }

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

// CMmMtpDpMetadataAccessWrapper::AddDummyFile

// Add one dummy file to dummy files array

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::AddDummyFileL( const TDesC& aDummyFileName )

    {

    PRINT1( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::AddDummyFile aDummyFileName(%S)" ), &aDummyFileName );

    iPlaylistArray->AppendL( aDummyFileName );

    }

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

// CMmMtpDpMetadataAccessWrapper::DeleteDummyFile

// Delete one dummy file from dummy files array

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::DeleteDummyFile( const TDesC& aDummyFileName )

    {

    PRINT1( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteDummyFile aDummyFileName(%S)" ), &aDummyFileName );

    TInt pos = 0;

    if ( iPlaylistArray->Count() > 0 )

        {

        if ( 0 == iPlaylistArray->Find( aDummyFileName, pos ) )

            {

            PRINT1( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteDummyFile pos = %d" ), pos );

            iPlaylistArray->Delete( pos );

            }

        }

    }

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

// CMmMtpDpMetadataAccessWrapper::CreateDummyFile

// Create a Dummy File from the virtual playlist URI

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

//

EXPORT_C void CMmMtpDpMetadataAccessWrapper::CreateDummyFile( const TDesC& aPlaylistName )

    {

    PRINT1( _L( "MM MTP => CMmMtpDpMetadataAccessWrapper::CreateDummyFile, filename = %S" ), &aPlaylistName );

    if ( MmMtpDpUtility::FormatFromFilename( aPlaylistName ) ==

        EMTPFormatCodeAbstractAudioVideoPlaylist )

        {

        RFile newfile;

        TInt err = newfile.Replace( iFramework.Fs(), aPlaylistName, EFileWrite );

        if ( err != KErrNone )

            {