/*

* 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:  Part of SyncML Data Synchronization Plug In Adapter

*

*/

#include "mediadsstore.h"

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessage.h>

#include "mediadsproviderdefs.h"

#include "mediamanager.h"

#include "cmdemanager.h"

#include "playlistitem.h"

#include "omadsfolderobject.h"

#include "snapshotitem.h"

#include "logger.h"

_LIT8( KFolderMimeType, "application/vnd.omads-folder+xml" );

_LIT8( KFolderMimeVersion, "1.2" );

_LIT8( KPlaylistMimeType, "audio/x-mpegurl");

_LIT8( KPlaylistMimeVersion, "1.0");

_LIT8( KSongMimeType, "application/x-song");

_LIT8( KSongMimeVersion, "1.0");

const TInt KDataBufferSize = 1024;

const TInt KAlbumsOffSet = 0x0000f000;

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

// CMediaDsDataStore::CMediaDsDataStore

// C++ default constructor can NOT contain any code, that might leave.

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

CMediaDsDataStore::CMediaDsDataStore( RFs& aFs):

    iKey(TKeyArrayFix(_FOFF(TSnapshotItem, ItemId()), ECmpTInt)),

    iFs( aFs )

    { 

    TRACE_FUNC;

    }

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

// CMediaDsDataStore::ConstructL

// Symbian 2nd phase constructor, can leave.

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

void CMediaDsDataStore::ConstructL()

    {

    TRACE_FUNC_ENTRY;

    // Item UID sets, used to transfer change info

    iNewItems = new (ELeave) CNSmlDataItemUidSet;

    iDeletedItems = new (ELeave) CNSmlDataItemUidSet;

    iUpdatedItems = new (ELeave) CNSmlDataItemUidSet;

    iMovedItems = new (ELeave) CNSmlDataItemUidSet;

    iSoftDeletedItems = new (ELeave) CNSmlDataItemUidSet;

    iHasher = CMD5::NewL();

    iMediaManager = CMediaManager::NewL( iFs, this, iKey, *iHasher );

    iMdEManager = CMdEManager::NewL( *this );

    TRACE_FUNC_EXIT;

    }

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

// CMediaDsDataStore::NewLC

// Two-phased constructor.

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

CMediaDsDataStore* CMediaDsDataStore::NewLC( RFs& aFs)

    {

    TRACE_FUNC_ENTRY;

    CMediaDsDataStore* self = new (ELeave) CMediaDsDataStore( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    TRACE_FUNC_EXIT;

    return self;    

    }

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

// CMediaDsDataStore::~CMediaDsDataStore

// Destructor

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

CMediaDsDataStore::~CMediaDsDataStore()

    {

    TRACE_FUNC_ENTRY;

    delete iDataBuffer;

    delete iChangeFinder;

    delete iNewItems;

    delete iDeletedItems;

    delete iUpdatedItems;

    delete iMovedItems;

    delete iSoftDeletedItems;

    delete iMediaManager;

    LOGGER_WRITE("iMediaManager deleted");

    delete iMdEManager;

    LOGGER_WRITE("iMdEManager deleted");

    delete iHasher;

    LOGGER_WRITE("iHasher deleted");

    // normally iSnapshot is NULL, but if error has occured we need to delete it.

    delete iSnapshot;

    TRACE_FUNC_EXIT;

    }

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

// CMediaDsDataStore::DoOpenL

// Opens database. This operation is performed SYNCHRONOUSLY

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

void CMediaDsDataStore::DoOpenL( const TDesC& aStoreName,

    MSmlSyncRelationship& aContext, TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    if ( iCurrentState != EClosed )

        {

        User::RequestComplete( iCallerStatus, KErrInUse );

        LOGGER_WRITE("CMmsDataStore::DoOpenL failed with KErrInUse.");

        return;

        }

    // Create ChangeFinder object

    if ( iChangeFinder )

        {

        delete iChangeFinder;

        iChangeFinder = NULL;

        }

    iChangeFinder = CChangeFinder::NewL( aContext, iKey, iHasHistory, KMediaDataProviderImplUid );

    if ( aStoreName.CompareF( KMediaDsRefreshDbName ) == 0 )

        {

        LOGGER_WRITE("Refresh library and open database");

        // just kick off scanner, don't wait ready status

        // Async. func. HandleCollectionMessage is called when ready

        iMediaManager->ScanL();

        }

    else if ( aStoreName.CompareF( KMediaDsDbName ) == 0 )

        {

        LOGGER_WRITE("Open database");

        if ( !iHasHistory )

            {

            LOGGER_WRITE("No history, scan library");

            // just kick off scanner, don't wait ready status

            // Async. func. HandleCollectionMessage is called when ready

            iMediaManager->ScanL();

            }

        }

    else

        {

        LOGGER_WRITE("Unknown database");

        User::Leave( KErrNotSupported );

        }

    // Set current snapshot, this will be compared against the old one   

    RegisterSnapshotL();

    TRACE_FUNC_EXIT;

    }

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

// CMediaDsDataStore::DoCancelRequest

// Not supported, does nothing.

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

void CMediaDsDataStore::DoCancelRequest()

    {

    TRACE_FUNC_ENTRY;

    if ( iCurrentState == EOpening )

        {

        LOGGER_WRITE("Cancel Open command");

        iMediaManager->Cancel();

        iMdEManager->Cancel();

        }

    TRACE_FUNC_EXIT;

    }

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

// CMediaDsDataStore::DoStoreName

// Returns the name of the DataStore

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

const TDesC& CMediaDsDataStore::DoStoreName() const

    {

    TRACE_FUNC;

    return KNullDesC;

    }

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

// CMediaDsDataStore::DoBeginTransactionL

// Transactions are not supported.

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

void CMediaDsDataStore::DoBeginTransactionL()

    {

    TRACE_FUNC;

    User::Leave( KErrNotSupported );

    }

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

// CMediaDsDataStore::DoCommitTransactionL

// Transactions are not supported.

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

void CMediaDsDataStore::DoCommitTransactionL( TRequestStatus& /*aStatus*/ )

    {

    TRACE_FUNC;

    User::Leave( KErrNotSupported );

    }

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

// CMediaDsDataStore::DoRevertTransaction

// Transactions are not supported.

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

void CMediaDsDataStore::DoRevertTransaction( TRequestStatus& aStatus )

    {

    TRACE_FUNC;

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    }

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

// CMediaDsDataStore::DoBeginBatchL

// Batching is not supported.

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

void CMediaDsDataStore::DoBeginBatchL()

    {

    TRACE_FUNC;

    User::Leave( KErrNotSupported );

    }

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

// CMediaDsDataStore::DoCommitBatchL

// Batching is not supported

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

//

void CMediaDsDataStore::DoCommitBatchL( RArray<TInt>& /*aResultArray*/, TRequestStatus& /*aStatus*/ )

    {

    TRACE_FUNC;

    User::Leave( KErrNotSupported );

    }

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

// CMediaDsDataStore::DoCancelBatch

// Batching is not supported

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

void CMediaDsDataStore::DoCancelBatch()

    {

    TRACE_FUNC;

    }

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

// CMediaDsDataStore::DoSetRemoteStoreFormatL

// Not supported

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

//

void CMediaDsDataStore::DoSetRemoteStoreFormatL( const CSmlDataStoreFormat& /*aServerDataStoreFormat*/ )

    {

    TRACE_FUNC;

    }

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

// CMediaDsDataStore::DoSetRemoteMaxObjectSize

// Not supported

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

void CMediaDsDataStore::DoSetRemoteMaxObjectSize( TInt /*aServerMaxObjectSize*/ )

    {

    TRACE_FUNC;

    }

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

// CMediaDsDataStore::DoMaxObjectSize

// Reads the maximum MMS Message size from the central repository

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

TInt CMediaDsDataStore::DoMaxObjectSize() const

    {

    TRACE_FUNC;

    return 0;

    }

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

// CMediaDsDataStore::DoOpenItemL

// Opens item in the DataStore, reads it (either completely or partially) 

// to the temporary buffer where it can be later read to the remote database.

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

void CMediaDsDataStore::DoOpenItemL( TSmlDbItemUid aUid, TBool& /*aFieldChange*/, 

    TInt& aSize, TSmlDbItemUid& aParent, TDes8& aMimeType, 

    TDes8& aMimeVer, TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1( "Opening item %d.", aUid );

    // Store these for later use

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iReadPosition=0;

    // Check that we're in a proper state

    if ( iCurrentState != EOpenAndWaiting )

        {

        LOGGER_WRITE_1( "CMediaDsDataStore::DoOpenItemL, invalid state %d.", iCurrentState );

        User::RequestComplete( iCallerStatus, KErrNotReady );

        return;

        }

    if ( !iDataBuffer )

        {

        iDataBuffer = CBufFlat::NewL( KDataBufferSize );

        }

    iDataBuffer->Reset();

    if ( aUid <= KLastFolderId )

        {

        COMADSFolderObject* folderObject = COMADSFolderObject::NewLC();

        switch ( aUid )

            {

            case KAllSongsFolderId:

                folderObject->SetName( KAllSongs );

                break;

            case KPlaylistsFolderId:

                folderObject->SetName( KPlaylists );

                break;

            case KAlbumsFolderId:

                folderObject->SetName( KAlbums );

                break;

            default:

                User::Leave( KErrNotFound );

                break;

            }

        folderObject->ExportFolderXmlL( *iDataBuffer );

        CleanupStack::PopAndDestroy( folderObject );

        aMimeType.Copy( KFolderMimeType );

        aMimeVer.Copy( KFolderMimeVersion );

        aParent = KErrNotFound;

        }

    else

        {

        CSongItem* song = CSongItem::NewLC();

        LOGGER_WRITE("Try to read song");

        TRAPD( err, iMediaManager->GetSongL( aUid, *song ));

        if ( !err )

            {

            RBufWriteStream stream( *iDataBuffer );

            CleanupClosePushL( stream );

            song->ExportL( stream );

            CleanupStack::PopAndDestroy( &stream );

            CleanupStack::PopAndDestroy( song );

            aMimeType.Copy( KSongMimeType );

            aMimeVer.Copy( KSongMimeVersion );

            aParent = KAllSongsFolderId;

            }

        else // could not read song, maybe it is playlist

            {

            CleanupStack::PopAndDestroy( song );

            CPlaylistItem* playList = CPlaylistItem::NewLC();

            LOGGER_WRITE("Try to read playlist");

            TRAP(err, iMediaManager->GetPlayListL( aUid, *playList ));

            if ( !err )

                {

                RBufWriteStream stream( *iDataBuffer );

                CleanupClosePushL( stream );

                playList->ExportL( stream );

                CleanupStack::PopAndDestroy( &stream );

                CleanupStack::PopAndDestroy( playList );

                aMimeType.Copy( KPlaylistMimeType );

                aMimeVer.Copy( KPlaylistMimeVersion );

                aParent = KPlaylistsFolderId;

                }

            else

                {

                CleanupStack::PopAndDestroy( playList );

                LOGGER_WRITE("Try to read album");

                // Could not read song, maybe it's a Album

                const CPlaylistItem& album = iMdEManager->AlbumL( MapSyncIdToAlbumId(aUid) );

                RBufWriteStream stream( *iDataBuffer );

                CleanupClosePushL( stream );

                album.ExportL( stream );

                CleanupStack::PopAndDestroy( &stream );

                aMimeType.Copy( KPlaylistMimeType );

                aMimeVer.Copy( KPlaylistMimeVersion );

                aParent = KAlbumsFolderId;

                }

            }

        }

    aSize = iDataBuffer->Size();

    LOGGER_WRITE_1("aSize: %d", aSize);

    // Signal we're complete

    User::RequestComplete( iCallerStatus, KErrNone ); 

    TRACE_FUNC_EXIT;

    }

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

// CMediaDsDataStore::DoCreateItemL

// Create new item to the message store.

// Return the id number of the newly created item

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

void CMediaDsDataStore::DoCreateItemL( TSmlDbItemUid& aUid, TInt aSize, TSmlDbItemUid aParent, 

    const TDesC8& aMimeType, const TDesC8& /*aMimeVer*/, TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1( "Parent folder: %d.", aParent );

    // Store some variables for further use

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    // Ensure that we're in proper state

    if ( iCurrentState != EOpenAndWaiting )

        {

        LOGGER_WRITE_1( "Invalid state %d.", iCurrentState );

        }

    iWrittenDataLength = 0;

    iCreatedUid = &aUid;

    LOGGER_WRITE8_1( "aMimeType: %S", &aMimeType );

    if ( aMimeType.Compare( KPlaylistMimeType() ) == 0 )

        {

        LOGGER_WRITE("Add Playlist");

        iCurrentState = ECreatePlaylist;

        }

    else if ( aMimeType.Compare( KSongMimeType() ) == 0 )

        {

        LOGGER_WRITE("Add Song not supported");

        User::Leave( KErrNotSupported );

        }

    else

        {

        User::RequestComplete( iCallerStatus, KErrNotSupported );

        LOGGER_WRITE("Bad MIME type");

        return;

        }

    if ( iDataBuffer )

        {

        iDataBuffer->ResizeL( aSize );

        }

    else

        {

        iDataBuffer = CBufFlat::NewL( KDataBufferSize );

        iDataBuffer->ResizeL( aSize );

        }

    LOGGER_WRITE_1("iDataBuffer->Size: %d", iDataBuffer->Size());

    LOGGER_WRITE_1("aSize: %d", aSize);

    iParentId = aParent;

    // Signal we're complete

    User::RequestComplete( iCallerStatus, KErrNone );

    TRACE_FUNC_EXIT;

    }

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

// CMediaDsDataStore::DoReplaceItemL

// Begin the replace operation, ensure that the item really exists

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

void CMediaDsDataStore::DoReplaceItemL( TSmlDbItemUid aUid, TInt aSize, TSmlDbItemUid aParent, 

    TBool /*aFieldChange*/, TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1("Replacing item %d.", aUid);

    LOGGER_WRITE_1("Parent folder: %d.", aParent);

    // Store some variables for further use

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    // Ensure proper state

    if ( iCurrentState != EOpenAndWaiting )

        {

        LOGGER_WRITE_1("Invalid state %d.", iCurrentState);

        }

    iCurrentState = EReplace;

    iParentId = aParent;

    iCurrentId = aUid;

    if ( iDataBuffer )

        {

        iDataBuffer->ResizeL( aSize );

        }

    else

        {

        iDataBuffer = CBufFlat::NewL( KDataBufferSize );

        iDataBuffer->ResizeL( aSize );

        }

    // Signal we're complete

    User::RequestComplete( iCallerStatus, KErrNone );

    TRACE_FUNC_EXIT;

    }