/*

* 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:  Contacts relocator.

*

*/

// INCLUDE FILES

#include <CPbk2ContactRelocator.h>

// Phonebook 2

#include <CPbk2StoreConfiguration.h>

#include <MPbk2ApplicationServices.h>

#include <Phonebook2PrivateCRKeys.h>

#include <MPbk2ContactRelocatorObserver.h>

#include <Pbk2CommonUi.rsg>

#include <CPbk2StoreProperty.h>

#include <CPbk2StorePropertyArray.h>

#include <MPbk2ContactNameFormatter.h>

#include <TPbk2DestructionIndicator.h>

// Virtual Phonebook

#include <MVPbkStoreContact.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStoreProperties.h>

#include <VPbkContactStoreUris.h>

#include <CVPbkContactStoreUriArray.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactLink.h>

#include <TVPbkContactStoreUriPtr.h>

#include <CVPbkContactLinkArray.h>

#include <CPbk2ApplicationServices.h>

#include <MVPbkContactCopyPolicy.h>

#include <CVPbkContactCopyPolicyManager.h>

// System includes

#include <centralrepository.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

/// Unnamed namespace for local definitions

namespace {

// LOCAL CONSTANTS AND MACROS

const TInt KFirstElement = 0;

const TInt KOneContact = 1;

const TInt KDefaultTitleFormat = MPbk2ContactNameFormatter::EUseSeparator;

#ifdef _DEBUG

// Definition for many contacts relocation

const TInt KLinkArrayRelocationMinCount = 2;

enum TPanicCode

    {

    EPanicPreCond_ContactsSaved,

    EPanicLogic_AskConfirmationL,

    EPanicPreCond_RelocateContactL,

    EPanicPreCond_RelocateContactsL,

    EPanicPreCond_RelocateAndLockContactL,

    EPanicPreCond_PrepareToRelocateContactL,

    EPanicPreCond_DeleteSourceContact,

    EPanicPreCond_VerifyRelocationQueryType

    };

void Panic( TInt aReason )

    {

    _LIT( KPanicText, "CPbk2ContactRelocator" );

    User::Panic( KPanicText, aReason );

    }

#endif // _DEBUG

/**

 * Fetches contact's store name, which can be use in relocation queries.

 * If store name cannot be fetched from global store properties, then

 * contact's store property is returned.

 *

 * @param aContact Reference to contact.

 * @param aStoreProperties Reference to store properties.

 * @return Pointer to store name. Ownership is not transferred

 */

const TDesC* StoreName(

        const MVPbkStoreContact* aContact,

        CPbk2StorePropertyArray& aStoreProperties )

    {

    const TDesC* storeName = NULL;

    if ( aContact )

        {

        // Fetch store name

        TVPbkContactStoreUriPtr uri =

            aContact->ParentStore().StoreProperties().Uri();

        const CPbk2StoreProperty* storeProperty =

            aStoreProperties.FindProperty( uri );

        if (storeProperty)

            {

            storeName = &storeProperty->StoreName();

            }

        else

            {

            storeName = &uri.UriDes();

            }        

        }

    return storeName;

    }

} // namespace

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

// CPbk2ContactRelocator::CPbk2ContactRelocator

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

//

CPbk2ContactRelocator::CPbk2ContactRelocator() :

        CActive( CActive::EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CPbk2ContactRelocator::~CPbk2ContactRelocator

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

//

CPbk2ContactRelocator::~CPbk2ContactRelocator()

    {

    Cancel();

    delete iSourceContact;

    delete iSourceContacts;

    delete iRelocatedContact;

    delete iContactRetriever;

    delete iSavedContactsRetriever;

    delete iContactCopier;

    delete iCopyPolicyManager;

    delete iQueryDialog;

    if ( iTargetStore )

        {

        iTargetStore->Close( *this );

        }

    if ( iDestroyedPtr )

        {

        *iDestroyedPtr = ETrue;

        }

    Release( iAppServices ); 

    }

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

// CPbk2ContactRelocator::NewL

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

//

EXPORT_C CPbk2ContactRelocator* CPbk2ContactRelocator::NewL()

    {

    CPbk2ContactRelocator* self =

        new ( ELeave ) CPbk2ContactRelocator();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2ContactRelocator::ConstructL

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

//

inline void CPbk2ContactRelocator::ConstructL()

    {

    iAppServices = CPbk2ApplicationServices::InstanceL();

    iRelocationPolicy = ReadRelocationPolicyL();

    }

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

// CPbk2ContactRelocator::RelocateContactL

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

//

EXPORT_C TBool CPbk2ContactRelocator::RelocateContactL(

        MVPbkStoreContact* aContact,

        MPbk2ContactRelocatorObserver& aObserver,

        Pbk2ContactRelocator::TPbk2ContactRelocationQueryPolicy aQueryPolicy,

        TUint32 aFlags )

    {

    __ASSERT_DEBUG( aContact, Panic( EPanicPreCond_RelocateContactL ) );

    // Adjust policy

    if ( iRelocationPolicy == Pbk2ContactRelocator::EPbk2CopyContactToPhoneMemoryAndLock )

        {

        iRelocationPolicy = Pbk2ContactRelocator::EPbk2CopyContactToPhoneMemory;

        }

    else if ( iRelocationPolicy == Pbk2ContactRelocator::EPbk2MoveContactToPhoneMemoryAndLock )

        {

        iRelocationPolicy = Pbk2ContactRelocator::EPbk2MoveContactToPhoneMemory;

        }

    return PrepareToRelocateContactL( aContact, NULL, aObserver,

        aQueryPolicy, aFlags );

    }

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

// CPbk2ContactRelocator::RelocateAndLockContactL

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

//

EXPORT_C TBool CPbk2ContactRelocator::RelocateAndLockContactL(

        MVPbkStoreContact* aContact,

        MPbk2ContactRelocatorObserver& aObserver,

        Pbk2ContactRelocator::TPbk2ContactRelocationQueryPolicy aQueryPolicy,

        TUint32 aFlags )

    {

    __ASSERT_DEBUG( aContact, Panic( EPanicPreCond_RelocateAndLockContactL ) );

    // Adjust policy

    if ( iRelocationPolicy == Pbk2ContactRelocator::EPbk2CopyContactToPhoneMemory )

        {

        iRelocationPolicy = Pbk2ContactRelocator::EPbk2CopyContactToPhoneMemoryAndLock;

        }

    else if ( iRelocationPolicy == Pbk2ContactRelocator::EPbk2MoveContactToPhoneMemory )

        {

        iRelocationPolicy = Pbk2ContactRelocator::EPbk2MoveContactToPhoneMemoryAndLock;

        }

    return PrepareToRelocateContactL( aContact, NULL, aObserver,

        aQueryPolicy, aFlags );

    }

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

// CPbk2ContactRelocator::RelocateContactsL

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

//

EXPORT_C TBool CPbk2ContactRelocator::RelocateContactsL(

        CVPbkContactLinkArray* aContacts,

        MPbk2ContactRelocatorObserver& aObserver,

        Pbk2ContactRelocator::TPbk2ContactRelocationQueryPolicy aQueryPolicy )

    {

    __ASSERT_DEBUG( aContacts, Panic(EPanicPreCond_RelocateContactsL ) );

    return PrepareToRelocateContactL( NULL, aContacts, aObserver,

        aQueryPolicy, EPbk2RelocatorExistingContact );

    }

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

// CPbk2ContactRelocator::IsPhoneMemoryContact

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

//

EXPORT_C TBool CPbk2ContactRelocator::IsPhoneMemoryContact(

        const MVPbkStoreContact& aContact) const

    {

    TBool ret = EFalse;

    TVPbkContactStoreUriPtr uri =

        aContact.ParentStore().StoreProperties().Uri();

    TVPbkContactStoreUriPtr phoneMemoryUri

        ( VPbkContactStoreUris::DefaultCntDbUri() );

    if (uri.Compare( phoneMemoryUri,

        TVPbkContactStoreUriPtr::EContactStoreUriStoreType ) == 0)

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CPbk2ContactRelocator::IsPhoneMemoryInConfigurationL

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

//

EXPORT_C TBool CPbk2ContactRelocator::IsPhoneMemoryInConfigurationL() const

    {

    TBool ret = EFalse;

    // Get current configuration

    CPbk2StoreConfiguration& storeConfig = iAppServices->StoreConfiguration();

    CVPbkContactStoreUriArray* uriArray = storeConfig.CurrentConfigurationL();

    // Check is phone memory included

    ret = uriArray->IsIncluded( VPbkContactStoreUris::DefaultCntDbUri() );

    delete uriArray;

    return ret;

    }

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

// CPbk2ContactRelocator::RunL

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

//

void CPbk2ContactRelocator::RunL()

    {

    // This methods gets called only when the relocation was cancelled or

    // otherwise stopped at the very beginning. The observer is needed to

    // be called back asynchronously, so the active object is set running.

    if ( iSourceContact )

        {

        MVPbkStoreContact* sourceContact = iSourceContact;

        iSourceContact = NULL;

        iObserver->ContactRelocationFailed( iErrorCode, sourceContact );

        }

    else if ( iSourceContacts )

        {

        CVPbkContactLinkArray* sourceContacts = iSourceContacts;

        iSourceContacts = NULL;

        iObserver->ContactsRelocationFailed( iErrorCode, sourceContacts );

        }

    }

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

// CPbk2ContactRelocator::DoCancel

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

//

void CPbk2ContactRelocator::DoCancel()

    {

    // Do nothing

    }

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

// CPbk2ContactRelocator::RunError

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

//

TInt CPbk2ContactRelocator::RunError( TInt /*aError*/ )

    {

    // No leaving code in RunL

    return KErrNone;

    }

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

// CPbk2ContactRelocator::StoreReady

// Phone memory store was succesfully opened.

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

//

void CPbk2ContactRelocator::StoreReady

        ( MVPbkContactStore& /*aContactStore*/ )

    {

    iTargetStoreOpen = ETrue;

    // Safe to ignore error

    TRAPD( err, DoRelocateContactL() );

    if ( err == KErrDiskFull )

        {

        IssueRequest();

        }

    }

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

// CPbk2ContactRelocator::IssueRequest

// Inform failure asynchronously

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

//

void CPbk2ContactRelocator::IssueRequest()

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CPbk2ContactRelocator::StoreUnavailable

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

//

void CPbk2ContactRelocator::StoreUnavailable

        ( MVPbkContactStore& /*aContactStore*/, TInt aReason )

    {

    // Problem in opening phone memory store

    iObserver->ContactRelocationFailed( aReason, iSourceContact );

    iSourceContact = NULL; // ownership was given away

    }

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

// CPbk2ContactRelocator::HandleStoreEventL

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

//

void CPbk2ContactRelocator::HandleStoreEventL

        ( MVPbkContactStore& /*aContactStore*/,

        TVPbkContactStoreEvent /*aStoreEvent*/ )

    {

    // Do nothing

    }

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

// CPbk2ContactRelocator::FieldAddedToContact

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

//

void CPbk2ContactRelocator::FieldAddedToContact

        ( MVPbkContactOperationBase& /*aOperation*/ )

    {

    // Do nothing

    }

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

// CPbk2ContactRelocator::FieldAddingFailed

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

//

void CPbk2ContactRelocator::FieldAddingFailed

        ( MVPbkContactOperationBase& /*aOperation*/, TInt /*aError*/ )

    {

    // Do nothing

    }

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

// CPbk2ContactRelocator::ContactsSaved

// Contact was succesfully saved to phone memory

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

//

void CPbk2ContactRelocator::ContactsSaved

        ( MVPbkContactOperationBase& /*aOperation*/,

        MVPbkContactLinkArray* aResults )

    {

    // There should be only one link in the results array

    __ASSERT_DEBUG( aResults && aResults->Count() == KOneContact,

        Panic( EPanicPreCond_ContactsSaved ) );

    TRAPD( err,

        {

        CleanupDeletePushL( aResults );

        // Next, retrieve the saved contact

        RetrieveSavedContactL( aResults->At( KFirstElement ) );

        CleanupStack::PopAndDestroy(); // aResults

        });

    if ( err != KErrNone )

        {

        iObserver->ContactRelocationFailed( err, iSourceContact );

        iSourceContact = NULL; // ownership was given away

        }

    }

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

// CPbk2ContactRelocator::ContactsSavingFailed

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

//

void CPbk2ContactRelocator::ContactsSavingFailed

        ( MVPbkContactOperationBase& /*aOperation*/, TInt aError )

    {

    // Contact was not succesfully saved to phone memory

    iObserver->ContactRelocationFailed( aError, iSourceContact );

    iSourceContact = NULL; // ownership was given away

    // Move to next request, if any. Safe to ignore error.

    TRAP_IGNORE( DoRelocateContactL() );

    }

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

// CPbk2ContactRelocator::VPbkSingleContactOperationComplete

// Contact was succesfully retrieved from a link.

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

//

void CPbk2ContactRelocator::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& aOperation,

        MVPbkStoreContact* aContact )

    {

    if ( &aOperation == iSavedContactsRetriever )

        {

        // Destroy the last relocated contact

        delete iRelocatedContact;

        iRelocatedContact = NULL;

        // Assign a new relocated contact

        iRelocatedContact = aContact;

        if ( ( iActivePolicy == Pbk2ContactRelocator::EPbk2CopyContactToPhoneMemoryAndLock ) ||

            ( iActivePolicy == Pbk2ContactRelocator::EPbk2MoveContactToPhoneMemoryAndLock ) )

            {

            // Lock the contact

            TRAPD( err, iRelocatedContact->LockL( *this ) );

            if ( err != KErrNone )

                {

                iObserver->ContactRelocationFailed( err, iSourceContact );

                iSourceContact = NULL; // ownership was given away

                // Move to next request, if any. Safe to ignore error.

                TRAP_IGNORE( DoRelocateContactL() );

                }

            }

        else if ( iActivePolicy == Pbk2ContactRelocator::EPbk2MoveContactToPhoneMemory )

            {

            DeleteSourceContact();

            }

        else // EPbk2CopyContactToPhoneMemory

            {

            DoHandleContactRelocated();

            TRAP_IGNORE( DoRelocateContactL() );

            FinalizeIfReady();

            }

        }

    else if ( &aOperation == iContactRetriever )

        {

        // One contact from given link array was retrieved, now it has

        // to be stored and then relocated

        iSourceContact = aContact;

        DoRelocateContactL();

        }

    }

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

// CPbk2ContactRelocator::VPbkSingleContactOperationFailed

// Contact was not succesfully retrieved from a link.

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

//

void CPbk2ContactRelocator::VPbkSingleContactOperationFailed

        ( MVPbkContactOperationBase& /*aOperation*/, TInt aError )

    {

    if ( aError != KErrDiskFull )

        {

        iObserver->ContactRelocationFailed( aError, iSourceContact );

        iSourceContact = NULL; // ownership was given away

        // Move to next request, if any

        TRAP_IGNORE( DoRelocateContactL() );

        }

    else

        {

        IssueRequest();