/*

* 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 <e32property.h>

#include "cmmmtpdpmetadataaccesswrapper.h"

#include "cmmmtpdpmetadatampxaccess.h"

#include "cmmmtpdpmetadatavideoaccess.h"

#include "mmmtpdputility.h"

#include "mmmtpdplogger.h"

const TInt KMMMTPDummyFileArrayGranularity = 5;

    MMTPDataProviderFramework& aFramework )

    {

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

    CleanupStack::PushL( me );

    me->ConstructL();

    CleanupStack::Pop( me );

    return me;

    }

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

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

    _LIT_SECURITY_POLICY_C1(KKeyReadPolicy, ECapabilityReadUserData);

    _LIT_SECURITY_POLICY_C1(KKeyWritePolicy, ECapabilityWriteUserData);

                       KKeyWritePolicy);

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

    }

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

// CMmMtpDpMetadataAccessWrapper::~CMmMtpDpMetadataAccessWrapper

// Destructor

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

//

CMmMtpDpMetadataAccessWrapper::~CMmMtpDpMetadataAccessWrapper()

    {

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

    RemoveDummyFiles();

    delete iMmMtpDpMetadataVideoAccess;

    delete iMmMtpDpMetadataMpxAccess;

    // unblock MPX

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

    }

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

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

//

    {

        {

        }

    }

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

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

        {

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

        {

        iMmMtpDpMetadataVideoAccess->RenameRecordL( aOldFileName, aNewFileName );

        }

    else

        {

        }

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

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

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

    {

    }

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

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

//

    {

    }

// CMmMtpDpMetadataAccessWrapper::AddObjectL

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

//

    {

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

        {

        User::Leave( KErrArgument );

        }

        {

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

        iMmMtpDpMetadataVideoAccess->AddVideoL( aFullFileName );

        }

    else

        {

            {

            }

        else

            {

            }

        }

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

    }

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

// CMmMtpDpMetadataAccessWrapper::GetModifiedContentL

// Get Modified content

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

//

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

    }

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

        {

            {

            PRINT1( _L( "MM MTP <> CMmMtpDpMetadataAccessWrapper::DeleteDummyFile pos = %d" ), 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 );