/*

* Copyright (c) 2002-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:  Handles SendUssd command

*

*/

#include    <exterror.h>

#include    "MSatSystemState.h"

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSendUssdHandler.h"

#include    "TSatExtErrorUtils.h"

#include    "SatLog.h"

const TUint8 KQuarterShift( 2 );

const TUint8 KHighNibbleShift( 4 );

const TUint8 KDcsCharacterSet7Bit( 0x00 );

const TUint8 KDcsCharacterSet8Bit( 0x01 );

const TUint8 KDcsCharacterSet16Bit( 0x02 );

const TUint8 KDcsCharacterSet7Bit2( 0x00 );

const TUint8 KDcsCharacterSet16Bit2( 0x01 );

const TInt   KSatMaxUSSDString( 182 );

// USSD DCS coding.

const TUint8 KSatDcs7Bit( 0x40 );

const TUint8 KSatDcs8Bit( 0x44 );

const TUint8 KSatDcsUCS2( 0x48 );

const TUint8 KSatDcsUnknown( 0xFF );

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

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

// Two-phased constructor.

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

//

CSendUssdHandler* CSendUssdHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::NewL calling" )

    CSendUssdHandler* self = new( ELeave ) CSendUssdHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CSendUssdHandler::~CSendUssdHandler()

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::~CSendUssdHandler calling" )

    Cancel();

    if ( iUssdClient )

        {

        delete iUssdClient;

        iUssdClient = NULL;

        }

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::~CSendUssdHandler exiting" )

    }

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

// From class MSatCommand.

// Response from the client

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

//

void CSendUssdHandler::ClientResponse()

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::ClientResponse calling" )

    if ( iQueryRsp.iAccepted && !iNotificationSent )

        {

        LOG( NORMAL, 

        "SENDUSSD: CSendUssdHandler::ClientResponse Sending notification" )

        iNotificationSent = ETrue;

        // Register service request

        TRAP_IGNORE( iUtils->RegisterServiceRequestL(

            ESatSProactiveNotification,

            ESatSProactiveNotificationResponse,

            this ) )

        // Send notification

        iUtils->SatUiHandler().UiSession()->SendCommand(

            &iNotificationDataPckg,

            &iNotificationRspPckg,

            ESatSProactiveNotification );

        }

    // Notification sent

    else if ( iNotificationRsp.iAccepted && iNotificationSent )

        {

        LOG( NORMAL, 

        "SENDUSSD: CSendUssdHandler::ClientResponse Notification response" )

        }

    // User reject

    else

        {

        iUserAccepted = EFalse;

        iSendUssdRsp.iInfoType = RSat::KMeProblem;

        iSendUssdRsp.iAdditionalInfo.SetLength( 1 );

        iSendUssdRsp.iAdditionalInfo[0] = RSat::KScreenBusy;

        // Cannot return KPCmdNotAcceptedByUser (ETSI 11.14 v8.3.0 p65)

        iSendUssdRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        if ( iQueryRsp.iSessionTerminatedByUser )

            {

            LOG( NORMAL, 

            "SENDUSSD: CSendUssdHandler::ClientResponse \

            ESessionTerminatedByUser" )

            // Notify sim session end command that next sim session end

            // should close the ui session.

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            }

        SendTerminalResponse();

        }

    // Release the wait

    if ( iWait.IsStarted() )

        {

        LOG( NORMAL, "SENDUSSD: CSendUssdHandler::ClientResponse stop iWait" )

        iWait.AsyncStop();

        }

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::ClientResponse exiting" )

    }

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

// From class CSatCommandHandler.

// Waits for indication of user rejection

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

//

void CSendUssdHandler::Event( TInt aEvent )

    {

    LOG2( SIMPLE,

        "SENDUSSD: CSendUssdHandler::Event calling, aEvent:%d", aEvent )

    switch ( aEvent )

        {

        case MSatUtils::ECancelledUsingEndKey:

            {

            // Notify sim session end command that next sim session end

            // should close the ui session.

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            // This event is handled as above, but notification must be done.

            }

        //lint -fallthrough intended here

        case MSatUtils::ECommandCancelled:

            {

            // Cancel Ussd sending

            if ( iUssdClient )

                {

                LOG( SIMPLE, 

                "SENDUSSD: CSendUssdHandler::Event iUssdClient true" )

                iUssdClient->SendSatMessageCancel();

                iSendUssdRsp.iGeneralResult =

                    RSat::KUssdTransactionTerminatedByUser;

                iSendUssdRsp.iInfoType = RSat::KNoAdditionalInfo;

                iSendUssdRsp.iAdditionalInfo.Zero();

                SendTerminalResponse();

                }

            break;

            }

        default:

            {

            // Move event to base class

            CSatCommandHandler::Event( aEvent );

            }

        }

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::Event exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CSendUssdHandler::DoCancel()

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySendUssdCancel();

    if ( iUssdClient )

        {

        LOG( SIMPLE, 

        "SENDUSSD: CSendUssdHandler::DoCancel iUssdClient true" )

        delete iUssdClient;

        iUssdClient = NULL;

        }

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CSendUssdHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::IssueUSATRequest calling" )

    // Clear the IPC package.

    new (&iSendUssdData) RSat::TSendUssdV1();

    iNeedUiSession = ETrue;

    iQueryRsp.iAccepted = EFalse; // default

    iNotificationRsp.iAccepted = EFalse;

    iSendUssdRsp.iGeneralResult = RSat::KPSessionTerminatedByUser; // default

    iUtils->USatAPI().NotifySendUssd( aStatus, iSendUssdPckg );

    // Unregister from events

    iUtils->UnregisterEvent( this, MSatUtils::ECommandCancelled );

    iUtils->UnregisterEvent( this, MSatUtils::ECancelledUsingEndKey );

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// Precheck before executing the command.

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

//

TBool CSendUssdHandler::CommandAllowed()

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::CommandAllowed calling" )

    // Allow next terminal response to be sent

    iTerminalRespSent = EFalse;

    iSendUssdRsp.iUssdString.iUssdString.FillZ();

    iSendUssdRsp.iUssdString.iDcs = 0;

    RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

        iUtils->SystemState().GetNetworkRegistrationStatus() );

    TBool commandAllowed( ETrue );

    // If icon data without alpha id

    if ( ( RSat::EAlphaIdProvided != iSendUssdData.iAlphaId.iStatus ) &&

        ( ( RSat::ESelfExplanatory == iSendUssdData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory == iSendUssdData.iIconId.iQualifier ) ) )

        {

        commandAllowed = EFalse;

        iSendUssdRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        iSendUssdRsp.iInfoType = RSat::KNoAdditionalInfo;

        iSendUssdRsp.iAdditionalInfo.Zero();

        LOG( SIMPLE,

        "SENDUSSD: CSendUssdHandler::CommandAllowed Icon without alphaid \

        not allowed" )

        }

    else if (

         ( RMobilePhone::ERegisteredOnHomeNetwork != registrationStatus ) &&

         ( RMobilePhone::ERegisteredRoaming != registrationStatus ) )

        {

        commandAllowed = EFalse;

        iSendUssdRsp.iInfoType = RSat::KMeProblem;

        iSendUssdRsp.iAdditionalInfo.SetLength( 1 );

        iSendUssdRsp.iAdditionalInfo[0] = RSat::KNoService;

        iSendUssdRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        LOG( SIMPLE,

        "SENDUSSD: CSendUssdHandler::CommandAllowed Not registered in legal \

        network" )

        }

    // OK

    else

        {

        // Check Ussd string validity

        TInt dataLength( iSendUssdData.iUssdString.iUssdString.Length() );

        LOG2( SIMPLE, 

        "SENDUSSD: CSendUssdHandler::CommandAllowed Length of string: %d", 

        dataLength )

        // Validate USSD string length.

        TBool dataValid(

            ( dataLength > 0 ) && ( dataLength <= KSatMaxUSSDString ) );

        if ( dataValid )

            {

            LOG( SIMPLE, "SENDUSSD:  dataValid true" )

            // Validate Data Coding Scheme.

            dataValid = DcsValid( iSendUssdData.iUssdString.iDcs );

            if ( !dataValid )

                {

                LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::CommandAllowed Dcs \

                not acceptable" )

                }

            }

        // Second check in case DcsValid() returns EFalse

        if ( !dataValid )

            {

            LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::CommandAllowed \

            dataValid false" )

            commandAllowed = EFalse;

            iSendUssdRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

            iSendUssdRsp.iInfoType = RSat::KNoAdditionalInfo;

            iSendUssdRsp.iAdditionalInfo.Zero();

            }

        }

    // Check is command allowd

    if ( !commandAllowed )

        {

        LOG( SIMPLE, "SENDUSSD: \

            CSendUssdHandler::CommandAllowed exiting - not allowed" )

        SendTerminalResponse();

        }

    // Set icon command flag whether icon data was received and set qualifier

    // to no icon id

    // To be removed when icons are allowed in this command

    else if ( ( RSat::ESelfExplanatory ==

        iSendUssdData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory ==

        iSendUssdData.iIconId.iQualifier ) )

        {

        LOG( SIMPLE, "SENDUSSD: \

            CSendUssdHandler::CommandAllowed ENoIconId" )

        iIconCommand = ETrue;

        iSendUssdData.iIconId.iQualifier = RSat::ENoIconId;

        }

    else

        {

        iIconCommand = EFalse;

        }

    LOG2( SIMPLE, "SENDUSSD: CSendUssdHandler::CommandAllowed exiting,\

    commandAllowed: %d", commandAllowed )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Answers for need of UI session.

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

//

TBool CSendUssdHandler::NeedUiSession()

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::NeedUiSession calling" )

    iNeedUiSession = !TransparentUssdSending();

    // Notify Cover UI if it's supported

    if ( iNeedUiSession && iUtils->CoverUiSupported() )

        {

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ESendUssd;

        medEventData.iAlphaId =  iSendUssdData.iAlphaId;

        if ( iUtils->SystemState().IsConfirmSatOperationsOn() )

            {

            LOG( SIMPLE, 

            "SENDUSSD: CSendUssdHandler::NeedUiSession KSatLongDuration" )

            medEventData.iDuration.iNumOfUnits = KSatLongDuration;

            }

        else

            {

            LOG( SIMPLE, 

            "SENDUSSD: CSendUssdHandler::NeedUiSession KSatDefaultDuration" )

            medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

            }

        medEventData.iDuration.iTimeUnit = RSat::ESeconds;

        medEventData.iIconID = iSendUssdData.iIconId;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG2( SIMPLE, 

    "SENDUSSD: CSendUssdHandler::NeedUiSession exiting,iNeedUiSession:%d",

    iNeedUiSession )

    return iNeedUiSession;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CSendUssdHandler::HandleCommand()

    {

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::HandleCommand calling" )

    iUtils->NotifyEvent( MSatUtils::ESendUssdExecuting );

    // This is ETrue, until user rejects

    iUserAccepted = ETrue;

    if ( iNeedUiSession )

        {

        TRAP_IGNORE(

        // Register to listen user cancel events:

        // Cancel key event from dialog

        iUtils->RegisterL( this, MSatUtils::ECommandCancelled );

        // End key from dialog

        iUtils->RegisterL( this, MSatUtils::ECancelledUsingEndKey ) )

        // Build Qyery and Notify packages

        TSatAlphaIdStatus alphaIdStatus;

        if ( RSat::EAlphaIdNotPresent == iSendUssdData.iAlphaId.iStatus )

            {

            LOG( SIMPLE, 

            "SENDUSSD: CSendUssdHandler::HandleCommand EAlphaIdNotPresent" )

            alphaIdStatus = ESatAlphaIdNotProvided;

            }

        else if ( RSat::EAlphaIdProvided == iSendUssdData.iAlphaId.iStatus )

            {

            LOG( SIMPLE, 

            "SENDUSSD: CSendUssdHandler::HandleCommand EAlphaIdProvided" )

            alphaIdStatus = ESatAlphaIdNotNull;

            }

        else

            {

            LOG( SIMPLE, 

            "SENDUSSD: CSendUssdHandler::HandleCommand others" )

            alphaIdStatus = ESatAlphaIdNull;

            }

        // Has to be casted to TInt before casting to TSatIconQualifier, because

        // GCC warns about the direct cast.

        const struct TSatIconId iconId = { iSendUssdData.iIconId.iIdentifier,

            static_cast<TSatIconQualifier>(

                static_cast<TInt>( iSendUssdData.iIconId.iQualifier ) ) };

        iQueryData.iCommand = ESatSSendUssdQuery;

        iQueryData.iQueryText = iSendUssdData.iAlphaId.iAlphaId;

        iQueryData.iIconId = iconId;

        iQueryData.iAlphaIdStatus = alphaIdStatus;

        iNotificationSent = EFalse;

        iNotificationData.iCommand = ESatSSendUssdNotify;

        iNotificationData.iText = iSendUssdData.iAlphaId.iAlphaId;

        iNotificationData.iIconId = iconId;

        iNotificationData.iAlphaIdStatus = alphaIdStatus;

        MSatUiSession* uiSession = iUtils->SatUiHandler().UiSession();

        // Send either query or notification

        if ( iQueryOn )

            {

            LOG( NORMAL, 

            "SENDUSSD: CSendUssdHandler::HandleCommand Sending Query" )

            iNotificationSent = EFalse;

            // Register service request

            TRAP_IGNORE( iUtils->RegisterServiceRequestL(

                ESatSProactiveQuery,

                ESatSProactiveQueryResponse,

                this ) )

            // Send query

            uiSession->SendCommand(

                &iQueryPckg,

                &iQueryRspPckg,

                ESatSProactiveQuery );

            }

         else

            {

            LOG( NORMAL, 

            "SENDUSSD: CSendUssdHandler::HandleCommand Sending notification" )

            iNotificationSent = ETrue;

            // Register service request

            TRAP_IGNORE( iUtils->RegisterServiceRequestL(

                ESatSProactiveNotification,

                ESatSProactiveNotificationResponse,

                this ) )

            // Send notification

            uiSession->SendCommand(

                &iNotificationDataPckg,

                &iNotificationRspPckg,

                ESatSProactiveNotification );

            }

        if ( !iWait.IsStarted() )

            {

            LOG( SIMPLE, 

            "SENDUSSD: CSendUssdHandler::HandleCommand start iWait" )

            // Notification / query sent to UI, wait for response

            iWait.Start();

            }

        }

    if ( iUserAccepted )

        {

        LOG( SIMPLE, 

        "SENDUSSD: CSendUssdHandler::HandleCommand UserAccepted" )

        // No need to wait response, send Ussd string

        SendUssdString();

        }

    LOG( SIMPLE, "SENDUSSD: CSendUssdHandler::HandleCommand exiting" )

    }