/*

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

*

*/

#include "CVPbkCompositeContactView.h"

#include <MVPbkFieldType.h>

#include <CVPbkSortOrder.h>

#include <CVPbkAsyncCallback.h>

#include <MVPbkContactLink.h>

#include "CVPbkEventArrayItem.h"

#include <VPbkError.h>

// Debugging headers

#include <VPbkProfile.h>

#include <VPbkDebug.h>

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

    enum TPanic

        {

        EPanicLogic_CreateBookmarkLC = 3

        };

    void Panic(TPanic aPanic)

        {

        _LIT(KPanicCat, "CVPbkCompositeContactView");

        User::Panic(KPanicCat, aPanic);

        }

#endif // _DEBUG

/// Observer granulatiry

const TInt KObserverArrayGranularity = 4;

/////////////////////////////////////////////////////////////////////////////

// Event sending functions for different amount of parameters

//

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

// SendEventToObservers

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

//

template <class NotifyFunc>

void SendEventToObservers( MVPbkContactViewBase& aView,

        RPointerArray<MVPbkContactViewObserver>& aObservers,

        NotifyFunc aNotifyFunc )

    {

    const TInt count = aObservers.Count();

    for (TInt i = count - 1; i >= 0; --i)

        {

        MVPbkContactViewObserver* observer = aObservers[i];

        (observer->*aNotifyFunc)(aView);

        }

    }

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

// SendEventToObservers

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

//

template <class NotifyFunc, class ParamType1, class ParamType2>

void SendEventToObservers( MVPbkContactViewBase& aView,

        RPointerArray<MVPbkContactViewObserver>& aObservers,

        NotifyFunc aNotifyFunc, ParamType1 aParam1, const ParamType2& aParam2 )

    {

    const TInt count = aObservers.Count();

    for (TInt i = count - 1; i >= 0; --i)

        {

        MVPbkContactViewObserver* observer = aObservers[i];

        (observer->*aNotifyFunc)(aView, aParam1, aParam2);

        }

    }

} /// namespace

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

// CVPbkCompositeContactView::CSubViewData::~CSubViewData

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

//

CVPbkCompositeContactView::CSubViewData::~CSubViewData()

    {

    delete iView;

    }

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

// CVPbkCompositeContactView::CVPbkCompositeContactView

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

//

CVPbkCompositeContactView::CVPbkCompositeContactView() :

        iAsyncOperation( CActive::EPriorityStandard ),

        iObservers( KObserverArrayGranularity )

    {

    }

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

// CVPbkCompositeContactView::~CVPbkCompositeContactView

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

//

CVPbkCompositeContactView::~CVPbkCompositeContactView()

    {

    delete iCompositePolicy;

    delete iSortOrder;

    iSubViews.ResetAndDestroy();

    iObservers.Close();

    iContactMapping.Reset();

    }

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

// CVPbkCompositeContactView::BaseConstructL

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

//

void CVPbkCompositeContactView::BaseConstructL

        (const MVPbkFieldTypeList& aSortOrder)

    {

    // Create sort order

    iSortOrder = CVPbkSortOrder::NewL(aSortOrder);

    // Always apply internal policy

    iCompositePolicy =

            CVPbkInternalCompositeViewPolicy::NewL( *this, iObservers );

    // External policy's view event buffering mechanism does not work when

    // native contact views reside in a separate process, therefore we

    // always apply internal policy.

    }

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

// CVPbkCompositeContactView::AddSubViewL

// Adds subview to this composite view.

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

//

void CVPbkCompositeContactView::AddSubViewL(MVPbkContactViewBase* aSubView, TInt  aViewId)

    {

    CSubViewData* subViewData =

        new(ELeave) CSubViewData(CSubViewData::ENotKnown);

    CleanupStack::PushL(subViewData);

    User::LeaveIfError(iSubViews.Append(subViewData));

    CleanupStack::Pop(subViewData);

    subViewData->iView = aSubView;

    subViewData->iViewId = aViewId;

    }

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

// CVPbkCompositeContactView::ActualContactCountL

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

//

TInt CVPbkCompositeContactView::ActualContactCountL() const

    {

    const TInt subViewCount = iSubViews.Count();

    TInt contactCount = 0;

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

        {

        if ( iSubViews[i]->iState == CSubViewData::EReady )

            {

            if ( iSubViews[i]->iView->Type() == EVPbkCompositeView )

                {

                // The view can be safely casted because

                // CVPbkCompositeContactView is VPbkEng internal

                // and EVPbkCompositeView type view is always

                // derived from CVPbkCompositeContactView.

                contactCount += static_cast<CVPbkCompositeContactView*>(

                    iSubViews[i]->iView )->ActualContactCountL();

                }

            else

                {

                contactCount += iSubViews[i]->iView->ContactCountL();

                }

            }

        }

    return contactCount;

    }

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

// CVPbkCompositeContactView::ApplyInternalCompositePolicyL

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

//

void CVPbkCompositeContactView::ApplyInternalCompositePolicyL()

    {

    if ( !iCompositePolicy || !iCompositePolicy->InternalPolicy() )

        {

        MVPbkCompositeContactViewPolicy* newPolicy =

                CVPbkInternalCompositeViewPolicy::NewL( *this, iObservers );

        delete iCompositePolicy;

        iCompositePolicy = newPolicy;

        }

    }

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

// CVPbkCompositeContactView::Type

// Returns view type.

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

//

TVPbkContactViewType CVPbkCompositeContactView::Type() const

    {

    return EVPbkCompositeView;

    }

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

// CVPbkCompositeContactView::ChangeSortOrderL

// Changes sort order.

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

//

void CVPbkCompositeContactView::ChangeSortOrderL

        (const MVPbkFieldTypeList& aSortOrder)

    {

    const TInt subViewCount = iSubViews.Count();

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

        {

        // All ready subviews go to unknown state because

        // they need to be re-sorted.

        // State is known again when an event comes.

        if (iSubViews[i]->iState == CSubViewData::EReady)

            {

            iSubViews[i]->iState = CSubViewData::ENotKnown;

            iSubViews[i]->iView->ChangeSortOrderL(aSortOrder);

            }

        }

    // Create new sort order and take it in use

    MVPbkFieldTypeList* sortOrder = CVPbkSortOrder::NewL(aSortOrder);

    delete iSortOrder;

    iSortOrder = sortOrder;

    }

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

// CVPbkCompositeContactView::SortOrder

// Returns current sort order.

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

//

const MVPbkFieldTypeList& CVPbkCompositeContactView::SortOrder() const

    {

    return *iSortOrder;

    }

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

// CVPbkCompositeContactView::RefreshL

// Refreshes all subviews

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

//

void CVPbkCompositeContactView::RefreshL()

    {

    const TInt subViewCount = iSubViews.Count();

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

        {

        iSubViews[i]->iView->RefreshL();

        }

    }

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

// CVPbkCompositeContactView::ContactCountL

// Returns contact count.

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

//

TInt CVPbkCompositeContactView::ContactCountL() const

    {

    return iCompositePolicy->ContactCountL();

    }

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

// CVPbkCompositeContactView::ContactAtL

// Returns contact at aIndex.

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

//

const MVPbkViewContact& CVPbkCompositeContactView::ContactAtL

        (TInt aIndex) const

    {

    __ASSERT_ALWAYS(

        aIndex >= 0, VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if ( aIndex >= iContactMapping.Count() )

        {

        User::Leave( KErrArgument );

        }

    const TContactMapping& mapping = iContactMapping[aIndex];

    MVPbkContactViewBase* view = iSubViews[mapping.iViewIndex]->iView;

    return view->ContactAtL( mapping.iContactIndex );

    }

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

// CVPbkCompositeContactView::CreateLinkLC

// Creates link from a contact at aIndex.

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

//

MVPbkContactLink* CVPbkCompositeContactView::CreateLinkLC(TInt aIndex) const

    {

    __ASSERT_ALWAYS(

        aIndex >= 0, VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if ( aIndex >= iContactMapping.Count() )

        {

        User::Leave( KErrArgument );

        }

    const TContactMapping& mapping = iContactMapping[aIndex];

    MVPbkContactViewBase* view = iSubViews[mapping.iViewIndex]->iView;

    return view->CreateLinkLC( mapping.iContactIndex );

    }

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

// CVPbkCompositeContactView::IndexOfLinkL

// Returns index of aContactLink.

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

//

TInt CVPbkCompositeContactView::IndexOfLinkL

        (const MVPbkContactLink& aContactLink) const

    {

    TIdentityRelation<TContactMapping> comparisonOperator

        (&CVPbkCompositeContactView::CompareMappings);

    TInt result = KErrNotFound;

    // Search the link from all the subviews

    const TInt subViewCount = iSubViews.Count();

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

        {

        // Check that the view is ready before using it.

        TInt index = KErrNotFound;

        if (iSubViews[i]->iState == CSubViewData::EReady)

            {

            index = iSubViews[i]->iView->IndexOfLinkL(aContactLink);

            }

        if (index != KErrNotFound)

            {

            // Establish contact mapping for view and contact index

            TContactMapping mapping;

            mapping.iViewIndex = i;

            mapping.iContactIndex = index;

            // Find the composite index by comparing the two mappings

            result = iContactMapping.Find(mapping, comparisonOperator);

            break;

            }

        }

    return result;

    }

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

// CVPbkCompositeContactView::AddObserverL

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

//

void CVPbkCompositeContactView::AddObserverL

        (MVPbkContactViewObserver& aObserver)

    {

    // Add the observer only if it is not already added

    TInt err( iObservers.InsertInAddressOrder(&aObserver) );

    if ( err != KErrNone && err != KErrAlreadyExists)

        {

        User::Leave( err );

        }

    TRAP(err,

        {

        VPbkEngUtils::MAsyncCallback* notifyObserver =

            VPbkEngUtils::CreateAsyncCallbackLC(

                *this,

                &CVPbkCompositeContactView::DoAddObserverL,

                &CVPbkCompositeContactView::AddObserverError,

                aObserver);

        iAsyncOperation.CallbackL(notifyObserver);

        CleanupStack::Pop(notifyObserver);

        });

    if (err != KErrNone)

        {

        RemoveObserver(aObserver);

        User::Leave(err);

        }

    }

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

// CVPbkCompositeContactView::RemoveObserver

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

//

void CVPbkCompositeContactView::RemoveObserver

        (MVPbkContactViewObserver& aObserver)

    {

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

    if (index != KErrNotFound)

        {

        iObservers.Remove(index);

        }

    }

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

// CVPbkCompositeContactView::MatchContactStore

// Check does any of the subviews match given contact store.

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

//

TBool CVPbkCompositeContactView::MatchContactStore

        (const TDesC& aContactStoreUri) const

    {

    const TInt count = iSubViews.Count();

    TBool result = EFalse;

    for (TInt i = 0; i < count && !result; ++i)

        {

        result = iSubViews[i]->iView->MatchContactStore(aContactStoreUri);

        }

    return result;

    }

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

// CVPbkCompositeContactView::MatchContactStoreDomain

// Check does any of the subviews match given contact store domain.

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

//

 TBool CVPbkCompositeContactView::MatchContactStoreDomain

        (const TDesC& aContactStoreDomain) const

    {

    const TInt count = iSubViews.Count();

    TBool result = EFalse;

    for (TInt i = 0; i < count && !result; ++i)

        {

        result = iSubViews[i]->iView->MatchContactStoreDomain

            (aContactStoreDomain);

        }

    return result;

    }

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

// CVPbkCompositeContactView::CreateBookmarkLC

// Creates a bookmark for given index.

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

//

MVPbkContactBookmark* CVPbkCompositeContactView::CreateBookmarkLC

        (TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0,

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

    __ASSERT_DEBUG(ContactCountL() > aIndex,

            Panic(EPanicLogic_CreateBookmarkLC));

    const TContactMapping& mapping = iContactMapping[aIndex];

    MVPbkContactViewBase* view = iSubViews[mapping.iViewIndex]->iView;

    return view->CreateBookmarkLC( mapping.iContactIndex );

    }

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

// CVPbkCompositeContactView::IndexOfBookmarkL

// Returns the index of given bookmark.

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

//

TInt CVPbkCompositeContactView::IndexOfBookmarkL

        (const MVPbkContactBookmark& aContactBookmark) const

    {

    TIdentityRelation<TContactMapping> comparisonOperator(

        &CVPbkCompositeContactView::CompareMappings);

    TInt result = KErrNotFound;

    // Search the bookmark from all the subviews

    const TInt subViewCount = iSubViews.Count();

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

        {

        // Check that the view is ready before using it.

        TInt index(KErrNotFound);

        if (iSubViews[i]->iState == CSubViewData::EReady)

            {

            index = iSubViews[i]->iView->IndexOfBookmarkL(aContactBookmark);

            }

        if (index != KErrNotFound)

            {

            // Establish contact mapping for view and contact index

            TContactMapping mapping;

            mapping.iViewIndex = i;

            mapping.iContactIndex = index;

            // Find the composite index by comparing the two mappings

            result = iContactMapping.Find(mapping, comparisonOperator);

            break;

            }

        }

    return result;

    }

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

// CVPbkCompositeContactView::ViewFiltering

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

//

MVPbkContactViewFiltering* CVPbkCompositeContactView::ViewFiltering()

    {

    // Composite views support filtering and is also a filtered view.

    // The subclass must implement the interface.

    return this;

    }

TAny* CVPbkCompositeContactView::ContactViewBaseExtension(TUid aExtensionUid)

    {

    MVPbkContactViewBaseChildAccessExtension* extChild = NULL;

    if ( aExtensionUid == TUid::Uid(KVPbkViewBaseExtChildAccess) )

        {

        extChild = this;

        }

    return extChild;

    }

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

// CVPbkCompositeContactView::ContactViewReady

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

//

void CVPbkCompositeContactView::ContactViewReady(MVPbkContactViewBase& aView)

    {

    TRAPD( res, HandleContactViewReadyL( aView ) );

    if ( res != KErrNone )

        {

        // There was an error when building a composite. Reset composite

        // inform client that this view unavailable and there is an error

        ResetContactMapping();

        SendViewUnavailableEvent();

        SendViewErrorEvent( res, EFalse );

        }

    }

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

// CVPbkCompositeContactView::ContactViewUnavailable

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