/*
* 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 handler for supplementary service procedures.
*
*/


// INCLUDE FILES
#include    <bldvariant.hrh>

#include    "CPhoneGsmSsHandler.h"
#include    "CPhoneGsmSsParser.h"
#include    "CPhoneGsmParserResult.h"

// LOCAL FUNCTION PROTOTYPES

/**
* Converts from service type to action.
*/
CPhoneGsmSsHandler::TAction ConvertFromServiceType( 
    CPhoneGsmSsParser::TServiceType aType );

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// ConvertFromServiceType
// -----------------------------------------------------------------------------
//
CPhoneGsmSsHandler::TAction ConvertFromServiceType( 
        CPhoneGsmSsParser::TServiceType aType )
    {
    CPhoneGsmSsHandler::TAction result = 
        CPhoneGsmSsHandler::EActivate;

    switch ( aType )
        {
        case CPhoneGsmSsParser::EServiceActivation:
            result = CPhoneGsmSsHandler::EActivate;
            break;
        case CPhoneGsmSsParser::EServiceDeactivation:
            result = CPhoneGsmSsHandler::EDeactivate;
            break;
        case CPhoneGsmSsParser::EServiceInterrogation:
            result = CPhoneGsmSsHandler::EInterrogate;
            break;
        case CPhoneGsmSsParser::EServiceRegistration:
            result = CPhoneGsmSsHandler::ERegister;
            break;
        case CPhoneGsmSsParser::EServiceErasure:
            result = CPhoneGsmSsHandler::EErase;
            break;

        default:
            break;
        }

    return result;
    }

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

// -----------------------------------------------------------------------------
// CPhoneGsmSsHandler::ProcessL
//
// Process result and call appropriate function.
// -----------------------------------------------------------------------------
//
EXPORT_C void CPhoneGsmSsHandler::ProcessL( 
        CPhoneGsmParserResult& aResult )
    {            
    switch( aResult.Uid() )
        {
        case KPhoneUidForwardingAll:
            DoProcessForwardingL( 
                EForwardingAll,
                aResult );
            break;

        case KPhoneUidForwardingAllConditional:
            DoProcessForwardingL(
                EForwardingAllConditional,
                aResult );
            break;

        case KPhoneUidForwardingUnconditional:
            DoProcessForwardingL(
                EForwardingUnconditional,
                aResult );
            break;

        case KPhoneUidForwardingNoReply:
            DoProcessForwardingL(
                EForwardingNoReply,
                aResult );
            break;

        case KPhoneUidForwardingNotReachable:
            DoProcessForwardingL(
                EForwardingNotReachable,
                aResult );
            break;

        case KPhoneUidForwardingBusy:
            DoProcessForwardingL( 
                EForwardingBusy,
                aResult );
            break;

        case KPhoneUidBarringAllOutgoingCalls:
            DoProcessBarringL( 
                EBarringAllOutgoingCalls,
                aResult );
            break;

        case KPhoneUidBarringAllIncomingCalls:
            DoProcessBarringL( 
                EBarringAllIncomingCalls,
                aResult );
            break;

        case KPhoneUidBarringAllServices:
            DoProcessBarringL( 
                EBarringAllServices,
                aResult );
            break;

        case KPhoneUidBarringAllOutgoingInternationalCalls:
            DoProcessBarringL( 
                EBarringAllOutgoingInternationalCalls,
                aResult );

            break;

        case KPhoneUidBarringAllOutgoingInternationalCallsExceptHome:
            DoProcessBarringL( 
                EBarringAllOutgoingInternationalCallsExceptHome,
                aResult );
            break;

        case KPhoneUidBarringAllOutgoingServices:
            DoProcessBarringL( 
                EBarringAllOutgoingServices,
                aResult );
            break;

        case KPhoneUidBarringAllIncomingCallsWhenRoaming:
            DoProcessBarringL( 
                EBarringAllIncomingCallsWhenRoaming,
                aResult );
            break;

        case KPhoneUidBarringAllIncomingServices:
            DoProcessBarringL( 
                EBarringAllIncomingServices,
                aResult );
            break;

        case KPhoneUidWaiting:
            {
            TPtrC ptr( KNullDesC );

            if ( aResult.CountParameters() )
                {
                ptr.Set( aResult.ParameterAt( 0 ) );
                }

            TUint data = aResult.AuxInformation();
            CPhoneGsmSsParser::TServiceType type;
            CPhoneGsmSsParser::TServiceSyntax syntax;

            CPhoneGsmSsParser::UnpackData( data, type, syntax );

            TAction action = ConvertFromServiceType( type ); 
            ProcessWaitingL( action, ptr );
            }
            break;

        case KPhoneUidCallingLineIdentificationPresentation:
            ProcessClipStatusL();
            break;

        case KPhoneUidCallingLineIdentificationRestriction:
            ProcessClirStatusL();
            break;

        case KPhoneUidConnectedLinePresentation:
            ProcessColpStatusL();
            break;

        case KPhoneUidConnectedLinePresentationRestriction:
            ProcessColrStatusL();
            break;

        case KPhoneUidPassword:
            {
            TPasswordProcedure procedure = EPasswordNetwork;
            if ( aResult.ParameterAt( 0 ).Length() )
                {
                procedure = EPasswordBarring;
                }

            ProcessPasswordChangeL( 
                procedure,
                aResult.ParameterAt(1),
                aResult.ParameterAt(2),
                aResult.ParameterAt(3) );
            }
            break;

        case KPhoneUidCallingNamePresentation:
            ProcessCnapStatusL();
            break;

        default:
            break;
        }

    }

// -----------------------------------------------------------------------------
// CPhoneGsmSsHandler::DoProcessBarringL
//
// Process barring procedures.
// -----------------------------------------------------------------------------
//
void CPhoneGsmSsHandler::DoProcessBarringL(
        TBarringProcedure aBarring,
        CPhoneGsmParserResult& aResult )
    {
    CPhoneGsmSsParser::TServiceType type;
    CPhoneGsmSsParser::TServiceSyntax syntax;
    TPtrC password( KNullDesC );
    TPtrC basicCode( KNullDesC );

    CPhoneGsmSsParser::UnpackData( 
        aResult.AuxInformation(),
        type,
        syntax );

    TAction action = ConvertFromServiceType( type ); 

    switch ( type )
        {
        case CPhoneGsmSsParser::EServiceDeactivation:
        case CPhoneGsmSsParser::EServiceActivation:
            
            // First parameter is password.
            if ( aResult.CountParameters() >= 1 )
                {
                password.Set( aResult.ParameterAt( 0 ) );
                }

            // Second parameter is basic service code.
            if ( aResult.CountParameters() >= 2 )
                {
                basicCode.Set( aResult.ParameterAt( 1 ) );
                }

            ProcessBarringL( 
                action,
                aBarring,
                password,
                basicCode );

            break;
    
        case CPhoneGsmSsParser::EServiceInterrogation:

            // First parameter is basic service code.
            if ( aResult.CountParameters() >= 1 )
                {
                basicCode.Set( aResult.ParameterAt( 0 ) );
                }

            ProcessBarringL(
                action,
                aBarring,
                KNullDesC,
                basicCode );

            break;

        case CPhoneGsmSsParser::EServiceRegistration:
        case CPhoneGsmSsParser::EServiceErasure:
            // These can never happen.
            break;

        default:
            break;
        }
    }

// -----------------------------------------------------------------------------
// CPhoneGsmSsHandler::DoProcessForwardingL
//
// Process result and call appropriate function.
// -----------------------------------------------------------------------------
//
void CPhoneGsmSsHandler::DoProcessForwardingL(
        TForwardingProcedure aForwarding,
        CPhoneGsmParserResult& aResult )
    {
    CPhoneGsmSsParser::TServiceType type;
    CPhoneGsmSsParser::TServiceSyntax syntax;

    CPhoneGsmSsParser::UnpackData( 
        aResult.AuxInformation(),
        type,
        syntax );

    TAction action = ConvertFromServiceType( type ); 

    TPtrC number( KNullDesC );
    TPtrC basicCode( KNullDesC );
    TPtrC timer( KNullDesC );

    switch ( type )
        {
        case CPhoneGsmSsParser::EServiceActivation:
        case CPhoneGsmSsParser::EServiceDeactivation:
        case CPhoneGsmSsParser::EServiceInterrogation:
        case CPhoneGsmSsParser::EServiceErasure:
            basicCode.Set( aResult.ParameterAt( 1 ) );
            break;

        case CPhoneGsmSsParser::EServiceRegistration:
            {
            number.Set( aResult.ParameterAt( 0 ) );
            
            if ( aResult.CountParameters() > 1 )
                {
                basicCode.Set( aResult.ParameterAt( 1 ) );
                }

            if ( aResult.CountParameters() > 2 )
                {
                timer.Set( aResult.ParameterAt( 2 ) );
                }
            }
            break;

        default:
            break;
        }

    ProcessForwardingL(
        action,
        aForwarding,
        number,
        basicCode,
        timer );
            
    }
    
//  End of File