/*

* 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:  Phonebook 2 contact view sort policy.

*

*/

#include "CPbk2ContactViewSortPolicy.h"

// Phonebook2

#include "CPbk2SortKeyArray.h"

#include "RPbk2LocalizedResourceFile.h"

#include "Pbk2DataCaging.hrh"

#include <Pbk2UIPolicyRes.rsg>

// Virtual Phonebook

#include <MVPbkFieldType.h>

#include <MVPbkViewContact.h>

#include <MVPbkBaseContactField.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkBaseContactFieldCollection.h>

#include <CVPbkContactManager.h>

#include <CVPbkFieldTypeSelector.h>

#include <CVPbkFieldFilter.h>

#include <CVPbkSortOrder.h>

// System includes

#include <coemain.h>

#include <barsread.h>

#include <SortUtil.h>

// Debugging headers

#include <Pbk2Profile.h>

/// Unnamed namespace for local definitions

namespace {

_LIT(KResourceFile, "Pbk2UIPolicyRes.rsc");

const TInt KNegative = -1;

const TInt KPositive = 1;

/**

 * Sort key array.

 */

class TPbk2SortKeyArray : public MSortKeyArray

    {

    public: // Interface

        /**

         * Constructor.

         *

         * @param aArray    Array.

         */

        TPbk2SortKeyArray(

                const MVPbkSortKeyArray& aArray );

        /**

         * Returns the count of the keys.

         *

         * @return  Count of the keys.

         */

        TInt SortKeyCount() const

            {

            return iArray.Count();

            }

        /**

         * Returns the key at aIndex.

         *

         * @param aIndex    Index to query.

         * @return  Key at queried index.

         */

        TSortKey SortKeyAt(

                TInt aIndex ) const;

    private: // Data

        /// Ref: Array

        const MVPbkSortKeyArray& iArray;

    };

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

// TPbk2SortKeyArray::TPbk2SortKeyArray

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

//

TPbk2SortKeyArray::TPbk2SortKeyArray( const MVPbkSortKeyArray& aArray ) :

        iArray( aArray )

    {

    }

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

// TPbk2SortKeyArray::SortKeyAt

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

//

TSortKey TPbk2SortKeyArray::SortKeyAt( TInt aIndex ) const

    {

    TSortKeyType sortKeyType( ESortKeyBasic );

    if ( iArray.SortKeyAt( aIndex ).Type() == EVPbkSortKeyPronounciation )

        {

        sortKeyType = ESortKeyPronounciation;

        }

    return TSortKey( iArray.SortKeyAt( aIndex ).Text(), sortKeyType );

    }

} /// namespace

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

// CPbk2ContactViewSortPolicy::CPbk2ContactViewSortPolicy

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

//

CPbk2ContactViewSortPolicy::CPbk2ContactViewSortPolicy()

    {

    }

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

// CPbk2ContactViewSortPolicy::~CPbk2ContactViewSortPolicy

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

//

CPbk2ContactViewSortPolicy::~CPbk2ContactViewSortPolicy()

    {

    delete iPronunciationFieldSelector;

    delete iRightSortKeyArray;

    delete iLeftSortKeyArray;

    delete iSortUtil;

    delete iSortOrder;

    }

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

// CPbk2ContactViewSortPolicy::NewL

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

//

CPbk2ContactViewSortPolicy* CPbk2ContactViewSortPolicy::NewL

        ( TParam* aParam )

    {

    CPbk2ContactViewSortPolicy* self =

        new ( ELeave ) CPbk2ContactViewSortPolicy;

    CleanupStack::PushL( self );

    self->ConstructL( aParam );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2ContactViewSortPolicy::ConstructL

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

//

void CPbk2ContactViewSortPolicy::ConstructL( TParam* aParam )

    {

    iSortUtil = CSortUtil::NewL();

    if ( aParam )

        {

        iSortPolicyParameterReceived = ETrue;

        iLeftSortKeyArray = CPbk2SortKeyArray::NewL();

        iRightSortKeyArray = CPbk2SortKeyArray::NewL();

        iSortOrder = CVPbkSortOrder::NewL(aParam->iSortOrder);

        iFieldMapper.SetSortOrder(*iSortOrder);

        RPbk2LocalizedResourceFile resFile(aParam->iFs);

        resFile.OpenLC( KPbk2RomFileDrive, KDC_RESOURCE_FILES_DIR,

            KResourceFile );

        HBufC8* selectorBuf = resFile.AllocReadLC

            ( R_PRONUNCIATION_FIELD_SELECTOR );

        TResourceReader reader;

        reader.SetBuffer( selectorBuf );

        iPronunciationFieldSelector = CVPbkFieldTypeSelector::NewL

            ( reader, aParam->iFieldTypes );

        CleanupStack::PopAndDestroy( 2 ); // buffer, resFile

        }

    }

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

// CPbk2ContactViewSortPolicy::SetSortOrderL

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

//

void CPbk2ContactViewSortPolicy::SetSortOrderL

        ( const MVPbkFieldTypeList& aSortOrder )

    {

    if ( !iSortPolicyParameterReceived )

        {

        // This class has been initialized without TParam

        User::Leave( KErrNotSupported );

        }

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

    delete iSortOrder;

    iSortOrder = sortOrder;

    iFieldMapper.SetSortOrder( *iSortOrder );

    }

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

// CPbk2ContactViewSortPolicy::SortStartL

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

//

void CPbk2ContactViewSortPolicy::SortStartL()

    {

    if ( !iSortPolicyParameterReceived )

        {

        // This class has been initialized without TParam

        User::Leave( KErrNotSupported );

        }

    iLeftSortKeyArray->Reset();

    iRightSortKeyArray->Reset();

    const TInt typeCount( iSortOrder->FieldTypeCount() );

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

        {

        const MVPbkFieldType& fieldType = iSortOrder->FieldTypeAt( i );

        if ( iPronunciationFieldSelector->IsFieldTypeIncluded( fieldType ) )

            {

            iLeftSortKeyArray->AppendL(

                TSortKey( KNullDesC, ESortKeyPronounciation ) );

            iRightSortKeyArray->AppendL(

                TSortKey( KNullDesC, ESortKeyPronounciation ) );

            }

        else

            {

            iLeftSortKeyArray->AppendL(

                TSortKey( KNullDesC, ESortKeyBasic ) );

            iRightSortKeyArray->AppendL(

                TSortKey( KNullDesC, ESortKeyBasic ) );

            }

        }

    }

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

// CPbk2ContactViewSortPolicy::SortCompleted

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

//

void CPbk2ContactViewSortPolicy::SortCompleted()

    {

    iLeftSortKeyArray->Reset();

    iRightSortKeyArray->Reset();

    }

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

// CPbk2ContactViewSortPolicy::CompareContacts

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

//

TInt CPbk2ContactViewSortPolicy::CompareContacts

        ( const MVPbkViewContact& aLhs, const MVPbkViewContact& aRhs )

    {

    TInt ret = 0;

    if ( iSortPolicyParameterReceived )

        {

        // Change the text in the sortkeys to correspond

        // fields in the contacts

        TInt i = 0;

PBK2_PROFILE_START( Pbk2Profile::ESortPolicyCompareContacts );

        iFieldMapper.SetContactFields( aLhs.Fields() );

        const TInt lhsCount = iFieldMapper.FieldCount();

        for ( i = 0; i < lhsCount; ++i )

            {

            const MVPbkBaseContactField* lhsField =

                iFieldMapper.FieldAt( i );

            if ( lhsField )

                {

                iLeftSortKeyArray->SetText( MVPbkContactFieldTextData::Cast

                    ( lhsField->FieldData() ).Text(), i );

                }

            else

                {

                iLeftSortKeyArray->SetText( KNullDesC, i );

                }

            }

        iFieldMapper.SetContactFields( aRhs.Fields() );

        const TInt rhsCount = iFieldMapper.FieldCount();

        for ( i = 0; i < rhsCount; ++i )

            {

            const MVPbkBaseContactField* rhsField =

                iFieldMapper.FieldAt( i );

            if ( rhsField )

                {

                iRightSortKeyArray->SetText( MVPbkContactFieldTextData::Cast

                    ( rhsField->FieldData() ).Text(), i );

                }

            else

                {

                iRightSortKeyArray->SetText( KNullDesC, i );

                }

            }

PBK2_PROFILE_END( Pbk2Profile::ESortPolicyCompareContacts );

PBK2_PROFILE_START( Pbk2Profile::ESortPolicySortUtil );

        TInt result( iSortUtil->Interface()->CompareItems

            ( *iLeftSortKeyArray, *iRightSortKeyArray ) );

PBK2_PROFILE_END( Pbk2Profile::ESortPolicySortUtil );

        ret = PostProcessResult( result );

        }

    return ret;

    }

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

// CPbk2ContactViewSortPolicy::CompareItems

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

//

TInt CPbk2ContactViewSortPolicy::CompareItems

        ( const MVPbkSortKeyArray& aLhs,

          const MVPbkSortKeyArray& aRhs ) const

    {

    const TPbk2SortKeyArray lhsKeyArray( aLhs );

    const TPbk2SortKeyArray rhsKeyArray( aRhs );

    return iSortUtil->Interface()->CompareItems( lhsKeyArray, rhsKeyArray );

    }

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

// CPbk2ContactViewSortPolicy::PostProcessResult

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

//

TInt CPbk2ContactViewSortPolicy::PostProcessResult( TInt aSortUtilResult )

    {

    // With this function we correct sort util result because it does not

    // give right answers if contact is "Unnamed".

    // So here is clarified how this function corrects the result.

    // If rightside has no data left is less (-1) otherwise greater (1).

    // "<Unnamed>"  vs. "<Unnamed>" = -1,   leftside comes before rightside

    // "a"          vs. "<Unnamed>" = -1,   leftside comes before rightside

    // "<Unnamed>"  vs. "a"         = 1     rightside comes before leftside

    //

    TInt result = aSortUtilResult;

    const TInt rhsCount( iRightSortKeyArray->SortKeyCount() );

    TBool rhsHasData( EFalse );

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

        {

        TSortKey key = iRightSortKeyArray->SortKeyAt( i );

        if ( key.Text().Length() > 0 )

            {

            rhsHasData = ETrue;

            break;

            }

        }

    if ( !rhsHasData )

        {

        // Here we have situation "something" vs "<Unnamed>" .

        // We want leftside to come before rightside.

        result = KNegative;

        }

    else

        {

        TBool lhsHasData( EFalse );

        const TInt lhsCount( iLeftSortKeyArray->SortKeyCount() );

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

            {

            TSortKey key = iLeftSortKeyArray->SortKeyAt( i );

            if ( key.Text().Length() > 0 )

                {

                lhsHasData = ETrue;

                break;

                }

            }

        if ( !lhsHasData )

            {

            // Here we have situation "<Unnamed>" vs. "something".

            // We want rightside to come before leftside.

            result = KPositive;

            }

        }

    return result;

    }

//  End of File