/*

* Copyright (c) 2005-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:  Phonebook 2 server app prepare single assign phase.

*

*/

#include "CPbk2PrepareSingleAssignPhase.h"

// Phonebook 2

#include "MPbk2ServicePhaseObserver.h"

#include "CPbk2ServerAppAppUi.h"

#include "Pbk2ContactAssignerFactory.h"

#include "TPbk2AssignNoteService.h"

#include "MPbk2SelectFieldProperty.h"

#include "Pbk2ServerApp.hrh"

#include "CPbk2KeyEventDealer.h"

#include <TPbk2DestructionIndicator.h>

#include <MPbk2ApplicationServices.h>

#include <Pbk2ServerApp.rsg>

// Virtual Phonebook

#include <MVPbkContactLink.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <VPbkContactStoreUris.h>

using namespace Pbk2ContactRelocator;

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

enum TPanicCode

    {

    ENullPointer,

    ELogicRelocation

    };

void Panic(TPanicCode aReason)

    {

    _LIT( KPanicText, "CPbk2PrepareSingleAssignPhase" );

    User::Panic( KPanicText, aReason );

    }

#endif // _DEBUG

} /// namespace

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

// CPbk2PrepareSingleAssignPhase::CPbk2PrepareSingleAssignPhase

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

//

CPbk2PrepareSingleAssignPhase::CPbk2PrepareSingleAssignPhase

        ( MPbk2ServicePhaseObserver& aObserver,

          MVPbkStoreContact* aStoreContact,

          MPbk2SelectFieldProperty* aSelectFieldProperty,

          TInt aSelectFieldResult, TInt& aFieldIndex, TUint& aNoteFlags,

          TUint aRelocationFlags ) :

            CActive( EPriorityIdle ),

            iObserver( aObserver ),

            iStoreContact( aStoreContact ),

            iSelectFieldResult( aSelectFieldResult ),

            iSelectFieldProperty( aSelectFieldProperty ),

            iFieldIndex( aFieldIndex ),

            iNoteFlags( aNoteFlags ),

            iRelocationFlags( aRelocationFlags )

    {

    CActiveScheduler::Add( this );

    }

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

// CPbk2PrepareSingleAssignPhase::~CPbk2PrepareSingleAssignPhase

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

//

CPbk2PrepareSingleAssignPhase::~CPbk2PrepareSingleAssignPhase()

    {

    Cancel();

    delete iContactRelocator;

    delete iStoreContact;

    delete iResults;

    delete iDealer;

    if ( iDestroyedPtr )

        {

        *iDestroyedPtr = ETrue;

        }

    }

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

// CPbk2PrepareSingleAssignPhase::ConstructL

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

//

inline void CPbk2PrepareSingleAssignPhase::ConstructL()

    {

    iEikEnv = CEikonEnv::Static();

    iDealer = CPbk2KeyEventDealer::NewL( *this );

    }

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

// CPbk2PrepareSingleAssignPhase::NewL

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

//

CPbk2PrepareSingleAssignPhase* CPbk2PrepareSingleAssignPhase::NewL

        ( MPbk2ServicePhaseObserver& aObserver,

          MVPbkStoreContact* aStoreContact,

          MPbk2SelectFieldProperty* aSelectFieldProperty,

          TInt aSelectFieldResult, TInt& aFieldIndex, TUint& aNoteFlags,

          TUint aRelocationFlags  )

    {

    CPbk2PrepareSingleAssignPhase* self =

        new ( ELeave ) CPbk2PrepareSingleAssignPhase

            ( aObserver, aStoreContact, aSelectFieldProperty,

              aSelectFieldResult, aFieldIndex, aNoteFlags,

              aRelocationFlags );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2PrepareSingleAssignPhase::LaunchServicePhaseL

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

//

void CPbk2PrepareSingleAssignPhase::LaunchServicePhaseL()

    {

    IssueRequest();

    }

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

// CPbk2PrepareSingleAssignPhase::CancelServicePhase

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

//

void CPbk2PrepareSingleAssignPhase::CancelServicePhase()

    {

    delete iContactRelocator;

    iContactRelocator = NULL;

    iObserver.PhaseCanceled( *this );

    }

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

// CPbk2PrepareSingleAssignPhase::RequestCancelL

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

//

void CPbk2PrepareSingleAssignPhase::RequestCancelL( TInt aExitCommandId )

    {

    delete iContactRelocator;

    iContactRelocator = NULL;

    // Withdraw our key event agent so that it does not react to

    // app shutter's escape key event simulation

    delete iDealer;

    iDealer = NULL;

   if ( aExitCommandId == EEikBidCancel )

        {

        iObserver.PhaseAborted( *this );

        }

    else

        {

        iObserver.PhaseCanceled( *this );

        }

    }

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

// CPbk2PrepareSingleAssignPhase::AcceptDelayed

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

//

void CPbk2PrepareSingleAssignPhase::AcceptDelayedL

        ( const TDesC8& /*aContactLinkBuffer*/ )

    {

    // Nothing to do

    }

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

// CPbk2PrepareSingleAssignPhase::Results

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

//

MVPbkContactLinkArray* CPbk2PrepareSingleAssignPhase::Results() const

    {

    return iResults;

    }

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

// CPbk2PrepareSingleAssignPhase::ExtraResultData

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

//

TInt CPbk2PrepareSingleAssignPhase::ExtraResultData() const

    {

    return KErrNotSupported;

    }

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

// CPbk2PrepareSingleAssignPhase::TakeStoreContact

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

//

MVPbkStoreContact* CPbk2PrepareSingleAssignPhase::TakeStoreContact()

    {

    MVPbkStoreContact* contact = iStoreContact;

    iStoreContact = NULL;

    return contact;

    }

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

// CPbk2PrepareSingleAssignPhase::FieldContent

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

//

HBufC* CPbk2PrepareSingleAssignPhase::FieldContent() const

    {

    return NULL;

    }

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

// CPbk2PrepareSingleAssignPhase::RunL

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

//

void CPbk2PrepareSingleAssignPhase::RunL()

    {

    PrepareForAssignL();

    }

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

// CPbk2PrepareSingleAssignPhase::RunError

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

//

TInt CPbk2PrepareSingleAssignPhase::RunError( TInt aError )

    {

    if ( aError != KErrDied )

        {

        // If this is destroyed it is not safe to use iObserver anymore

        iObserver.PhaseError( *this, aError );

        }

    return KErrNone;

    }

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

// CPbk2SelectCreateNewPropertyPhase::DoCancel

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

//

void CPbk2PrepareSingleAssignPhase::DoCancel()

    {

    // Nothing to do

    }

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

// CPbk2PrepareSingleAssignPhase::ContactRelocatedL

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

//

void CPbk2PrepareSingleAssignPhase::ContactRelocatedL

        ( MVPbkStoreContact* aRelocatedContact )

    {

    delete iStoreContact;

    iStoreContact = aRelocatedContact;

    AppendResultL( iStoreContact );

    }

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

// CPbk2PrepareSingleAssignPhase::ContactRelocationFailed

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

//

void CPbk2PrepareSingleAssignPhase::ContactRelocationFailed

        ( TInt aReason, MVPbkStoreContact* aContact )

    {

    delete aContact;

    if ( aReason != KErrCancel )

        {

        iObserver.PhaseError( *this, aReason );

        }

    }

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

// CPbk2PrepareSingleAssignPhase::ContactsRelocationFailed

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

//

void CPbk2PrepareSingleAssignPhase::ContactsRelocationFailed

        ( TInt /*aReason*/, CVPbkContactLinkArray* /*aContacts*/ )

    {

    // The code should never enter here

    __ASSERT_DEBUG( EFalse, Panic( ELogicRelocation ) );

    }

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

// CPbk2PrepareSingleAssignPhase::RelocationProcessComplete

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

//

void CPbk2PrepareSingleAssignPhase::RelocationProcessComplete()

    {

    // Next phase is select single property

    iObserver.PreviousPhase( *this );

    }

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

// CPbk2PrepareSingleAssignPhase::Pbk2ProcessKeyEventL

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

//

TBool CPbk2PrepareSingleAssignPhase::Pbk2ProcessKeyEventL

        ( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TBool ret = EFalse;

    if ( aType == EEventKey && aKeyEvent.iCode == EKeyEscape )

        {

        iObserver.PhaseOkToExit( *this, EEikBidCancel );

        ret = ETrue;

        }

    return ret;

    }

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

// CPbk2PrepareSingleAssignPhase::RelocateContactL

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

//

TBool CPbk2PrepareSingleAssignPhase::RelocateContactL

        ( Pbk2ContactRelocator::TPbk2ContactRelocationQueryPolicy aPolicy,

          TBool& aThisDestroyed )

    {

    delete iContactRelocator;

    iContactRelocator = NULL;

    iContactRelocator = CPbk2ContactRelocator::NewL();

    MVPbkStoreContact* contact = iStoreContact;

    iStoreContact = NULL;

    // Asynchronously relocate the contact

    TBool relocate = iContactRelocator->RelocateContactL

        ( contact, *this, aPolicy, iRelocationFlags );

    if ( !aThisDestroyed )

        {

        if ( !relocate )

            {

            // Cancel

            TPbk2AssignNoteService noteService;

            noteService.ShowInformationNoteL

                ( R_QTN_PHOB_NOTE_DETAIL_NOT_ADDED );

            }

        else

            {

            // User accepted relocation

            if ( !iContactRelocator->IsPhoneMemoryInConfigurationL() )

                {

                // Note is shown only if phone memory is not in configuration

                iNoteFlags = KPbk2NoteFlagOneContactRelocated;

                }

            }

        }

    return relocate;

    }

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

// CPbk2PrepareSingleAssignPhase::QueryForDataReplaceL

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

//

TInt CPbk2PrepareSingleAssignPhase::QueryForDataReplaceL()

    {

    TInt ret = KErrNone;

    TBool thisDestroyed = EFalse;

    iDestroyedPtr = &thisDestroyed;

    TPbk2DestructionIndicator indicator

        ( &thisDestroyed, iDestroyedPtr );

    CPbk2ServerAppAppUi& appUi = static_cast<CPbk2ServerAppAppUi&>

        ( *iEikEnv->EikAppUi() );

    // Query for data replace

    TPbk2AssignNoteService noteService;

    TInt queryResult = noteService.ShowReplaceDetailQueryL

        ( appUi.ApplicationServices().NameFormatter(), *iStoreContact );

    if ( !thisDestroyed && !queryResult )

        {

        // User didn't agree to replace data

        if ( IsContactFromPhoneMemoryL( *iStoreContact ) )

            {

            TPbk2AssignNoteService noteService;

            noteService.ShowInformationNoteL

                ( R_QTN_PHOB_NOTE_DETAIL_NOT_ADDED );

            ret = KErrCancel;

            }

        else

            {

            TPbk2ContactRelocationQueryPolicy relocationPolicy =

                EPbk2DisplayBasicQuery;

            if ( RelocateContactL( relocationPolicy, thisDestroyed ) )

                {

                ret = KErrNotReady;

                }

            else

                {

                ret = KErrCancel;

                }

            }

        }

    if ( thisDestroyed )

        {

        ret = KErrDied;

        }

    return ret;

    }

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

// CPbk2PrepareSingleAssignPhase::QueryForRelocationL

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

//

TInt CPbk2PrepareSingleAssignPhase::QueryForRelocationL()

    {

    TInt ret = KErrCancel;

    TBool thisDestroyed = EFalse;

    iDestroyedPtr = &thisDestroyed;

    TPbk2DestructionIndicator indicator

        ( &thisDestroyed, iDestroyedPtr );

    if ( iSelectFieldProperty->SelectedFieldType() )

        {

        CPbk2ServerAppAppUi& appUi = static_cast<CPbk2ServerAppAppUi&>

            ( *iEikEnv->EikAppUi() );

        TPbk2AssignNoteService noteService;

        noteService.ShowCanNotAddDetailNoteL

            ( appUi.ApplicationServices().NameFormatter(), *iStoreContact );

        }

    if ( IsContactFromPhoneMemoryL( *iStoreContact ) )

        {

        TPbk2AssignNoteService noteService;

        noteService.ShowInformationNoteL

            ( R_QTN_PHOB_NOTE_DETAIL_NOT_ADDED );

        }

    else

        {

        TPbk2ContactRelocationQueryPolicy relocationPolicy =

            EPbk2DisplayStoreDoesNotSupportQuery;

        if ( RelocateContactL( relocationPolicy, thisDestroyed ) )

            {

            ret = KErrNotReady;

            }

        }

    if ( thisDestroyed )

        {

        ret = KErrDied;

        }

    return ret;

    }

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

// CPbk2PrepareSingleAssignPhase::PrepareForAssignL

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

//

void CPbk2PrepareSingleAssignPhase::PrepareForAssignL()

    {

    CPbk2ServerAppAppUi& appUi = static_cast<CPbk2ServerAppAppUi&>

        ( *iEikEnv->EikAppUi() );

    switch( iSelectFieldResult )

        {

        case KErrNone:

            // leave iFieldIndex intact.

            {

            iObserver.NextPhase( *this );

            break;

            }

        case KErrNotFound:

            {

            iFieldIndex = KErrNotFound;

            iObserver.NextPhase( *this );

            break;

            }

        case KErrPathNotFound:

            {

            TInt fieldIndex = iSelectFieldProperty->SelectedFieldIndex();

            if ( fieldIndex > KErrNotFound )

                {

                iFieldIndex = fieldIndex;

                }

            iObserver.NextPhase( *this );

            break;

            }

        case KErrAlreadyExists:

            {

            TInt result = QueryForDataReplaceL();

            if ( result == KErrNone )

                {

                iFieldIndex = iSelectFieldProperty->SelectedFieldIndex();

                iObserver.NextPhase( *this );

                }

            else if ( result == KErrCancel )

                {

                iObserver.PhaseCanceled( *this );

                }

            else if ( result == KErrNotReady )

                {

                // Contact relocation took place, do not inform observer yet

                }

            else if ( result == KErrDied )

                {