/*

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

*

*/

#include "CViewBase.h"

// INCLUDES

// VPbkCntModel

#include "CContactStore.h"

#include "CFieldFactory.h"

#include "CContact.h"

#include "CFieldTypeList.h"

#include "CContactLink.h"

#include "CContactBookmark.h"

#include "CFindView.h"

#include "VPbkCntModelRemoteViewPreferences.h"

#include "CSortOrderAcquirerList.h"

// VPbkEng

#include <MVPbkContactViewObserver.h>

#include <MVPbkFieldType.h>

#include <VPbkError.h>

#include <CVPbkSortOrder.h>

#include <CVPbkAsyncCallback.h>

#include <VPbkPrivateUid.h>     // KFindPluingUID

#include <VPbkSendEventUtility.h>

#include <CVPbkContactViewDefinition.h>

#include <MVPbkContactStoreProperties.h>

// System includes

#include <cntitem.h>

// Debugging headers

#include <VPbkDebug.h>

namespace VPbkCntModel {

// CONSTANTS

const TInt KObserverArrayGranularity = 4;

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

// CViewBase::CViewBase

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

//

CViewBase::CViewBase( CContactStore& aParentStore ) :

        iObservers( KObserverArrayGranularity ),

        iParentStore( aParentStore )

    {

    }

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

// CViewBase::~CViewBase

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

//

CViewBase::~CViewBase()

    {

    delete iObserverOp;

    delete iFilterObsOp;

    delete iEventLink;

    if (iView)

        {

        iView->Close(*this);

        }

    delete iCurrentContact;

    iObservers.Close();

    iFilteringObservers.Close();

    delete iViewDefinition;

    delete iSortOrder;

    iParentStore.RemoveObserver(*this);

    }

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

// CViewBase::ConstructL

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

//

void CViewBase::ConstructL(

        const CVPbkContactViewDefinition& aViewDefinition,

        MVPbkContactViewObserver& aObserver,

        const MVPbkFieldTypeList& aSortOrder )

    {

    iParentStore.AddObserverL(*this);

    iSortOrder = CVPbkSortOrder::NewL(aSortOrder);

    iViewDefinition = CVPbkContactViewDefinition::NewL( aViewDefinition );

    if ( iParentStore.IsOpened() )

        {

        InitializeViewL( aViewDefinition, aSortOrder );

        }

    iObserverOp =

        CVPbkAsyncObjectOperation<MVPbkContactViewObserver>::NewL();

    iFilterObsOp =

        CVPbkAsyncObjectOperation<MFilteredViewSupportObserver>::NewL();

    AddObserverL(aObserver);

    }

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

// CViewBase::ConstructL

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

//

void CViewBase::ConstructL(

        const CVPbkContactViewDefinition& aViewDefinition,

        const MVPbkFieldTypeList& aSortOrder )

    {

    iParentStore.AddObserverL(*this);

    iSortOrder = CVPbkSortOrder::NewL(aSortOrder);

    iViewDefinition = CVPbkContactViewDefinition::NewL( aViewDefinition );

    if ( iParentStore.IsOpened() )

        {

        InitializeViewL( aViewDefinition, aSortOrder );

        }

    iObserverOp =

        CVPbkAsyncObjectOperation<MVPbkContactViewObserver>::NewL();

    iFilterObsOp =

        CVPbkAsyncObjectOperation<MFilteredViewSupportObserver>::NewL();

    }

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

// CViewBase::ChangeSortOrderL

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

//

void CViewBase::ChangeSortOrderL(const MVPbkFieldTypeList& aSortOrder)

    {

    // If this view is a remote view in Contacts server a strict policy

    // must be applied for changing sortorder. Shared views are used

    // widely in S60 applications so their sortorder must be controlled

    // by S60 Phonebook application.

    LeaveIfIncorrectSortOrderL( aSortOrder );

    CVPbkSortOrder* newSortOrder = CVPbkSortOrder::NewL(aSortOrder);

    CleanupStack::PushL(newSortOrder);

    RContactViewSortOrder viewSortOrder = CreateSortOrderL(aSortOrder);

    CleanupClosePushL(viewSortOrder);

    if ( !DoChangeSortOrderL( *iViewDefinition, viewSortOrder ) )

        {

        TeardownView();

        InitializeViewL( *iViewDefinition, aSortOrder );

        }

    CleanupStack::PopAndDestroy(); // viewSortOrder

    CleanupStack::Pop(); // newSortOrder

    delete iSortOrder;

    iSortOrder = newSortOrder;

    }

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

// CViewBase::SortOrder

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

//

const MVPbkFieldTypeList& CViewBase::SortOrder() const

    {

    return *iSortOrder;

    }

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

// CViewBase::RefreshL

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

//

void CViewBase::RefreshL()

    {

    // make the view sort itself again to refresh contents

    RContactViewSortOrder viewSortOrder = CreateSortOrderL(*iSortOrder);

    CleanupClosePushL(viewSortOrder);

    DoChangeSortOrderL( *iViewDefinition, viewSortOrder );

    CleanupStack::PopAndDestroy(); // viewSortOrder

    }

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

// CViewBase::ContactCountL

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

//

TInt CViewBase::ContactCountL() const

    {

    TInt result = 0;

    if (iViewReady)

        {

        result = iView->CountL();

        }

    return result;

    }

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

// CViewBase::ContactAtL

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

//

const MVPbkViewContact& CViewBase::ContactAtL(TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

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

    if ( aIndex >= ContactCountL() )

        {

        User::Leave( KErrArgument );

        }

    const ::CViewContact& viewContact = iView->ContactAtL(aIndex);

    iCurrentContact->SetViewContact(viewContact);

    return *iCurrentContact;

    }

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

// CViewBase::CreateLinkLC

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

//

MVPbkContactLink* CViewBase::CreateLinkLC(TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

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

    if ( aIndex >= ContactCountL() )

        {

        User::Leave( KErrArgument );

        }

    TContactItemId contactId = iView->AtL(aIndex);

    return CContactLink::NewLC(iParentStore, contactId);

    }

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

// CViewBase::IndexOfLinkL

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

//

TInt CViewBase::IndexOfLinkL(const MVPbkContactLink& aContactLink) const

    {

    TInt result = KErrNotFound;

        {

        const CContactLink& link = static_cast<const CContactLink&>(aContactLink);

        result = iView->FindL(link.ContactId());

        }

    return result;

    }

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

// CViewBase::AddObserverL

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

//

void CViewBase::AddObserverL(MVPbkContactViewObserver& aObserver)

    {

    CVPbkAsyncObjectCallback<MVPbkContactViewObserver>* callback =

        VPbkEngUtils::CreateAsyncObjectCallbackLC(

            *this,

            &CViewBase::DoAddObserverL,

            &CViewBase::AddObserverError,

            aObserver);

    iObserverOp->CallbackL( callback );

    CleanupStack::Pop( callback );

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

    /// Last inserted gets notifcation last.

    iObservers.InsertL( &aObserver, 0 );

    }

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

// CViewBase::RemoveObserver

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

//

void CViewBase::RemoveObserver(MVPbkContactViewObserver& aObserver)

    {

    iObserverOp->CancelCallback( &aObserver );

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

    if (index != KErrNotFound)

        {

        iObservers.Remove(index);

        }

    }

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

// CViewBase::MatchContactStore

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

//

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

    {

    return iParentStore.MatchContactStore(aContactStoreUri);

    }

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

// CViewBase::MatchContactStoreDomain

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

//

TBool CViewBase::MatchContactStoreDomain

        ( const TDesC& aContactStoreDomain ) const

    {

    return iParentStore.MatchContactStoreDomain( aContactStoreDomain );

    }

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

// CViewBase::CreateBookmarkLC

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

//

MVPbkContactBookmark* CViewBase::CreateBookmarkLC(TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

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

    TContactItemId contactId = iView->AtL(aIndex);

    // Link implements also the bookmark interface in this store

    return CContactBookmark::NewLC( contactId, iParentStore );

    }

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

// CViewBase::IndexOfBookmarkL

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

//

TInt CViewBase::IndexOfBookmarkL(

        const MVPbkContactBookmark& aContactBookmark) const

    {

    TInt result = KErrNotFound;

    // Bookmark is implemeted as a link in this store

    const CContactBookmark* bookmark =

        dynamic_cast<const CContactBookmark*>(&aContactBookmark);

    if (bookmark &&

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

        {

        result = iView->FindL( bookmark->ContactId() );

        }

    return result;

    }

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

// CViewBase::AddFilteringObserverL

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

//

void CViewBase::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,

            &CViewBase::DoAddFilteringObserverL,

            &CViewBase::DoAddFilteringObserverError,

            aObserver);

    iFilterObsOp->CallbackL( callback );

    CleanupStack::Pop( callback );

    }

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

// CViewBase::RemoveFilteringObserver

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

//

void CViewBase::RemoveFilteringObserver(

        MFilteredViewSupportObserver& aObserver )

    {

    iFilterObsOp->CancelCallback( &aObserver );

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

    if ( index != KErrNotFound )

        {

        iFilteringObservers.Remove( index );

        }

    }

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

// CViewBase::ViewFiltering

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

//

MVPbkContactViewFiltering* CViewBase::ViewFiltering()

    {

    // Both contact view and group view support filtering

    return this;

    }

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

// CViewBase::CreateFilteredViewLC

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

//

MVPbkContactViewBase* CViewBase::CreateFilteredViewLC(

        MVPbkContactViewObserver& aObserver,

        const MDesCArray& aFindWords,

        const MVPbkContactBookmarkCollection* aAlwaysIncludedContacts )

    {

    CFindView* findView = CFindView::NewLC( aFindWords, *this, aObserver,

            aAlwaysIncludedContacts, Store().ContactStoreDomainFsSession() );

    findView->ActivateContactMatchL();

    return findView;

    }

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

// CViewBase::UpdateFilterL

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

//

void CViewBase::UpdateFilterL(

        const MDesCArray& /*aFindWords*/,

        const MVPbkContactBookmarkCollection* /*aAlwaysIncludedContacts*/ )

    {

    // CViewBase implementations are "all contacts" views and not itself

    // filtered views. Only creating a filtered view is supported.

    User::Leave( KErrNotSupported );

    }

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

// CViewBase::ParentObject

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

//

MVPbkObjectHierarchy& CViewBase::ParentObject() const

    {

    return iParentStore;

    }

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

// CViewBase::StoreReady

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

//

void CViewBase::StoreReady( MVPbkContactStore& /*aContactStore*/ )

    {

    if ( !iViewReady )

        {

        TeardownView();

        TRAPD( error, InitializeViewL( *iViewDefinition, *iSortOrder ) );

        if ( error != KErrNone )

            {

            iViewReady = EFalse;

            SendViewErrorEvent( error );

            }

        }

    }

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

// CViewBase::StoreUnavailable

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

//

void CViewBase::StoreUnavailable

        ( MVPbkContactStore& /*aContactStore*/, TInt /*aReason*/ )

    {

    TeardownView();

    iViewReady = EFalse;

    SendViewStateEvent();

    }

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

// CViewBase::HandleStoreEventL

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

//

void CViewBase::HandleStoreEventL(

        MVPbkContactStore& /*aContactStore*/,

        TVPbkContactStoreEvent /*aStoreEvent*/)

    {

    // No need to handle this here, events are received from the view

    }

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

// CViewBase::HandleContactViewEvent

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

//

void CViewBase::HandleContactViewEvent

        ( const CContactViewBase& /*aView*/,

          const TContactViewEvent& aEvent )

    {

    switch ( aEvent.iEventType )

        {

        case TContactViewEvent::EUnavailable:

            {

            VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

                ("CViewBase::HandleContactViewEvent(0x%x) EUnavailable"),

                this );

            iViewReady = EFalse;

            SendViewStateEvent();

            break;

            }

        case TContactViewEvent::EReady:

            {

            VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

                ("CViewBase::HandleContactViewEvent(0x%x) EReady"),

                this);

            iViewReady = ETrue;

            SendViewStateEvent();

            break;

            }

        case TContactViewEvent::EItemAdded:

            {

            VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

                ("CViewBase::HandleContactViewEvent(0x%x) EItemAdded\

                 index %d id %d"), this, aEvent.iInt, aEvent.iContactId);

            iViewReady = ETrue;

            iEventLink->SetContactId(aEvent.iContactId);

            VPbkEng::SendViewEventToObservers( *this, aEvent.iInt, *iEventLink,

                iObservers, &MVPbkContactViewObserver::ContactAddedToView,

                &MVPbkContactViewObserver::ContactViewError );

            VPbkEng::SendViewEventToObservers( *this, aEvent.iInt, *iEventLink,

                iFilteringObservers,

                &MVPbkContactViewObserver::ContactAddedToView,

                &MVPbkContactViewObserver::ContactViewError );

            break;

            }

        case TContactViewEvent::EItemRemoved:

            {

            VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

                ("CViewBase::HandleContactViewEvent(0x%x) EItemRemoved\

                index %d id %d"),

                this, aEvent.iInt, aEvent.iContactId);

            iViewReady = ETrue;

            iEventLink->SetContactId( aEvent.iContactId );

            VPbkEng::SendViewEventToObservers( *this, aEvent.iInt, *iEventLink,

                iObservers,

                &MVPbkContactViewObserver::ContactRemovedFromView,

                &MVPbkContactViewObserver::ContactViewError );