/*

* 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:  CSconAsyncHandler implementation

*

*/

#include "sconasynchandler.h"

#include <ecom/ecom.h>

#include <SmlDataProvider.h>

#include <s32mem.h>

#include <nsmlchangefinder.h>

#include <e32cmn.h>

#include <ecom/ImplementationInformation.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "sconsyncclientserver.h"

#include "sconsyncrelationship.h"

#include "scondataproviderinfo.h"

#include "debug.h"

#include "logdatastoreformat.h"

// Data Store interface implementation Uid.

// Load all plugins with this uid.

const TUid KDSEcomIFUid = {0x101F4D3A};

const TInt KDefaultExpandSize = 1024;

// one store per computer, max store count.

const TInt KMaxStoresCount = 10;

const TInt KDefaultTimeOutInMicroSeconds = 30 * 1000000; // 30 seconds

const TInt KDeleteAllTimeOutInMicroSeconds = 300 * 1000000; // 5 minutes

const TInt KOpenStoreTimeOutInMicroSeconds = 180 * 1000000; // 180 seconds

CSconAsyncHandler::~CSconAsyncHandler()

    {

    TRACE_FUNC_ENTRY;

    Cancel();

    DoCloseStore();

    delete iItems;

    delete iWriteData;

    delete iDataStore;

    delete iDataProvider;

    delete iContext;

    delete iStoreFormat;

    iStringPool.Close();

    iFs.Close();

    REComSession::FinalClose();

    iChunk.Close();

    delete iTimeOut;

    TRACE_FUNC_EXIT;

    }

CSconAsyncHandler::CSconAsyncHandler(): CActive( EPriorityStandard )

    {

    TRACE_FUNC;

    CActiveScheduler::Add( this );

    }

CSconAsyncHandler* CSconAsyncHandler::NewL()

    {

    TRACE_FUNC;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CSconAsyncHandler::ConstructL()

    {

    TRACE_FUNC;

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

    TInt err = iFs.CreatePrivatePath( EDriveC );

    LOGGER_WRITE_1("CreatePrivatePath err: %d", err);

    iStringPool.OpenL();

    iTimeOut = CCSconTimeOut::NewL( *this );

    }

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

// CSconAsyncHandler::HandleServiceL()

// Handles the client request

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

//

void CSconAsyncHandler::HandleServiceL( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY;

    if ( aMessage.Function() == ECancelRequest )

        {

        LOGGER_WRITE("ECancelRequest");

        if ( IsActive() )

            {

            Cancel();

            LOGGER_WRITE("iMessage.Complete( KErrCancel )");

            CompleteRequest( KErrCancel );

            }

        LOGGER_WRITE("aMessage.Complete( KErrNone )");

        aMessage.Complete( KErrNone );

        TRACE_FUNC_EXIT;

        return;

        }

    iTimeOut->Start( KDefaultTimeOutInMicroSeconds );

    iMessage = aMessage;

    switch ( aMessage.Function() )

        {

        case ESendChunkHandle:

            LOGGER_WRITE( "CSconSyncSession::ServiceL() : ESendChunkHandle" );

            HandleChunkMessage();

            break;

        case EListImplementations:

            LOGGER_WRITE( "CSconSyncSession::ServiceL() : EListImplementations" );

            ListAllImplementationsL();

            break;

        case EOpenStore:

            LOGGER_WRITE( "CSconSyncSession::ServiceL() : EOpenStore" );

            iTimeOut->Start( KOpenStoreTimeOutInMicroSeconds );

            OpenStoreL();

            break;

        case EOpenItem:

            OpenItemL();

            break;

        case ECreateItem:

            CreateItemL();

            break;

        case EReplaceItem:

            ReplaceItemL();

            break;

        case EMoveItem:

            MoveItemL();

            break;

        case EDeleteItem:

            DeleteItemL();

            break;

        case ESoftDeleteItem:

            SoftDeleteItemL();

            break;

        case EDeleteAllItems:

            iTimeOut->Start( KDeleteAllTimeOutInMicroSeconds );

            DeleteAllItemsL();

            break;

        case EReadParent:

            ReadParentL();

            break;

        case EHasHistory:

            HasHistoryL();

            break;

        case EAddedItems:

            AddedItemsL();

            break;

        case EDeletedItems:

            DeletedItemsL();

            break;

        case ESoftDeletedItems:

            SoftDeletedItemsL();

            break;

        case EModifiedItems:

            ModifiedItemsL();

            break;

        case EMovedItems:

            MovedItemsL();

            break;

        case EResetChangeInfo:

            ResetChangeInfoL();

            break;

        case ECommitChangeInfo:

            CommitChangeInfoL();

            break;

        case ECloseStore:

            CloseStore();

            break;

        case ESetSyncTimeStamp:

            SetSyncTimeStampL();

            break;

        case EGetSyncTimeStamp:

            GetSyncTimeStampL();

            break;

        case EExportStoreFormat:

            ExportStoreFormatL();

            break;

        case ESetRemoteStoreFormat:

            SetRemoteStoreFormatL();

            break;

        default:

            aMessage.Complete(KErrNotSupported);

            break;

        }

    TRACE_FUNC_EXIT;

    }

void CSconAsyncHandler::RunL()

    {

    TRACE_FUNC_ENTRY;

    LOGGER_WRITE_1("iStatus.Int(): %d", iStatus.Int());

    switch ( iMessage.Function() )

        {

        case EOpenStore:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EOpenStore" );

            CompleteRequest( iStatus.Int() );

            break;

        case EOpenItem:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EOpenItem" );

            OpenItemCompletedL( iStatus.Int() );

            break;

        case ECreateItem:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : ECreateItem" );

            if (!iCommitInProgress)

                {

                // Write data to item

                CreateItemCompletedL( iStatus.Int() );

                }

            else

                {

                // commit is done, all ready

                LOGGER_WRITE( "CSconAsyncHandler::RunL() : ECreateItem, commit done" );

                TPckg<TSmlDbItemUid> pckg(iNewItem);

                iMessage.WriteL( 0, pckg, 0);

                CompleteRequest( iStatus.Int() );

                }

            break;

        case EReplaceItem:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EReplaceItem" );

            if (!iCommitInProgress)

                {

                // Write data to item

                ReplaceItemCompletedL( iStatus.Int() );

                }

            else

                {

                // commit is done, all ready

                LOGGER_WRITE( "CSconAsyncHandler::RunL() : EReplaceItem, commit done" );

                CompleteRequest( iStatus.Int() );

                }

            break;

        case EMoveItem:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EMoveItem" );

            CompleteRequest( iStatus.Int() );

            break;

        case EDeleteItem:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EDeleteItem" );

            CompleteRequest( iStatus.Int() );

            break;

        case ESoftDeleteItem:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : ESoftDeleteItem" );

            CompleteRequest( iStatus.Int() );

            break;

        case EDeleteAllItems:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EDeleteAllItems" );

            CompleteRequest( iStatus.Int() );

            break;

        case EReadParent:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EReadParent" );

            ReadParentCompletedL( iStatus.Int() );

            break;

        case EResetChangeInfo:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : EResetChangeInfo" );

            CompleteRequest( iStatus.Int() );

            break;

        case ECommitChangeInfo:

            LOGGER_WRITE( "CSconAsyncHandler::RunL() : ECommitChangeInfo" );

            delete iItems;

            iItems = NULL;

            CompleteRequest( iStatus.Int() );

            break;

        default:

            LOGGER_WRITE("Not asynchronous function")

            CompleteRequest( KErrNotSupported );

            break;

        }

    TRACE_FUNC_EXIT;

    }

TInt CSconAsyncHandler::RunError(TInt aError)

    {

    LOGGER_WRITE_1("CSconAsyncHandler::RunError() aError: %d", aError);

    delete iItems;

    iItems = NULL;

    delete iWriteData;

    iWriteData = NULL;

    if ( IsActive() )

        {

        LOGGER_WRITE("IsActive");

        //iDataStore->CancelRequest();

        Cancel();

        }

    if ( iDataStore && iMessage.Function() == EOpenItem )

        {

        LOGGER_WRITE( "CSconAsyncHandler::RunError() : EOpenItem" );

        iDataStore->CloseItem();

        }

    CompleteRequest( aError );

    aError = KErrNone;

    LOGGER_WRITE_1("CSconAsyncHandler::RunError() : Return %d", aError);

    return aError;

    //return KErrNone;//aError;

    }

void CSconAsyncHandler::DoCancel()

    {

    TRACE_FUNC_ENTRY;

    iDataStore->CancelRequest();

    iTimeOut->Cancel();

    if ( iStatus == KRequestPending )

        {

        LOGGER_WRITE( "iStatus == KRequestPending" );

        }

    if ( iDataStore && iMessage.Function() == EOpenItem )

        {

        LOGGER_WRITE( "CSconAsyncHandler::RunError() : EOpenItem" );

        iDataStore->CloseItem();

        }

    TRACE_FUNC_EXIT;

    }

void CSconAsyncHandler::TimeOut()

    {

    TRACE_FUNC_ENTRY;

    if ( IsActive() )

        {

        Cancel();

        CompleteRequest( KErrCancel );

        }

    TRACE_FUNC_EXIT;

    }

void CSconAsyncHandler::HandleChunkMessage()

    {

    TRACE_FUNC_ENTRY;

    TInt ret ( KErrNone );

    ret = iChunk.Open( iMessage, 0, EFalse );

    LOGGER_WRITE_1( "CSconAsyncHandler::HandleChunkMessageL() : ret %d", ret );

    CompleteRequest( ret );

    }

void CSconAsyncHandler::ListAllImplementationsL()

    {

    TRACE_FUNC_ENTRY;

    RImplInfoPtrArray implInfoArray;

    CleanupResetAndDestroyPushL( implInfoArray );

    REComSession::ListImplementationsL( KDSEcomIFUid, implInfoArray );

    const TInt KDataproviderInfoSize = 250; // 250 bytes should be enought

    TInt requiredSize = implInfoArray.Count() * KDataproviderInfoSize;

    if ( iChunk.Size() < requiredSize )

        {

        User::LeaveIfError( iChunk.Adjust( requiredSize ) );

        }

    RMemWriteStream stream ( iChunk.Base(), iChunk.Size() );

    CleanupClosePushL( stream );

    RSconDataProviderInfoArray dpInfoArray;

    CleanupResetAndDestroyPushL( dpInfoArray );

    // Collect information from dataproviders

    for ( TInt i=0; i < implInfoArray.Count(); i++ )

        {

        LOGGER_WRITE_1("implInfoArray: %d",i);

        CImplementationInformation& implInfo = *implInfoArray[i];

        CSmlDataProvider* dp(NULL);

        TRAPD( err, dp = CSmlDataProvider::NewL( implInfo.ImplementationUid().iUid ) );

        LOGGER_WRITE_2("CSmlDataProvider::NewL, uid(0x%08x) err: %d",implInfo.ImplementationUid().iUid, err );

        if ( !err )

            {

            CleanupStack::PushL( dp );

            CSconDataproviderInfo *dpInfo = CSconDataproviderInfo::NewL();

            CleanupStack::PushL( dpInfo );

            dpInfo->SetImplementationUid( implInfo.ImplementationUid() );

            LOGGER_WRITE_1("ImplementationUid: 0x%08x", implInfo.ImplementationUid().iUid );

            dpInfo->SetDisplayNameL( implInfo.DisplayName() );

            LOGGER_WRITE_1("DisplayName: %S", &implInfo.DisplayName() );

            dpInfo->SetDefaultStoreL( dp->DefaultStoreL() );

            LOGGER_WRITE_1("DefaultStoreL: %S", &dp->DefaultStoreL() );

            CDesCArray* stores = dp->ListStoresLC();

            dpInfo->SetStoresL( *stores );

            CleanupStack::PopAndDestroy( stores );

            dpInfoArray.AppendL( dpInfo );

            CleanupStack::Pop( dpInfo );

            CleanupStack::PopAndDestroy( dp );

            }

        }

    // Wrtie to stream

    stream.WriteUint16L( dpInfoArray.Count() );

    for ( TInt i = 0; i < dpInfoArray.Count(); i++ )

        {

        CSconDataproviderInfo& dpInfo = *dpInfoArray[i];

        dpInfo.ExternalizeL( stream );

        }

    stream.CommitL();

    CleanupStack::PopAndDestroy( &dpInfoArray );

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::PopAndDestroy( &implInfoArray );

    CompleteRequest( KErrNone );

    TRACE_FUNC_EXIT;

    }

void CSconAsyncHandler::OpenStoreL()

    {

    TRACE_FUNC_ENTRY;

    if ( iDataStore )

        {

        LOGGER_WRITE("Warning: Previous DataStore was not closed properly.");

        DoCloseStore();

        }

    // copy data from the chunk

    RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

    CleanupClosePushL( readStream );

    TSmlDataProviderId providerId = readStream.ReadUint32L();

    LOGGER_WRITE_1("providerId: 0x%08x", providerId);

    TInt len = readStream.ReadUint32L();

    HBufC* storeName = HBufC::NewLC(len);

    TPtr storeNamePtr = storeName->Des();

    readStream.ReadL(storeNamePtr, len);

    LOGGER_WRITE_1("storeName: %S", &storeNamePtr);

    TInt contextUid = readStream.ReadUint32L();

    LOGGER_WRITE_1("contextIdentifier: 0x%08x", contextUid);

    LOGGER_WRITE("Open provider");

    delete iDataProvider;

    iDataProvider = NULL;

    iDataProvider = CSmlDataProvider::NewL( providerId );

    delete iContext;

    iContext = NULL;

    delete iStoreFormat;

    iStoreFormat = NULL;

    LOGGER_WRITE("Create context");

    iContext = CSconSyncRelationship::NewL( iFs, TUid::Uid(contextUid), providerId );

    LOGGER_WRITE("Create NewStoreInstanceLC");

    iDataStore = iDataProvider->NewStoreInstanceLC();

    CleanupStack::Pop( iDataStore );

    SetActive();

    iStatus = KRequestPending;

    LOGGER_WRITE("OpenL");

    TRAPD(err, iDataStore->OpenL(storeNamePtr,*iContext, iStatus));

    if ( err )

        {

        // we are on active state, call request completed (RunL)

        LOGGER_WRITE_1("iDataStore->OpenL leaved with err: %d", err);

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, err );

        }

    CleanupStack::PopAndDestroy( storeName );

    CleanupStack::PopAndDestroy( &readStream );

    TRACE_FUNC_EXIT;

    }

void CSconAsyncHandler::OpenItemL()

    {

    TRACE_FUNC_ENTRY;

    LeaveIfNoInstanceL();

    if ( IsActive() )

        {

        LOGGER_WRITE("Was still in Active");

        Cancel();

        }

    TSmlDbItemUid itemUid = iMessage.Int0();

    LOGGER_WRITE_1("Open item: %d", itemUid);

    // set default values