/*

* Copyright (c) 2002 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:  Principal parser for supplementary service procedures.

*

*/

// INCLUDE FILES

#include    <bldvariant.hrh>

#include    <featmgr.h>

#include    <nwdefs.h>

#include    "cphonegsmssparser.h" 

#include    "cphonegsmparserresult.h" 

#include    "phonegsmparser.h" 

#include    "cphonegsmoptioncontainer.h" 

#include    "cphoneparserfeatures.h" 

// CONSTANTS

// Granularity of service array

const TInt KPhoneServiceArrayGranularity = 20;

// Activation starts with *. See also registration.

_LIT( KPhoneSsActivation, "*" );

// Deactivation starts with #.

_LIT( KPhoneSsDeactivation, "#" );

// Interrogation starts with *#.

_LIT( KPhoneSsInterrogation, "*#" );

// Registration starts with ** OR *. Case * is handled in the code.

_LIT( KPhoneSsRegistration, "**" );

// Erasure starts with ##.

_LIT( KPhoneSsErasure, "##" );

// It defines characters that can be used in these prefixes (see above).

_LIT( KPhoneSsActionCharacters, "*#" );

// It defines string that ends all ss requests.

_LIT( KPhoneSsEnd, "#" );

// It defines characters that are considered to be digits.

_LIT( KPhoneSsDigits, "1234567890" );

// Asterisk.

const TInt KPhoneSsAsterisk = '*';

// Hash.

const TInt KPhoneSsHash = '#';

// Plus.

const TInt KPhoneSsPlus = '+';

// Remainder: single character

const TInt KPhoneSsRemainderSingle = 1;

// Remainder: still a parameter, but ok ss

const TInt KPhoneSsRemainderMinLength = 2; // something + #

const TInt KPhoneSsPasswordLength = 4; 

// Remainder: passwordk, ok ss

const TInt KPhoneSsRemainderPasswordMinLength = 5; // four digits + #

// Maximum length of directory number.

const TInt KPhoneSsDirectoryNumberMaxLength = 38;

// Maximum length of basic service code.

const TInt KPhoneSsBasicCodeMaxLength = 2;

// Maximum length of group code.

const TInt KPhoneSsGroupCodeMaxLength = 4;

// Maximum length of timer.

const TInt KPhoneSsTimerMaxLength = 2;

// The only acceptable group code (change of barring password)

const TUint KPhoneSsOnlyAllowedGroupCode = 330;

// Pack: shift

const TInt KPhoneGsmPackShift = 8;

// Pack: mask

const TInt KPhoneGsmPackMask = 255;

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

// Syntax:

//    

//      SC      Service code

//      A       Activation

//      D       Deactivation

//      I       Interrogation

//      R       Registration

//      E       Erasure

//

//     Text string must contain each of these in the following order

//     "SC A D I R E" (separated by space). Following values correspond

//      

//

//     0 - ENotAllowed       

//     1 - ENoParameters

//     2 - EEmptyOrBasicCode

//     3 - ENumberOptBasicCodeOptTimer

//     4 - ENumberOptBasicCode     

//     5 - EPasswordOptBasicCode

//     6 - EOptGroupCodePasswordNewPasswordNewPassword    

//     7 - EEmptyOrBasicCode2         

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

_LIT( KPhoneUidForwardingAllCode,                                   "002 2 2 0 3 2" );

_LIT( KPhoneUidForwardingAllConditionalCode,                        "004 2 2 0 3 2" );

_LIT( KPhoneUidForwardingUnconditionalCode,                         "21  2 2 2 4 2" );

_LIT( KPhoneUidForwardingNoReplyCode,                               "61  2 2 2 3 2" );

_LIT( KPhoneUidForwardingNotReachableCode,                          "62  2 2 2 4 2" );

_LIT( KPhoneUidForwardingBusyCode,                                  "67  2 2 2 4 2" );

_LIT( KPhoneUidBarringAllOutgoingCallsCode,                         "33  5 5 1 0 0" );

_LIT( KPhoneUidBarringAllIncomingCallsCode,                         "35  5 5 1 0 0" );

_LIT( KPhoneUidBarringAllServicesCode,                              "330 0 5 0 0 0" );

_LIT( KPhoneUidBarringAllOutgoingInternationalCallsCode,            "331 5 5 1 0 0" );

_LIT( KPhoneUidBarringAllOutgoingInternationalCallsExceptHomeCode,  "332 5 5 1 0 0" );

_LIT( KPhoneUidBarringAllOutgoingServicesCode,                      "333 0 5 0 0 0" );

_LIT( KPhoneUidBarringAllIncomingCallsWhenRoamingCode,              "351 5 5 1 0 0" );

_LIT( KPhoneUidBarringAllIncomingServicesCode,                      "353 0 5 0 0 0" );

_LIT( KPhoneUidWaitingCode,                                         "43  7 7 7 0 0" );

_LIT( KPhoneUidCallingLineIdentificationPresentationCode,           "30  0 0 1 0 0" );

_LIT( KPhoneUidCallingLineIdentificationRestrictionCode,            "31  0 0 1 0 0" );

_LIT( KPhoneUidConnectedLinePresentationCode,                       "76  0 0 1 0 0" );

_LIT( KPhoneUidConnectedLinePresentationRestrictionCode,            "77  0 0 1 0 0" ); 

_LIT( KPhoneUidPasswordCode,                                        "03  6 0 0 6 0" );

_LIT( KPhoneUidCallingNamePresentationCode,                         "300 0 0 1 0 0" );

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

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

// CPhoneGsmSsParser::CPhoneGsmSsParser

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

//

CPhoneGsmSsParser::CPhoneGsmSsParser()

    {

    }

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

// CPhoneGsmSsParser::ConstructL

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

//

void CPhoneGsmSsParser::ConstructL()

    {

    iArray = 

        new ( ELeave ) CServiceArray( 

            KPhoneServiceArrayGranularity );

    // Check AddL method for details what these really mean.

    // Forwarding

    AddL( KPhoneUidForwardingAllCode, 

        KPhoneUidForwardingAll );

    AddL( KPhoneUidForwardingAllConditionalCode, 

        KPhoneUidForwardingAllConditional );

    AddL( KPhoneUidForwardingUnconditionalCode, 

        KPhoneUidForwardingUnconditional );

    AddL( KPhoneUidForwardingNoReplyCode, 

        KPhoneUidForwardingNoReply );

    AddL( KPhoneUidForwardingNotReachableCode, 

        KPhoneUidForwardingNotReachable );

    AddL( KPhoneUidForwardingBusyCode, 

        KPhoneUidForwardingBusy );

    // Barring

    AddL( KPhoneUidBarringAllOutgoingCallsCode, 

        KPhoneUidBarringAllOutgoingCalls );

    AddL( KPhoneUidBarringAllIncomingCallsCode, 

        KPhoneUidBarringAllIncomingCalls );

    AddL( KPhoneUidBarringAllServicesCode, 

        KPhoneUidBarringAllServices );

    AddL( KPhoneUidBarringAllOutgoingInternationalCallsCode, 

        KPhoneUidBarringAllOutgoingInternationalCalls );

    AddL( KPhoneUidBarringAllOutgoingInternationalCallsExceptHomeCode, 

        KPhoneUidBarringAllOutgoingInternationalCallsExceptHome );

    AddL( KPhoneUidBarringAllOutgoingServicesCode, 

        KPhoneUidBarringAllOutgoingServices );

    AddL( KPhoneUidBarringAllIncomingCallsWhenRoamingCode, 

        KPhoneUidBarringAllIncomingCallsWhenRoaming );

    AddL( KPhoneUidBarringAllIncomingServicesCode, 

        KPhoneUidBarringAllIncomingServices );

    // Waiting

    AddL( KPhoneUidWaitingCode, 

        KPhoneUidWaiting );

    // Calling line identification presentation

    AddL( KPhoneUidCallingLineIdentificationPresentationCode, 

        KPhoneUidCallingLineIdentificationPresentation );

    // Calling line identification restriction

    AddL( KPhoneUidCallingLineIdentificationRestrictionCode, 

        KPhoneUidCallingLineIdentificationRestriction );

    // Connected line presentation

    AddL( KPhoneUidConnectedLinePresentationCode, 

        KPhoneUidConnectedLinePresentation );

    // Connected line presentation restriction.

    AddL( KPhoneUidConnectedLinePresentationRestrictionCode, 

        KPhoneUidConnectedLinePresentationRestriction );

    // CNAP.  

    if ( CPhoneParserFeatures::FeatureSupported( KFeatureIdPhoneCnap ) )

        {

        AddL( KPhoneUidCallingNamePresentationCode, 

            KPhoneUidCallingNamePresentation );

        }

    // Password

    AddL( KPhoneUidPasswordCode, 

        KPhoneUidPassword );

    }

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

// CPhoneGsmSsParser::NewLC

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

//

CPhoneGsmSsParser* CPhoneGsmSsParser::NewLC()

    {

    CPhoneGsmSsParser* self = new ( ELeave ) CPhoneGsmSsParser;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CPhoneGsmSsParser::~CPhoneGsmSsParser

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

//

CPhoneGsmSsParser::~CPhoneGsmSsParser()

    {

    delete iArray;

    }

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

// CPhoneGsmSsParser::ParseL

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

//

TBool CPhoneGsmSsParser::ParseL( 

        const TDesC& aString, 

        CPhoneGsmParserResult& aResult,

        CPhoneGsmOptionContainerBase& aOptions )

    {

    TBool result = EFalse;

    aResult.ClearL();      

// All operations require SEND.

// If VoIP call no action needed here.

    if ( !aOptions.FindOptionStatus( KPhoneOptionSend ) ||

         aOptions.FindOptionStatus( KPhoneOptionVoipCall ) )

        {

        return EFalse;

        }

    TLex input( aString );

    TPtrC action( 

        FindString( 

            input, 

            KPhoneSsActionCharacters() ) );

    // Check if action is proper for service requests.

    TServiceType type = EServiceActivation;

    // This variable will indicate if action was ok.

    TBool ok = ETrue;

    // Fill type.

    if ( action == KPhoneSsActivation )

        {

        type = EServiceActivation;

        }

    else if ( action == KPhoneSsDeactivation )

        {

        type = EServiceDeactivation;

        }

    else if ( action == KPhoneSsInterrogation )

        {

        type = EServiceInterrogation;

        }

    else if ( action == KPhoneSsRegistration )

        {

        type = EServiceRegistration;

        }

    else if ( action == KPhoneSsErasure )

        {

        type = EServiceErasure;

        }

    else 

        {

        // Not ok.

        ok = EFalse;

        }

    // Prefix must be one of the service types.

    if ( ok )

        {

        TPtrC serviceCode( FindString( input, KPhoneSsDigits() ) );

        // Check that service code is not too long.

        if ( serviceCode.Length() > KPhoneGsmSsServiceCodeMaxLength )

            {

            return EFalse;

            }

        TKeyArrayFix key( _FOFF( TServiceInfo, iCode ), ECmpNormal );

        TServiceInfo info;

        TInt position;       

        info.iCode = serviceCode;

        // Check if the string can be a service request.

        if ( !iArray->FindIsq( info, key, position ) )

            {

            info = iArray->At( position );

            }

        else

            {

            // Not found.

            return EFalse;

            }

        TServiceSyntax syntax = ESyntaxNotAllowed;

        // Take syntax from info record.

        switch ( type )

            {

            case EServiceActivation:

                syntax = info.iActivation;

                break;

            case EServiceDeactivation:

                syntax = info.iDeactivation;

                break;

            case EServiceInterrogation:

                syntax = info.iInterrogation;

                break;

            case EServiceRegistration:

                syntax = info.iRegistration;

                break;

            case EServiceErasure:

                syntax = info.iErasure;

                break;

            default:

                PhoneGsmParser::Panic( PhoneGsmParser::EShouldNeverHappen );

                break;

            }

        TUint data;

        PackData( data, type, syntax );

        aResult.SetUid( info.iUid );

        aResult.SetAuxInformation( data );

        // We may have to backtrack in case HandleParametersL fails.

        TLexMark mark;

        input.Mark( mark );

        // First attempt

        result = HandleParametersL( input, aResult, syntax );

        // If action was activation and result was failure, then try registration.

        if ( !result && type == EServiceActivation )

            {

            // Backtrack.

            input.UnGetToMark( mark );

            // Clear previous results & fill information again.

            type = EServiceRegistration;

            syntax = info.iRegistration;

            PackData( data, type, syntax );

            aResult.ClearL();

            aResult.SetUid( info.iUid );

            aResult.SetAuxInformation( data );

            // Try again. If this fails, then it is really failure.

            result = HandleParametersL( input, aResult, syntax );

            }

        }

    return result;

    }

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

// CPhoneGsmSsParser::PackData

//

// Combine data to integer.

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

//

void CPhoneGsmSsParser::PackData(

        TUint& aResult,

        TServiceType aType,

        TServiceSyntax aSyntax )

    {

    aResult = 

        ( ( ( TUint )aType ) << KPhoneGsmPackShift ) + ( ( TUint )aSyntax );

    }

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

// CPhoneGsmSsParser::UnpackData

// 

// Take data from integer.

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

//

void CPhoneGsmSsParser::UnpackData(

        TUint aData,

        TServiceType& aResultType,

        TServiceSyntax& aResultSyntax )

    {

    aResultSyntax = 

        CPhoneGsmSsParser::TServiceSyntax( aData & KPhoneGsmPackMask );

    aResultType = 

        CPhoneGsmSsParser::TServiceType( 

            ( aData >> KPhoneGsmPackShift ) & 

            KPhoneGsmPackMask );

    }

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

// CPhoneGsmSsParser::HandleParametersL

//

// Selects correct function by syntax information.

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

//

TBool CPhoneGsmSsParser::HandleParametersL( 

        TLex& aInput, 

        CPhoneGsmParserResult& aResult,

        TServiceSyntax aSyntax )

    {

    TBool result = EFalse;

    switch ( aSyntax )

        {

        case ESyntaxNotAllowed:

            result = 

                HandleNotAllowedL( aInput, aResult );

            break;

        case ESyntaxNoParameters:

            result = 

                HandleNoParametersL( aInput, aResult );

            break;

        case ESyntaxEmptyOrBasicCode:

            result = 

                HandleEmptyOrBasicCodeL( aInput, aResult );

            break;

        case ESyntaxNumberOptBasicCodeOptTimer:

            result = 

                HandleNumberOptBasicCodeOptTimerL( 

                    aInput, 

                    aResult );

            break;

        case ESyntaxNumberOptBasicCode:

            result = 

                HandleNumberOptBasicCodeL( 

                    aInput, 

                    aResult );

            break;

        case ESyntaxPasswordOptBasicCode:

            result = 

                HandlePasswordOptBasicCodeL( 

                    aInput, 

                    aResult );

            break;

        case ESyntaxOptGroupCodePasswordNewPasswordNewPassword:

            result = 

                HandleOptGroupCodePasswordNewPasswordNewPasswordL( 

                    aInput, 

                    aResult );

            break;

        case ESyntaxEmptyOrBasicCode2:

            result = 

                HandleEmptyOrBasicCode2L( 

                    aInput, 

                    aResult );

            break;

        default:

            break;

        }          

    return result;

    }

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

// CPhoneGsmSsParser::HandleNotAllowedL

//

// Just clear the result and return that parsing failed.

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

//

TBool CPhoneGsmSsParser::HandleNotAllowedL( 

        TLex& /*aInput*/, 

        CPhoneGsmParserResult& aResult )

    {

    aResult.ClearL();

    return EFalse;

    }

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

// CPhoneGsmSsParser::HandleNoParametersL

//

// Handle no more parameters, only hash