/*+
−
* Copyright (c) 2004-2006 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:  Utils for IM modules.+
−
*+
−
*/+
−
+
−
+
−
#include "CAUtils.h"+
−
#include "CCAStorageManagerFactory.h"+
−
#include "MCAStoredContacts.h"+
−
#include "ChatDebugPrint.h"+
−
#include "impsbuilddefinitions.h"+
−
+
−
#include <EscapeUtils.h>+
−
#include <collate.h>+
−
+
−
// needed to skip prefixes in domain-neutral comparison (TUint version)+
−
const TUint KColonUInt( ':' );+
−
+
−
// needed to skip domains in domain-neutral comparison (TUint version)+
−
const TUint KAtUInt( '@' );+
−
// general colon needed in various places+
−
_LIT( KColon, ":" );+
−
+
−
// general slash needed in various places+
−
_LIT( KSlash, "/" );+
−
+
−
// needed to skip domains in domain-neutral comparison+
−
_LIT( KAt, "@" );+
−
+
−
// "test character identity and accents, ignore case"+
−
const TInt KCollationLevel = 1;+
−
+
−
// max number to store any values+
−
const TInt KMAX_NUMBER = 12;+
−
+
−
// max number to fit+
−
const TInt KMAX_LIMIT = 255;+
−
+
−
// max number base+
−
const TInt KMAX_NUMBERBASE = 10;+
−
+
−
// some character value constants+
−
//const TUint K7LSBMask       = 0x7f     // bitmask for 7 lsb bits+
−
const TUint K8BitMask       = 0xff;     // full bitmask+
−
//const TUint KCharCodeZero   = 0x30     // '0'+
−
//const TUint KCharCodeSmallZ = 0x7a     // 'z'+
−
//const TUint KCharCodeSpace  = 0x20     // ' '+
−
const TUint KCharToArea     = 0x030;+
−
+
−
// Unused areas (2) in ISO 8859-1 specification+
−
//const TUint KUnused8859start1 = 0x00+
−
const TUint KUnused8859end1 = 0x1F;+
−
const TUint KUnused8859start2 = 0x7F;+
−
const TUint KUnused8859end2 = 0x9F;+
−
+
−
// forbidden characters that cannot appear in Wireless Village Ids+
−
_LIT( KWVForbiddenCharacters, "/@+ \t:" );+
−
+
−
/**+
−
 * Constants to use in validation.+
−
 *+
−
 */+
−
_LIT( KCUImpsId_WhiteSpace, " " );+
−
_LIT( KCUImpsId_At, "@" );+
−
_LIT( KCUImpsId_Dot, "." );+
−
_LIT( KCUImpsId_TwoDots, ".." );+
−
_LIT( KCUImpsId_Slash, "/" );+
−
_LIT( KCUImpsId_Plus, "+" );+
−
_LIT( KCUImpsId_Tabulator, "\t" );+
−
_LIT( KCUImpsId_WVPrefix, "wv:" );+
−
+
−
_LIT( KCUImpsId_AtEnc, "%40" );+
−
_LIT( KCUImpsId_SlashEnc, "%2F" );+
−
_LIT( KCUImpsId_PlusEnc, "%2B" );+
−
_LIT( KCUImpsId_TabulatorEnc, "%09" );+
−
_LIT( KCUImpsId_WhiteSpaceEnc, "%20" );+
−
+
−
// length of "wv:" prefix+
−
const TInt KCUImpsId_WVPrefixLength = 3;+
−
+
−
// maximum length of user id+
−
const TInt KServerWVUserIdMaxLength = 50;+
−
+
−
// defines how far we are going to search for the protocol part in user id+
−
const TInt KMaxLengthSearchProtPart = 4;+
−
+
−
// maximum numerical value to append to generated WVID.+
−
const TInt KMaxAppendNumber = 9999;+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::NeutralCompare+
−
// -----------------------------------------------------------------------------+
−
//+
−
TInt CAUtils::NeutralCompare( const TDesC& aId1,+
−
                              const TDesC& aId2, TBool aDomainNeutral )+
−
    {+
−
    // points to user part of id+
−
    TPtrC ptrId1( aId1 );+
−
    TPtrC ptrId2( aId2 );+
−
+
−
    // Reduce looking for protocol part only to beginning of the WVID and+
−
    // skip protocol part ("anything:") in the beginning of the WVID+
−
    TInt colonPos1 = aId1.Left( KMaxLengthSearchProtPart ).Locate( KColonUInt );+
−
+
−
    // first id+
−
    if ( ( KErrNotFound != colonPos1 ) && ( aId1.Length() - 1 != colonPos1 ) )+
−
        {+
−
        // contains ":", and it is not the last char+
−
        ptrId1.Set( aId1.Mid( colonPos1 + 1 ) );+
−
        }+
−
+
−
    TInt colonPos2 = aId2.Left( KMaxLengthSearchProtPart ).Locate( KColonUInt );+
−
+
−
    // second id+
−
    if ( ( KErrNotFound != colonPos2 ) && ( aId2.Length() - 1 != colonPos2 ) )+
−
        {+
−
        // contains ":", and it is not the last char+
−
        ptrId2.Set( aId2.Mid( colonPos2 + 1 ) );+
−
        }+
−
+
−
    // find out if we have domains in the ids+
−
    TInt domainPos1( ptrId1.Locate( KAtUInt ) );+
−
    TInt domainPos2( ptrId2.Locate( KAtUInt ) );+
−
+
−
    TBool domainIn1( KErrNotFound != domainPos1 );+
−
    TBool domainIn2( KErrNotFound != domainPos2 );+
−
+
−
    // points to domains in the neutral id+
−
    TPtrC ptrDom1( KNullDesC );+
−
    TPtrC ptrDom2( KNullDesC );+
−
+
−
    // points to user parts in the neutral id+
−
    TPtrC ptrUid1( ptrId1 );+
−
    TPtrC ptrUid2( ptrId2 );+
−
+
−
    // separate user id parts and domain parts+
−
    if ( domainIn1 )+
−
        {+
−
        ptrDom1.Set( ptrId1.Mid( domainPos1 + 1 ) );+
−
        ptrUid1.Set( ptrId1.Mid( 0, domainPos1 ) );+
−
        }+
−
+
−
    if ( domainIn2 )+
−
        {+
−
        ptrDom2.Set( ptrId2.Mid( domainPos2 + 1 ) );+
−
        ptrUid2.Set( ptrId2.Mid( 0, domainPos2 ) );+
−
        }+
−
+
−
    // Create custom collation method to ignore punctuations+
−
    // index 0 gets the default method+
−
    TCollationMethod collation =+
−
        *Mem::CollationMethodByIndex( 0 );+
−
    collation.iFlags |= TCollationMethod::EIgnoreNone;+
−
+
−
    // domains are compared only when it is really needed+
−
    // check if userid part is the same in both ids+
−
    TInt idResult = ptrUid1.CompareC( ptrUid2, KCollationLevel, &collation );+
−
+
−
    if ( idResult != 0 )+
−
        {+
−
        return idResult;+
−
        }+
−
+
−
    // id part is same, we have to compare domain+
−
+
−
    // If domain comparison is neutral and one id is without domain+
−
    // -> Domains are same. Other situation domainResult stays valid.+
−
    if ( aDomainNeutral && ( domainIn1 ^ domainIn2 ) )+
−
        {+
−
        return 0;+
−
        }+
−
    else+
−
        {+
−
        return ptrDom1.CompareC( ptrDom2, KCollationLevel, &collation );+
−
        }+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::DisplayId+
−
// -----------------------------------------------------------------------------+
−
//+
−
TPtrC CAUtils::DisplayId( const TDesC& aId, TBool aListHiding )+
−
    {+
−
    TPtrC ret( aId );+
−
+
−
    MCAStoredContacts* contacts = NULL;+
−
    TRAPD( err, contacts = CCAStorageManagerFactory::ContactListInterfaceL() );+
−
    if ( err != KErrNone || !contacts )+
−
        {+
−
        // some error, don't modify+
−
        CHAT_DP_FUNC_DP( "DisplayId", "Got some error, not hiding" );+
−
        return ret;+
−
        }+
−
+
−
    // if we've branded the feature out, don't modify anything+
−
    // UI CR : 101-39728:  Check for prefix hiding or Wv hiding.+
−
    if ( contacts->WVHiding() || contacts->WVHidingPrefixOnly() )+
−
        {+
−
        // locate ":" for userid, groupid.+
−
        // locate "/" for list id.+
−
        TInt pos = aId.FindC( aListHiding ? KSlash : KColon );+
−
+
−
        if ( ( pos != KErrNotFound ) && ( pos != aId.Length() - 1 ) )+
−
            {+
−
            // contains the special character, and it is not the last char+
−
            // remove everything before the special char (including the char)+
−
            ret.Set( aId.Mid( pos + 1 ) );+
−
            }+
−
        if ( contacts->WVHiding() || aListHiding )+
−
            {+
−
            // remove also the domain part+
−
            TInt domainPos = ret.FindC( KAt );+
−
            if ( ( domainPos != KErrNotFound ) && ( domainPos != 0 ) )+
−
                {+
−
                ret.Set( ret.Mid( 0, domainPos ) );+
−
                }+
−
+
−
            }+
−
        }+
−
+
−
    return ret;+
−
    }+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::GenerateIdLC+
−
// -----------------------------------------------------------------------------+
−
//+
−
HBufC* CAUtils::GenerateIdLC( const TDesC& aId, TInt aNum )+
−
    {+
−
    // copy ID+
−
    HBufC* result = HBufC::NewLC( KServerWVUserIdMaxLength );+
−
    TPtr resultPtr( result->Des() );+
−
    resultPtr.Copy( aId );+
−
+
−
    TInt len( resultPtr.Length() );+
−
+
−
    // Start from end of data+
−
    for ( TInt i( len - 1 ); i >= 0; --i )+
−
        {+
−
        // Do quick and dirty UNICODE to ISO-8859-1 conversion+
−
        // and modify all non-ISO-8859-1 characters+
−
        // to be in valid ranges+
−
        const TInt& currentChar = resultPtr[ i ];+
−
        TUint ch = currentChar & K8BitMask;+
−
+
−
        // is ch in first unused area+
−
        if ( ch <= KUnused8859end1 )+
−
            {+
−
            ch += KUnused8859end1 + 1;+
−
            }+
−
+
−
        // is ch in second unused area+
−
        if ( ch >= KUnused8859start2 && ch <= KUnused8859end2 )+
−
            {+
−
            TInt difference = ch - KUnused8859start2;+
−
            ch = KUnused8859end2 + difference + 1;+
−
            }+
−
+
−
        TChar isoFixedChar = TChar( ch );+
−
        // put it into the string+
−
        HBufC* isoFixed = HBufC::NewLC( 1 );+
−
        isoFixed->Des().Append( isoFixedChar );+
−
+
−
        resultPtr.Replace( i, 1, *isoFixed );+
−
        CleanupStack::PopAndDestroy( isoFixed );+
−
+
−
        // now all the specials get removed+
−
        TPtrC c = resultPtr.Mid( i, 1 );  // next character+
−
        TInt position = KWVForbiddenCharacters().FindF( c );+
−
+
−
        if ( position != KErrNotFound )+
−
            {+
−
            // the current character is a FORBIDDEN CHARACTER,+
−
            // remove it+
−
            resultPtr.Delete( i, 1 );+
−
            }+
−
        }+
−
+
−
    CHAT_DP( D_CHAT_LIT( "CAUtils::GenerateIdLC conversion '%S' -> '%S'" ), &aId, &resultPtr );+
−
+
−
    // "Append" number+
−
    if ( aNum > 0 && aNum <= KMaxAppendNumber )+
−
        {+
−
        TBuf<KMAX_NUMBER> number; // 12, enough space to store a very large number+
−
        number.AppendNum( aNum );+
−
+
−
        TInt numLength = number.Length();+
−
        TInt resultLength = resultPtr.Length();+
−
        if ( numLength + resultLength > KServerWVUserIdMaxLength )+
−
            {+
−
            // can't append directly because we would exceed the space.+
−
            // use replace instead+
−
            TInt usableSpace = KServerWVUserIdMaxLength - resultLength;+
−
            TInt startPos = resultLength - numLength + usableSpace;+
−
            TInt replaceAmount = numLength - usableSpace;+
−
+
−
            resultPtr.Replace( startPos, replaceAmount, number );+
−
            }+
−
        else+
−
            {+
−
            // enough space in the end, just append+
−
            resultPtr.AppendNum( aNum );+
−
            }+
−
        }+
−
+
−
    CHAT_DP( D_CHAT_LIT( "CAUtils::GenerateIdLC returning '%S'" ), &resultPtr );+
−
    return result;+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
//  CAUtils::ExternalizeBufferToStreamL+
−
//  Helper method for externalize the buffer+
−
// -----------------------------------------------------------------------------+
−
//+
−
void CAUtils::ExternalizeBufferToStreamL( const TDesC& aBuffer, RWriteStream& aStream )+
−
    {+
−
    aStream.WriteInt32L( aBuffer.Length() );+
−
    aStream.WriteL( aBuffer );+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
//  CAUtils::ExternalizeBufferToStreamL+
−
//  Helper method for externalize the buffer+
−
// -----------------------------------------------------------------------------+
−
//+
−
void CAUtils::ExternalizeBufferToStreamL( const TDesC8& aBuffer, RWriteStream& aStream )+
−
    {+
−
    aStream.WriteInt32L( aBuffer.Length() );+
−
    aStream.WriteL( aBuffer );+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::InternalizeBufferFromStreamL+
−
// Helper method for internalize the buffer+
−
// -----------------------------------------------------------------------------+
−
//+
−
HBufC* CAUtils::InternalizeBufferFromStreamLC( RReadStream& aStream )+
−
    {+
−
    HBufC* buffer = NULL;+
−
+
−
    TInt length = aStream.ReadInt32L();+
−
+
−
    if ( length == 0 )+
−
        {+
−
        buffer = KNullDesC().AllocLC();+
−
        }+
−
    else+
−
        {+
−
        buffer = HBufC::NewLC( length );+
−
        TPtr ptr( buffer->Des() );+
−
        aStream.ReadL( ptr, length );+
−
        }+
−
+
−
    return buffer;+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::InternalizeBufferFromStreamL+
−
// Helper method for internalize the buffer+
−
// -----------------------------------------------------------------------------+
−
//+
−
HBufC8* CAUtils::InternalizeBuffer8FromStreamLC( RReadStream& aStream )+
−
    {+
−
    HBufC8* buffer = NULL;+
−
+
−
    TInt length = aStream.ReadInt32L();+
−
+
−
    if ( length == 0 )+
−
        {+
−
        buffer = KNullDesC8().AllocLC();+
−
        }+
−
    else+
−
        {+
−
        buffer = HBufC8::NewLC( length );+
−
        TPtr8 ptr( buffer->Des() );+
−
        aStream.ReadL( ptr, length );+
−
        }+
−
+
−
    return buffer;+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::InternalizeBufferFromStreamL+
−
// Helper method for internalize the buffer+
−
// -----------------------------------------------------------------------------+
−
//+
−
HBufC* CAUtils::InternalizeBufferFromStreamL( RReadStream& aStream )+
−
    {+
−
    HBufC* buffer = InternalizeBufferFromStreamLC( aStream );+
−
    CleanupStack::Pop( buffer );+
−
    return buffer;+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::InternalizeBufferFromStreamL+
−
// Helper method for internalize the buffer+
−
// -----------------------------------------------------------------------------+
−
//+
−
HBufC8* CAUtils::InternalizeBuffer8FromStreamL( RReadStream& aStream )+
−
    {+
−
    HBufC8* buffer = InternalizeBuffer8FromStreamLC( aStream );+
−
    CleanupStack::Pop( buffer );+
−
    return buffer;+
−
    }+
−
+
−
// -----------------------------------------------------------------------------+
−
// CAUtils::ValidLoginIdL()+
−
// -----------------------------------------------------------------------------+
−
//+
−
TBool CAUtils::ValidLoginIdL( const TDesC& aPresenceId )+
−
    {+
−
    TBool incorrectDomain ( EFalse );+
−
    TBool forbiddenChars ( EFalse );+
−
    TBool incorrectUserPart ( EFalse );+
−
+
−
    HBufC* wvId = aPresenceId.AllocLC();+
−
    TPtr wvIdPtr = wvId->Des();+
−
+
−
    TInt maxLength ( KServerWVUserIdMaxLength );+
−
+
−
    // let's take out the "wv:" from beginning of user id+
−
    TInt position( KErrNotFound );+
−
    if ( KCUImpsId_WVPrefix().CompareF( wvId->Left( KCUImpsId_WVPrefix().Length() ) ) == 0 )+
−
        {+
−
        wvIdPtr.Delete( 0, KCUImpsId_WVPrefix().Length() );+
−
        position = KErrNotFound;+
−
        // we just took out 3 characters from the id, we have to adjust the max length+
−
        maxLength = maxLength - KCUImpsId_WVPrefixLength;+
−
        }+
−
+
−
    // where is "@" ?+
−
    TInt atIndex( wvId->Find( KCUImpsId_At ) );+
−
    // we want the domain part without the '@'+
−
    TPtrC domainPart( wvId->Mid( atIndex + 1 ) );+
−
+
−
    if ( atIndex > 0 )+
−
        {+
−
        // check if the domain part is empty+
−
        if ( domainPart.Length() == 0 )+
−
            {+
−
            incorrectDomain = ETrue;+
−
            }+
−
        }+
−
    else if ( atIndex == 0 )+
−
        {+
−
        // the '@' is the first character+
−
        incorrectUserPart = ETrue;+
−
        }+
−
+
−
    TInt returnValue = domainPart.Find( KCUImpsId_At() );+
−
    // check the correctness of the domain part+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        // extra @-mark found in the domain part+
−
        incorrectDomain = ETrue;+
−
        }+
−
+
−
    returnValue = domainPart.Find( KCUImpsId_Dot() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        // the part after the '.'+
−
        TPtrC partAfterDot ( domainPart.Mid( returnValue + 1 ) );+
−
        // the part before the '.'+
−
        TPtrC partBeforeDot ( domainPart.Left( returnValue ) );+
−
        // if the '.' is the last character or the first character after the '@'+
−
        // the domain part is wrong+
−
        if ( ( 0 == partAfterDot.Length() ) || ( 0 == partBeforeDot.Length() ) )+
−
            {+
−
            // the '.' is the last character+
−
            incorrectDomain = ETrue;+
−
            }+
−
        }+
−
+
−
    returnValue = domainPart.Find( KCUImpsId_TwoDots() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        // there are two sequential dots in the domain part+
−
        incorrectDomain = ETrue;+
−
        }+
−
+
−
+
−
    // check the wvid for forbidden chars+
−
+
−
    // first we must delete one '@' char if existing+
−
    position = wvIdPtr.Find( KCUImpsId_At );+
−
    if ( position != KErrNotFound )+
−
        {+
−
        wvIdPtr.Delete( position, KCUImpsId_At().Length() );+
−
        }+
−
+
−
    returnValue = wvIdPtr.Find( KCUImpsId_WhiteSpace() );+
−
    // no empty chars allowed in the user part+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
    // no encoded empty chars allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_WhiteSpaceEnc() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
+
−
    // no '+' allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_Plus() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
    // no encoded '+' allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_PlusEnc() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
+
−
+
−
    // no '\t' allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_Tabulator() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
    // no encoded tabulator allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_TabulatorEnc() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
+
−
    // no '/' allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_Slash() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
    // no encoded '/' allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_SlashEnc() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
+
−
    // no encoded '@' chars allowed in the user part+
−
    returnValue = wvIdPtr.Find( KCUImpsId_AtEnc() );+
−
    if ( returnValue != KErrNotFound )+
−
        {+
−
        forbiddenChars = ETrue;+
−
        }+
−
+
−
    TPtr userId = wvId->Des();+
−
+
−
    // no 16bit Unicode chars characters allowed in the user part+
−
    for ( TInt index = 0; index < wvIdPtr.Length(); index++ )+
−
        {+
−
        TUint value = userId[index];+
−
        // if the character does not fit into 8 bits, it's forbidden 255+
−
        if ( value > KMAX_LIMIT )+
−
            {+
−
            forbiddenChars = ETrue;+
−
            }+
−
        }+
−
+
−
    TBool tooLongId ( EFalse );+
−
+
−
    // check if the user id is too long when encoded, but only if there are no forbidden chars+
−
    if ( !forbiddenChars )+
−
        {+
−
        HBufC* encodedUserId = EscapeUtils::EscapeEncodeL( *wvId, EscapeUtils::EEscapeUrlEncoded );+
−
+
−
        if ( atIndex != KErrNotFound )+
−
            {+
−
            // @-character was removed from the ID, since it should not be encoded+
−
            // so the maxlength has to be decreased by it's length+
−
            maxLength = maxLength - KCUImpsId_At().Length();+
−
            }+
−
+
−
        if ( encodedUserId->Length() > maxLength )+
−
            {+
−
            tooLongId = ETrue;+
−
            }+
−
        delete encodedUserId;+
−
        }+
−
+
−
    CleanupStack::PopAndDestroy( wvId );+
−
+
−
    if ( forbiddenChars )+
−
        {+
−
        return EFalse;+
−
        }+
−
    else if ( incorrectDomain )+
−
        {+
−
        return EFalse;+
−
        }+
−
    else if ( tooLongId )+
−
        {+
−
        return EFalse;+
−
        }+
−
    else if ( incorrectUserPart )+
−
        {+
−
        return EFalse;+
−
        }+
−
+
−
    return ETrue;+
−
    }+
−
+
−
+
−
// ---------------------------------------------------------+
−
// CAUtils::ReconstructIdL+
−
// (other items were commented in a header).+
−
// ---------------------------------------------------------+
−
//+
−
HBufC* CAUtils::ReconstructIdL( const TDesC& aOrigId, const TDesC& aUserId )+
−
    {+
−
    CHAT_DP( D_CHAT_LIT( "** ReconstructIdL, the original  id: %S" ), &aOrigId );+
−
    CHAT_DP( D_CHAT_LIT( "** ReconstructIdL, user entered  id: %S" ), &aUserId );+
−
+
−
    // we got user id, add the removed parts ("wv:" and "@something" )+
−
    TInt colonPos( aOrigId.Locate( KColonUInt ) );+
−
    TInt domainPos( aOrigId.Locate( KAtUInt ) );+
−
    TInt userColonPos( aUserId.Locate( KColonUInt ) );+
−
    TInt userDomainPos( aUserId.Locate( KAtUInt ) );+
−
+
−
    // calculate the new length and determine what additions are needed+
−
    TInt newLength( aUserId.Length() );+
−
    TBool addPrefix( EFalse );+
−
    TBool addDomain( EFalse );+
−
+
−
    if ( colonPos != KErrNotFound &&+
−
         ( colonPos + 1 ) != aOrigId.Length() &&+
−
         userColonPos == KErrNotFound )+
−
        {+
−
        // the original id had ":" (not last character) and the current one doesn't+
−
        // => we'll be adding "wv:"+
−
        newLength += colonPos + 1;+
−
        addPrefix = ETrue;+
−
        }+
−
+
−
    if ( domainPos != KErrNotFound && userDomainPos == KErrNotFound )+
−
        {+
−
        // the original id had domain and the current one doesn't+
−
        // => we'll be adding "@something"+
−
        newLength += aOrigId.Length() - domainPos;+
−
        addDomain = ETrue;+
−
        }+
−
+
−
    HBufC* newId = HBufC::NewL( newLength );+
−
    // NOTE: NO LEAVING METHODS ALLOWED AFTER THIS!+
−
+
−
    TPtr newIdPtr( newId->Des() );+
−
    newIdPtr.Zero();+
−
+
−
    if ( addPrefix )+
−
        {+
−
        // add removed "wv:" prefix+
−
        newIdPtr.Append( aOrigId.Left( colonPos + 1 ) );+
−
        }+
−
    newIdPtr.Append( aUserId );+
−
    if ( addDomain )+
−
        {+
−
        // add removed domain part+
−
        newIdPtr.Append( aOrigId.Right( aOrigId.Length() - domainPos ) );+
−
        }+
−
+
−
    CHAT_DP( D_CHAT_LIT( "** ReconstructIdL, reconstructed id: %S" ), &newIdPtr );+
−
    return newId;+
−
    }+
−
+
−
// ---------------------------------------------------------+
−
// CAUtils::NeutralFind+
−
// ---------------------------------------------------------+
−
//+
−
TInt CAUtils::NeutralFind( const MDesCArray& aUserList, const TDesC& aUserId )+
−
    {+
−
    TInt count( aUserList.MdcaCount() );+
−
    for ( TInt i( 0 ); i < count; ++i )+
−
        {+
−
        if ( CAUtils::NeutralCompare( aUserList.MdcaPoint( i ),+
−
                                      aUserId ) == 0 )+
−
            {+
−
            return i;+
−
            }+
−
        }+
−
    return KErrNotFound;+
−
    }+
−
+
−
// ---------------------------------------------------------+
−
// Static helper method used in+
−
// LanguageSpecificNumberConversion.+
−
// ---------------------------------------------------------+
−
//+
−
static TChar NumberToBase( TChar ch )+
−
    {+
−
    TDigitType d[] = { EDigitTypeWestern,+
−
                       EDigitTypeArabicIndic,+
−
                       EDigitTypeEasternArabicIndic,+
−
                       EDigitTypeDevanagari,+
−
                       EDigitTypeThai+
−
                     };+
−
    TInt i = 0;+
−
    TInt num = sizeof( d ) / sizeof( d[0] );+
−
    // code scanner warning can be ignored+
−
    while ( i < num )+
−
        {+
−
        if ( ch > TChar( d[i] ) && ch < TChar( d[i] + KMAX_NUMBERBASE ) )+
−
            {+
−
            return d[i];+
−
            }+
−
        i++;+
−
        }+
−
+
−
    return ch;+
−
    }+
−
+
−
// ---------------------------------------------------------+
−
// CAUtils::LanguageSpecificNumberConversion+
−
// ---------------------------------------------------------+
−
//+
−
void CAUtils::LanguageSpecificNumberConversion( TDes& aDes )+
−
    {+
−
    // Get current locale and digit type+
−
    TLocale locale;+
−
    locale.Refresh();+
−
    TDigitType digitType = locale.DigitType();+
−
+
−
    // Check if conversion is needed+
−
    TBool conversion = ( digitType == EDigitTypeArabicIndic )+
−
                       || ( digitType == EDigitTypeEasternArabicIndic )+
−
                       || ( digitType == EDigitTypeDevanagari );+
−
+
−
    if ( !conversion )+
−
        {+
−
        // Don't do anything+
−
        return;+
−
        }+
−
+
−
    // Do conversion, logic for this conversion+
−
    // comes from AknTextUtils::LanguageSpecificNumberConversion.+
−
    // Logic is copied here to avoid using Avkon in engine side.+
−
    TChar toArea = KCharToArea;+
−
+
−
    switch ( digitType )+
−
        {+
−
        case EDigitTypeWestern:+
−
        case EDigitTypeArabicIndic:+
−
        case EDigitTypeEasternArabicIndic:+
−
        case EDigitTypeDevanagari:+
−
        case EDigitTypeThai:    // Flowthrough+
−
            {+
−
            toArea = digitType;+
−
            break;+
−
            }+
−
        case EDigitTypeUnknown:+
−
        case EDigitTypeAllTypes:+
−
        default:    // Flowthrough+
−
            {+
−
            return;+
−
            }+
−
        }+
−
+
−
    TInt length = aDes.Length();+
−
+
−
    for ( TInt i = 0; i < length; i++ )+
−
        {+
−
        TChar ch = aDes[i];+
−
        TChar fromArea = NumberToBase( ch );+
−
        TChar::TBdCategory cat = ch.GetBdCategory();+
−
        switch ( cat )+
−
            {+
−
            case TChar::EArabicNumber:+
−
            case TChar::EEuropeanNumber:    // Flowthrough+
−
                {+
−
                ch += toArea;+
−
                ch -= fromArea;+
−
                aDes[i] = TUint16( ch );+
−
                break;+
−
                }+
−
            default:+
−
                {+
−
                break;+
−
                }+
−
            }+
−
        }+
−
    }+
−
// ---------------------------------------------------------+
−
// CAUtils::CapitalizeListNameL : UI CR :  101-39727+
−
// ---------------------------------------------------------+
−
//+
−
HBufC* CAUtils::CapitalizeListNameL( const TDesC& aListname )+
−
    {+
−
    MCAStoredContacts* contacts = NULL;+
−
    TRAPD( err, contacts = CCAStorageManagerFactory::ContactListInterfaceL() );+
−
+
−
    if ( err == KErrNone && contacts+
−
         && contacts->CapitalizingEnabled()+
−
         && ( aListname.Length() ) )+
−
        {+
−
        HBufC* capitalPartBuf = HBufC::NewL( KServerWVUserIdMaxLength );+
−
        TPtr capitalPartptr( capitalPartBuf->Des() );+
−
+
−
        if ( aListname.Length() == 1 )+
−
            {+
−
            capitalPartptr.CopyUC( aListname );+
−
            return capitalPartBuf;+
−
            }+
−
        capitalPartptr.CopyUC( aListname.Left( 1 ) );// copy and capitalize first letter+
−
        capitalPartptr.Append( aListname.Right( ( aListname.Length() - 1 ) ) );// append the remaining+
−
        return capitalPartBuf;+
−
        }+
−
+
−
    // some error, don't modify+
−
    CHAT_DP_FUNC_DP( "CapitalizeListNameL", "Got some error, not Capitalizing" );+
−
    HBufC* capitalPartBuf = aListname.AllocL();+
−
    return capitalPartBuf;+
−
    }+
−
+
−
+
−
// ---------------------------------------------------------+
−
// CAUtils::CapitalizingEnabled   UI CR : 101-39727+
−
// ---------------------------------------------------------+
−
//+
−
TBool CAUtils::CapitalizingEnabled()+
−
    {+
−
    MCAStoredContacts* contacts = NULL;+
−
    TRAPD( err, contacts = CCAStorageManagerFactory::ContactListInterfaceL() );+
−
    if ( err != KErrNone || !contacts )+
−
        {+
−
        // some error, return Efalse+
−
        return EFalse;+
−
        }+
−
    return ( contacts->CapitalizingEnabled() );+
−
    }+
−
+
−
+
−
// ---------------------------------------------------------+
−
// CAUtils::CapitalizeListNameL   UI CR : 101-39727+
−
// ---------------------------------------------------------+
−
//+
−
+
−
HBufC* CAUtils::CapitalizeListIdL( const TDesC& aId )+
−
    {+
−
    TPtrC ret( aId );+
−
    TBool slashfound( EFalse );+
−
    TBool domainfound( EFalse );+
−
    // locate "/" for list id.+
−
    TInt pos = aId.FindC( KSlash  );+
−
+
−
    if ( ( pos != KErrNotFound ) && ( pos != aId.Length() - 1 ) )+
−
        {+
−
        // make it true if slash found and it should not be at the last position+
−
        slashfound = ETrue;+
−
        }+
−
+
−
    // locate for the domain part+
−
+
−
    TInt domainPos = ret.FindC( KAt );+
−
    if ( ( domainPos != KErrNotFound ) && ( domainPos != 0 ) )+
−
        {+
−
        // make it true if domain part is found and itshould not be at the first position+
−
        domainfound = ETrue;+
−
        }+
−
+
−
    MCAStoredContacts* contacts = NULL;+
−
    TRAPD( err, contacts = CCAStorageManagerFactory::ContactListInterfaceL() );+
−
+
−
    if ( err == KErrNone && contacts                      // extrachecking here bcoz+
−
         && contacts->CapitalizingEnabled()// it has to return NULL+
−
         && aId.Length() )                 // (not the list id)+
−
        {                                                   // if error occurs+
−
        if ( slashfound && !domainfound )+
−
            {+
−
            //remove upto  '/' and capitalize+
−
            return  CAUtils::CapitalizeListNameL( aId.Right( ( aId.Length() - ( pos + 1 ) ) ) );+
−
            }+
−
        else  if ( slashfound && domainfound )+
−
            {+
−
            // remove upto  '/' and after domain part and capitalize+
−
            return CAUtils::CapitalizeListNameL( aId.Mid( pos + 1, ( domainPos - pos - 1 ) ) );+
−
            }+
−
        else+
−
            {+
−
            // if only domain part found or both part not found just capitalize listId+
−
            return CAUtils::CapitalizeListNameL( aId );+
−
            }+
−
+
−
        }+
−
+
−
    // some error,return null+
−
    return NULL;+
−
    }+
−
+
−
// End of file+
−