/*

* Copyright (c) 2002-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:  A contact operation for deleting multiple contacts

*

*/

// INCLUDE FILES

#include "CDeleteContactsOperation.h"

#include <MVPbkBatchOperationObserver.h>

#include "CContactStore.h"

#include "CRemoteStore.h"

#include "VPbkSimStoreError.h"

namespace VPbkSimStore {

// CONSTANTS

// Contacts are delete one contact at a time

const TInt KStepSize = 1;

// ============================= LOCAL FUNCTIONS ===============================

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

// SendStepFailed

// Send step failed event to given observer.

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

//

inline TBool SendStepFailed( CDeleteContactsOperation& aOperation, TInt aError,

    MVPbkBatchOperationObserver& aObserver )

    { 

    return aObserver.StepFailed( aOperation, KStepSize, aError );

    }

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

// SendStepComplete

// Send step completed event to given observer.

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

//

inline void SendStepComplete( CDeleteContactsOperation& aOperation,

    MVPbkBatchOperationObserver& aObserver )

    {

    aObserver.StepComplete( aOperation, KStepSize );

    }

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

// SendOperationComplete

// Send operation completed event to given observer.

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

//

inline void SendOperationComplete( CDeleteContactsOperation& aOperation,

    MVPbkBatchOperationObserver& aObserver )

    {

    aObserver.OperationComplete( aOperation );

    }

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

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

// CDeleteContactsOperation::CDeleteContactsOperation

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

// might leave.

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

//

CDeleteContactsOperation::CDeleteContactsOperation( CContactStore& aStore, 

    MVPbkBatchOperationObserver& aObserver )

    :   iStore( aStore ),

        iObserver( aObserver )

    {

    }

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

// CDeleteContactsOperation::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDeleteContactsOperation::ConstructL( 

    const TArray<TInt>& aSimIndexes )

    {

    const TInt count = aSimIndexes.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        iSimIndexes.AppendIntL( aSimIndexes[i] );

        }

    __ASSERT_DEBUG( iSimIndexes.Count() > 0,

        VPbkSimStore::Panic( VPbkSimStore::EZeroIndexesInDeleteOperation ) );

    }

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

// CDeleteContactsOperation::NewL

// Two-phased constructor.

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

//

CDeleteContactsOperation* CDeleteContactsOperation::NewL( 

    CContactStore& aStore, MVPbkBatchOperationObserver& aObserver,

    const TArray<TInt>& aSimIndexes )

    {

    CDeleteContactsOperation* self = 

        new( ELeave ) CDeleteContactsOperation( aStore, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aSimIndexes );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CDeleteContactsOperation::~CDeleteContactsOperation()

    {

    Cancel();

    }

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

// CDeleteContactsOperation::StartL

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

//

void CDeleteContactsOperation::StartL()

    {

    // Open store because the operation must listen to store events.

    iStore.OpenL( *this );

    }

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

// CDeleteContactsOperation::Cancel

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

//

void CDeleteContactsOperation::Cancel()

    {

    delete iSimOperation;

    iSimOperation = NULL;

    iStore.Close( *this );

    iSimIndexes.Close();

    }

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

// CDeleteContactsOperation::ContactEventComplete

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

//

void CDeleteContactsOperation::ContactEventComplete( TEvent /*aEvent*/, 

    CVPbkSimContact* /*aContact*/ )

    {

    // All the contacts have been deleted. Complete operation.

    SendOperationComplete( *this, iObserver );  

    }

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

// CDeleteContactsOperation::ContactEventError

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

//

void CDeleteContactsOperation::ContactEventError( TEvent /*aEvent*/, 

    CVPbkSimContact* /*aContact*/, TInt aError )

    {

    // An error happened, the operatio can not continue.

    CompleteWithError( aError );

    }

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

// CDeleteContactsOperation::ContactEventError

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

//

void CDeleteContactsOperation::StoreReady(MVPbkContactStore& /*aContactStore*/)

    {

    TRAPD( res, iSimOperation = iStore.NativeStore().DeleteL( 

        iSimIndexes, *this ) );

    if ( res != KErrNone )

        {

        CompleteWithError( res );

        }

    }

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

// CDeleteContactsOperation::ContactEventError

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

//

void CDeleteContactsOperation::StoreUnavailable(

        MVPbkContactStore& /*aContactStore*/, 

        TInt aReason)

    {

    CompleteWithError( aReason );

    }

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

// CDeleteContactsOperation::ContactEventError

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

//

void CDeleteContactsOperation::HandleStoreEventL(

        MVPbkContactStore& /*aContactStore*/, 

        TVPbkContactStoreEvent aStoreEvent)

    {

    if ( aStoreEvent.iEventType == TVPbkContactStoreEvent::EContactDeleted )

        {

        SendStepComplete( *this, iObserver );

        }

    }

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

// CDeleteContactsOperation::CompleteWithError

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

//

void CDeleteContactsOperation::CompleteWithError( TInt aError )

    {

    // Delete the async operation so that it doesn't send events after error

    delete iSimOperation;

    iSimOperation = NULL;

    // Close store so that the operation doesn't get store events after error.

    iStore.Close( *this );

    // Send error code to client.

    if ( SendStepFailed( *this, aError, iObserver ) )

        {

        // If client does continue call OperationComplete() for it.

        SendOperationComplete( *this, iObserver );        

        }

    }    

} // namespace VPbkSimStore

//  End of File