/*

* Copyright (c) 2005-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 <e32base.h>

#include <msvstd.h>

#include <msvapi.h>

#include <msvids.h>

#include <mtclreg.h> 

#include <mmsconst.h>

#include <centralrepository.h>

#include <mmscodecclient.h>

#include <sysutil.h>

#include <MmsEngineInternalCRKeys.h>

#include "mmsdatastore.h"

#include "omadsfolderobject.h"

#include "mmsadaptermsvapi.h"

#include "mmsdataproviderdefs.h"

#include "logger.h"

_LIT8( KMmsMimeType, "application/vnd.wap.mms-message" );

_LIT8( KMmsMimeVersion, "1.2" );

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

_LIT8( KFolderMimeVersion, "1.2" );

const TInt KDataBufferSize = 1024;

const TUint KMMS_Flag_Read = 0x01;

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

// CMmsDataStore::CMmsDataStore

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

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

CMmsDataStore::CMmsDataStore():

    iHasHistory(EFalse),

    iDataBaseOpened(EFalse),

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

    { 

    }

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

// CMmsDataStore::ConstructL

// Symbian 2nd phase constructor, can leave.

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

void CMmsDataStore::ConstructL(CMsvSession &aMsvSession)

    {

    LOGGER_ENTERFN("CMmsDataStore::ConstructL");

    iMsvSession = &aMsvSession;

    // Waiter object to be used with CodecClient

    iMsvWait = CMsvOperationActiveSchedulerWait::NewLC();

    CleanupStack::Pop( iMsvWait );

    iCodecClient = CMmsCodecClient::NewL( *iMsvSession );

    iMsvApi = CMmsAdapterMsvApi::NewL( *iMsvSession );

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

    iFolderObjectParser = COMADSFolderObject::NewL();

    LOGGER_LEAVEFN("CMmsDataStore::ConstructL");

    }

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

// CMmsDataStore::NewL

// Two-phased constructor.

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

CMmsDataStore* CMmsDataStore::NewL( CMsvSession &aMsvSession)

    {

    CMmsDataStore* self = new (ELeave) CMmsDataStore;

    CleanupStack::PushL( self );

    self->ConstructL( aMsvSession );

    CleanupStack::Pop( self );

    return self;    

    }

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

// CMmsDataStore::~CMmsDataStore

// Destructor

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

CMmsDataStore::~CMmsDataStore()

    {

    LOGGER_ENTERFN("CMmsDataStore::~CMmsDataStore()");

    delete iDataBuffer;

    delete iChangeFinder;

    delete iFolderObjectParser;

    delete iNewItems;

    delete iDeletedItems;

    delete iUpdatedItems;

    delete iMovedItems;

    delete iSoftDeletedItems;

    delete iMsvApi;

    delete iCodecClient;

    delete iMsvWait;

    LOGGER_LEAVEFN("CMmsDataStore::~CMmsDataStore()");

    }

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

// CMmsDataStore::DoOpenL

// Opens database. This operation is performed SYNCHRONOUSLY

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

void CMmsDataStore::DoOpenL( const TDesC& /*aStoreName*/,

    MSmlSyncRelationship& aContext, TRequestStatus& aStatus )

    {

    LOGGER_ENTERFN("CMmsDataStore::DoOpenL");

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    if ( iDataBaseOpened )

        {

        User::RequestComplete( iCallerStatus, KErrInUse );

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

        return;

        }

    *iContext = aContext;

    // Create ChangeFinder object

    if ( iChangeFinder )

        {

        delete iChangeFinder;

        iChangeFinder = NULL;

        }

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

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

    RegisterSnapshotL();

    iDataBaseOpened = ETrue;

    iCurrentState = EMmsOpenAndWaiting;

    User::RequestComplete( iCallerStatus, KErrNone );   

    LOGGER_LEAVEFN("CMmsDataStore::DoOpenL");

    }

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

// CMmsDataStore::DoCancelRequest

// Not supported, does nothing.

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

void CMmsDataStore::DoCancelRequest()

    {

    LOGGER_ENTERFN("CMmsDataStore::DoCancelRequestL");

    LOGGER_LEAVEFN("CMmsDataStore::DoCancelRequestL");

    }

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

// CMmsDataStore::DoStoreName

// Returns the name of the DataStore

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

const TDesC& CMmsDataStore::DoStoreName() const

    {

    LOGGER_ENTERFN("CMmsDataStore::DoStoreName");

    if ( iDataBaseOpened )

        {

        LOGGER_LEAVEFN( "CMmsDataStore::DoStoreName" );

        LOGGER_WRITE_1( "Database name: %S", &KNSmlDefaultLocalDbName );

        return KNSmlDefaultLocalDbName;

        }

    LOGGER_LEAVEFN( "CMmsDataStore::DoStoreName" );

    return KNullDesC;

    }

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

// CMmsDataStore::DoBeginTransactionL

// Transactions are not supported.

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

void CMmsDataStore::DoBeginTransactionL()

    {

    LOGGER_ENTERFN("CMmsDataStore::DoBeginTransactionL");

    LOGGER_WRITE( "CMmsDataStore::DoBeginTransactionL leaved with KErrNotSupported." );

    User::Leave( KErrNotSupported );

    }

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

// CMmsDataStore::DoCommitTransactionL

// Transactions are not supported.

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

void CMmsDataStore::DoCommitTransactionL( TRequestStatus& aStatus )

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoCommitTransactionL" ); 

    LOGGER_WRITE( "CMmsDataStore::DoCommitTransactionL failed with KErrNotSupported." );

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    }

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

// CMmsDataStore::DoRevertTransaction

// Transactions are not supported.

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

void CMmsDataStore::DoRevertTransaction( TRequestStatus& aStatus )

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoRevertTransaction" ); 

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    LOGGER_LEAVEFN( "CMmsDataStore::DoRevertTransaction" );

    }

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

// CMmsDataStore::DoBeginBatchL

// Batching is not supported.

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

void CMmsDataStore::DoBeginBatchL()

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoBeginBatchL" );

    LOGGER_WRITE( "CMmsDataStore::DoBeginBatchL leaved with KErrNotSupported." );

    User::Leave( KErrNotSupported );    

    }

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

// CMmsDataStore::DoCommitBatchL

// Batching is not supported

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

//

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

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoCommitBatchL" );  

    LOGGER_WRITE( "CMmsDataStore::DoCommitBatchL failed with KErrNotSupported" );

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    }

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

// CMmsDataStore::DoCancelBatch

// Batching is not supported

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

void CMmsDataStore::DoCancelBatch()

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoCancelBatch" );

    LOGGER_LEAVEFN( "CMmsDataStore::DoCancelBatch" );

    }

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

// CMmsDataStore::DoSetRemoteStoreFormatL

// Not supported

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

//

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

    {

    LOGGER_ENTERFN("CMmsDataStore::DoSetRemoteStoreFormatL");

    LOGGER_LEAVEFN("CMmsDataStore::DoSetRemoteStoreFormatL");

    }

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

// CMmsDataStore::DoSetRemoteMaxObjectSize

// Not supported

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

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

    {

    LOGGER_ENTERFN("CMmsDataStore::DoSetRemoteMaxObjectSize");

    LOGGER_LEAVEFN("CMmsDataStore::DoSetRemoteMaxObjectSize");

    }

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

// CMmsDataStore::DoMaxObjectSize

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

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

TInt CMmsDataStore::DoMaxObjectSize() const

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoMaxObjectSize" );

    CRepository* repository( NULL );

    TInt error( KErrNone );

    TInt maxSendSize( 0 );

    // Create central repository instance

    TRAP( error, repository = CRepository::NewL( KCRUidMmsEngine ) );  

    if ( error == KErrNone )

        {

        // Obtain the size from the central repository.

        // In the case of error we'll set the value to zero ("anything goes").

        error = repository->Get( KMmsEngineMaximumSendSize, maxSendSize );

        if ( error != KErrNone )

            {

            maxSendSize = 0;

            }

        delete repository;

        }

    else

        {

        LOGGER_WRITE_1( "CRepository::NewL leaved with %d", error );

        }       

    LOGGER_LEAVEFN( "CMmsDataStore::DoMaxObjectSize" );

    return maxSendSize;

    }

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

// CMmsDataStore::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 CMmsDataStore::DoOpenItemL( TSmlDbItemUid aUid, TBool& aFieldChange, 

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

    TDes8& aMimeVer, TRequestStatus& aStatus )

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoOpenItemL" );

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

    // Store these for later use

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    // Check that we're in a proper state

    if ( iCurrentState != EMmsOpenAndWaiting )

        {

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

        User::RequestComplete( iCallerStatus, KErrNotReady );

        return;

        }

    TBool userFolderFound( EFalse );

    TTime timeStamp;

    TPtrC folderName;

    userFolderFound = iMsvApi->FindUserFolderL( aUid, folderName, timeStamp );

    if ( userFolderFound )

        {

        // Allocate new buffer

        SAFEDELETE( iDataBuffer );

        iDataBuffer = CBufFlat::NewL( KDataBufferSize );

        iFolderObjectParser->SetName( folderName );

        iFolderObjectParser->SetCreatedDate( timeStamp.DateTime() );

        iFolderObjectParser->SetModifiedDate( timeStamp.DateTime() );

        iFolderObjectParser->ExportFolderXmlL( *iDataBuffer ); 

        iParentId = KMsvMyFoldersEntryIdValue;

        iCurrentState = EFolderOpen;

        iReadPosition = 0;

        aSize = iDataBuffer->Size();

        }

    else // Open MMS message

        {

        TInt error( KErrNone );

        CMsvEntry* entry( NULL );

        TRAP( error, entry = iMsvSession->GetEntryL(aUid) );

        if ( error != KErrNone )

            {

            User::RequestComplete( iCallerStatus, KErrNotFound ); 

            LOGGER_WRITE_1("iMsvSession->GetEntryL failed with %d.", error);

            return;

            }

        TMsvEntry messageEntry = entry->Entry();

        SAFEDELETE( entry );

        iCurrentId = aUid;

        iParentId = messageEntry.Parent();

        iReadCounter = 0;

        // Check whether we need to send the whole item

        if ( iChangeFinder->UpdatePartialL( aUid ) )

            {

            LOGGER_WRITE("EMmsItemOpenFieldUpdate");

            aSize = 1;

            iCurrentState = EMmsItemOpenFieldUpdate;

            }

        else    

            {

            // Read the whole item from the message store to the buffer

            TUint32 flags( 0 );

            TRAP( error, iCodecClient->InitializeChunkedRetrievingL(

                iCurrentId,

                iParentId,

                flags,

                iUnread,

                aSize,

                iMsvWait->iStatus) );

            if ( error != KErrNone ) 

                {

                User::RequestComplete( iCallerStatus, error );

                LOGGER_WRITE_1("iCodecClient->InitializeChunkedRetrievingL failed with %d.", error); 

                return;         

                }

            // Wait until the message has been processed

            iMsvWait->Start();

            if ( iMsvWait->iStatus != KErrNone )

                {

                User::RequestComplete( iCallerStatus, iMsvWait->iStatus.Int() );

                LOGGER_WRITE_1( "iCodecClient->InitializeChunkedRetrievingL failed with %d",

                    iMsvWait->iStatus.Int() ); 

                return;

                }

            LOGGER_WRITE_1("iUnread: %d", (TInt)iUnread);

            aSize++; // Status byte will be added also, reserve one additional byte for that.

            iCurrentState = EMmsItemOpen;

            }

        } // Open MMS message

    aParent = iParentId;

    aFieldChange = iCurrentState == EMmsItemOpenFieldUpdate ? ETrue : EFalse;

    if ( iCurrentState == EFolderOpen ) // Message folder

        {

        TInt targetLength = KFolderMimeType().Length();

        if ( aMimeType.MaxLength() < targetLength )

            {

            targetLength = aMimeType.MaxLength();

            }

        aMimeType.Copy( KFolderMimeType().Ptr(), targetLength );

        // Set mime version (do not exceed the allocated buffer)

        targetLength = KFolderMimeVersion().Length();

        if ( aMimeVer.MaxLength() < targetLength )

            {

            targetLength = aMimeVer.MaxLength();

            }

        aMimeVer.Copy( KFolderMimeVersion().Ptr(), targetLength );

        }

    else // EMmsMessage

        {   

        TInt targetLength = KMmsMimeType().Length();

        if ( aMimeType.MaxLength() < targetLength )

            {

            targetLength = aMimeType.MaxLength();

            }

        aMimeType.Copy( KMmsMimeType().Ptr(), targetLength );

        // Set mime version (do not exceed the allocated buffer)

        targetLength = KMmsMimeVersion().Length();

        if ( aMimeVer.MaxLength() < targetLength )

            {

            targetLength = aMimeVer.MaxLength();

            }

        aMimeVer.Copy( KMmsMimeVersion().Ptr(), targetLength );

        }

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

    // Signal we're complete

    User::RequestComplete( iCallerStatus, KErrNone ); 

    LOGGER_LEAVEFN("CMmsDataStore::DoOpenItemL");

    }

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

// CMmsDataStore::DoCreateItemL

// Create new item to the message store.

// Return the id number of the newly created item

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

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

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

    {

    LOGGER_ENTERFN( "CMmsDataStore::DoCreateItemL" );

    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 != EMmsOpenAndWaiting )

        {

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

        }

    TBool createFolder( EFalse );

    LOG( aMimeType );

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

        {

        createFolder = ETrue;

        }

    else if ( aMimeType.Compare( KMmsMimeType() ) != 0 )

        {

        User::RequestComplete( iCallerStatus, KErrNotSupported );

        LOGGER_WRITE("Bad MIME type");

        return;

        }

    // Ensure that we've got enough disk space for the item

    if ( iCodecClient->DiskSpaceBelowCriticalLevelL( aSize ) )

        {

        User::RequestComplete( iCallerStatus, KErrDiskFull );

        LOGGER_WRITE( "Disk full" );

        return;

        }

    if( createFolder )

        {

        if ( aParent != KMsvMyFoldersEntryIdValue )

            {

            User::RequestComplete( iCallerStatus, KErrNotSupported );

            LOGGER_WRITE( "Bad parent folder" );

            return;

            }

        SAFEDELETE( iDataBuffer );

        iDataBuffer = CBufFlat::NewL( KDataBufferSize );

        iCurrentState = EFolderCreating;