/*
* Copyright (c) 2005-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:   Provide interface for the client requestin availability class.
*
*/



#include "musavacontactavailability.h"
#include "musavaavailabilityobserver.h"
#include "musavasettingsimp.h"
#include "musavaobserver.h"
#include "muslogger.h"
#include "mussettings.h"
#include "musavacalleventmonitor.h"

#include <CPbkContactItem.h>
#include <CPbkContactEngine.h>
#include <CPbkFieldInfo.h>
#include <TPbkContactItemField.h>
#include <cntviewbase.h>
#ifdef UNIT_TESTING // if unit testing
#include <digia/eunit/eunitdecorators.h>
#endif // UNIT_TESTING

const TInt KNumberMatchingDigitsRequired = 7;
const TInt KContactsArraySize = 10;


_LIT( KMusAvaSip,               "sip:" );
_LIT( KMusAvaTel,               "tel:" );
_LIT( KMusAvaPlus,              "+"    );
_LIT( KMusAvaAtSign ,           "@"    );
_LIT( KMusEmptyStringSymbol,    ""     );
_LIT( KMusSpaceSymbol,          " "    );
_LIT( KMusAvaTestString,        "*#"   );


CMusAvaContactAvailability* CMusAvaContactAvailability::NewL(
    MMusAvaAvailabilityObserver& aObserver,
    CMusAvaSettingsImp& aSettings )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::NewL()" )

    CMusAvaContactAvailability* self =
        CMusAvaContactAvailability::NewLC(
            aObserver,
            aSettings );
    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaContactAvailability::NewL()" )
    return self;
    }


CMusAvaContactAvailability* CMusAvaContactAvailability::NewLC(
    MMusAvaAvailabilityObserver& aObserver,
    CMusAvaSettingsImp& aSettings )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::NewL()" )
    CMusAvaContactAvailability* self =
     new( ELeave ) CMusAvaContactAvailability(
        aObserver,
        aSettings );
    CleanupStack::PushL( self );
    self->ConstructL();

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaContactAvailability::NewL()" )
    return self;
    }


CMusAvaContactAvailability::~CMusAvaContactAvailability()
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::\
             ~CMusAvaContactAvailability()" )
    delete iContactName;
    iContactName = NULL;
    if ( iPhoneStatus )
        {
        iPhoneStatus->Cancel();
        }
    delete iPhoneStatus;
    iPhoneStatus = NULL; 
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaContactAvailability::\
             ~CMusAvaContactAvailability()" )
    }


CMusAvaContactAvailability::CMusAvaContactAvailability(
    MMusAvaAvailabilityObserver& aObserver,
    CMusAvaSettingsImp& aSettings )
    :CMusAvaAvailability( aObserver ),
    iContactName( NULL ),
    iSettings( aSettings )
    {
    }


void CMusAvaContactAvailability::ConstructL()
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::ConstructL()" )
    iOperatorVariant = MultimediaSharingSettings::OperatorVariantSettingL();
    iPhoneStatus = CMusAvaCallEventMonitor::NewL( *this );
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaContactAvailability::ConstructL()" )
    }


// -------------------------------------------------------------------------
//  Starts the loopy execution.
// -------------------------------------------------------------------------
//
void CMusAvaContactAvailability::DoExecuteL()
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::DoExecuteL()" )
    iPhoneStatus->StartMonitoringL();

    CContactIdArray* idArray = NULL;

    #ifdef UNIT_TESTING // if unit testing
    EUNIT_DISABLE_ALLOC_DECORATOR;
    #endif // UNIT_TESTING
    CPbkContactEngine* pbkContactEngine = CPbkContactEngine::NewL();
    CleanupStack::PushL( pbkContactEngine );

    // resolve the name order     
    CContactViewBase& contactView = pbkContactEngine->AllContactsView();
    const RContactViewSortOrder& sortOrder = contactView.SortOrderL();
    #ifdef UNIT_TESTING // if unit testing
    EUNIT_ENABLE_ALLOC_DECORATOR;
    #endif // UNIT_TESTING
    
    iBeginWithFirstName = ETrue;
    TBool foundOrder = EFalse;
	for( TInt i = 0; i < sortOrder.Count() && !foundOrder; ++i )
	    {
	    if ( sortOrder[i] == KUidContactFieldFamilyName )
		    {
            iBeginWithFirstName = EFalse;
            foundOrder = ETrue;
		    }
	    else if ( sortOrder[i] == KUidContactFieldGivenName )
		    {
		    iBeginWithFirstName = ETrue;
		    foundOrder = ETrue;
		    }
	    }

    CDesCArrayFlat* contactsArray
        = new ( ELeave ) CDesCArrayFlat( KContactsArraySize );
    CleanupStack::PushL( contactsArray );

    if ( ContactL( idArray, *pbkContactEngine ) )
        {
        CleanupStack::PushL( idArray );

        TInt idArrayCount = idArray->Count();
        MUS_LOG1( "mus: [MUSAVA]     idArray->Count %d", idArrayCount )
        CPbkContactItem* pbkItem = NULL;
        TPbkFieldId fieldId = ContactIdSearch( *idArray, *pbkContactEngine );

        for ( TInt i = 0; i < idArrayCount; i++ )
            {
            MUS_LOG1( "mus: [MUSAVA]     i %d", i )
            TContactItemId itemId( KErrNotFound );
            itemId = ( *idArray )[i];

            TRAPD( error, pbkItem = pbkContactEngine->ReadContactL( itemId ) );

            if ( !error )
                {
                TBool found = EFalse;
                if ( fieldId == EPbkFieldIdShareView )
                    {
                    found = ResolveAddressesL( 
                                *pbkItem, contactsArray, EPbkFieldIdShareView );
                    }
                else if( fieldId == EPbkFieldIdSIPID)
                    {
                    found = ResolveAddressesL( 
                                *pbkItem, contactsArray, EPbkFieldIdSIPID );
                    }

                if ( !found )
                    {
                    PhoneResolutionL( *pbkItem, contactsArray );
                    }
                    
                    // tbd: causes test case to fail
                    // break;
                }

            delete pbkItem; 
            pbkItem = NULL;
            }

        idArray->Reset();
        CleanupStack::PopAndDestroy( idArray );
        }
    else
        {
        ActiveCallL( contactsArray );
        }

    iSettings.SetSipAddressesL( *contactsArray );

    contactsArray->Reset();

    CleanupStack::PopAndDestroy( contactsArray );

    CleanupStack::PopAndDestroy( pbkContactEngine );

    SetState( MMusAvaObserver::EMusAvaStatusAvailable );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaContactAvailability::DoExecuteL()" )
    }

// -------------------------------------------------------------------------
//  This function is called when a cs call is connected.
// -------------------------------------------------------------------------
//
void CMusAvaContactAvailability::CallConnectedL( const TDesC& aTelNumber )
    {
    MUS_LOG( "mus: [MUSAVA]  \
                -> CMusAvaContactAvailability::CallConnectedL()" )
                
    iSettings.SetTelNumberL(aTelNumber);              
    DoExecuteL();

    MUS_LOG( "mus: [MUSAVA]  \
                <- CMusAvaContactAvailability::CallConnectedL()" )
    }
void CMusAvaContactAvailability::ConferenceCallL()
    {   
    }


// -------------------------------------------------------------------------
//  This function is called when a cs call goes hold
// -------------------------------------------------------------------------
//
void CMusAvaContactAvailability::CallHoldL( const TDesC& /*aTelNumber*/ )
    {    
    }


// -------------------------------------------------------------------------
//  This function is called when a cs call goes into a state
//  that is not connected.
// -------------------------------------------------------------------------
//
void CMusAvaContactAvailability::NoActiveCallL()
    {
    }

// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::ActiveCallL( CDesCArrayFlat*& aContactsArray )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::ActiveCallL()" )

    const TDesC& phoneNumber = iSettings.TelNumber();
    TInt retval = EFalse;
    
    if ( phoneNumber.Length() > 0 &&
         ( iOperatorVariant == MusSettingsKeys::EOperatorSpecific ||
           phoneNumber.Left(1).Compare( KMusAvaPlus() ) == 0 ) )
        {
        MUS_LOG( "mus: [MUSAVA]     Phone number found with + prefix \
                                     (or operator variant)" )
        // No, it doesn't, so add the prefix to the new address.
        MUS_LOG( "mus: [MUSAVA]     Prefix to the new address is added" )
        //Create contact array
        //Create tel bufer
        HBufC* tmpDescriptor = HBufC::NewLC( KMusAvaTel().Length() +
                                              phoneNumber.Length() );
        tmpDescriptor->Des().Append( KMusAvaTel() );
        tmpDescriptor->Des().Append( phoneNumber );
        //Add to array
        aContactsArray->AppendL( tmpDescriptor->Des() );
        CleanupStack::PopAndDestroy( tmpDescriptor );
        retval = ETrue;
        }
    else
        {
        MUS_LOG( "mus: [MUSAVA]     Phone number not found " )
        retval = EFalse;
        }
    MUS_LOG1( "mus: [MUSAVA]     <- CMusAvaContactAvailability::\
              ActiveCallL return %d", retval )

    return retval;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::ContactL(
                                    CContactIdArray*& aContactIdArray,
                                    CPbkContactEngine& aPbkContactEngine )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::ContactL()" )
    CPbkContactItem* pbkContactItem = NULL;

    TInt conRes = EFalse;

    TInt err = ContactArrayL( aContactIdArray, aPbkContactEngine );
    if ( !err )
        {
        err = ContactItem( *aContactIdArray, pbkContactItem, aPbkContactEngine );
        // NOTE: KErrNotSupported means there is more than one contact id.
        if ( err == KErrNotSupported )
            {
            iSettings.SetContactId( KErrNotSupported );
            conRes = ETrue;
            }
        else if( err != KErrNone )
            {
            MUS_LOG( "mus: [MUSAVA]     No contact item found; contact id = \
                KErrNotFound" )
            conRes = EFalse;
            }
        else
            {
            TContactItemId itemId = pbkContactItem->Id();
            MUS_LOG1( "mus: [MUSAVA]        Setting contact id to be %d",
                      itemId )
            CleanupStack::PushL( pbkContactItem );
            iSettings.SetContactId( itemId );
            UpdateContactNameL( pbkContactItem->ContactItem() );
            CleanupStack::Pop( pbkContactItem );
            conRes = ETrue;
            }
        }
    MUS_LOG1( "mus: [MUSAVA]     <- CMusAvaContactAvailability::\
              ContactL return %d", conRes )

    delete pbkContactItem;
    pbkContactItem = NULL;

    return conRes;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
void CMusAvaContactAvailability::UpdateContactNameL( 
                                                CContactItem& aContactItem )
    {
    MUS_LOG( "mus: [MUSAVA ]  -> CMusAvaContactAvailability::\
        UpdateContactName" )
    //TBuf<KMusNameFieldMaxLength> givenName;
    //TBuf<KMusNameFieldMaxLength> familyName;

    HBufC* givenName = NULL;
    HBufC* familyName = NULL;

    delete iContactName;
    iContactName = NULL;
    iContactName = HBufC::NewL( 0 );

    CContactItemFieldSet& fieldSet = aContactItem.CardFields();

    TInt pos = fieldSet.Find( KUidContactFieldGivenName );
    if ( pos != KErrNotFound )
        {
        CContactItemField& itemField = fieldSet[pos];
        //givenName = HBufC::NewL( itemField.TextStorage()->Text().Length() );

        //givenName.Copy( itemField.TextStorage()->Text().Alloc() );
        givenName = itemField.TextStorage()->Text().AllocLC();

        }
    else
        {
        //givenName = KMusEmptyStringSymbol;
        givenName = KMusEmptyStringSymbol().AllocLC();
        }

    pos = fieldSet.Find( KUidContactFieldFamilyName );
    if ( pos != KErrNotFound )
        {
        CContactItemField& itemField = fieldSet[pos];
        //familyName = HBufC::NewL( itemField.TextStorage()->Text().Length() );
        //familyName.Copy( field.TextStorage()->Text() );
        familyName = itemField.TextStorage()->Text().AllocLC();
        }
    else
        {
        familyName = KMusEmptyStringSymbol().AllocLC();
        }

    TInt strLength = NULL;
    TBool bothNames = givenName->Length() > 0 && familyName->Length() > 0;
    
    if ( bothNames )
        {
        strLength = givenName->Length() +
                     KMusSpaceSymbol().Length() +
                     familyName->Length();
        }
    else
        {
        strLength = givenName->Length() + familyName->Length();
        }
    
    if ( strLength > iContactName->Length() )
        {
        iContactName = iContactName->ReAllocL( strLength );
        }

    if ( strLength > 1 )
        {
        TPtr ptr = iContactName->Des();
        if ( iBeginWithFirstName )
            {
            if ( bothNames )
                {
                ptr.Append( givenName->Des() );
                ptr.Append( KMusSpaceSymbol );
                ptr.Append( familyName->Des() );
                }
            else
                {
                ptr.Append( givenName->Des() );
                ptr.Append( familyName->Des() );
                }
            }
        else            
            {
            if ( bothNames )
                {
                ptr.Append( familyName->Des() );
                ptr.Append( KMusSpaceSymbol );
                ptr.Append( givenName->Des() );
                }
            else
                {
                ptr.Append( familyName->Des() );
                ptr.Append( givenName->Des() );
                }
            } 
        }

    CleanupStack::PopAndDestroy( familyName );
    CleanupStack::PopAndDestroy( givenName );

    TRAP_IGNORE( iSettings.SetContactNameL( iContactName->Des() ) )

    MUS_LOG( "mus: [MUSAVA ]  <- CMusAvaContactAvailability::\
        UpdateContactName" )
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TInt CMusAvaContactAvailability::ContactArrayL(
                                    CContactIdArray*& aContactIdArray,
                                    CPbkContactEngine& aPbkContactEngine )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::ContactArrayL()" )

    const TDesC& phoneNumber = iSettings.TelNumber();
    TInt retval = KErrNotFound;

    if ( phoneNumber.Length() > 0 )
        {
        MUS_LOG( "mus: [MUSAVA]     Phone number found " )
        // Instantiate a PhonebookContactEngine object, which represents a
        // connection to the Phonebook contact database:
        #ifdef UNIT_TESTING // if unit testing
        EUNIT_DISABLE_ALLOC_DECORATOR;
        #endif // UNIT_TESTING
        CContactIdArray* tmpContactIdArray =
                        aPbkContactEngine.MatchPhoneNumberL(
                                             phoneNumber,
                                             KNumberMatchingDigitsRequired );
        #ifdef UNIT_TESTING // if unit testing
        EUNIT_ENABLE_ALLOC_DECORATOR;
        #endif // UNIT_TESTING
        if ( tmpContactIdArray->Count() > 0 )
            {
            aContactIdArray = tmpContactIdArray;    
            retval = KErrNone;
            }
        else
            {
            tmpContactIdArray->Reset();
            delete tmpContactIdArray;
            MUS_LOG( 
            "mus: [MUSAVA]     Phone number not found in CPbkContactEngine" )
            }
        }
    else
        {
        MUS_LOG( "mus: [MUSAVA]     Phone number not found " )
        }
    
    MUS_LOG1( "mus: [MUSAVA]     <- CMusAvaContactAvailability::\
          ContactArrayL return %d", retval )

    return retval;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TInt CMusAvaContactAvailability::ContactItem( 
                                        CContactIdArray& aContactIdArray,
                                        CPbkContactItem*& aPbkContactItem,
                                        CPbkContactEngine& aPbkContactEngine )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::ContactItem()" )
    CPbkContactItem* pbkItem = NULL;
    TInt retval = KErrNotFound;
    TInt contactIdsCount = aContactIdArray.Count();
    
    if( contactIdsCount > 1 )
      {
      // NOTE: KErrNotSupported means there is more than one contact id.
      MUS_LOG( "mus: [MUSAVA]    More than one Contact ID found." )
      retval = KErrNotSupported;
      }
    else if ( contactIdsCount == 1 )
        {
        // Contact card whose phone number matches that of the other party
        // was found. The ID(s) of the contacts are recorded in iIdArray.
        MUS_LOG( "mus: [MUSAVA]     Contact ID found." )

        TContactItemId itemId( KErrNotFound );

        MUS_LOG1( "mus: [MUSAVA]    ID array has <%d> elements",
                  contactIdsCount )
        // iterate through the contact cards we consider as belonging to
        // the other party, that is, those saved in iIdArray:
        for ( TInt i = 0; i < contactIdsCount; i++ )
            {
            itemId = ( aContactIdArray )[i];
            MUS_LOG2( "mus: [MUSAVA]        Current array index == <%d>, \
                    contact ID == <%d>", i, itemId )
            TRAPD( pbkFailure, pbkItem =
                   aPbkContactEngine.ReadContactL( itemId ) );

            if ( pbkFailure )
                {
                // Contact lookup failed.
                MUS_LOG1( "mus: [MUSAVA]    Leave code <%d> occurred at call \
                        of ReadContactL.", pbkFailure )
                }
            else
                {
                aPbkContactItem = pbkItem;
                retval = KErrNone;
                }
            }
        }
    else
        {
        MUS_LOG( "mus: [MUSAVA]     No contact card whose phone number\
             matches that of the other party" )
        }
    
    MUS_LOG1( "mus: [MUSAVA]  <- CMusAvaContactAvailability::\
                 ContactItem() return %d", retval )
        
    return retval;
    }

// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::PhoneResolutionL( CPbkContactItem& aPbkItem,
                                           CDesCArrayFlat*& aContactsArray )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::PhoneResolutionL()" )
    TInt retval = ETrue;
    if ( ResolvePhoneContactL( aPbkItem, aContactsArray ) )
        {
        MUS_LOG( "mus: [MUSAVA]     Stop Execution" )
        }
    else
        {
        if ( ActiveCallL( aContactsArray ) )
            {
            MUS_LOG( "mus: [MUSAVA]     Stop Execution" )
            }
        else
            {
            MUS_LOG( "mus: [MUSAVA]     Stop Execution" )
            retval = EFalse;
            }
        }
        
    MUS_LOG1( "mus: [MUSAVA]  <- CMusAvaContactAvailability::\
                 PhoneResolutionL() return %d", retval )
    return retval;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::ContactId( CPbkContactItem& aPbkItem,
                                                  TPbkFieldId aTPbkFieldId  )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::ContactId()" )

    CPbkFieldArray& fieldArray = aPbkItem.CardFields();
    TPbkContactItemField itemField;
    TBool returnValue = EFalse;

    // Get the number of detail fields of the phonebook contact item.
    const TInt fieldCount( fieldArray.Count() );

    for ( TInt index = 0; index < fieldCount && returnValue == EFalse; 
        index++ )
        {
        itemField = fieldArray.At( index );

        if ( itemField.FieldInfo().Match( aTPbkFieldId ) &&
              itemField.Text().Find( KMusAvaAtSign() ) != KErrNotFound )
            {
            returnValue = ETrue;
            MUS_LOG( "mus: [MUSAVA]     Contact id found" )
            }
        }
    MUS_LOG1( "mus: [MUSAVA]     <- CMusAvaContactAvailability::\
              ContactId() return %d", returnValue )
    return returnValue;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TPbkFieldId CMusAvaContactAvailability::ContactIdSearch(
                                        CContactIdArray& aContactIdArray,
                                        CPbkContactEngine& aPbkContactEngine )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::\
    ContactIdSearch()" )
    
    TInt contactIdsCount = aContactIdArray.Count();
    MUS_LOG1( "mus: [MUSAVA]     aContactIdArray.Count %d", \
    contactIdsCount )

    CPbkContactItem* pbkItem = NULL;
    TPbkFieldId retFieldId = EPbkFieldIdNone;

    for ( TInt i = 0; 
        i < contactIdsCount && retFieldId == EPbkFieldIdNone; 
        i++ )
        {
        MUS_LOG1( "mus: [MUSAVA]     i %d", i )
        TContactItemId itemId( KErrNotFound );
        itemId = ( aContactIdArray )[i];

        #ifdef UNIT_TESTING // if unit testing
        EUNIT_DISABLE_ALLOC_DECORATOR;
        #endif // UNIT_TESTING
        TRAPD( error, pbkItem = aPbkContactEngine.ReadContactL( itemId ) )
        #ifdef UNIT_TESTING // if unit testing
        EUNIT_ENABLE_ALLOC_DECORATOR;
        #endif // UNIT_TESTING
        if ( error != KErrNone )
            {
            return retFieldId;
            }
        if ( ContactId( *pbkItem, EPbkFieldIdShareView ) )
            {
            MUS_LOG( "mus: [MUSAVA]     Contact have a prefix = \
            EPbkFieldIdShareView" )
            delete pbkItem;
            retFieldId = EPbkFieldIdShareView;
            }
        else if ( ContactId( *pbkItem, EPbkFieldIdSIPID ) )
            {
            MUS_LOG( "mus: [MUSAVA]     Contact have a prefix = \
            EPbkFieldIdSIPID" )
            delete pbkItem;
            retFieldId = EPbkFieldIdSIPID;
            }
        else if ( ContactId( *pbkItem, EPbkFieldIdPhoneNumberGeneral ) )
            {
            // this part never run!!!!
            MUS_LOG( "mus: [MUSAVA]     Contact have a prefix = \
            EPbkFieldIdPhoneNumberGeneral" )
            delete pbkItem;
            retFieldId = EPbkFieldIdPhoneNumberGeneral;
            }
        else
            {
            MUS_LOG( "mus: [MUSAVA]     Contact have no prefix " )
            delete pbkItem;
            }
        }
    return retFieldId;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::ResolveAddressesL( CPbkContactItem& aPbkItem,
                                        CDesCArrayFlat*& aContactsArray,
                                        TPbkFieldId aTPbkFieldId  )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::\
        ResolveAddressesL()" )

    CPbkFieldArray& fieldArray = aPbkItem.CardFields();
    TPbkContactItemField itemField;
    HBufC* tmpDescriptor( NULL );
    TBool returnValue( EFalse );

    // Get the number of detail fields of the phonebook contact item.
    const TInt fieldCount( fieldArray.Count() );

    for ( TInt index = 0; index < fieldCount; index++ )
        {
        itemField = fieldArray.At( index );

        if ( itemField.FieldInfo().Match( aTPbkFieldId ) &&
             itemField.Text().Find( KMusAvaAtSign() ) != KErrNotFound && 
             ( iOperatorVariant != MusSettingsKeys::EOperatorSpecific || 
               itemField.Text().Find( KMusAvaTestString() ) != KErrNotFound ) )
            {
            returnValue = ETrue;
            MUS_LOG( "mus: [MUSAVA]     Contact id found" )            
            
            HBufC* sipAddress;
            if ( iOperatorVariant == MusSettingsKeys::EOperatorSpecific )
                {
                sipAddress = HBufC::NewLC( itemField.Text().Length() - 
                                           KMusAvaTestString().Length() );
                TInt pos = itemField.Text().Find( KMusAvaTestString() );
                sipAddress->Des().Append( itemField.Text().Left( pos ) );
                sipAddress->Des().Append( itemField.Text().Right( 
                                    itemField.Text().Length() - 
                                    pos - KMusAvaTestString().Length() ) );
                }
            else                
                {
                sipAddress = itemField.Text().AllocLC();
                }

            if ( sipAddress->Find( KMusAvaSip() ) == KErrNotFound )
                {
                // No, it doesn't, so add the prefix to the new address.
                MUS_LOG( "mus: [MUSAVA]     Prefix to the new address is added" )
                tmpDescriptor = HBufC::NewLC( KMusAvaSip().Length() +
                                              sipAddress->Length() );
                tmpDescriptor->Des().Append( KMusAvaSip() );
                tmpDescriptor->Des().Append( *sipAddress );
                // if multiple contact have same phone number then 
                // sip address can be repeated . To avoid this check
                // whether sip address exist already in array
                // it not exist then add it to array.
                if(! IsExistAlready(*aContactsArray,*tmpDescriptor))
                    {
                    aContactsArray->AppendL( *tmpDescriptor );    
                    }                
                CleanupStack::PopAndDestroy( tmpDescriptor );
                }
            else
                {
                MUS_LOG( "mus: [MUSAVA]     Contact have a prefix" )
                 // if multiple contact have same phone number then 
                // sip address can be repeated . To avoid this check
                // whether sip address exist already in array
                // it not exist then add it to array.
                if(! IsExistAlready(*aContactsArray,*sipAddress))
                    {
                    aContactsArray->AppendL( *sipAddress );
                    }
                }
                
            CleanupStack::PopAndDestroy( sipAddress );                
            }
        }
    MUS_LOG1( "mus: [MUSAVA]     <- CMusAvaContactAvailability::\
              ResolveAddressesL() return %d", returnValue )
    return returnValue;
    }


// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::ResolvePhoneContactL(
                                                CPbkContactItem& aPbkItem,
                                              CDesCArrayFlat*& aContactsArray )
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaContactAvailability::\
        ResolvePhoneContactL()" )
    CPbkFieldArray& fieldArray = aPbkItem.CardFields();
    TPbkContactItemField itemField;
    HBufC* tmpDescriptor( NULL );
    TBool returnValue = EFalse;

    // Get the number of detail fields of the phonebook contact item.
    const TInt fieldCount( fieldArray.Count() );

    for ( TInt index = 0; index < fieldCount; index++ )
        {
        itemField = fieldArray.At( index );

        if ( itemField.FieldInfo().IsPhoneNumberField() && 
             ( iOperatorVariant == MusSettingsKeys::EOperatorSpecific ||
               itemField.Text().Left(1) == KMusAvaPlus() ) )
            {
            MUS_LOG( "mus: [MUSAVA]     Contact id found" )
            // No, it doesn't, so add the prefix to the new address.
            MUS_LOG( "mus: [MUSAVA]     Prefix to the new address is added" )
            tmpDescriptor = HBufC::NewLC( KMusAvaTel().Length() +
                                          itemField.Text().Length() );
            tmpDescriptor->Des().Append( KMusAvaTel() );
            tmpDescriptor->Des().Append( itemField.Text() );
            aContactsArray->AppendL( *tmpDescriptor );
            CleanupStack::PopAndDestroy( tmpDescriptor );
            returnValue = ETrue;
            }
        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaContactAvailability::\
        ResolvePhoneContactL()" )
    return returnValue;
    }


MMusAvaObserver::TAvailabilityName CMusAvaContactAvailability::Name()
    {
    return MMusAvaObserver::EMusAvaNameContactStatus;
    }


// -------------------------------------------------------------------------
// Checks that whether aDesItem present in aDesArray.
// Utility function used to avoid dublication.
// -------------------------------------------------------------------------
//
TBool CMusAvaContactAvailability::IsExistAlready(const MDesCArray& aDesArray,
                                          const TDesC& aDesItem)                                              
    {    
    for ( TInt i=0;i<aDesArray.MdcaCount();i++)
        {
        if (! aDesArray.MdcaPoint(i).Compare( aDesItem ) ) 
            {
            return ETrue;            
            }
        }
    return EFalse;
    }
