/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*

*/

//  INCLUDE FILES

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <etelmm.h>

#include <etelsat.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/serviceapi/mmgsmwcdmautils.h> // utility functions

#include <mmlist.h>   // list types

#include <ctsy/serviceapi/mmtsy_defaults.h> // for kmaxlengthofussdmessage

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <ss_wmisi.h>

#include <tisi.h>

#include <uiccisi.h>

#include "cmmcallmesshandler.h" // utility function MapTypeOfNumberMmToIsi

#include "cmmmessagerouter.h"

#include "cmmphonetsender.h"

#include "cmmstaticutility.h" // utility functions

#include "cmmsupplservmesshandler.h"

#include "tssparser.h" // for parsing service string

#include "tsylogger.h"

#include "cmmuiccmesshandler.h"

#include "cmmphonemesshandler.h"  // for CallForwFlagsCachingCompleted

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmsupplservmesshandlerTraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    //None

// EXTERNAL FUNCTION PROTOTYPES

    //None

// CONSTANTS

const TUint8 KSsPadding = 0x00; // Filler byte for ISI messages

const TInt KIpcNoValue = 0;

const TUint16 KSsCodeNoValue = 0xFFFF;

const TUint8 KDataAppendToServiceReqHeaderInBytes = 7;

_LIT(KGsmNewPasswordFiller, "0000");

_LIT(KGsmVerifiedPasswordFiller, "1111");

// MACROS

    //None

// LOCAL CONSTANTS AND MACROS

    //None

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

    //None

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

// CMmSupplServMessHandler::CMmSupplServMessHandler

// C++ default constructor

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

//

CMmSupplServMessHandler::CMmSupplServMessHandler

    (

    //none

    )

    {

TFLOGSTRING( "TSY: CMmSupplServMessHandler::CMmSupplServMessHandler - Start" );

    //none

    }

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

// CMmSupplServMessHandler::NewL

// Two-phased constructor.

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

//

CMmSupplServMessHandler* CMmSupplServMessHandler::NewL

    (

    CMmPhoNetSender* aPhoNetSender, //pointer to the phonet sender

    CMmPhoNetReceiver* aPhoNetReceiver, // pointer to the phoner receiver

    CMmMessageRouter* aMessageRouter, // pointer to the message router

    CMmUiccMessHandler* aUiccMessHandler

    )

    {

TFLOGSTRING( "TSY: CMmSupplServMessHandler::NewL" );

    CMmSupplServMessHandler* supplServMessHandler =

        new ( ELeave ) CMmSupplServMessHandler();

    CleanupStack::PushL( supplServMessHandler );

    supplServMessHandler->iPhoNetSender = aPhoNetSender;

    supplServMessHandler->iMessageRouter = aMessageRouter;

    supplServMessHandler->iMmUiccMessHandler = aUiccMessHandler;

    supplServMessHandler->ConstructL();

    aPhoNetReceiver->RegisterL(

        supplServMessHandler,

        PN_SS,

        SS_SERVICE_COMPLETED_RESP );

    aPhoNetReceiver->RegisterL(

        supplServMessHandler,

        PN_SS,

        SS_SERVICE_FAILED_RESP );

    aPhoNetReceiver->RegisterL(

        supplServMessHandler,

        PN_SS,

        SS_SERVICE_NOT_SUPPORTED_RESP );

    aPhoNetReceiver->RegisterL(

        supplServMessHandler,

        PN_SS,

        SS_GSM_USSD_SEND_RESP );

    aPhoNetReceiver->RegisterL(supplServMessHandler, PN_SS, SS_STATUS_IND );

    aPhoNetReceiver->RegisterL(

        supplServMessHandler,

        PN_SS,

        SS_SERVICE_COMPLETED_IND );

    CleanupStack::Pop( supplServMessHandler );

    return supplServMessHandler;

    }

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

// CMmSupplServMessHandler::ConstructL

// Symbian 2nd phase constructor. Initialises internal attributes.

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

//

void CMmSupplServMessHandler::ConstructL

    (

    //none

    )

    {

TFLOGSTRING( "TSY: CMmSupplServMessHandler::ConstructL" );

    iVoiceServiceMappedToTelephony = EFalse;

    iCircuitServiceMappedToAllBearer = EFalse;

    iGetCallForwardingNumber = EFalse;

    iAlsLine = RMobilePhone::EAlternateLineUnknown;

    //initialize IPC and SsCode

    iIpc = KIpcNoValue;

    iSsCode = KSsCodeNoValue;

    iMsgFlagType = EMsgFlagTypeRel4;

    iGetIccCallForwardingStatus = EFalse;

    iCheckInfoSubblock = EFalse;

    iFdnCheck = EFalse;

    iResourceControlSuppress = EFalse;

    }

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

// CMmSupplServMessHandler::~CMmSupplServMessHandler

// Destructor

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

//

CMmSupplServMessHandler::~CMmSupplServMessHandler

    (

    //none

    )

    {

TFLOGSTRING( "TSY: CMmSupplServMessHandler::~CMmSupplServMessHandler" );

    delete iCFResults;

    delete iCBResults;

    delete iCWResults;

    }

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

// CMmSupplServMessHandler::ExtFuncL

// Forwards requests coming from the Symbian OS layer to the

// specific method.

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

//

TInt CMmSupplServMessHandler::ExtFuncL

    (

    TInt aIpc,

    const CMmDataPackage* aDataPackage

    )

    {

TFLOGSTRING2("TSY: CMmSupplServMessHandler::ExtFuncL: IPC: %d", aIpc);

    //*************************************************************//

    // NOTE

    //

    // LICENSEE SPECIFIC MESSAGE HANDLER IMPLEMENTATION STARTS HERE

    //

    //*************************************************************//

    TInt ret( KErrNone );

    // Note: all SS requests use one of the values in

    // TSSOperationType as their transaction ID. This is needed in order

    // to route failed responses to the correct completion method (the

    // response messages for failed and not supported cases don't contain

    // the SS code).

    //save IPC,

    //in case call control changes SS request we can complete right request

    iIpc = aIpc;

    switch ( aIpc )

        {

        case EMobilePhoneGetCallForwardingStatusPhase1:

            {

            //unpack parameters: forwarding condition and service group

            RMobilePhone::TMobilePhoneCFCondition conditionETel =

                RMobilePhone::ECallForwardingUnspecified;

            RMobilePhone::TMobileService serviceGroup =

                RMobilePhone::EServiceUnspecified;

            aDataPackage->UnPackData ( conditionETel, serviceGroup );

            TUint8 operation( SS_INTERROGATION );

            TUint8 basicServiceCode( SS_ALL_TELE_AND_BEARER );

            // Map MM API condition to SS server condition

            ret = MapCFConditionMmToIsi( conditionETel, &iSsCode );

            User::LeaveIfError( ret );

            // If user wishes to get some specific group, then send

            // a different SS request.

            if ( RMobilePhone::EAllServices != serviceGroup &&

                 RMobilePhone::EServiceUnspecified != serviceGroup )

                {

                // Map MM API enum to SS server constant

                ret = MapMobileServiceToBasicServiceCodeIsi(

                    serviceGroup, &basicServiceCode );

                User::LeaveIfError( ret );

                }

            ret = SsCallForwServiceReq(

                ESSOperationTypeGetCallForwardingStatus,

                operation,

                iSsCode,

                0,

                0,

                &KNullDesC,

                basicServiceCode );

            break;

            }

        case EMobilePhoneSetCallForwardingStatus:

            {

            //unpack parameters: TMobilePhoneCFCondition and TMobilePhoneCFChangeV1

            RMobilePhone::TMobilePhoneCFCondition conditionETel =

                RMobilePhone::ECallForwardingUnspecified;

            RMobilePhone::TMobilePhoneCFChangeV1* changeInfo;

            aDataPackage->UnPackData ( conditionETel, changeInfo );

            TUint8 operation( 0 );

            TUint8 typeOfNumber( 0 );

            TInt noReplyTime( 0 );

            TUint8 mmiBasicServiceCode( SS_UNKNOWN_SERVICE );

            iMmCFCondition = conditionETel;

            iMobileService = changeInfo->iServiceGroup;

            iCFAddress = changeInfo->iNumber;

TFLOGSTRING2("TSY: CMmSupplServMessHandler::ExtFuncL - EMobilePhoneSetCallForwardingStatus - Number: %S", &iCFAddress.iTelNumber);

TFLOGSTRING2("TSY: CMmSupplServMessHandler::ExtFuncL - EMobilePhoneSetCallForwardingStatus - MobileService: %d", iMobileService);

TFLOGSTRING2("TSY: CMmSupplServMessHandler::ExtFuncL - EMobilePhoneSetCallForwardingStatus - Condition: %d", iMmCFCondition);

            //map operation

            ret = MapOperationMmToIsi( changeInfo->iAction, &operation );

            if ( KErrNone == ret )

                {

                //map condition

                ret = MapCFConditionMmToIsi( conditionETel, &iSsCode );

                if ( KErrNone == ret )

                    {

                    //map type of number

                    MapTypeOfNumberMmToIsi(

                        iCFAddress.iTypeOfNumber,

                        iCFAddress.iNumberPlan,

                        typeOfNumber );

                    //map basic service code

                    ret = MapMobileServiceToBasicServiceCodeIsi(

                        changeInfo->iServiceGroup,

                        &mmiBasicServiceCode );

                    if ( KErrNone == ret )

                        {

                        //map the reply time

                        // -1 is defined in Etel MM API as undefined timeout

                        if ( -1 == changeInfo->iTimeout )

                            {

                            noReplyTime = SS_UNDEFINED_TIME;

                            }

                        else

                            {

                            noReplyTime = changeInfo->iTimeout;

                            }

                        //make a pointer to the phone number

                        //call the method

                        ret = SsCallForwServiceReq(

                            ESSOperationTypeSetCallForwardingStatus,

                            operation,

                            iSsCode,

                            typeOfNumber,

                            noReplyTime,

                            &( iCFAddress.iTelNumber ),

                            mmiBasicServiceCode );

                        }

                    }

                }

            break;

            }

        case EMobilePhoneGetBarringStatusPhase1:

            {

            //unpack parameter: barring condition

            RMobilePhone::TMobilePhoneCBCondition conditionETel =

                RMobilePhone::EBarUnspecified;

            aDataPackage->UnPackData ( conditionETel );

            //map condition

            ret = MapCBConditionMmToIsi( conditionETel, &iSsCode );

            if ( KErrNone == ret )

                {

                // password subblock is not added to the ISI

                // message, because all passwords are empty

                ret = SsGsmBarringReq(

                    ESSOperationTypeGetCallBarringStatus,

                    SS_INTERROGATION,

                    iSsCode,

                    &KNullDesC,

                    KNullDesC,

                    KNullDesC ,

                    SS_ALL_TELE_AND_BEARER );

                }

            break;

            }

        case EMobilePhoneSetCallBarringStatus:

            {

            //unpack parameters: TMobilePhoneCBCondition and TMobilePhoneCBChangeV1

            RMobilePhone::TMobilePhoneCBCondition conditionETel =

                RMobilePhone::EBarUnspecified;

            RMobilePhone::TMobilePhoneCBChangeV1* changeInfo;

            aDataPackage->UnPackData ( conditionETel, changeInfo );

            TUint8 operation( 0 );

            TUint8 mmiBasicServiceCode( SS_UNKNOWN_SERVICE );

            //map operation

            ret = MapOperationMmToIsi( changeInfo->iAction, &operation );

            if ( KErrNone == ret )

                {

                //map call barring condition

                ret = MapCBConditionMmToIsi( conditionETel, &iSsCode );

                if ( KErrNone == ret )

                    {

                    //map basic service code

                    ret = MapMobileServiceToBasicServiceCodeIsi(

                        changeInfo->iServiceGroup,

                        &mmiBasicServiceCode );

                    if ( KErrNone == ret )

                        {

                        //send ss call barring service request

                        // fillers are used to send "bad" SS_GSM_PASSWORD

                        // subblock to SS server in case password is omitted

                        ret = SsGsmBarringReq(

                            ESSOperationTypeSetCallBarringStatus,

                            operation,

                            iSsCode,

                            &( changeInfo->iPassword ),

                            KGsmNewPasswordFiller,

                            KGsmVerifiedPasswordFiller,

                            mmiBasicServiceCode );

                        }

                    }

                }

            break;

            }

        case EMobilePhoneSetSSPassword:

            {

            //unpack parameter: TMobilePhonePasswordChangeV2 and TUint16

            RMobilePhone::TMobilePhonePasswordChangeV2 passwd;

            aDataPackage->UnPackData ( passwd, iSsCode );

            // password change affects all services

            TUint8 mmiBasicServiceCode = SS_ALL_TELE_AND_BEARER;

            // client is fully responsible for making

            // "bad" password subblock

            ret = SsGsmBarringReq(

                ESSOperationTypeSetSSPassword,

                SS_GSM_PASSWORD_REGISTRATION,

                iSsCode,

                &passwd.iOldPassword,

                passwd.iNewPassword,

                passwd.iVerifiedPassword,

                mmiBasicServiceCode );

            break;

            }

        case EMobilePhoneGetWaitingStatusPhase1:

            {

            // no packed parameters

            // send ss call waiting service request

            ret = SsGsmWaitingReq(

                ESSOperationTypeGetCallWaitingStatus,

                SS_INTERROGATION,

                SS_GSM_CALL_WAITING,

                SS_ALL_TELE_AND_BEARER );

            iSsCode = SS_GSM_CALL_WAITING;

            break;

            }

        case EMobilePhoneSetCallWaitingStatus:

            {

            //unpack parameters: TMobileService and TMobilePhoneServiceAction

            RMobilePhone::TMobileService serviceGroup =

                RMobilePhone::EServiceUnspecified;

            RMobilePhone::TMobilePhoneServiceAction action;

            aDataPackage->UnPackData ( serviceGroup, action );

            TUint8 operation( 0 );

            TUint8 mmiBasicServiceCode( SS_UNKNOWN_SERVICE );

            //map operation

            ret = MapOperationMmToIsi( action, &operation );

            if ( KErrNone == ret )

                {

                //map basic service code

                ret = MapMobileServiceToBasicServiceCodeIsi(

                    serviceGroup,

                    &mmiBasicServiceCode );

                if ( KErrNone == ret )

                    {

                    // send call waiting service request

                    ret = SsGsmWaitingReq(

                        ESSOperationTypeSetCallWaitingStatus,

                        operation,

                        SS_GSM_CALL_WAITING,

                        mmiBasicServiceCode );

                    iSsCode = SS_GSM_CALL_WAITING;

                    }

                }

            break;

            }

        case EMobilePhoneGetIdentityServiceStatus:

            {

            // packed parameter: TMobilePhoneIdService (service code)

            RMobilePhone::TMobilePhoneIdService serviceETel;

            aDataPackage->UnPackData ( serviceETel );

            MapIdentityServiceMmToIsi( serviceETel, &iSsCode );

            // send ss identity service request

            ret = SsIdentityServiceReq(

                ESSOperationTypeGetIdentityServiceStatus,

                iSsCode );

            break;

            }

        case EMobilePhoneSendNetworkServiceRequest:

        case EMobilePhoneSendNetworkServiceRequestNoFdnCheck:

            {

            // These IPCs are received in case of SAT originated SS request.

            // In that case SS_GSM_SIM_ATK_INFO subblock must be inserted to

            // SS_SERVICE_NO_SIMATK_REQ to indicate if FDN check should be

            // done or not

            TUint8 trId( ESSOperationTypeSendNetworkServiceRequestNoFdnCheck );

            TUint8 operation( SS_OPERATION_UNDEFINED );

            TUint16 serviceCode( SS_CODE_UNDEFINED );

            TPtrC ssInfoA;

            TPtrC ssInfoB;

            TPtrC ssInfoC;

            TPtrC* serviceString;

            TSsParser ssParser;

            // indicates that SS_GSM_SIMATK_INFO subblock must be added

            iCheckInfoSubblock = ETrue;

            // depending on ipc, FDN check must be done or not

            if ( EMobilePhoneSendNetworkServiceRequest == aIpc )

                {

                trId = ESSOperationTypeSendNetworkServiceRequest;