/*

* 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 contact fetch phase.

*

*/

#include "CPbk2ContactFetchPhase.h"

// Phonebook 2

#include "MPbk2ServicePhaseObserver.h"

#include "CPbk2ServerAppAppUi.h"

#include "CPbk2ServerAppStoreManager.h"

#include <CPbk2FetchDlg.h>

#include <MPbk2ApplicationServices.h>

#include <CPbk2ContactViewBuilder.h>

// Virtual Phonebook

#include <MVPbkContactLink.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactViewBase.h>

#include <CVPbkContactManager.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkFieldType.h>

#include <CVPbkFieldTypeSelector.h>

#include <MVPbkStoreContact.h>

#include <MVPbkStoreContactFieldCollection.h>

/// Unnamed namespace for local definitions

namespace {

const TInt KFirstElement = 0;

} /// namespace

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

// CPbk2ContactFetchPhase::CPbk2ContactFetchPhase

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

//

CPbk2ContactFetchPhase::CPbk2ContactFetchPhase

        ( MPbk2ServicePhaseObserver& aObserver,

          CPbk2ServerAppStoreManager& aStoreManager,

          CPbk2FetchDlg::TParams aFetchParams,

          TBool aFetchOkToExit,

          MPbk2FetchDlgObserver::TPbk2FetchAcceptSelection

            aFetchAcceptPolicy,

          CVPbkFieldTypeSelector* aViewFilter,

          TBool aUsingDefaultConfig,

          const CVPbkContactStoreUriArray* aStoreUris ) :

                iObserver( aObserver ),

                iServerAppStoreManager( aStoreManager ),

                iFetchParams( aFetchParams ),

                iFetchOkToExit( aFetchOkToExit ),

                iFetchAcceptPolicy( aFetchAcceptPolicy ),

                iViewFilter( aViewFilter ),

                iUsingDefaultConfig( aUsingDefaultConfig ),

                iStoreUris( aStoreUris )

    {

    }

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

// CPbk2ContactFetchPhase::~CPbk2ContactFetchPhase

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

//

CPbk2ContactFetchPhase::~CPbk2ContactFetchPhase()

    {

    if ( iFetchDialogEliminator )

        {

        iFetchDialogEliminator->ForceExit();

        }

    delete iFetchNamesListView;

    delete iFetchGroupsListView;

    delete iFetchResults;

    delete iContactLinks;

    delete iRetrieveOperation;

    }

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

// CPbk2ContactFetchPhase::NewL

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

//

CPbk2ContactFetchPhase* CPbk2ContactFetchPhase::NewL

        ( MPbk2ServicePhaseObserver& aObserver,

          CPbk2ServerAppStoreManager& aStoreManager,

          CPbk2FetchDlg::TParams aFetchParams,

          TBool aFetchOkToExit,

          MPbk2FetchDlgObserver::TPbk2FetchAcceptSelection

            aFetchAcceptPolicy,

          CVPbkFieldTypeSelector* aViewFilter,

          TBool aUsingDefaultConfig,

          const CVPbkContactStoreUriArray* aStoreUris )

    {

    CPbk2ContactFetchPhase* self =

        new ( ELeave ) CPbk2ContactFetchPhase

            ( aObserver, aStoreManager, aFetchParams, aFetchOkToExit,

              aFetchAcceptPolicy, aViewFilter, aUsingDefaultConfig,

              aStoreUris );

    return self;

    }

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

// CPbk2ContactFetchPhase::LaunchServicePhaseL

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

//

void CPbk2ContactFetchPhase::LaunchServicePhaseL()

    {

    CPbk2ServerAppAppUi* appUi = static_cast<CPbk2ServerAppAppUi*>

            ( CEikonEnv::Static()->EikAppUi() );

    TUint32 flags = EVPbkContactViewFlagsNone;

    // Because the filter needs to have the contact store open,

    // we can't build the view earlier

    delete iFetchNamesListView;

    iFetchNamesListView = NULL;

    iFetchNamesListView = iServerAppStoreManager.BuildFetchViewL

        ( EVPbkContactsView, *iStoreUris, iViewFilter,

          appUi->ApplicationServices().StoreProperties(),

          appUi->ApplicationServices().SortOrderManager(),

          flags );

    flags = EVPbkExcludeEmptyGroups;

    delete iFetchGroupsListView;

    iFetchGroupsListView = NULL;

    iFetchGroupsListView = iServerAppStoreManager.BuildFetchViewL

        ( EVPbkGroupsView, *iStoreUris, iViewFilter,

          appUi->ApplicationServices().StoreProperties(),

          appUi->ApplicationServices().SortOrderManager(),

          flags );

    // Launch the fetch dialog

    iFetchParams.iExitCallback = this;

    iFetchParams.iNamesListView = iFetchNamesListView;

    iFetchParams.iGroupsListView = iFetchGroupsListView;

    iFetchDlg = CPbk2FetchDlg::NewL( iFetchParams, *this );

    iFetchDialogEliminator = iFetchDlg;

    iFetchDialogEliminator->ResetWhenDestroyed( &iFetchDialogEliminator );

    iFetchDlg->ExecuteLD();

    }

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

// CPbk2ContactFetchPhase::CancelServicePhase

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

//

void CPbk2ContactFetchPhase::CancelServicePhase()

    {

    if ( iFetchDialogEliminator )

        {

        iFetchDialogEliminator->ForceExit();

        }

    }

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

// CPbk2ContactFetchPhase::RequestCancelL

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

//

void CPbk2ContactFetchPhase::RequestCancelL( TInt aExitCommandId )

    {

    if ( iFetchDialogEliminator )

        {

        iFetchDialogEliminator->RequestExitL( aExitCommandId );

        }

    }

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

// CPbk2ContactFetchPhase::AcceptDelayed

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

//

void CPbk2ContactFetchPhase::AcceptDelayedL

        ( const TDesC8& aContactLinkBuffer )

    {

    if ( iFetchDlg )

        {

        iFetchDlg->AcceptDelayedFetchL( aContactLinkBuffer );

        }

    }

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

// CPbk2ContactFetchPhase::Results

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

//

MVPbkContactLinkArray* CPbk2ContactFetchPhase::Results() const

    {

    return iFetchResults;

    }

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

// CPbk2ContactFetchPhase::ExtraResultData

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

//

TInt CPbk2ContactFetchPhase::ExtraResultData() const

    {

    return KErrNotSupported;

    }

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

// CPbk2ContactFetchPhase::TakeStoreContact

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

//

MVPbkStoreContact* CPbk2ContactFetchPhase::TakeStoreContact()

    {

    // No store contact concept in fetch

    return NULL;

    }

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

// CPbk2ContactFetchPhase::FieldContent

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

//

HBufC* CPbk2ContactFetchPhase::FieldContent() const

    {

    return NULL;

    }

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

// CPbk2ContactFetchPhase::Pbk2AcceptFetchSelectionL

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

//

MPbk2FetchDlgObserver::TPbk2FetchAcceptSelection

    CPbk2ContactFetchPhase::AcceptFetchSelectionL

        ( TInt aNumMarkedEntries, MVPbkContactLink& aLastSelection )

    {

    MPbk2FetchDlgObserver::TPbk2FetchAcceptSelection result =

        iFetchAcceptPolicy;

    if ( result == MPbk2FetchDlgObserver::EFetchDelayed )

        {

        HBufC8* linkData = aLastSelection.PackLC();

        TPckg<TInt> buffer(aNumMarkedEntries);

        iObserver.PhaseAccept( *this, buffer, *linkData );

        CleanupStack::PopAndDestroy(); // linkData

        }

    return result;

    }

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

// CPbk2ContactFetchPhase::FetchCompletedL

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

//

void CPbk2ContactFetchPhase::FetchCompletedL

        ( MVPbkContactLinkArray* aMarkedEntries )

    {

    delete iFetchResults;

    iFetchResults = NULL;

    iFetchResults = CVPbkContactLinkArray::NewL();

    CVPbkContactLinkArray* linkArray = iFetchResults;

    // View filter can not guarentee that returned contacts match the filter.

    // If user selects a group all the contacts of the group are returned

    // by fetch and we must manually filter them here.

    if ( iViewFilter )

        {

        delete iContactLinks;

        iContactLinks = NULL;

        iContactLinks = CVPbkContactLinkArray::NewL();

        linkArray = iContactLinks;

        }

    const TInt count = aMarkedEntries->Count();

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

        {

        linkArray->AppendL( aMarkedEntries->At(i).CloneLC() );

        CleanupStack::Pop(); // aMarkedEntries->At(i).CloneLC()

        }

    if ( iViewFilter )

        {

        // Go through contacts one by one

        RetrieveContactL();

        }

    else

        {

        // Finished

        iObserver.NextPhase( *this );

        }

    }

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

// CPbk2ContactFetchPhase::FetchCanceled

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

//

void CPbk2ContactFetchPhase::FetchCanceled()

    {

    delete iFetchResults;

    iFetchResults = NULL;

    delete iRetrieveOperation;

    iRetrieveOperation = NULL;

    iObserver.PhaseCanceled( *this );

    }

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

// CPbk2ContactFetchPhase::FetchAborted

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

//

void CPbk2ContactFetchPhase::FetchAborted()

    {

    delete iFetchResults;

    iFetchResults = NULL;

    iObserver.PhaseAborted( *this );

    }

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

// CPbk2ContactFetchPhase::FetchOkToExit

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

//

TInt CPbk2ContactFetchPhase::FetchOkToExit()

    {

    return iFetchOkToExit;

    }

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

// CPbk2ContactFetchPhase::OkToExitL

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

//

TBool CPbk2ContactFetchPhase::OkToExitL( TInt aCommandId )

    {

    return iObserver.PhaseOkToExit( *this, aCommandId );

    }

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

// CPbk2ContactFetchPhase::VPbkSingleContactOperationComplete

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

//

void CPbk2ContactFetchPhase::VPbkSingleContactOperationComplete

        ( MVPbkContactOperationBase& /*aOperation*/,

          MVPbkStoreContact* aContact )

    {

    TRAPD( err, HandleContactOperationCompleteL( aContact ) );

    if ( err != KErrNone )

        {

        iObserver.PhaseError( *this, err );

        }

    }

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

// CPbk2ContactFetchPhase::VPbkSingleContactOperationFailed

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

//

void CPbk2ContactFetchPhase::VPbkSingleContactOperationFailed

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

    {

    iObserver.PhaseError( *this, aError );

    }

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

// CPbk2ContactFetchPhase::HandleContactOperationCompleteL

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

//

void CPbk2ContactFetchPhase::HandleContactOperationCompleteL

        ( MVPbkStoreContact* aContact )

    {

    // Verify current contact

    VerifyContactL( aContact );

    // Retrieve next contact

    RetrieveContactL();

    }

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

// CPbk2ContactFetchPhase::RetrieveContactL

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

//

void CPbk2ContactFetchPhase::RetrieveContactL()

    {

    CPbk2ServerAppAppUi* appUi = static_cast<CPbk2ServerAppAppUi*>

            ( CEikonEnv::Static()->EikAppUi() );

    // Fetch one contact at a time if service cancellation is not

    // commanded.

    if ( iContactLinks && iContactLinks->Count() > 0 )

        {

        delete iRetrieveOperation;

        iRetrieveOperation = NULL;

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

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

        iContactLinks->Delete( KFirstElement );

        }

    else

        {

        iObserver.NextPhase( *this );

        }

    }

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

// CPbk2ContactFetchPhase::VerifyContactL

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

//

void CPbk2ContactFetchPhase::VerifyContactL( MVPbkStoreContact* aContact )

    {

    CleanupDeletePushL( aContact );

    MVPbkStoreContactFieldCollection& fields = aContact->Fields();

    TInt fieldCount = fields.FieldCount();

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

        {

        const MVPbkStoreContactField& field = fields.FieldAt( i );

        const MVPbkFieldType* fieldType = field.BestMatchingFieldType();

        if ( fieldType && iViewFilter->IsFieldTypeIncluded( *fieldType ) )

            {

            MVPbkContactLink* link = aContact->CreateLinkLC();

            CleanupStack::Pop(); // link

            iFetchResults->AppendL( link );

            break;

            }

        }

    CleanupStack::PopAndDestroy(); // aContact

    }

// End of File