/*

* Copyright (c) 2007-2008 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:  An operation for importing and updating contacts to the store

*

*/

#include "CVPbkImportToContactsMergeOperation.h"

#include "VPbkVCardEngError.h"

#include "CVPbkVCardImporter.h"

// Virtual Phonebook

#include <MVPbkStoreContact.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactLink.h>

#include <CVPbkVCardEng.h>

#include <CVPbkContactManager.h>

#include <MVPbkFieldType.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkSingleContactOperationObserver.h>

namespace{

        };

    void Panic(TPanic aPanic)

        _LIT(KPanicCat, "CVPbkImportToContactsMergeOperation");

        User::Panic(KPanicCat, aPanic);

        }

    #endif // _DEBUG

} //namespace

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

// CVPbkImportToContactsMergeOperation::CVPbkImportToContactsMergeOperation

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

//

CVPbkImportToContactsMergeOperation::CVPbkImportToContactsMergeOperation(

        :   CActive( EPriorityStandard ),

            iObserver( aObserver ),

            iData(aData)

    {

    CActiveScheduler::Add(this);

    iGroupcardHandler = NULL;

    iOperationImpl = NULL;

    iVPbkOperation = NULL;

    }

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

// CVPbkImportToContactsMergeOperation::ConstructL

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

//

void CVPbkImportToContactsMergeOperation::ConstructL( TVPbkImportCardType aType, RReadStream& aSourceStream)

    {

    if ( aType == EVCard )

        {

        iOperationImpl = CVPbkVCardImporter::NewL(iImportedContacts, aSourceStream, iTargetStore, iData );

        }

    else

        {

        User::Leave( KErrArgument );

        }    

    iGroupcardHandler = CVPbkGroupCardHandler::NewL(iData);   

    }

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

// CVPbkImportToContactsMergeOperation::NewL

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

//

CVPbkImportToContactsMergeOperation * CVPbkImportToContactsMergeOperation::NewL( 

             TVPbkImportCardType aType,

             CVPbkVCardData& aData, 

             const MVPbkContactLink& aReplaceContact, 

             MVPbkContactStore& aTargetStore, 

             RReadStream& aSourceStream, 

             MVPbkSingleContactOperationObserver& aObserver )

    {

    CVPbkImportToContactsMergeOperation* self =

    new( ELeave ) CVPbkImportToContactsMergeOperation( aReplaceContact,aObserver, aTargetStore, aData);

    CleanupStack::PushL( self );

    self->ConstructL( aType, aSourceStream);

    CleanupStack::Pop( self );

    return self;

    }

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

// CVPbkImportToContactsMergeOperation::~CVPbkImportToContactsMergeOperation

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

//

CVPbkImportToContactsMergeOperation::~CVPbkImportToContactsMergeOperation()

    {

    if(iOperationImpl)

        {

        delete iOperationImpl;

        iOperationImpl = NULL;

        }

    if (iGroupcardHandler)

        {

        delete iGroupcardHandler;

        iGroupcardHandler = NULL;

        }

    if(iVPbkOperation)

        delete iVPbkOperation;

    iImportedContacts.ResetAndDestroy();

    CActive::Cancel();

    }

void CVPbkImportToContactsMergeOperation::StartL()

    {

    __ASSERT_DEBUG( iOperationImpl, VPbkVCardEngError::Panic(

        VPbkVCardEngError::EPreCond_CVPbkImportToStoreOperation_StartL ) );

    iOperationImpl->SetObserver( *this );

    iOperationImpl->StartL();

    }

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

// From class MVPbkContactOperation

// CVPbkImportToStoreOperation::Cancel

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

//

void CVPbkImportToContactsMergeOperation::Cancel()

    {

    if(iOperationImpl)

    delete iOperationImpl;

    iOperationImpl = NULL;

    }

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

// CVPbkImportToContactsMergeOperation::RunL

// from CActive

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

//

void CVPbkImportToContactsMergeOperation::RunL()

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

// CVPbkImportToContactsMergeOperation::RunError

// from CActive

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

//

TInt CVPbkImportToContactsMergeOperation::RunError( TInt aError )

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

// CVPbkImportToContactsMergeOperation::DoCancel

// from CActive

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

//

void CVPbkImportToContactsMergeOperation::DoCancel()

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

// From class MVPbkImportOperationObserver

// CVPbkImportToStoreOperation::ContactsImported

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

//

void CVPbkImportToContactsMergeOperation::ContactsImported()

    {

    if (iVPbkOperation)

        delete iVPbkOperation;

    iVPbkOperation = NULL;

    //At the Start of contact replace,aContact will be Null, it will be retrived later

    HandleContactReplacing(NULL); 

    }

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

// From class MVPbkImportOperationObserver

// CVPbkImportToStoreOperation::ContactsImportedCompleted

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

//

void CVPbkImportToContactsMergeOperation::ContactsImportingCompleted()

    {

    //not used

    }

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

// From class MVPbkImportOperationObserver

// CVPbkImportToStoreOperation::ContactImportingFailed

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

//

void CVPbkImportToContactsMergeOperation::ContactImportingFailed( TInt aError )

    {

    if(iVPbkOperation)

        delete iVPbkOperation;

    iVPbkOperation = NULL;

    HandleError( aError );

    }

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

// CVPbkImportToContactsMergeOperation::HandleContactReplacing

// To initiate and start contact replacing

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

//

void CVPbkImportToContactsMergeOperation::HandleContactReplacing(MVPbkStoreContact* aContact)

    {

    switch( iState )

        {

        case EImport:

            {

            // initiate contact replacing

            if ( iImportedContacts.Count() == 1 )

                {

                NextState( ERetrieve );

                }

            else

                {

                // invalid arguments

                HandleError( KErrArgument );

                }

            break;

            }

        case ERetrieve:

            {

            delete iContact;

            iContact = aContact;

            NextState( ELock );

            break;

            }

        case EReRetrieve:

            {

            delete iContact;

            iContact = aContact;

            NextState( EComplete );

            break;

            }

        default:

            __ASSERT_DEBUG( EFalse, Panic(EPanicInvalidState) );

            HandleError( KErrGeneral );

        }

    }

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

// CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationComplete

// from class MVPbkSingleContactOperationObserver

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

//

void CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationComplete(

                MVPbkContactOperationBase& /*aOperation*/,

                MVPbkStoreContact* aContact )

    {

    if (iVPbkOperation)

        delete iVPbkOperation;

    iVPbkOperation = NULL;

    HandleContactReplacing(aContact);

    }

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

// CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationFailed

// from class MVPbkSingleContactOperationObserver

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

//

void CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationFailed(

                MVPbkContactOperationBase& /*aOperation*/, 

                TInt aError )

    {

    delete iVPbkOperation;

    iVPbkOperation = NULL;

    HandleError( aError );

    }

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

// CVPbkImportToContactsMergeOperation::ContactOperationCompleted

// from class MVPbkContactObserver

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

//

void CVPbkImportToContactsMergeOperation::ContactOperationCompleted(

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

// CVPbkImportToContactsMergeOperation::ContactOperationFailed

// from class MVPbkContactObserver

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

//

void CVPbkImportToContactsMergeOperation::ContactOperationFailed(

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

// CVPbkImportToContactsMergeOperation::HandleError

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

//

void CVPbkImportToContactsMergeOperation::HandleError(TInt aError)

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

// CVPbkImportToContactsMergeOperation::RetrieveContactL

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

//

inline void CVPbkImportToContactsMergeOperation::RetrieveContactL()

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

// CVPbkImportToContactsMergeOperation::ReRetrieveContactL

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

//

inline void CVPbkImportToContactsMergeOperation::ReRetrieveContactL()

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

// CVPbkImportToContactsMergeOperation::LockContactL

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

//

inline void CVPbkImportToContactsMergeOperation::LockContactL()

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

// CVPbkImportToContactsMergeOperation::CommitContactL

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

//

inline void CVPbkImportToContactsMergeOperation::CommitContactL()

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

// CVPbkImportToContactsMergeOperation::UpdateContactL

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

//

inline void CVPbkImportToContactsMergeOperation::UpdateContactL()

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

// From class MVPbkImportOperationObserver

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

//

        {

        if ( type )

            {