/*

* Copyright (c) 2009-2010 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 <sysutil.h> 

#include <cntfldst.h>

#include "contactsgrpdatastore.h"

#include "contactsgrpconverter.h"

#include "changefinder.h"

#include "contactsgrpdataproviderdefs.h"

#include "logger.h"

const TInt KDefaultBufferSize = 1024;

const TInt KDataBufferNotReady = -1;

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

// CContactsGrpDataStore::CContactsGrpDataStore

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

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

CContactsGrpDataStore::CContactsGrpDataStore() :

    {

    TRACE_FUNC;

    }

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

// CContactsGrpDataStore::ConstructL

// Symbian 2nd phase constructor, can leave.

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

void CContactsGrpDataStore::ConstructL()

    {

    TRACE_FUNC_ENTRY;

    User::LeaveIfError( iFs.Connect() );

    iNewItems       = new ( ELeave ) CNSmlDataItemUidSet;

    iDeletedItems   = new ( ELeave ) CNSmlDataItemUidSet;

    iUpdatedItems   = new ( ELeave ) CNSmlDataItemUidSet;

    iEmptyList      = new ( ELeave ) CNSmlDataItemUidSet;

    iConverter = CContactsGrpConverter::NewL();

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpDataStore::~CContactsGrpDataStore

// Destructor

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

CContactsGrpDataStore::~CContactsGrpDataStore()

    {

    TRACE_FUNC_ENTRY;

    delete iDataBuffer;

    delete iNewItems;

    delete iDeletedItems;

    delete iUpdatedItems;

    delete iEmptyList;

    if ( iChangeFinder )

        {

        TRAPD( error, iChangeFinder->CloseL() );

        if ( error != KErrNone )

            {

            LOGGER_WRITE_1( "iChangeFinder->CloseL() leaved with %d", error );

            }

        }

    delete iChangeFinder;

    delete iConverter;

    delete iContactsDb;

    iFs.Close();

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpDataStore::NewL

// Two-phased constructor.

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

CContactsGrpDataStore* CContactsGrpDataStore::NewL()

    {

    TRACE_FUNC_ENTRY;

    CContactsGrpDataStore* self = CContactsGrpDataStore::NewLC();

    CleanupStack::Pop( self );

    TRACE_FUNC_EXIT;

    return self;

    }

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

// CContactsGrpDataStore::NewLC

// Two-phased constructor.

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

CContactsGrpDataStore* CContactsGrpDataStore::NewLC()

    {

    TRACE_FUNC_ENTRY;

    CContactsGrpDataStore* self = new ( ELeave ) CContactsGrpDataStore();

    CleanupStack::PushL( self );

    self->ConstructL();

    TRACE_FUNC_EXIT;

    return self;

    }

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

// CContactsGrpDataStore::DoOpenL

// Opens database.

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

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

    MSmlSyncRelationship& aContext, TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;           

    *iCallerStatus = KRequestPending;

    if ( iContactsDb )

        {

        // already opened

        User::RequestComplete( iCallerStatus, KErrInUse );

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

        return;

        }

    // Create ChangeFinder

    if ( iChangeFinder )

        {

        delete iChangeFinder;

        iChangeFinder = NULL;

        }

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

    iContactsDb = CContactDatabase::OpenL();

    RegisterSnapshotL();

    User::RequestComplete( iCallerStatus, KErrNone );

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpDataStore::DoCancelRequest

// Not supported, does nothing.

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

void CContactsGrpDataStore::DoCancelRequest()

    {

    TRACE_FUNC;

    }

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

// CContactsGrpDataStore::DoStoreName

// Returns the name of the DataStore

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

const TDesC& CContactsGrpDataStore::DoStoreName() const

    {

    TRACE_FUNC;

    if ( iContactsDb )

        {

        return KContactsGrpStoreName;

        }

    else

        {

        return KNullDesC;

        }

    }

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

// CContactsGrpDataStore::DoBeginTransactionL

// Transactions are not supported.

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

void CContactsGrpDataStore::DoBeginTransactionL()

    {

    TRACE_FUNC;

    User::Leave( KErrNotSupported );

    }

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

// CContactsGrpDataStore::DoCommitTransactionL

// Transactions are not supported.

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

void CContactsGrpDataStore::DoCommitTransactionL( TRequestStatus& aStatus )

    {

    TRACE_FUNC;

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    }

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

// CContactsGrpDataStore::DoRevertTransaction

// Transactions are not supported.

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

void CContactsGrpDataStore::DoRevertTransaction( TRequestStatus& aStatus )

    {

    TRACE_FUNC;

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    }

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

// CContactsGrpDataStore::DoBeginBatchL

// Batching is not supported.

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

void CContactsGrpDataStore::DoBeginBatchL()

    {

    TRACE_FUNC;

    User::Leave( KErrNotSupported );

    }

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

// CContactsGrpDataStore::DoCommitBatchL

// Batching is not supported

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

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

    {

    TRACE_FUNC;

    iCallerStatus = &aStatus;

    User::RequestComplete( iCallerStatus, KErrNotSupported );

    }

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

// CContactsGrpDataStore::DoCancelBatch

// Batching is not supported

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

void CContactsGrpDataStore::DoCancelBatch()

    {

    TRACE_FUNC;

    }

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

// CContactsGrpDataStore::DoSetRemoteStoreFormatL

// Not supported

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

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

    {

    TRACE_FUNC;

    }

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

// CContactsGrpDataStore::DoSetRemoteMaxObjectSize

// Not supported

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

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

    {

    TRACE_FUNC;

    }

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

// CContactsGrpDataStore::DoMaxObjectSize

// Reads the maximum object size from the central repository

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

TInt CContactsGrpDataStore::DoMaxObjectSize() const

    {

    TRACE_FUNC;

    return 0; // no limit

    }

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

// CContactsGrpDataStore::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 CContactsGrpDataStore::DoOpenItemL(

    TSmlDbItemUid aUid, 

    TBool& aFieldChange, 

    TInt& aSize, 

    TSmlDbItemUid& aParent, 

    TDes8& aMimeType, 

    TDes8& aMimeVer, 

    TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

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

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    aFieldChange = EFalse;

    aParent = KErrNotFound;

    delete iDataBuffer;

    iDataBuffer = NULL;

    if ( !iContactsDb )

        {

        User::Leave( KErrNotReady );

        }

    iDataBuffer = CBufFlat::NewL( KDefaultBufferSize ); 

    iReaderPosition = 0;

    CContactItem* item = iContactsDb->ReadContactLC( aUid );

    if ( item->Type() != KUidContactGroup )

        {

        CleanupStack::PopAndDestroy( item );

        User::Leave( KErrNotFound );

        }

    iConverter->ImportDbItemL( *static_cast<CContactGroup*>(item) );

    CleanupStack::PopAndDestroy( item );

    iConverter->ExportVCardL( *iDataBuffer );

    iConverter->ResetL();

    aSize = iDataBuffer->Size();

    // Set mime type to correct one

    AssignString( aMimeType, KContactsGrpItemMimeType );

    AssignString( aMimeVer, KContactsGrpItemMimeVersion );

    User::RequestComplete( iCallerStatus, KErrNone );   

    iCurrentState = EContactGrpOpening;

    TRACE_FUNC_EXIT;   

    }

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

// CContactsGrpDataStore::DoCreateItemL

// Create new item to the message store.

// Return the id number of the newly created item

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

void CContactsGrpDataStore::DoCreateItemL(

    TSmlDbItemUid& aUid, 

    TInt aSize, 

    TSmlDbItemUid /*aParent*/, 

    const TDesC8& /*aMimeType*/, 

    const TDesC8& /*aMimeVer*/, 

    TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    // Ensure that we're in a proper state

    if ( iCurrentState != EOpenAndWaiting )

        {

        LOGGER_WRITE_1( "Warning: Unexpected current state: %d", iCurrentState );

        }

    if ( !iContactsDb )

        {

        LOGGER_WRITE( "iContactsDb not ready" );

        User::Leave( KErrNotReady );

        }

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

    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, aSize, EDriveC ) )

        {

        User::RequestComplete( iCallerStatus, KErrDiskFull );

        LOGGER_WRITE( "SysUtil::DiskSpaceBelowCriticalLevelL failed with KErrDiskFull." );

        return;

        }

    // item uid is updated when groups is saved to db.

    iCurrentItem = &aUid; 

    // Save current operation-state so we know what operation

    // is needed to do on DoCommitItemL

    iCurrentState = EContactGrpCreating;

    delete iDataBuffer;

    iDataBuffer = NULL;

    iDataBuffer = CBufFlat::NewL( KDefaultBufferSize );

    iWriterPosition = 0;

    User::RequestComplete( iCallerStatus, KErrNone );  

    TRACE_FUNC_EXIT;    

    }

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

// CContactsGrpDataStore::DoReplaceItemL

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

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

void CContactsGrpDataStore::DoReplaceItemL(

    TSmlDbItemUid aUid, 

    TInt aSize, 

    TSmlDbItemUid /*aParent*/,

    TBool /*aFieldChange*/, 

    TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

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

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    if ( !iContactsDb )

        {

        LOGGER_WRITE( "iContactsDb not ready" );

        User::Leave( KErrNotReady );

        }

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

    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, aSize, EDriveC ) )

        {

        User::RequestComplete( iCallerStatus, KErrDiskFull );

        LOGGER_WRITE( "SysUtil::DiskSpaceBelowCriticalLevelL failed with KErrDiskFull." );

        return;

        }

    // check that item exist and is Group-type

    CContactItem* item = iContactsDb->ReadContactLC( aUid );

    if ( item->Type() != KUidContactGroup )

        {

        CleanupStack::PopAndDestroy( item );

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( item );

    // init databuffer

    delete iDataBuffer;

    iDataBuffer = NULL;

    iDataBuffer = CBufFlat::NewL( KDefaultBufferSize );

    iWriterPosition = 0;

    // Save current item, so we know what item needs to be replaced

    iItemToBeReplaced = aUid;

    // Save current operation-state so we know what operation

    // is needed to do on DoCommitItemL

    iCurrentState = EContactGrpUpdating;

    User::RequestComplete( iCallerStatus, KErrNone );   

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpDataStore::DoReadItemL

// Read specified amount of data from the temporary buffer

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

void CContactsGrpDataStore::DoReadItemL( TDes8& aBuffer )

    {

    TRACE_FUNC_ENTRY;

    if ( iCurrentState != EContactGrpOpening || !iDataBuffer )

        {

        LOGGER_WRITE_1( "Unexpected state %d", iCurrentState );

        User::Leave( KErrNotReady );

        }

    if ( iReaderPosition == KDataBufferNotReady )

        {

        LOGGER_WRITE( "No data to read" );

        User::Leave( KErrEof );

        }

    // Thiw is how much data there is left in the buffer    

    TInt left = iDataBuffer->Size() - iReaderPosition;

    if ( left > 0 )

        {

        // This is how much there's space in the destination buffer

        TInt destSize = aBuffer.MaxSize();

        // This is how much we can read

        TInt toRead = destSize < left ? destSize : left;

        // Read the data from the buffer, then update the position      

        iDataBuffer->Read( iReaderPosition, aBuffer, toRead );

        iReaderPosition += toRead;

        }

    else

        {

        iReaderPosition = KDataBufferNotReady;

        LOGGER_WRITE( "No data to read" );

        User::Leave( KErrEof );

        }   

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpDataStore::DoWriteItemL

// Write specified amount of data to the temporary buffer

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

void CContactsGrpDataStore::DoWriteItemL( const TDesC8& aData )

    {

    TRACE_FUNC_ENTRY;

    if ( iCurrentState != EContactGrpCreating && iCurrentState != EContactGrpUpdating )

        {

        LOGGER_WRITE_1( "Unexpected current state: %d", iCurrentState );

        User::Leave( KErrNotReady );

        }

    // Calculate total size

    TInt totalSize = aData.Size() + iDataBuffer->Size();

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

    if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, totalSize, EDriveC ) )

        {

        User::RequestComplete( iCallerStatus, KErrDiskFull );

        LOGGER_WRITE("SysUtil::DiskSpaceBelowCriticalLevelL failed with KErrDiskFull.");

        return;

        }

    // Add data to buffer       

    iDataBuffer->InsertL( iWriterPosition, aData );

    iWriterPosition += aData.Size();

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpDataStore::DoCommitItemL

// Commits item from temporary buffer to the message store

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

void CContactsGrpDataStore::DoCommitItemL( TRequestStatus& aStatus )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;