/*

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

*

*/

// INCLUDE FILES

#include <CVPbkSimContactView.h>

#include "CStoreBase.h"

#include "CContactArray.h"

#include "CSimCntSortUtil.h"

#include "CContactArray.h"

#include "VPbkSimStoreImplError.h"

#include <CVPbkSimContactBuf.h>

#include <CVPbkSimContact.h>

#include <CVPbkSimCntField.h>

#include <CVPbkAsyncOperation.h>

#include <CVPbkAsyncCallback.h>

#include <CVPbkSimFieldTypeFilter.h>

#include <CVPbkContactFindPolicy.h>

#include <MVPbkSimViewObserver.h>

#include <MVPbkSimViewFindObserver.h>

#include <MVPbkSimStoreOperation.h>

#include <RVPbkStreamedIntArray.h>

#include <TVPbkSimStoreProperty.h>

#include <VPbkSimStoreTemplateFunctions.h>

#include <VPbkDebug.h>

// CONSTANTS

enum TVPbkSimViewState

    {

    /// View has no clients. It doesn' listen to store/contact array events

    ENotReady,

    /// View has clients but the store is not available or the view is resorting.

    /// It listens to store events but not contact array events.

    EUnvavailable,

    /// View has clients and it's ready to use.

    EReady

    };

namespace VPbkSimStoreImpl {

/**

* An active object for contact matching

*/

NONSHARABLE_CLASS(CContactMatchingOperation) : 

        public CActive,

        public MVPbkSimStoreOperation

    {

    public: // Construction and destruction

        static CContactMatchingOperation* NewL( 

            const MDesCArray& aFindStrings, 

            MVPbkSimViewFindObserver& aObserver,

            MVPbkSimCntView& aSimCntView );

        ~CContactMatchingOperation();

    public: // New functions

        void Activate();

    public: // Functions from CActive

        void RunL();

        void DoCancel();

        TInt RunError( TInt aError );

    private:

        /**

        * C++ constructor

        */

        CContactMatchingOperation( 

            const MDesCArray& aFindStrings, 

            MVPbkSimViewFindObserver& aObserver,

            MVPbkSimCntView& aSimCntView );

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        /**

        * Contact matched

        *

        * @param aSimContact SIM contact to be matched

        * @param aType SIM contact field to be matched with find string

        * @return ETrue, if contact matched, EFalse if not

        */

        TBool ContactMatchedL( 

            MVPbkSimContact& aSimContact,

            TVPbkSimCntFieldType aType );

    private:       

        /// Ref: strings used in find        

        const MDesCArray& iFindStrings;

        /// Ref: Observer that is interested in the result of the find

        MVPbkSimViewFindObserver& iObserver;

        /// Ref: View of SimStore to existing contacts

        MVPbkSimCntView& iSimCntView;

        /// Own: The result of the find

        RVPbkStreamedIntArray iMatchingResults;

        /// Own: Makes a string comparison

        CVPbkContactFindPolicy* iContactFindPolicy;

    };    

// ============================ MEMBER FUNCTIONS ============================

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

// CContactMatchingOperation::CContactMatchingOperation

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CContactMatchingOperation::CContactMatchingOperation( 

	    const MDesCArray& aFindStrings, 

        MVPbkSimViewFindObserver& aObserver,

        MVPbkSimCntView& aSimCntView )

        :   CActive( EPriorityStandard ),

            iFindStrings( aFindStrings ),

            iObserver( aObserver ),

            iSimCntView( aSimCntView )

    {

    }

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

// CContactMatchingOperation::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CContactMatchingOperation::ConstructL()

    {

    CActiveScheduler::Add( this );     

    //Create contact find policy

    iContactFindPolicy = CVPbkContactFindPolicy::NewL();       

    }

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

// CVPbkSimContactViewFindOperation::NewL

// Two-phased constructor.

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

//

CContactMatchingOperation* CContactMatchingOperation::NewL( 

        const MDesCArray& aFindStrings, 

        MVPbkSimViewFindObserver& aObserver,

        MVPbkSimCntView& aSimCntView )

    {

    CContactMatchingOperation* self = 

        new( ELeave ) CContactMatchingOperation( aFindStrings, aObserver, 

                                                 aSimCntView );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CContactMatchingOperation::~CContactMatchingOperation()

    {        

    delete iContactFindPolicy;

    iMatchingResults.Close();

    Cancel();

    // iContactFindPolicy is an ECOM plugin so call FinalClose after delete.

    REComSession::FinalClose();

    }

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

// CContactMatchingOperation::Activate

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

//

void CContactMatchingOperation::Activate()

    {        

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CContactMatchingOperation::ContactMatchedL

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

//    

TBool CContactMatchingOperation::ContactMatchedL( 

        MVPbkSimContact& aSimContact,

        TVPbkSimCntFieldType aType )

    {

    TBool result( EFalse );    

    MVPbkSimContact::TFieldLookup lookup = 

            aSimContact.FindField( aType );            

    if ( !lookup.EndOfLookup() )

        {                        

        const TDesC& data =                     

            aSimContact.ConstFieldAt( lookup.Index() ).Data();

        const TInt findCount( iFindStrings.MdcaCount() );

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

            {

            // Match refine

            if ( iContactFindPolicy->MatchRefineL( 

                 data, iFindStrings.MdcaPoint( i ) ) )

                {

                iMatchingResults.AppendIntL( aSimContact.SimIndex() );

                result = ETrue;

                break;

                }              

            }                    

        }

    return result;

    }

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

// CContactMatchingOperation::RunL

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

//

void CContactMatchingOperation::RunL()

    {

	const TInt count( iSimCntView.CountL() );

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

		{        

		MVPbkSimContact& simContact = iSimCntView.ContactAtL( i );        

        MVPbkSimContact::TFieldLookup lookupSimName = simContact.FindField( EVPbkSimName );                                      

        //try to fetch contact with EVPbkSimName

        if ( !lookupSimName.EndOfLookup() )

        	{

            ContactMatchedL( simContact, EVPbkSimName ); 

			}

        //if contact without name, then try to fetch it with EVPbkSimGsmNumber

        else

            {

            MVPbkSimContact::TFieldLookup lookupGsmNum = simContact.FindField( EVPbkSimGsmNumber );

            if ( !lookupGsmNum.EndOfLookup() )

            	{

            	ContactMatchedL( simContact, EVPbkSimGsmNumber ); 

                }

            }                              

		}        

	iObserver.ViewFindCompleted( iSimCntView, iMatchingResults );

    }

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

// CContactMatchingOperation::DoCancel

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

//

void CContactMatchingOperation::DoCancel()

    {

    // Operation has no handles to any services -> do nothing

    }

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

// CContactMatchingOperation::RunError

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

//

TInt CContactMatchingOperation::RunError( TInt aError )

    {    

    iObserver.ViewFindError( iSimCntView, aError ); 

    return KErrNone;

    }    

} // namespace VPbkSimStoreImpl

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

// CVPbkSimContactView::CVPbkSimContactView

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CVPbkSimContactView::CVPbkSimContactView( MVPbkSimCntStore& aParentStore, 

    TVPbkSimViewConstructionPolicy aConstructionPolicy ) 

    :   iParentStore( aParentStore ),

        iConstructionPolicy( aConstructionPolicy ),

        iViewState( ENotReady )

    {

    }

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

// CVPbkSimContactView::~CVPbkSimContactView

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

//

CVPbkSimContactView::~CVPbkSimContactView()

    {

    delete iIdleSort;

    SetToNotReadyState();

    delete iAsyncOperation;

    iObservers.Close();

    iSortOrder.Close();

    delete iViewName;

    delete iSortUtil;

    delete iCurrentContact;

    delete iTempContactForSorting;

    delete iFilter;

    }

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

// CVPbkSimContactView::NewLC

// Two-phased constructor.

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

//

EXPORT_C CVPbkSimContactView* CVPbkSimContactView::NewLC( 

        const RVPbkSimFieldTypeArray& aSortOrder,

        TVPbkSimViewConstructionPolicy aConstructionPolicy, 

        MVPbkSimCntStore& aParentStore, const TDesC& aViewName,

        CVPbkSimFieldTypeFilter* aFilter )

    {

    CVPbkSimContactView* self = 

            new ( ELeave ) CVPbkSimContactView( aParentStore, 

                aConstructionPolicy  );

    CleanupStack::PushL( self );

    self->ConstructL( aSortOrder, aViewName );

    self->iFilter = aFilter;

    return self;

    }

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

// CVPbkSimContactView::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVPbkSimContactView::ConstructL( const RVPbkSimFieldTypeArray& aSortOrder, 

    const TDesC& aViewName )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: CVPbkSimContactView(0x%x)::ConstructL name=%S"), 

        this, &aViewName );

    iIdleSort = CIdle::NewL( CActive::EPriorityStandard );

    ResetAndCopySortOrderL( aSortOrder );

    iViewName = aViewName.AllocL();

    iAsyncOperation = 

            CVPbkAsyncObjectOperation<MVPbkSimViewObserver>::NewL();

    iCurrentContact = CVPbkSimContactBuf::NewL( iParentStore );

    iTempContactForSorting = CVPbkSimContactBuf::NewL( iParentStore );

    }

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

// CVPbkSimContactView::Name

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

//

const TDesC& CVPbkSimContactView::Name() const

    {

    return *iViewName;

    }

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

// CVPbkSimContactView::ParentStore

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

//

MVPbkSimCntStore& CVPbkSimContactView::ParentStore() const

    {

    return iParentStore;

    }

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

// CVPbkSimContactView::OpenL

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

//

void CVPbkSimContactView::OpenL( MVPbkSimViewObserver& aObserver )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

    "VPbkSimStoreImpl: CVPbkSimContactView(0x%x)::OpenL name=%S,aObserver=0x%x,state=%d"),

    this, iViewName, &aObserver, iViewState );

    if ( ViewStateNotReady() )

        {

        // Call close first to ensure store is not opened many times

        iParentStore.Close( *this );

        // Open a store asynchronously.

        iParentStore.OpenL( *this );

        }

    else 

        {

        void( CVPbkSimContactView::* notifyFuncPtr)( MVPbkSimViewObserver& ) =

                &CVPbkSimContactView::DoViewOpenCallbackL;    

        if ( ViewStateUnavailable() )

            {

            notifyFuncPtr = &CVPbkSimContactView::DoViewUnavailableCallbackL;

            }

        CVPbkAsyncObjectCallback<MVPbkSimViewObserver>* callback =

            VPbkEngUtils::CreateAsyncObjectCallbackLC(

                *this, 

                notifyFuncPtr, 

                &CVPbkSimContactView::DoViewErrorCallback,

                aObserver );

        iAsyncOperation->CallbackL(callback);

        CleanupStack::Pop(); // callBack

        }

    if ( iObservers.Find( &aObserver ) == KErrNotFound )

        {

        iObservers.AppendL( &aObserver );

        }

    }

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

// CVPbkSimContactView::Close

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

//

void CVPbkSimContactView::Close( MVPbkSimViewObserver& aObserver )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: CVPbkSimContactView::Close name=%S,aObserver=0x%x,state=%d"),

        iViewName, &aObserver, iViewState );

    iAsyncOperation->CancelCallback( &aObserver );

    TInt index = iObservers.Find( &aObserver );

    if ( index >= 0 )

        {

        iObservers.Remove( index );

        if ( iObservers.Count() == 0 )    

            {     

            SetToNotReadyState();

            }

        }

    }

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

// CVPbkSimContactView::CountL

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

//        

TInt CVPbkSimContactView::CountL() const

    {

    return iViewContacts.Count();

    }

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

// CVPbkSimContactView::ContactAtL

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

//        

MVPbkSimContact& CVPbkSimContactView::ContactAtL( TInt aIndex )

    {

    if ( aIndex < 0 || aIndex >= iViewContacts.Count() )

        {

        User::Leave( KErrArgument );

        }

    const MVPbkSimContact* fullContact = 

        iParentStore.ContactAtL( iViewContacts[aIndex].iSimIndex );

    // Check that view is up to date

    __ASSERT_DEBUG( fullContact, 

            Panic( VPbkSimStoreImpl::EViewArrayNotUpToDate ) );

    if ( !fullContact )

        {

        User::Leave( KErrNotFound );

        }

    CVPbkSimContact* cnt = 

        CVPbkSimContact::NewLC( iParentStore );

    // Copy fields that have same type as in the sortorder

    TInt count = iSortOrder.Count();

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

        {

        MVPbkSimContact::TFieldLookup lookup = 

            fullContact->FindField( iSortOrder[i] );

        if ( !lookup.EndOfLookup() )

            {

            CVPbkSimCntField* field = cnt->CreateFieldLC( iSortOrder[i] );

            field->SetDataL( fullContact->ConstFieldAt( lookup.Index() ).Data() );

            cnt->AddFieldL( field );

            CleanupStack::Pop( field );

            }

        }

    cnt->SetSimIndex( fullContact->SimIndex() );

    iCurrentContact->SetL( cnt->ETelContactL() );

    CleanupStack::PopAndDestroy( cnt );

    return *iCurrentContact;

    }

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

// CVPbkSimContactView::ChangeSortOrderL

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

//

void CVPbkSimContactView::ChangeSortOrderL( const RVPbkSimFieldTypeArray& aSortOrder )

    {

    // Copy the new sort order to the view

    ResetAndCopySortOrderL( aSortOrder );

    // Change state only if the view is currently ready, Otherwise

    // the view is already waiting sorting or store event.

    if ( ViewStateReady() )

        {

        // Change to unavailable: view will be ready after sorting.

        SetToUnavailableState();

        // Resort view.

        StartSorting();

        }

    }

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

// CVPbkSimContactView::MapSimIndexToViewIndexL

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

//

TInt CVPbkSimContactView::MapSimIndexToViewIndexL( TInt aSimIndex )

    {

    TViewContact cnt( aSimIndex );

    return iViewContacts.Find( cnt, 

            TIdentityRelation<TViewContact>( &CVPbkSimContactView::CompareViewContactSimIndex ) );

    }

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

// CVPbkSimContactView::ContactMatchingPrefixL

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

//

MVPbkSimStoreOperation* CVPbkSimContactView::ContactMatchingPrefixL(

        const MDesCArray& aFindStrings, 

        MVPbkSimViewFindObserver& aObserver )

    {

    VPbkSimStoreImpl::CContactMatchingOperation* operation = 

            VPbkSimStoreImpl::CContactMatchingOperation::NewL( aFindStrings, 

                aObserver, *this );

    operation->Activate();    

    return operation;

    }