/*

* 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 Model store filtered contact view implementation.

*

*/

// INCLUDES

#include "CFindViewBase.h"

// VPbkCntModel

#include "CContactStore.h"

#include "CRefineView.h"

#include "CViewBase.h"

#include "CContactLink.h"

#include "CContactBookmark.h"

// VPbkEng

#include <CVPbkFieldTypeRefsList.h>

#include <CVPbkContactFieldIterator.h>

#include <VPbkError.h>

#include <CVPbkAsyncCallback.h>

#include <MVPbkContactNameConstructionPolicy.h>

#include <MVPbkContactFindPolicy.h>

#include <VPbkSendEventUtility.h>

// System includes

#include <cntviewbase.h>

namespace{

    #ifdef _DEBUG

        enum TPanic

            {

            EPreCond_SetFindStringsL = 1

            };

        void Panic(TPanic aPanic)

            {

            _LIT(KPanicCat, "CFindViewBase");

            User::Panic(KPanicCat, aPanic);

            }

    #endif // _DEBUG

} //namespace

namespace VPbkCntModel {

// CONSTANTS

const TInt KGranularity( 4 );

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

// CCompareView::CCompareView

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

//

CCompareView::CCompareView( const CContactDatabase& aDb ) :

        CContactViewBase( aDb )

    {

    }

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

// CCompareView::CompareFieldsL

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

//

TInt CCompareView::CompareFieldsL( const ::CViewContact &aFirst,

            const ::CViewContact &aSecond )

    {

    return CContactViewBase::CompareFieldsL( aFirst, aSecond );

    }

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

// CFindViewBase::CFindViewBase

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

//

CFindViewBase::CFindViewBase(

        MParentViewForFiltering& aParentView,

        CViewBase& aBaseView,

        TBool aOwnsContacts ) :

            iParentView( aParentView ),

            iBaseView( aBaseView ),

            iOwnsContacts( aOwnsContacts )

    {

    }

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

// CFindViewBase::BaseConstructL

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

//

void CFindViewBase::BaseConstructL( const MDesCArray& aFindStrings,

        MVPbkContactFindPolicy& aFindPolicy,

        MVPbkContactViewObserver& aExternalViewObserver )

    {

    iObserverOp =

        CVPbkAsyncObjectOperation<MVPbkContactViewObserver>::NewL();

    iFilterObsOp =

        CVPbkAsyncObjectOperation<MFilteredViewSupportObserver>::NewL();

    iFindStrings = new(ELeave)CDesCArrayFlat( KGranularity );

    SetFindStringsL( aFindStrings );

    // Set contact find policy

    iContactFindPolicy = &aFindPolicy;

    // Add the external observer

    iObservers.AppendL( &aExternalViewObserver );

    //Create field type list

    iFieldTypeRefsList = CVPbkFieldTypeRefsList::NewL();

    iViewContact = CViewContact::NewL( iBaseView, SortOrder() );

    }

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

// CFindViewBase::~CFindViewBase

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

//

CFindViewBase::~CFindViewBase()

    {

    delete iObserverOp;

    delete iFilterObsOp;

    ResetContacts();

    iMatchedContacts.Close();

    iParentView.RemoveFilteringObserver( *this );

    iObservers.Close();

    iFilteringObservers.Close();

    delete iViewContact;

    delete iFieldTypeRefsList;

    delete iFindStrings;

    }

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

// CFindViewBase::ActivateContactMatchL

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

//

void CFindViewBase::ActivateContactMatchL()

    {

    // Remove first if this called second time when updating.

    iParentView.RemoveFilteringObserver( *this );

    // This will cause an asynchrnous view event to this view from the

    // parent view.

    iParentView.AddFilteringObserverL( *this );

    }

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

// CFindViewBase::ParentObject

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

//

MVPbkObjectHierarchy& CFindViewBase::ParentObject() const

    {

    return iParentView.ParentObject();

    }

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

// CFindViewBase::RefreshL

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

//

void CFindViewBase::RefreshL()

    {

    iParentView.RefreshL();

    }

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

// CFindViewBase::ContactCountL

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

//

TInt CFindViewBase::ContactCountL() const

    {

    return iMatchedContacts.Count();

    }

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

// CFindViewBase::ContactAtL

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

//

const MVPbkViewContact& CFindViewBase::ContactAtL(

        TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if ( aIndex >= ContactCountL() )

        {

        User::Leave( KErrArgument );

        }

    const ::CViewContact& viewContact = *iMatchedContacts[ aIndex ];

    iViewContact->SetViewContact(viewContact);

    return *iViewContact;

    }

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

// CFindViewBase::CreateLinkLC

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

//

MVPbkContactLink* CFindViewBase::CreateLinkLC(

        TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if ( aIndex >= ContactCountL() )

        {

        User::Leave( KErrArgument );

        }

    TContactItemId contactId = iMatchedContacts[aIndex]->Id();

    return CContactLink::NewLC( iBaseView.Store(), contactId );

    }

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

// CFindViewBase::IndexOfLinkL

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

//

TInt CFindViewBase::IndexOfLinkL(

        const MVPbkContactLink& aContactLink ) const

    {

    if (&aContactLink.ContactStore() == &iParentView.ContactStore())

        {

        const CContactLink& link =

            static_cast<const CContactLink&>(aContactLink);

        const TInt count( iMatchedContacts.Count() );

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

            {

            if ( iMatchedContacts[ i ]->Id() == link.ContactId() )

                {

                return i;

                }

            }

        }

    return KErrNotFound;

    }

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

// CFindViewBase::Type

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

//

TVPbkContactViewType CFindViewBase::Type() const

    {

    return iParentView.Type();

    }

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

// CFindViewBase::ChangeSortOrderL

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

//

void CFindViewBase::ChangeSortOrderL(const MVPbkFieldTypeList& aSortOrder)

    {

    iParentView.ChangeSortOrderL( aSortOrder );

    }

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

// CFindViewBase::SortOrder

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

//

const MVPbkFieldTypeList& CFindViewBase::SortOrder() const

    {

    return iParentView.SortOrder();

    }

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

// CFindViewBase::AddObserverL

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

//

void CFindViewBase::AddObserverL( MVPbkContactViewObserver& aObserver )

    {

    CVPbkAsyncObjectCallback<MVPbkContactViewObserver>* callback =

        VPbkEngUtils::CreateAsyncObjectCallbackLC(

            *this,

            &CFindViewBase::DoAddObserver,

            &CFindViewBase::DoAddObserverError,

            aObserver);

    iObserverOp->CallbackL( callback );

    CleanupStack::Pop( callback );

    // Insert to first position because events are send in reverse order.

    iObservers.InsertL( &aObserver, 0 );

    }

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

// CFindViewBase::RemoveObserver

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

//

void CFindViewBase::RemoveObserver(MVPbkContactViewObserver& aObserver)

    {

    const TInt index = iObservers.Find( &aObserver );

    if ( index != KErrNotFound )

        {

        iObservers.Remove( index );

        }

    }

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

// CFindViewBase::MatchContactStore

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

//

TBool CFindViewBase::MatchContactStore(const TDesC& aContactStoreUri) const

    {

    return iParentView.MatchContactStore( aContactStoreUri );

    }

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

// CFindViewBase::MatchContactStoreDomain

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

//

TBool CFindViewBase::MatchContactStoreDomain(const TDesC& aContactStoreDomain) const

    {

    return iParentView.MatchContactStoreDomain( aContactStoreDomain );

    }

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

// CFindViewBase::CreateBookmarkLC

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

//

MVPbkContactBookmark* CFindViewBase::CreateBookmarkLC(

        TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    TContactItemId contactId = iMatchedContacts[aIndex]->Id();

    // Link implements also the bookmark interface in this store

    return CContactBookmark::NewLC( contactId, iBaseView.Store() );

    }

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

// CFindViewBase::IndexOfBookmarkL

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

//

TInt CFindViewBase::IndexOfBookmarkL(

        const MVPbkContactBookmark& aContactBookmark ) const

    {

    // Bookmark is implemented in this store

    const CContactBookmark* bookmark =

        dynamic_cast<const CContactBookmark*>(&aContactBookmark);

    if (bookmark &&

        &bookmark->ContactStore() == &iParentView.ContactStore() )

        {

        const TInt count( iMatchedContacts.Count() );

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

            {

            if ( iMatchedContacts[ i ]->Id() == bookmark->ContactId() )

                {

                return i;

                }

            }

        }

    return KErrNotFound;

    }

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

// CFindViewBase::AddFilteringObserverL

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

//

void CFindViewBase::AddFilteringObserverL(

        MFilteredViewSupportObserver& aObserver )

    {

    // Insert observer in callback function. That ensures that the observer

    // will always get the event asynchronously.

    CVPbkAsyncObjectCallback<MFilteredViewSupportObserver>* callback =

        VPbkEngUtils::CreateAsyncObjectCallbackLC(

            *this,

            &CFindViewBase::DoAddFilteringObserverL,

            &CFindViewBase::DoAddFilteringObserverError,

            aObserver);

    iFilterObsOp->CallbackL( callback );

    CleanupStack::Pop( callback );

    }

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

// CFindViewBase::RemoveFilteringObserver

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

//

void CFindViewBase::RemoveFilteringObserver(

        MFilteredViewSupportObserver& aObserver )

    {

    iFilterObsOp->CancelCallback( &aObserver );

    const TInt index( iFilteringObservers.Find( &aObserver ) );

    if ( index != KErrNotFound )

        {

        iFilteringObservers.Remove( index );

        }

    }

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

// CFindViewBase::ViewFiltering

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

//

MVPbkContactViewFiltering* CFindViewBase::ViewFiltering()

    {

    // This view supports further filtering.

    return this;

    }

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

// CFindViewBase::CreateFilteredViewLC

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

//

MVPbkContactViewBase* CFindViewBase::CreateFilteredViewLC(

        MVPbkContactViewObserver& aObserver,

        const MDesCArray& aFindWords,

        const MVPbkContactBookmarkCollection* /*aAlwaysIncludedContacts*/ )

    {

    // NOTE: aAlwaysIncludedContacts is commented because in VPbkCntModel

    // filtered views are linked. CFindView->CRefineView->CRefineView etc.

    // Only the CFindView saves the always included contacts and they

    // are used also by all CRefineView instances through

    // MAlwaysIncludedContacts interface.

    CRefineView* refineView = CRefineView::NewLC( aFindWords, *this,

        iBaseView, aObserver, *iContactFindPolicy,

        *this );

    refineView->ActivateContactMatchL();

    return refineView;

    }

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

// CFindViewBase::ContactViewReady

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

//

void CFindViewBase::ContactViewReady(

        MVPbkContactViewBase& /*aView*/ )

    {

    SendViewStateEventToObservers();

    }

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

// CFindViewBase::ContactViewUnavailable

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

//

void CFindViewBase::ContactViewUnavailable(

        MVPbkContactViewBase& /*aView*/ )

    {

    SendViewStateEventToObservers();

    }

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

// CFindViewBase::ContactAddedToView

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

//

void CFindViewBase::ContactAddedToView(

        MVPbkContactViewBase& aView,

        TInt aIndex,

        const MVPbkContactLink& aContactLink )

    {

    TRAPD( error, HandleContactAddedToViewL( aView, aIndex, aContactLink ) );

    if ( error != KErrNone )

        {

        ContactViewError( aView, error, EFalse );

        }

    }

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

// CFindViewBase::ContactRemovedFromView

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

//

void CFindViewBase::ContactRemovedFromView(

        MVPbkContactViewBase& aView,

        TInt aIndex,

        const MVPbkContactLink& aContactLink )

    {

    TRAPD( error, HandleContactRemovedFromViewL( aView, aIndex, aContactLink ) );

    if ( error != KErrNone )

        {

        ContactViewError( aView, error, EFalse );

        }

    }

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

// CFindViewBase::ContactViewError

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

//

void CFindViewBase::ContactViewError( MVPbkContactViewBase& /*aView*/,

        TInt aError, TBool aErrorNotified )

    {

    iViewReady = EFalse;

    ResetContacts();

    SendContactViewErrorEvent( aError, aErrorNotified );

    }

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

// CFindViewBase::ContactViewReadyForFiltering

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

//

void CFindViewBase::ContactViewReadyForFiltering(

        MParentViewForFiltering& aView )

    {

    TRAPD( error, DoContactViewReadyForFilteringL( aView ) );

    if ( error != KErrNone )

        {

        ContactViewError( aView, error, EFalse );

        }

    }

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

// CFindViewBase::ContactViewUnavailableForFiltering

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

//

void CFindViewBase::ContactViewUnavailableForFiltering(

        MParentViewForFiltering& /*aView*/ )

    {

    iViewReady = EFalse;

    ResetContacts();

    VPbkEng::SendViewEventToObservers( *this, iFilteringObservers,

        &MFilteredViewSupportObserver::ContactViewUnavailableForFiltering,

        &MVPbkContactViewObserver::ContactViewError );

    }

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

// CFindViewBase::IsMatchL

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

//

TBool CFindViewBase::IsMatchL( const MVPbkViewContact& aViewContact )

    {

    return iContactFindPolicy->MatchContactNameL( *iFindStrings,

                                                  aViewContact );

    }