/*

* Copyright (c) 2007 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:    XML importer

*

*/

// System includes

#include <CVPbkContactManager.h>        // CVPbkContactManager

#include <MVPbkContactOperationBase.h>  // MVPbkContactOperationBase

#include <MVPbkContactLinkArray.h>      // MVPbkContactLinkArray

#include <CVPbkContactLinkArray.h>      // CVPbkContactLinkArray

#include <MVPbkContactLink.h>           // MVPbkContactLink

#include <MVPbkContactOperation.h>      // MVPbkContactOperation

#include <e32def.h>

// User includes

#include "pdccontactdeletion.h"         // CPdcContactDeletion

#include "pdclogger.h"

// ======== MEMBER FUNCTIONS ========

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

// CPdcContactDeletion::NewL

// Symbian 1st phase constructor

// @param    aFs     file system

// @param    aContactDatabase   contacts database

// @return Self pointer to CPdcContactDeletion pushed to

// the cleanup stack.

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

//

CPdcContactDeletion* CPdcContactDeletion::NewL(

        CVPbkContactManager& aContactManager )

    {

    CPdcContactDeletion* self = new( ELeave )

        CPdcContactDeletion( aContactManager);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPdcContactDeletion::~CPdcContactDeletion

// Destructor

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

//

CPdcContactDeletion::~CPdcContactDeletion()

    {

    delete iDeleteOp;

    delete iLinkArray;

    delete iDeleteArray;

    }

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

// CPdcContactDeletion::CPdcContactDeletion

// C++ constructor

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

//

CPdcContactDeletion::CPdcContactDeletion(

        CVPbkContactManager& aContactManager )

    : iContactManager( aContactManager )

    {

    }

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

//  CPdcContactDeletion::ConstructL

//  Second-phase constructor

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

//

void CPdcContactDeletion::ConstructL()

    {

    }

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

// CPdcContactDeletion::GetXmlContactsL 

// Starts the asyncronous deletion of existing contacts

// @param   aLinkArray   array of links to contacts to be deleted,

//                        takes ownership

// @param   aCallerStatus       iStatus of caller

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

//

void CPdcContactDeletion::DeleteContactsL( MVPbkContactLinkArray* aLinkArray,

                                     TRequestStatus& aCallerStatus,TBool aDeleteStoredContact  )

    {

    LOGTEXT(_L("CPdcContactDeletion::DeleteContactsL"));

    iDeleteStoredContact = aDeleteStoredContact;

    // Create the array of links

    iDeleteArray = CVPbkContactLinkArray::NewL();

    // Set the index to the number of contacts in the link array.

    iLinkArray = aLinkArray;

    iIndex = iLinkArray->Count();

    // Store the caller's request status

    iCallerStatus = &aCallerStatus;

    aCallerStatus = KRequestPending;

    // Delete the contacts

    DeleteNextContact();    

    }

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

// CPdcContactDeletion::Cancel

// Cancels the deletion process

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

//

void CPdcContactDeletion::Cancel()

    {

    LOGTEXT(_L("CPdcContactDeletion::Cancel"));

    if( iDeleteOp )

    	{

    	// The delete operation is cancelled by deleting the operation.

        MVPbkContactOperation* contactOp =

            STATIC_CAST( MVPbkContactOperation*, iDeleteOp );

        contactOp->Cancel();

    	}

    }

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

// CPdcContactDeletion::StepComplete

// From MVPbkBatchOperationObserver.

// Called when one step of the delete operation is completed.

// IGNORED

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

//

void CPdcContactDeletion::StepComplete( 

        MVPbkContactOperationBase& /*aOperation*/, TInt /*aStepSize*/ )

    {

    }

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

// CPdcContactDeletion::StepFailed

// From MVPbkBatchOperationObserver.

// Called when one step of the delete operation fails.

//

// @return ETrue if the batch operation should continue, 

//               EFalse otherwise

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

//

TBool CPdcContactDeletion::StepFailed( 

        MVPbkContactOperationBase& /*aOperation*/,

        TInt /*aStepSize*/, TInt /*aError*/ )

    {

    LOGTEXT(_L("CPdcContactDeletion::StepFailed"));

    // Attempt to delete the next contact if it exists

    if( iDeleteStoredContact)

        {

        DeleteNextContact();

        }

    else

    	{

    	User::RequestComplete( iCallerStatus, KErrNone );	

    	}

    return EFalse;

    }

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

// CPdcContactDeletion::OperationComplete

// From MVPbkBatchOperationObserver.

// Called when delete operation is completed.

// This is called when all steps are executed.

//

// @param aOperation    the completed operation

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

//

void CPdcContactDeletion::OperationComplete(

        MVPbkContactOperationBase& /*aOperation*/ )

    {

    LOGTEXT(_L("CPdcContactDeletion::OperationComplete"));    

    // Attempt to delete the next contact if it exists

    if( iDeleteStoredContact)

        {

        DeleteNextContact();

        }

    else

        {

        User::RequestComplete( iCallerStatus, KErrNone );   

        }

    }

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

// CPdcContactDeletion::DeleteNextContact()

// Traps the leaving function DeleteNextContactL()

// 

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

//

void CPdcContactDeletion::DeleteNextContact()

    {

    LOGTEXT(_L("CPdcContactDeletion::DeleteNextContact"));

    TBool nextContact = EFalse;

    // Attempt to delete the next contact, if there is no

    // more contacts complete the caller's TRequestStatus

    TRAP_IGNORE( ( nextContact = DeleteNextContactL()  ))

    if ( !nextContact )

        {

        User::RequestComplete( iCallerStatus, KErrNone );

        }

    }

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

// CPdcContactDeletion::DeleteNextContactL()

// Deletes first contact in the link array, and removes it from the list.

//

// IMPORTANT NOTE:

// Each contact in the link array needs to be deleted individually. Although 

// CVPbkContactManager::DeleteContactsL can delete an array of contacts if the

// deletion process fails for some reason such as the contact has already been 

// deleted, it does not continue to delete the rest of the elements. ( The 

// in-code description  for the MVPbkBatchOperationObserver callback appear to

// be incorrect ).

// 

// @return ETrue if there is a contact to be deleted.

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

//

TBool CPdcContactDeletion::DeleteNextContactL()

    {

    TBool returnValue = EFalse;

    // Decrement the index

    --iIndex;

    if ( iIndex >= 0 )

        {

        // There is a contact to be deleted

        returnValue = ETrue;

        // Remove any entries in the delete array

        if ( iDeleteArray->Count() != 0 )

            {

            iDeleteArray->Delete( 0 );

            }

        // Get the link to be deleted

        const MVPbkContactLink& link = iLinkArray->At( iIndex );

        // Create a copy of the link and add it to

        // the delete array

        MVPbkContactLink* copiedLink = link.CloneLC();

        iDeleteArray->AppendL( copiedLink );

        CleanupStack::Pop(); // copiedLink 

        // delete the existing operation

        delete iDeleteOp;

        iDeleteOp = NULL;

        // Create the delete operation

        iDeleteOp = iContactManager.DeleteContactsL( *iDeleteArray, *this );

        }

    return returnValue;

    }

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

// CPdcContactDeletion::DeleteStoredContactsL 

// Starts the asyncronous deletion of existing contacts

// @param   aLinkArray   array of links to contacts to be deleted,

//                        takes ownership

// @param   aCallerStatus       iStatus of caller

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

//    

void CPdcContactDeletion::DeleteStoredContactsL( 

        MVPbkContactLinkArray* aLinkArray,

        TRequestStatus& aCallerStatus,

        TBool aDeleteStoredContact )

    {

    LOGTEXT(_L("CPdcContactDeletion::DeleteStoredContactsL"));

    iDeleteStoredContact = aDeleteStoredContact;

    // Create the array of links

    delete iDeleteArray;

    iDeleteArray = NULL;    

    iDeleteArray = CVPbkContactLinkArray::NewL();

    // Set the index to the number of contacts in the link array.

    MVPbkContactLinkArray* linkArray = aLinkArray;

    iIndex = linkArray->Count();  

    while(iIndex)

        {

        const MVPbkContactLink& link = linkArray->At( iIndex-1 );

        // Create a copy of the link and add it to

        // the delete array

        MVPbkContactLink* copiedLink = link.CloneLC();

        iDeleteArray->AppendL( copiedLink );

        CleanupStack::Pop(); // copiedLin

        iIndex--;

        }       

    delete iDeleteOp;

    iDeleteOp = NULL;  

    iDeleteOp = iContactManager.DeleteContactsL( *iDeleteArray, *this );

    // Store the caller's request status

    iCallerStatus = &aCallerStatus;

    aCallerStatus = KRequestPending;  

    }

// End of File