/*

* 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 address selection.

*

*/

#include <CPbk2AddressSelect.h>

// Phonebook 2

#include "CPbk2SelectFieldDlg.h"

#include "MPbk2ControlKeyObserver.h"

#include <MPbk2ContactNameFormatter.h>

#include <CPbk2FieldPropertyArray.h>

#include <TPbk2AddressSelectParams.h>

#include <MPbk2ApplicationServices.h>

#include <MPbk2ApplicationServices2.h>

#include <CPbk2ServiceManager.h>

#include <MPbk2AppUi.h>

#include <Pbk2UIControls.rsg>

#include <Pbk2Commands.rsg>

#include <CPbk2ApplicationServices.h>

#include <TPbk2StoreContactAnalyzer.h>

// Virtual Phonebook

#include <CVPbkFieldFilter.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkStoreContact.h>

#include <CVPbkFieldTypeSelector.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <CVPbkContactManager.h>

#include <CVPbkDefaultAttribute.h>

#include <MVPbkFieldType.h>

#include <TVPbkFieldVersitProperty.h>

// System includes

#include <avkon.hrh>

#include <aknnotewrappers.h>

#include <StringLoader.h>

//SpSettings

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <spsettingsvoiputils.h>

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPostCond_Constructor = 1,

    EPanicPreCond_ExecuteLD

    };

static void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2AddressSelect");

    User::Panic(KPanicText, aReason);

    }

#endif // _DEBUG

#define KOneVOIPServiceAvailable    1

const TInt KFirstField = 0;

const TInt KDefaultTitleFormat = MPbk2ContactNameFormatter::EUseSeparator;

/**

 * Returns index of given field in store contact field collection.

 *

 * @param aCollection   Store contact field collection.

 * @param aField        Store contact field to search for.

 * @return  Index of the given field.

 */

inline TInt IndexOfField(

        const MVPbkStoreContactFieldCollection& aCollection,

        const MVPbkStoreContactField& aField )

    {

    TInt ret = KErrNotFound;

    const TInt count = aCollection.FieldCount();

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

        {

        MVPbkStoreContactField* field = aCollection.FieldAtLC( i );

        if ( aField.IsSame( *field ) )

            {

            ret = i;

            CleanupStack::PopAndDestroy(); // field

            break;

            }

        CleanupStack::PopAndDestroy(); // field

        }

    return ret;

    }

} /// namespace

// MODULE DATA STRUCTURES

/**

 * Special field selection dialog class for CPbk2AddressSelect.

 * The main purpose of this class is to

 * get #include of MPbk2ControlKeyObserver

 * away from public header CPbk2AddressSelect.h.

 */

NONSHARABLE_CLASS(CPbk2AddressSelect::CSelectFieldDlg) :

        public CPbk2SelectFieldDlg,

        private MPbk2ControlKeyObserver

    {

    public:  // Construction

        /**

         * Constructor.

         *

         * @param aParent   Parent.

         */

        CSelectFieldDlg( CPbk2AddressSelect& aParent ) :

                iParent( aParent )

            {

            SetObserver( this );

            }

    private: // From MPbk2ControlKeyObserver

        TKeyResponse Pbk2ControlKeyEventL

            ( const TKeyEvent& aKeyEvent, TEventCode aType );

    private: // Data

        /// Ref: Parent

        CPbk2AddressSelect& iParent;

    };

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

// CPbk2AddressSelect::CSelectFieldDlg::Pbk2ControlKeyEventL

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

//

TKeyResponse CPbk2AddressSelect::CSelectFieldDlg::Pbk2ControlKeyEventL

        ( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    // Forward call to virtual function in CPbk2AddressSelect interface

    return iParent.Pbk2ControlKeyEventL( aKeyEvent,aType );

    }

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

// CPbk2AddressSelect::CPbk2AddressSelect

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

//

CPbk2AddressSelect::CPbk2AddressSelect( 

    TPbk2AddressSelectParams& aParams,

    const TArray<MVPbkStoreContact*>* aStoreContactsArray,

    const TArray<CPbk2PresenceIconInfo*>* aPresenceIconsArray ):

    iParams( aParams ),

    iStoreContactsArray( aStoreContactsArray ),

    iPresenceIconsArray( aPresenceIconsArray )

    {

    __ASSERT_DEBUG

        ( !iFieldDlg && !iDestroyedPtr,

          Panic( EPanicPostCond_Constructor ) );

    }

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

// CPbk2AddressSelect::~CPbk2AddressSelect

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

//

EXPORT_C CPbk2AddressSelect::~CPbk2AddressSelect()

    {

    // Tell ExecuteLD this object is already destroyed

    if (iDestroyedPtr)

        {

        *iDestroyedPtr = ETrue;

        }

    // Set eliminator pointer to NULL

    if ( iSelfPtr )

        {

        *iSelfPtr = NULL;

        }

    delete iFieldDlg;

    delete iFieldFilter;

    delete iFieldTypeSelector;

    iFieldFilterArray.ResetAndDestroy();

    }

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

// CPbk2AddressSelect::NewL

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

//

EXPORT_C CPbk2AddressSelect* CPbk2AddressSelect::NewL

        ( TPbk2AddressSelectParams& aParams )

    {

    CPbk2AddressSelect* self = new ( ELeave ) CPbk2AddressSelect(

        aParams, NULL, NULL );

    CleanupStack::PushL( self );

    self->ConstructL( NULL );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2AddressSelect::NewL

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

//

EXPORT_C CPbk2AddressSelect* CPbk2AddressSelect::NewL

        ( TPbk2AddressSelectParams& aParams,

          CVPbkFieldTypeSelector& aFieldTypeSelector,

          const TArray<MVPbkStoreContact*>* aStoreContactsArray,

          const TArray<CPbk2PresenceIconInfo*>* aPresenceIconsArray )

    {

    CPbk2AddressSelect* self = new ( ELeave ) CPbk2AddressSelect( aParams,

        aStoreContactsArray, aPresenceIconsArray );

    CleanupStack::PushL( self );

    self->ConstructL( &aFieldTypeSelector );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2AddressSelect::ConstructL

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

//

void CPbk2AddressSelect::ConstructL(

    CVPbkFieldTypeSelector* aFieldTypeSelector )

    {

    // Read the resource referenced in address select resource struct

    const TInt fieldTypeSelectorRes = iParams.iResReader.ReadInt32();

    TResourceReader selectorReader;

    CCoeEnv::Static()->CreateResourceReaderLC

        ( selectorReader, fieldTypeSelectorRes );

    if ( aFieldTypeSelector == NULL )

        {

        // Give that resource reader to the field type selector

        iFieldTypeSelector = CVPbkFieldTypeSelector::NewL

            ( selectorReader, iParams.iContactManager.FieldTypes() );

        }

    else

        {

        iFieldTypeSelector = CVPbkFieldTypeSelector::NewL(

            *aFieldTypeSelector );

        }

    CleanupStack::PopAndDestroy(); // selectorReader

    iNoAddressesForNamePromptResource = iParams.iResReader.ReadInt32();

    iNoAddressesPromptResource = iParams.iResReader.ReadInt32();

    iSoftKeyResource = iParams.iResReader.ReadInt32();

    const CVPbkFieldFilter::TConfig config

        ( const_cast<MVPbkStoreContactFieldCollection&>

            ( iParams.iContact.Fields() ),

                iFieldTypeSelector, NULL );

    iFieldFilter = CVPbkFieldFilter::NewL( config );

    if ( iStoreContactsArray != NULL && iStoreContactsArray->Count() != 0 )

        {

        TInt count = iStoreContactsArray->Count();

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

            {

            const CVPbkFieldFilter::TConfig conf

                ( const_cast<MVPbkStoreContactFieldCollection&>

                    ( iStoreContactsArray->operator[](i)->Fields() ),

                      iFieldTypeSelector, NULL );

            CVPbkFieldFilter* fieldFilter = CVPbkFieldFilter::NewL( conf );

            CleanupStack::PushL( fieldFilter );

            iFieldFilterArray.AppendL( fieldFilter );

            CleanupStack::Pop(); //fieldfilter

            }

        }

    CPbk2ApplicationServices* appServices =

        CPbk2ApplicationServices::InstanceLC();

    iAttributeManager =

        &appServices->ContactManager().ContactAttributeManagerL();

    CleanupStack::PopAndDestroy(); // appServices

    }

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

// CPbk2AddressSelect::ExecuteLD

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

//

EXPORT_C MVPbkStoreContactField* CPbk2AddressSelect::ExecuteLD()

    {

    __ASSERT_DEBUG( !iFieldDlg, Panic( EPanicPreCond_ExecuteLD ) );

    // "D" function semantics

    CleanupStack::PushL( this );

    TBool thisDestroyed = EFalse;

    // Ensure that thisDestroyed will be ETrue if this object is destroyed.

    // See in destructor how this is done.

    iDestroyedPtr = &thisDestroyed;

    SelectFieldL();

    MVPbkStoreContactField* returnedField = NULL;

    if ( iSelectedField )

        {

        // We cannot return iSelectedField directly since if its NULL,

        // it's value changes to 0xdedede before it is returned.

        // Therefore we must test iSelectedField before assigning it

        // to returnedField.

        returnedField = iSelectedField;

        }

    if ( thisDestroyed )

        {

        // This object has already been destroyed

        CleanupStack::Pop( this );

        returnedField = NULL;

        }

    else

        {

        CleanupStack::PopAndDestroy( this );

        }

    return returnedField;

    }

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

// CPbk2AddressSelect::AttemptExitL

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

//

EXPORT_C void CPbk2AddressSelect::AttemptExitL( TBool aAccept )

    {

    if ( iFieldDlg )

        {

        iFieldDlg->AttemptExitL( aAccept );

        }

    }

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

// CPbk2AddressSelect::Pbk2ControlKeyEventL

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

//

EXPORT_C TKeyResponse CPbk2AddressSelect::Pbk2ControlKeyEventL

        ( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TKeyResponse ret = EKeyWasNotConsumed;

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

        {

        // Event is Send key, tell field selection dialog to accept

        // current selection

        AttemptExitL( ETrue );

        ret = EKeyWasConsumed;

        }

    return ret;

    }

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

// CPbk2AddressSelect::SetCba

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

//

EXPORT_C void CPbk2AddressSelect::SetCba( TInt aCbaResourceId )

    {

    iSoftKeyResource = aCbaResourceId;

    }

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

// CPbk2AddressSelect::RequestExitL

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

//

void CPbk2AddressSelect::RequestExitL( TInt aCommandId )

    {

    if ( aCommandId == EEikBidCancel )

        {

        AttemptExitL( EFalse );

        }

    else if ( aCommandId == EEikBidOk )

        {

        AttemptExitL( ETrue );

        }

    }

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

// CPbk2AddressSelect::ForceExit

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

//

void CPbk2AddressSelect::ForceExit()

    {

    TRAPD( err, AttemptExitL( EFalse ) );

    if ( err != KErrNone )

        {

        // If not nicely then use the force

        delete this;

        }

    }

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

// CPbk2AddressSelect::ResetWhenDestroyed

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

//

void CPbk2AddressSelect::ResetWhenDestroyed(

        MPbk2DialogEliminator** aSelfPtr )

    {

    iSelfPtr = aSelfPtr;

    }

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

// CPbk2AddressSelect::AddressField

// Returns true if aField is an applicable address field.

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

//

TBool CPbk2AddressSelect::AddressField

        ( const MVPbkStoreContactField& aField ) const

    {

    TBool ret = EFalse;

    // Return true if field belongs to the selector

    ret = ( iFieldFilter->FindField( aField ) ==

        KErrNotFound ) ? EFalse : ETrue;

    return ret;

    }

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

// CPbk2AddressSelect::NoAddressesL

// Called if there are no applicable address fields in a contact passed

// to ExecuteLD.

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

//

void CPbk2AddressSelect::NoAddressesL

        ( TPbk2AddressSelectParams aParams ) const

    {

    if ( !aParams.iSuppressWarnings )

        {

        HBufC* prompt = NULL;

        HBufC* name = aParams.iNameFormatter.GetContactTitleOrNullL

            ( iParams.iContact.Fields(), KDefaultTitleFormat );

        if ( name )

            {

            CleanupStack::PushL(name);

            prompt = StringLoader::LoadL

                ( iNoAddressesForNamePromptResource, *name );

            CleanupStack::PopAndDestroy(); // name

            }

        else

            {

            prompt = StringLoader::LoadL( iNoAddressesPromptResource );

            }

        if ( prompt )

            {

            CleanupStack::PushL( prompt );

            // This is a waiting dialog because the address select might be

            // used from the application server and the information note will

            // disappear if the application server closes before the

            // note timeout has expired, thus causing blinking

            CAknInformationNote* noteDlg =

                new ( ELeave ) CAknInformationNote( ETrue );

            noteDlg->ExecuteLD( *prompt );

            CleanupStack::PopAndDestroy(); // prompt

            }

        }

    }

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

// CPbk2AddressSelect::SelectFieldL

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

//

inline void CPbk2AddressSelect::SelectFieldL()

    {

    // If currently focused field is an applicable field

    if ( iParams.iFocusedField && AddressField( *iParams.iFocusedField ) )

        {

        // Applicable field was focused -> return field

        SetSelectedFieldL( iParams.iFocusedField );

        }

    else

        {

        TBool found = EFalse;

        // Focus is in on some other field, first check default field

        if ( iParams.iDefaultPriorities &&

             iParams.iUseDefaultDirectly &&

             iParams.iDefaultPriorities->Count() > 0 )

            {

            found = SelectFromDefaultFieldsL();

            }

        if ( !found )

            {

            // No direct call to focused or default number, we have to

            // select from applicable fields

            SelectFromApplicableFieldsL();

            }

        }

    }

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

// CPbk2AddressSelect::SelectFromApplicableFieldsL

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

//

inline void CPbk2AddressSelect::SelectFromApplicableFieldsL()

    {

    TInt indexOfDefault = IndexOfDefaultFieldL();

    TInt fieldCount = iFieldFilter->FieldCount();

    // check also addiotnal contacts

    if ( iFieldFilterArray.Count() > 0 )

        {

        TInt count = iFieldFilterArray.Count();

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

            {

            fieldCount += iFieldFilterArray[i]->FieldCount();

            }

        }

    // Different actions for different number of applicable fields found

    if ( fieldCount == 0 )

        {

        // No applicable addresses found

        NoAddressesL( iParams );

        }