/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

* 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 <e32std.h>        // error values

#include <etelmm.h>

#include <ctsy/serviceapi/mmtsy_defaults.h>

#include <ss_wmisi.h>

#include <tisi.h>

#include "cmmmessagerouter.h"

#include "cmmphonetsender.h"

#include "cmmstaticutility.h"

#include "cmmussdmesshandler.h"

#include "tsylogger.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

//  External Data Structures

    //  none

// External Function Prototypes

    //  none

// LOCAL CONSTANTS AND MACROS

// hard-coded transaction id for ISA messages.

const TUint8 KUssdTransId = 5;

const TUint8 KFiller = 0x00;

// MODULE DATA STRUCTURES

    //  none

// Local Data Structures

    //  none

// Local Function Prototypes

    //  none

//  LOCAL FUNCTIONS

    //  none

// MEMBER FUNCTIONS

//=============================================================================

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

// CMmUssdMessHandler::ConstructL

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

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

//

CMmUssdMessHandler::CMmUssdMessHandler

    (

    // None

    )

    {

TFLOGSTRING("TSY: CMmUssdMessHandler::CMmUssdMessHandler");

OstTrace0( TRACE_NORMAL, CMMUSSDMESSHANDLER_CMMUSSDMESSHANDLER, "CMmUssdMessHandler::CMmUssdMessHandler" );

    //None

    }

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

// CMmUssdMessHandler::~CMmUssdMessHandler

// Destructor

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

//

CMmUssdMessHandler::~CMmUssdMessHandler

    (

    // None

    )

    {

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

OstTrace0( TRACE_NORMAL, DUP1_CMMUSSDMESSHANDLER_CMMUSSDMESSHANDLER, "CMmUssdMessHandler::~CMmUssdMessHandler" );

    }

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

// CMmUssdMessHandler::ConstructL

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

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

//

void CMmUssdMessHandler::ConstructL

    (

    // None

    )

    {

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

OstTrace0( TRACE_NORMAL, CMMUSSDMESSHANDLER_CONSTRUCTL, "CMmUssdMessHandler::ConstructL" );

    // The flag indicates the correct complete method in failed case for

    // SS_SERVICE_FAILED_RESP

    iIsSendReleaseCalled = EFalse;

    //No ongoing request

    iIsUssdSendReqOnGoing = EFalse;

    //No pending request

    iIsSendReleaseReqPending = EFalse;

    iNoFdnUSSDReq = EFalse;

    }

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

// CMmUssdMessHandler::NewL

// Two-phased constructor.

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

//

CMmUssdMessHandler* CMmUssdMessHandler::NewL

    (

    CMmPhoNetSender* aPhoNetSender, //pointer to phonet sender

    CMmPhoNetReceiver* aPhoNetReceiver, // pointer to phonet receiver

    CMmMessageRouter* aMessageRouter    //pointer to message router

    )

    {

TFLOGSTRING("TSY: CMmUssdMessHandler::NewL.\n");

OstTrace0( TRACE_NORMAL, CMMUSSDMESSHANDLER_NEWL, "CMmUssdMessHandler::NewL" );

    CMmUssdMessHandler* ussdMessHandler =

        new( ELeave ) CMmUssdMessHandler();

    CleanupStack::PushL( ussdMessHandler );

    ussdMessHandler->ConstructL();

    ussdMessHandler->iPhoNetSender = aPhoNetSender;

    ussdMessHandler->iMessageRouter = aMessageRouter;

    aPhoNetReceiver->RegisterL(ussdMessHandler, PN_SS, SS_GSM_USSD_SEND_RESP);

    aPhoNetReceiver->RegisterL(ussdMessHandler, PN_SS, SS_SERVICE_FAILED_RESP);

    aPhoNetReceiver->RegisterL(ussdMessHandler, PN_SS, SS_GSM_USSD_RECEIVE_IND);

    CleanupStack::Pop( ussdMessHandler );

    return ussdMessHandler;

    }

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

// CMmUssdMessHandler::ReceiveMessageL

// Called when an ISI message has been received.

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

//

void CMmUssdMessHandler::ReceiveMessageL

    (

    const TIsiReceiveC& aIsiMessage    // ISI-message received

    )

    {

    TInt resource (aIsiMessage.Get8bit(ISI_HEADER_OFFSET_RESOURCEID) );

    TInt messageId (aIsiMessage.Get8bit(ISI_HEADER_OFFSET_MESSAGEID) );

TFLOGSTRING3("TSY: CMmUssdMessHandler::ReceiveMessageL - resouce: %d, msgId: %d", resource, messageId);

OstTraceExt2( TRACE_NORMAL, CMMUSSDMESSHANDLER_RECEIVEMESSAGEL, "CMmUssdMessHandler::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId );

    switch( resource )

        {

        case PN_SS:

            {

            switch( messageId )

                {

                case SS_GSM_USSD_SEND_RESP:

                    {

                    SsGsmUssdSendResp( aIsiMessage );

                    break;

                    }

                case SS_SERVICE_FAILED_RESP:

                    {

                    SsServiceFailedResp( aIsiMessage );

                    // SS_SERVICE_FAILED_RESP message is needed by Custom

                    // message handler

                    break;

                    }

                case SS_GSM_USSD_RECEIVE_IND:

                    {

                    SsGsmUssdReceiveInd( aIsiMessage );

                    break;

                    }

                default:

                    {

TFLOGSTRING2("TSY: CMmUssdMessHandler::ReceiveMessageL - PN_SS - unknown msgId: %d", messageId);

OstTrace1( TRACE_NORMAL, DUP1_CMMUSSDMESSHANDLER_RECEIVEMESSAGEL, "CMmUssdMessHandler::ReceiveMessageL;unknown messageId=%d", messageId );

                    // No propiert handler methods for ISI-message found

                    break;

                    }

                }

            break;

            }

        default:

            {

TFLOGSTRING2("TSY: CMmUssdMessHandler::ReceiveMessageL - unknown resource: %d", resource);

OstTrace1( TRACE_NORMAL, DUP2_CMMUSSDMESSHANDLER_RECEIVEMESSAGEL, "CMmUssdMessHandler::ReceiveMessageL;resource=%d", resource );

            break;

            }

        }

    }

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

// CMmUssdMessHandler::SsGsmUssdSendReq

// Construct a SS_GSM_USSD_SEND_REQ ISI message

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

//

TInt CMmUssdMessHandler::SsGsmUssdSendReq

    (

    const CMmDataPackage* aDataPackage

    )

    {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsGsmUssdSendReq");

OstTrace0( TRACE_NORMAL, CMMUSSDMESSHANDLER_SSGSMUSSDSENDREQ, "CMmUssdMessHandler::SsGsmUssdSendReq" );

    TInt ret ( KErrNone );

    TBuf8<RMobileUssdMessaging::KGsmUssdDataSize> data( 0 );

    TDes8* attributes( 0 );

    TUint8 numOfSubblocks( 2 );

    aDataPackage->UnPackData( data, attributes );

    RMobileUssdMessaging::TMobileUssdAttributesV1Pckg* msgAttrPck (

        (RMobileUssdMessaging::TMobileUssdAttributesV1Pckg*) ( attributes ) );

    RMobileUssdMessaging::TMobileUssdAttributesV1 msgAttr ( ( *msgAttrPck )() );

TFLOGSTRING2("TSY: CMmUssdMessHandler::SsGsmUssdSendReq. AttributeType: %d", msgAttr.iType );

OstTrace1( TRACE_NORMAL, DUP1_CMMUSSDMESSHANDLER_SSGSMUSSDSENDREQ, "CMmUssdMessHandler::SsGsmUssdSendReq;msgAttr.iType=%d", msgAttr.iType );

    TUint8 ussdType( KFiller ); //initialize ussdtype to 0

    if ( RMobileUssdMessaging::KUssdMessageType & msgAttr.iFlags )

        {

        switch ( msgAttr.iType )

            {

            // User has requested to send MO USSD

            case RMobileUssdMessaging::EUssdMORequest:

                ussdType = SS_GSM_USSD_COMMAND;

                break;

            // User is replying to MT USSD.

            case RMobileUssdMessaging::EUssdMOReply:

                ussdType = SS_GSM_USSD_MT_REPLY;

                break;

            // User is signing for the MT request

            case RMobileUssdMessaging::EUssdMOAcknowledgement:

                ussdType = SS_GSM_USSD_NOTIFY;

                break;

            // Unknown or illegal cases return error to client

            default:

                // ussd type is unknown, report error

                ret = KErrArgument;

                break;

            }

        }

    else

        {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsGsmUssdSendReq. Type flag missing" );

OstTrace0( TRACE_NORMAL, DUP2_CMMUSSDMESSHANDLER_SSGSMUSSDSENDREQ, "CMmUssdMessHandler::SsGsmUssdSendReq, Type flag missing" );

        // ussd type is unknown, report error

        ret = KErrArgument;

        }

    TUint8 codingInfo( KFiller );  //initialize codinginfo to 0

    // If messagetype was valid, check data coding scheme.

    if ( KErrNone == ret )

        {

        if ( RMobileUssdMessaging::KUssdMessageDcs & msgAttr.iFlags )

            {

            //get data coding scheme

            codingInfo = msgAttr.iDcs;

            }

         else

            {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsGsmUssdSendReq. DCS flag missing" );

OstTrace0( TRACE_NORMAL, DUP3_CMMUSSDMESSHANDLER_SSGSMUSSDSENDREQ, "CMmUssdMessHandler::SsGsmUssdSendReq, DCS flag missing" );

            // data coding scheme is unknown, report error.

            ret = KErrArgument;

            }

        }

    // If messagetype and data coding scheme were valid, send message.

    if ( KErrNone == ret )

        {

        if ( RMobileUssdMessaging::KUssdDataFormat & msgAttr.iFlags )

            {

            // Create UssdSendReq ISI-message

            TIsiSend ssGsmUssdSendReq( iPhoNetSender->SendBufferDes() );

            ssGsmUssdSendReq.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_SS );

            ssGsmUssdSendReq.Set8bit( ISI_HEADER_OFFSET_TRANSID, KUssdTransId );

            ssGsmUssdSendReq.Set8bit(

                ISI_HEADER_OFFSET_MESSAGEID,

                SS_GSM_USSD_SEND_REQ );

            ssGsmUssdSendReq.Set8bit( ISI_HEADER_SIZE +

                SS_GSM_USSD_SEND_REQ_OFFSET_USSDTYPE, ussdType );

            // Create SsGsmUssdString subblock.

            // subblock header + ussd string length subblock max length = 164

            TBuf8<KMaxLengthOfUssdMessage + 3> ssGsmUssdStringSb( 0 );

            TIsiSubBlock subblockSSGsmUssdString(

                ssGsmUssdStringSb, SS_GSM_USSD_STRING, EIsiSubBlockTypeId8Len8 );

            ssGsmUssdStringSb.Append( codingInfo );

            ssGsmUssdStringSb.Append( data.Length() );

            ssGsmUssdStringSb.Append( data );

            ssGsmUssdSendReq.CopyData( ISI_HEADER_SIZE +

                SIZE_SS_GSM_USSD_SEND_REQ,

                subblockSSGsmUssdString.CompleteSubBlock() );

            // create subblock SS_SB_CHECK_INFO

            TBuf8<SIZE_SS_SB_CHECK_INFO>sbData( 0 );

            TIsiSubBlock ssCheckInfoSb(

                sbData,

                SS_SB_CHECK_INFO,

                EIsiSubBlockTypeId8Len8 );

            if( iNoFdnUSSDReq )

                {

                sbData.Append( SS_FDN_CHECK_SUPPRESS );

                }

            else

                {

                sbData.Append( SS_NO_FDN_CHECK_SUPPRESS );

                }

            sbData.Append( SS_NO_RESOURCE_CONTROL_SUPPRESS );

            // add the SIZE_SS_SB_CHECK_INFO subblock to service req

            ssGsmUssdSendReq.CopyData(

                ISI_HEADER_SIZE + SIZE_SS_GSM_USSD_SEND_REQ +

                ssGsmUssdStringSb.Length(),

                ssCheckInfoSb.CompleteSubBlock( ) );

            ssGsmUssdSendReq.Set8bit( ISI_HEADER_SIZE +

                SS_GSM_USSD_SEND_REQ_OFFSET_SUBBLOCKCOUNT, numOfSubblocks );

            //send message via phonet

            ret = iPhoNetSender->Send( ssGsmUssdSendReq.Complete() );

            }

        else

            {

            // dataformat is unspecified, report error.

            ret = KErrArgument;

            }

        }

    return ret;

    }

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

// CMmUssdMessHandler::SsGsmUssdSendReq

// Construct a SS_GSM_USSD_SEND_REQ ISI message that ends ussd session

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

//

TInt CMmUssdMessHandler::SsGsmUssdSendReq

    (

    void

    )

    {

TFLOGSTRING("LTSY: CMmUssdMessHandler::SsGsmUssdSendReq. End USSD session" );

OstTrace0( TRACE_NORMAL, DUP4_CMMUSSDMESSHANDLER_SSGSMUSSDSENDREQ, "CMmUssdMessHandler::SsGsmUssdSendReq" );

    // Change the flag to indicate the correct complete method for failed resp

    iIsSendReleaseCalled = ETrue;

    // No pending request anymore

    iIsSendReleaseReqPending = EFalse;

    // create buffer for isi msg data

    TBuf8<2> messageData( 0 );

    messageData.Append( SS_GSM_USSD_END );

    // number of sub blocks

    messageData.Append( 0 );

    return iPhoNetSender->Send(

        PN_SS,

        KUssdTransId,

        SS_GSM_USSD_SEND_REQ,

        messageData );

    }

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

// CMmUssdMessHandler::SsGsmUssdSendResp

// Completes successful Ss Gsm Ussd Send Request.

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

//

void CMmUssdMessHandler::SsGsmUssdSendResp

    (

    const TIsiReceiveC &aIsiMessage //received isi message

    )

    {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsGsmUssdSendResp" );

OstTrace0( TRACE_NORMAL, CMMUSSDMESSHANDLER_SSGSMUSSDSENDRESP, "CMmUssdMessHandler::SsGsmUssdSendResp" );

    TUint8 length ( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + SS_GSM_USSD_SEND_RESP_OFFSET_LENGTHOFUSSDSTRING ) );

    TBuf8<KMaxLengthOfUssdMessage> ussdString ( aIsiMessage.GetData(

        ISI_HEADER_SIZE + SS_GSM_USSD_SEND_RESP_OFFSET_USSDSTRING, length ) );

    TUint8 ussdType ( aIsiMessage.Get8bit(

        ISI_HEADER_SIZE + SS_GSM_USSD_SEND_RESP_OFFSET_USSDTYPE ) );

    //create package.

    CMmDataPackage package;

    // If the message sent was of type SS_GSM_USSD_END, and the request

    // was a SendRelease request, then a different request must be completed

    if ( SS_GSM_USSD_END == ussdType && iIsSendReleaseCalled )

        {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsGsmUssdSendResp. Response to SendRelease." );

OstTrace0( TRACE_NORMAL, DUP1_CMMUSSDMESSHANDLER_SSGSMUSSDSENDRESP, "CMmUssdMessHandler::SsGsmUssdSendResp, Response to SendRelease" );

        // Reset the flag

        iIsSendReleaseCalled = EFalse;

        RMobilePhone::TMobilePhoneSendSSRequestV3 returnResult;

        returnResult.iOpCode = KErrNone;

        returnResult.iAdditionalInfo.Append( KErrNone );

        //pack the data

        package.PackData( &returnResult );

        //complete the request

        iMessageRouter->Complete(

            EMobileUssdMessagingSendRelease,

            &package,

            KErrNone);

        }

    // otherwise complete the send message request

    else

        {

        if ( iNoFdnUSSDReq )

            {

            // Call CompleteSendMessageNoFdnCheck request.

            iMessageRouter->Complete(

                EMobileUssdMessagingSendMessageNoFdnCheck,

                KErrNone );

            }

        else

            {

            // Call CompleteSendMessage request.

            iMessageRouter->Complete(

                EMobileUssdMessagingSendMessage,

                KErrNone );

            }

        //Req is not ongoing anymore

        iIsUssdSendReqOnGoing = EFalse;

        //if a cancel request has been made

        if ( iIsSendReleaseReqPending )

            {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsGsmUssdSendResp. SendRelease pending." );

OstTrace0( TRACE_NORMAL, DUP2_CMMUSSDMESSHANDLER_SSGSMUSSDSENDRESP, "CMmUssdMessHandler::SsGsmUssdSendResp, SendRelease pending" );

            TInt ret ( KErrNone );

            ret = SsGsmUssdSendReq();

            if ( KErrNone != ret )

                {

                RMobilePhone::TMobilePhoneSendSSRequestV3 returnResult;

                returnResult.iOpCode = static_cast <TUint8 > ( KErrGeneral );

                returnResult.iAdditionalInfo.Append(

                    static_cast < TUint8 > ( KErrGeneral ) );

                //complete the request

                iMessageRouter->Complete(

                    EMobileUssdMessagingSendRelease,

                    &package,

                    KErrGeneral );

                }

            }

        }

    }

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

// CMmUssdMessHandler::SsServiceFailedResp

// Completes unsuccessful Ss Gsm Ussd Send Request ( MO USSD ).

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

//

void CMmUssdMessHandler::SsServiceFailedResp

    (

    const TIsiReceiveC &aIsiMessage //received isi message

    )

    {

TFLOGSTRING("TSY: CMmUssdMessHandler::SsServiceFailedResp" );

OstTrace0( TRACE_NORMAL, CMMUSSDMESSHANDLER_SSSERVICEFAILEDRESP, "CMmUssdMessHandler::SsServiceFailedResp" );

    // Initialize cause type and value, if no specified.

    // subblock found, use SS_UNSPECIFIED_REASON.

    TUint8 causeType( KErrNone );

    TUint8 causeValue( SS_UNSPECIFIED_REASON );

    // If no sub block, set epocerror to KErrGeneral.

    TInt epocError( KErrGeneral );

    // offset where the subblock starts

    TUint sbStartOffset( KErrNone );

    //create package.

    CMmDataPackage package;

    if( KErrNone == aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE + SIZE_SS_SERVICE_FAILED_RESP,

        SS_GSM_INDICATE_MSG_ERROR,

        EIsiSubBlockTypeId8Len8,

        sbStartOffset ) )

        {

        causeType = SS_GSM_INDICATE_MSG_ERROR;

        causeValue = aIsiMessage.Get8bit(

            sbStartOffset + SS_GSM_INDICATE_MSG_ERROR_OFFSET_MESSAGEERRORCODE );

        }

    else if( KErrNone == aIsiMessage.FindSubBlockOffsetById(

        ISI_HEADER_SIZE + SIZE_SS_SERVICE_FAILED_RESP,

        SS_GSM_INDICATE_ERROR,

        EIsiSubBlockTypeId8Len8,