/*

* Copyright (c) 2009-2010 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:  Implementation of the VmbxUtilities class

*

*/

// INCLUDE FILES

#include <featmgr.h>

#include "vmbxlogger.h"

#include "vmbxcenrephandler.h"

#include "vmbxemergencycall.h"

#include "vmbxutilities.h"

#include "voicemailboxdefsinternal.h"

// CONSTANTS

const TInt KVmbxPhoneNumMinLength = 2;

const TInt KVmbxPhoneNumMaxLength = 40;

_LIT( KAllowedTelNumChars, "0123456789" );

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

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

// VmbxUtilities::IsValidPhoneNumber

// Validates phone number

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

//

TBool VmbxUtilities::IsValidPhoneNumber( const TDesC& aNumber )

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::IsValidPhoneNumber: =>" );

    TBool result( EFalse );

    if ( KVmbxPhoneNumMinLength < aNumber.Length() 

        && KVmbxPhoneCharMaxLength >= aNumber.Length() )

        {

        VMBLOGSTRING2( "VMBX: VmbxUtilities::IsValidPhoneNumber: aNumber %S",

        &aNumber );

        TLex lexer( aNumber );

        lexer.SkipSpace();

        TChar current = lexer.Peek();

        // If no SS code then consider this is valid and return true.    

        if ( '*' == current )

            {

            // check whether accord ss regulation,

            lexer.Inc(); // Skip first *

            }

    result = ValidateTelNum( lexer );

    // If zero length then consider as valid and return value of 

    // result, If not the end of the string, check if it's DTMF numbers

    if ( !lexer.Eos() && result )

        {

        result = ValdateDtmfPart( lexer );

        }

    }

    VMBLOGSTRING2( "VMBX: VmbxUtilities::IsValidPhoneNumber: result = %d<=",

        result );

    return result;

    }

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

// VmbxUtilities::AlsLine

// 

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

//

TVmbxAlsLineType VmbxUtilities::AlsLine()

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::AlsLine: =>" );

    TInt ssLine( ESSSettingsAlsNotSupported );

    TVmbxAlsLineType alsLine( EVmbxAlsLineDefault );

    RSSSettings ssSettings;

    TInt res = ssSettings.Open();

    if( KErrNone == res )

        {

        res = ssSettings.Get( ESSSettingsAls, ssLine );

        if( KErrNone == res )

            {

            if ( ESSSettingsAlsAlternate == ssLine )

                 {

                 alsLine = EVmbxAlsLine2;

                 }

            else if ( ESSSettingsAlsPrimary == ssLine )

                {

                 alsLine = EVmbxAlsLine1;

                }

            }

        }

    ssSettings.Close();

    VMBLOGSTRING2( "VMBX: VmbxUtilities::AlsLine: alsLine=%I <=",

       alsLine );

    return alsLine;

    }

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

// CVmbxUiUtilities::VideoSupported

// 

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

//

TBool VmbxUtilities::VideoSupported()

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::VideoSupported: =>" );

    TBool result( EFalse );

    if ( FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) )

        {

        CVmbxCenRepHandler* cenRepHandler( NULL );

        // TRAP_IGNORE for no leave function

        TRAP_IGNORE( cenRepHandler = CVmbxCenRepHandler::NewL() );

        if ( cenRepHandler )

            {

            result = cenRepHandler->VideoSupported();

            }

        delete cenRepHandler;

        cenRepHandler = NULL;

        }

    VMBLOGSTRING2( "VMBX: VmbxUtilities::VideoSupported: %d <=", result );

    return result;

    }

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

// VmbxUtilities::IsEmergencyNumber

// Verifies if the given number is an emergency number

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

//

TBool VmbxUtilities::IsEmergencyNumber( const TDesC& aNumber )

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::IsEmergencyNumber: =>" );

    TBool result( EFalse );

    CVmbxEmergencyCall* emergencyCall( NULL );

    // TRAP_IGNORE for no leave function

    TRAP_IGNORE( emergencyCall = CVmbxEmergencyCall::NewL() );

    if ( emergencyCall )

        {

        result = emergencyCall->IsEmergencyNumber( aNumber );

        }

    delete emergencyCall;

    emergencyCall = NULL;

    VMBLOGSTRING2( "VMBX: VmbxUtilities::IsEmergencyNumber: result%d <=", 

            result);

    return result;

    }

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

// CVmbxUiUtilities::VoIPSupported

// 

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

//

TBool VmbxUtilities::VoIPSupported()

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::VoIPSupported: <=>" );

    return FeatureManager::FeatureSupported( KFeatureIdCommonVoip );

    }

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

// VmbxUtilities::ValidateTelNum

// Parses string until end or invalid tel number character is found.

// Check number length.

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

//  

TBool VmbxUtilities::ValidateTelNum( TLex& aLexer ) 

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::ValidateTelNum: =>" );

    TBool result( ETrue );

    // Skip country code prefix '+'

    if ( '+' == aLexer.Peek() )

        {

        aLexer.Inc(); // Skip country code separator

        }

    TInt telNumDigits( 0 );

    TBool invalidCharFound( EFalse );

    // Parse until invalid telnumber char found

    while ( !aLexer.Eos() && !invalidCharFound )

        {

        const TChar nextChar = aLexer.Peek();

        // Check validSS chars

        if ( KErrNotFound == KAllowedTelNumChars().Locate( nextChar ) )

            {

            // Invalid char found so string before it is the tel number part

            invalidCharFound = ETrue;

            }

        else

            {

            aLexer.Inc();

            telNumDigits++;

            }

        }

    VMBLOGSTRING2( "VMBX: VmbxUtilities::ValidateTelNum:\

        telNumDigits %d", telNumDigits );

    // digitlength <3 or digit length>40, invalid telnumber

    if ( KVmbxPhoneNumMinLength >= telNumDigits 

        || KVmbxPhoneNumMaxLength < telNumDigits 

        )

        {

        result = EFalse;

        }

    VMBLOGSTRING2( "VMBX: VmbxUtilities::ValidateTelNum:\

         result %d<=", result );

    return result;

    }

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

// VmbxUtilities::ValdateDtmfPart

// Parse string until end and validate for allowed characters.

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

//       

TBool VmbxUtilities::ValdateDtmfPart( TLex& aLexer )

    {

    VMBLOGSTRING( "VMBX: VmbxUtilities::ValdateDtmfPart: =>" );

    // DTMF string consists of following three parts:

    // the first part of the string is a phone number,

    // the second part of the string a DTMF special character (p, w or +),

    // the last third part is an actual DTMF tone string, which is sent to the

    // remote end.

    TBool result( EFalse );

    // check the second part of the string

    const TChar nextChar = aLexer.Peek();

    // Check DTMF number discover or not

    if ( 'p' == nextChar || 'P' == nextChar 

        || 'w'== nextChar || 'W' == nextChar || '+' == nextChar )

        {

        // After DTMF char, is tone string, there is no specfic rule about tone string,

        // so just do a simple check.

        result = ETrue;

        VMBLOGSTRING( "VMBX: VmbxUtilities::ValdateDtmfPart DtmfNumberDiscover" );

        }

    VMBLOGSTRING2( "VMBX: VmbxUtilities::ValdateDtmfPart: result = %d<=",

        result );

    return result;

    }

// End of file