/*

* 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 attribute address select phase.

*

*/

#include "CPbk2AttributeAddressSelectPhase.h"

// Phonebook 2

#include "MPbk2ServicePhaseObserver.h"

#include "CPbk2ServerAppAppUi.h"

#include "CPbk2KeyEventDealer.h"

#include <MPbk2DialogEliminator.h>

#include <CPbk2AddressSelect.h>

#include <TPbk2AddressSelectParams.h>

#include <MPbk2ApplicationServices.h>

#include <Pbk2UIControls.rsg>

#include <CPbk2StoreManager.h>

// Virtual Phonebook

#include <MVPbkContactLink.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactManager.h>

#include <CVPbkSpeedDialAttribute.h>

#include <VPbkFieldTypeSelectorFactory.h>

#include <CVPbkFieldTypeSelector.h>

#include <VPbkFieldTypeSelectors.rsg>

#include <VPbkContactViewFilterBuilder.h>

// System includes

#include <barsread.h>

#include <avkon.rsg>

#include <featmgr.h>

/// Unnamed namespace for local definitions

namespace {

const TInt KFirstElement = 0;

/**

 * Copies a link array to another.

 *

 * @param aSourceLinkArray    Link array which is copied

 * @param aTargetLinkArray    Links are copied to this

 */

void CopyContactLinksL( const MVPbkContactLinkArray& aSourceLinkArray,

        CVPbkContactLinkArray& aTargetLinkArray )

    {

    const TInt count = aSourceLinkArray.Count();

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

        {

        const MVPbkContactLink& contactLink = aSourceLinkArray.At(i);

        aTargetLinkArray.AppendL( contactLink.CloneLC() );

        CleanupStack::Pop(); // link

        }

    }

} /// namespace

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

// CPbk2AttributeAddressSelectPhase::CPbk2AttributeAddressSelectPhase

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

//

CPbk2AttributeAddressSelectPhase::CPbk2AttributeAddressSelectPhase

        ( MPbk2ServicePhaseObserver& aObserver,

          TPbk2AttributeAssignData aAttributeData,

          TBool aRskBack ) :

            iObserver( aObserver ),

            iAttributeData( aAttributeData ),

            iRskBack( aRskBack )

    {

    }

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

// CPbk2AttributeAddressSelectPhase::~CPbk2AttributeAddressSelectPhase

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

//

CPbk2AttributeAddressSelectPhase::~CPbk2AttributeAddressSelectPhase()

    {

    if ( iAddressSelectEliminator )

        {

        iAddressSelectEliminator->ForceExit();

        }

    delete iStoreContact;

    delete iRetrieveOperation;

    delete iContactLinks;

    delete iResults;

    delete iDealer;

    FeatureManager::UnInitializeLib();

    }

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

// CPbk2AttributeAddressSelectPhase::ConstructL

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

//

inline void CPbk2AttributeAddressSelectPhase::ConstructL

        ( MVPbkContactLinkArray* aContactLinks )

    {

    iEikEnv = CEikonEnv::Static();

    iContactLinks = CVPbkContactLinkArray::NewL();

    if ( aContactLinks )

        {

        CopyContactLinksL( *aContactLinks, *iContactLinks );

        }

    FeatureManager::InitializeLibL();

    }

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

// CPbk2AttributeAddressSelectPhase::NewL

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

//

CPbk2AttributeAddressSelectPhase* CPbk2AttributeAddressSelectPhase::NewL

        ( MPbk2ServicePhaseObserver& aObserver,

          MVPbkContactLinkArray* aContactLinks,

          TPbk2AttributeAssignData aAttributeData,

          TBool aRskBack )

    {

    CPbk2AttributeAddressSelectPhase* self =

        new ( ELeave ) CPbk2AttributeAddressSelectPhase

            ( aObserver, aAttributeData, aRskBack );

    CleanupStack::PushL( self );

    self->ConstructL( aContactLinks );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2AttributeAddressSelectPhase::LaunchServicePhaseL

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

//

void CPbk2AttributeAddressSelectPhase::LaunchServicePhaseL()

    {

    RetrieveContactL();

    }

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

// CPbk2AttributeAddressSelectPhase::CancelServicePhase

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

//

void CPbk2AttributeAddressSelectPhase::CancelServicePhase()

    {

    if ( iAddressSelectEliminator )

        {

        iAddressSelectEliminator->ForceExit();

        }

    iObserver.PhaseCanceled( *this );

    }

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

// CPbk2AttributeAddressSelectPhase::RequestCancelL

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

//

void CPbk2AttributeAddressSelectPhase::RequestCancelL( TInt aExitCommandId )

    {

    if ( iAddressSelectEliminator )

        {

        iAddressSelectEliminator->RequestExitL( aExitCommandId );

        }

    // 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 );

        }

    }

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

// CPbk2AttributeAddressSelectPhase::AcceptDelayed

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

//

void CPbk2AttributeAddressSelectPhase::AcceptDelayedL

        ( const TDesC8& /*aContactLinkBuffer*/ )

    {

    // Nothing to accept

    }

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

// CPbk2AttributeAddressSelectPhase::DenyDelayed

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

//

void CPbk2AttributeAddressSelectPhase::DenyDelayedL

        ( const TDesC8& /*aContactLinkBuffer*/ )

    {

    // Nothing to deny

    }

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

// CPbk2AttributeAddressSelectPhase::Results

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

//

MVPbkContactLinkArray* CPbk2AttributeAddressSelectPhase::Results() const

    {

    return iResults;

    }

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

// CPbk2AttributeAddressSelectPhase::ExtraResultData

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

//

TInt CPbk2AttributeAddressSelectPhase::ExtraResultData() const

    {

    return KErrNotSupported;

    }

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

// CPbk2AttributeAddressSelectPhase::TakeStoreContact

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

//

MVPbkStoreContact* CPbk2AttributeAddressSelectPhase::TakeStoreContact()

    {

    // Not supported

    return NULL;

    }

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

// CPbk2AttributeAddressSelectPhase::FieldContent

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

//

HBufC* CPbk2AttributeAddressSelectPhase::FieldContent() const

    {

    return NULL;

    }

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

// CPbk2AttributeAddressSelectPhase::VPbkSingleContactOperationComplete

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

//

void CPbk2AttributeAddressSelectPhase::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& /*aOperation*/,

          MVPbkStoreContact* aContact )

    {

    CPbk2ServerAppAppUi& appUi = static_cast<CPbk2ServerAppAppUi&>

        ( *iEikEnv->EikAppUi() );

    TInt err( KErrNone );

    // Contact retrieval complete

    delete iStoreContact;

    iStoreContact = aContact;

    TRAP( err, SelectAddressesL() );       

    if ( err != KErrNone )

        {

		// Deregister store events if something went wrong. 

        appUi.StoreManager().DeregisterStoreEvents( *this );

        iObserver.PhaseError( *this, err );

        }

    }

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

// CPbk2AttributeAddressSelectPhase::VPbkSingleContactOperationFailed

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

//

void CPbk2AttributeAddressSelectPhase::VPbkSingleContactOperationFailed

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

    {

    iObserver.PhaseError( *this, aError );

    }

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

// CPbk2AttributeAddressSelectPhase::Pbk2ProcessKeyEventL

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

//

TBool CPbk2AttributeAddressSelectPhase::Pbk2ProcessKeyEventL

        ( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TBool ret = EFalse;

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

        {

        iObserver.PhaseOkToExit( *this, EEikBidCancel );

        ret = ETrue;

        }

    return ret;

    }

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

// CPbk2AttributeAddressSelectPhase::StoreReady

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

//

void CPbk2AttributeAddressSelectPhase::StoreReady(

    MVPbkContactStore& /*aContactStore*/ )

    {

    // not interested

    }

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

// CPbk2AttributeAddressSelectPhase::StoreUnavailable

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

//

void CPbk2AttributeAddressSelectPhase::StoreUnavailable(

    MVPbkContactStore& /*aContactStore*/,

    TInt /*aReason*/ )

    {

    // not interested

    }

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

// CPbk2AttributeAddressSelectPhase::StoreUnavailable

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

//    

void CPbk2AttributeAddressSelectPhase::HandleStoreEventL(

     MVPbkContactStore& /*aContactStore*/,

     TVPbkContactStoreEvent aEvent )

    {

    if ( aEvent.iContactLink != NULL && iStoreContact != NULL )

        {

        if ( aEvent.iContactLink->RefersTo( *iStoreContact ) )

            {

            RDebug::Print(_L("----CPbk2AttributeAddressSelectPhase::HandleStoreEventL() - dismiss dialog"));

            // dismiss address selection dialog since contact was changed

            if ( iAddressSelectEliminator )

                {

                iAddressSelectEliminator->ForceExit();

                }

            // observer will be notified in SelectAddressesL() after closing 

            // address selection dialog

            }

        }

    }

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

// CPbk2AttributeAddressSelectPhase::RetrieveContactL

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

//

void CPbk2AttributeAddressSelectPhase::RetrieveContactL()

    {

    CPbk2ServerAppAppUi& appUi =

        static_cast<CPbk2ServerAppAppUi&>

            ( *iEikEnv->EikAppUi() );

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    iRetrieveOperation = appUi.ApplicationServices().ContactManager().

        RetrieveContactL( iContactLinks->At( KFirstElement ), *this );

    }

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

// CPbk2AttributeAddressSelectPhase::SelectAddressesL

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

//

void CPbk2AttributeAddressSelectPhase::SelectAddressesL()

    {

    MVPbkStoreContactField* field = CheckIfFieldAlreadySelectedL();

    if ( !field )

        {

        TInt resourceId = AddressSelectResourceId( iAttributeData );

        // Field was not already selected --> querying it

        TResourceReader reader;

        CCoeEnv::Static()->CreateResourceReaderLC( reader, resourceId );

        CPbk2ServerAppAppUi& appUi = static_cast<CPbk2ServerAppAppUi&>

            ( *iEikEnv->EikAppUi() );

        TPbk2AddressSelectParams params

            ( *iStoreContact, appUi.ApplicationServices().ContactManager(),

              appUi.ApplicationServices().NameFormatter(),

              appUi.ApplicationServices().FieldProperties(),

              reader, R_QTN_PHOB_TITLE_SELECT_DEFAULT );

        params.SetTitleToIncludeContactName( EFalse );

        CVPbkFieldTypeSelector* fieldTypeSelector = NULL;

        // In speed dial, for voip fields we build a fieldselector 

        // from vpbkfieldtypeselectorfactory. This makes sure the

        // right voip fields are shown in the address select dialog

        if ( iAttributeData.iAttributeUid ==

                 TUid::Uid( KVPbkSpeedDialAttributeImplementationUID ) )

            {

            // Speedial specific filter

            if( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )

                {

                fieldTypeSelector = VPbkFieldTypeSelectorFactory::

                    BuildContactActionTypeSelectorL(

                        VPbkFieldTypeSelectorFactory::EVOIPCallSelector,

                        appUi.ApplicationServices().ContactManager().FieldTypes() );

                CleanupStack::PushL( fieldTypeSelector );

                }

            else

                {

                fieldTypeSelector = CVPbkFieldTypeSelector::NewL( 

                        appUi.ApplicationServices().ContactManager().FieldTypes() );

                CleanupStack::PushL( fieldTypeSelector );

                }

            VPbkContactViewFilterBuilder::BuildContactViewFilterL( 

                                      *fieldTypeSelector, 

                                      EVPbkContactViewFilterPhoneNumber, 

                                      appUi.ApplicationServices().ContactManager() );

            }

        // Run address select

        CPbk2AddressSelect* addressSelect = CPbk2AddressSelect::NewL(

                params,

                *fieldTypeSelector,

                NULL,

                NULL );

        // Correct CBA buttons

        TInt correctedCba = CorrectRSK( resourceId );

        if ( correctedCba > KErrNone )

            {

            addressSelect->SetCba( correctedCba );

            }

        // Execute

        iAddressSelectEliminator = addressSelect;

        iAddressSelectEliminator->ResetWhenDestroyed

            ( &iAddressSelectEliminator );

        appUi.StoreManager().RegisterStoreEventsL( *this );

        field = addressSelect->ExecuteLD();

        appUi.StoreManager().DeregisterStoreEvents( *this );

        if ( fieldTypeSelector )

			{

			CleanupStack::PopAndDestroy( 2 ); // fieldTypeSelector, reader

			}

		else

			{

			CleanupStack::PopAndDestroy(); // reader

			}

        }

    if ( field )

        {

        CleanupDeletePushL( field );

        AppendResultL( field );

        CleanupStack::PopAndDestroy( field );

        iObserver.NextPhase( *this );

        }

    else

        {

        iObserver.PhaseCanceled( *this );

        }

    }

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

// CPbk2AttributeAddressSelectPhase::CheckIfFieldAlreadySelectedL

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

//

inline MVPbkStoreContactField*

        CPbk2AttributeAddressSelectPhase::CheckIfFieldAlreadySelectedL()

    {

    MVPbkStoreContactField* ret = NULL;

    const MVPbkContactLink& contactLink = iContactLinks->At( KFirstElement );

    MVPbkStoreContactFieldCollection& fields = iStoreContact->Fields();

    MVPbkStoreContactField* field = fields.RetrieveField( contactLink );

    if ( field )

        {

        ret = field->CloneLC();

        CleanupStack::Pop(); // field->CloneLC()

        }

    return ret;

    }

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

// CPbk2AttributeAddressSelectPhase::AddressSelectResourceId

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

//

inline TInt CPbk2AttributeAddressSelectPhase::AddressSelectResourceId

        ( TPbk2AttributeAssignData aAttributeData )

    {

    TInt result = KErrNotFound;

    if ( aAttributeData.iAttributeUid ==

         TUid::Uid( KVPbkSpeedDialAttributeImplementationUID ) )

        {

        result = R_PBK2_PHONE_NUMBER_SELECT;

        }

    return result;

    }

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

// CPbk2AttributeAddressSelectPhase::CorrectRSK

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

//

inline TInt CPbk2AttributeAddressSelectPhase::CorrectRSK

        ( TInt aAddressSelectResourceId )

    {

    TInt result = KErrNone;

    if ( iRskBack )

        {

        switch ( aAddressSelectResourceId )

            {

            case R_PBK2_PHONE_NUMBER_SELECT:

                {

                result = R_AVKON_SOFTKEYS_SELECT_BACK__SELECT;

                break;

                }

            default:

                {

                // Do nothing

                break;

                }

            }

        }