/*

* Copyright (c) 2002-2009 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 SendSS command

*

*/

#include    <cphonegsmparserbase.h>

#include    <cphonegsmparserresult.h>

#include    <phonegsmparser.h>

#include    <cphonegsmoptioncontainerbase.h>

#include    "MSatSystemState.h"

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSendSsHandler.h"

#include    "SatLog.h"

#include    "csatsendssrequestcompletehandler.h"

#include    "csatsendssadditionalinfohandler.h"

#include    "csatsendsshandler.h"

// CustomAPI returns KCustomApiSsGsmActive=0x01

const TInt KSsGsmActiveSuccess = 0x01;

// CustomAPI returns KCustomApiSsGsmRegistered=0x02

const TInt KSsGsmRegistered = 0x02;

// CustomAPI returns KCustomApiSsGsmProvisioned=0x04

const TInt KSsGsmProvisioned = 0x04;

// CustomAPI returns KCustomApiSsGsmQuiescent=0x08

const TInt KSsGsmQuiescent = 0x08;

// CustomAPI returns SsServiceFailedResp=0xFFFF

const TInt KSsServiceFailed = 0xFFFF;

// Error code for NetworkFailure = 0xFFFE

const TInt KSsNetworkError = 0xFFFE;

//interval wait for ussd send

const TInt KCallbackInterval = 1000000;

// Interval wait for additional info

const TInt KSSRequestCallbackInterval = 5000000;

// Ss OperationCode value.

const TInt KSsOperationShowFDNLIst = 0x05;

const TInt KSsOperationPasswordRegistration = 0x06;

// Ss error

const TInt KSsSimAtkCcRejected = 0x13;

const TInt KTwo = 2;

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

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

// Two-phased constructor.

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

//

CSendSSHandler* CSendSSHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::NewL calling" )

    CSendSSHandler* self = new( ELeave ) CSendSSHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SENDSS: CSendSSHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CSendSSHandler::~CSendSSHandler()

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::~CSendSSHandler calling" )

    Cancel();

    // Destroy all objects.

    delete iAdditionalInfoHandler;

    delete iRequestCompleteHandler;

    delete iPhoneGsmHandlerBase;

    delete iParser;

    delete iResult;

    delete iPhoneGsmOptionContainerBase;

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        iTimer = NULL;

        }

    LOG( SIMPLE, "SENDSS: CSendSSHandler::~CSendSSHandler exiting" )

    }

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

// Processes the SS Request Complete.

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

//

void CSendSSHandler::DispatchSsRequestComplete( TInt aErrCode )

    {

    LOG2( SIMPLE, "SENDSS: CSendSSHandler::DispatchSsRequestComplete \

    called aErrCode: %i", aErrCode )

    if ( ( KSsGsmActiveSuccess == aErrCode ) ||

         ( KSsGsmRegistered == aErrCode ) ||

         ( KSsGsmProvisioned == aErrCode ) ||

         ( KSsGsmQuiescent == aErrCode ) )

        {

        iSsResult = KErrNone;

        }

    else

        {

        iSsResult = aErrCode;

        }

    // Store result for later use

    iSsResult = aErrCode;

    iRequestCompleteArrived = ETrue;

    //is additional info received

    if ( iAdditionalInfoArrived )

        {

        LOG( SIMPLE, 

        "SENDSS: CSendSSHandler::DispatchSsRequestComplete \

        iAdditionalInfoArrived true" )

        HandleSendSsResult();

        }

    else    //if not 5 second timer to get additional info

        {

        if ( !iTimer )

            {

            LOG( SIMPLE, 

            "CSendSSHandler::DispatchSsRequestComplete iTimer false" )

            TRAPD( err, iTimer = CPeriodic::NewL( CActive::EPriorityStandard ); );

            LOG2( NORMAL, "SENDSS: CSendSSHandler::DispatchSsRequestComplete \

            CPeriodic::NewL err: %d ", err )              

            if ( KErrNone == err )

                {

                iTimer->Start( KSSRequestCallbackInterval,

                    KCallbackInterval, TCallBack( SSRequestCallback, this ) );

                }

            }

        }

    LOG( SIMPLE, "CSendSSHandler::DispatchSsRequestComplete exit" )

    }

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

// Processes the SS aditional info.

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

//

void CSendSSHandler::DispatchSsAdditionalInfo(

    const TDesC& aAdditionalInfo )

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo called" )

    iAdditionalInfoArrived = ETrue;

    iAdditionalInfo.Copy( aAdditionalInfo );

    LOG2( SIMPLE, "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo length of\

    aAdditionalInfo: %i", aAdditionalInfo.Length())

    if ( aAdditionalInfo.Length() > 0 )

        {

        // This is special case due tsy will not send request complete.

        if ( ( ( KSsOperationPasswordRegistration == aAdditionalInfo[0] ) ||

               ( KSsOperationShowFDNLIst == aAdditionalInfo[0] ) ) &&

             ( !iRequestCompleteArrived ) )

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo special case" )

            iSsResult = KErrNone;

            iRequestCompleteArrived = ETrue;

            }

        }

    //is requestcompletenotification reveived

    if ( iRequestCompleteArrived )

        {

        LOG( SIMPLE, 

        "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo \

        iRequestCompleteArrived true" )

        HandleSendSsResult();

        }

    else    //if not 5 second timer to get requestcompletenote

        {

        if ( !iTimer )

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo iTimer false" )

            TRAPD( err, iTimer = CPeriodic::NewL( CActive::EPriorityStandard ); );

            LOG2( NORMAL, "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo \

            CPeriodic::NewL err: %d ", err )            

            if ( KErrNone == err )

                {

                iTimer->Start( KSSRequestCallbackInterval,

                    KCallbackInterval, TCallBack( SSRequestCallback, this ) );

                }

            }

        }

    LOG( SIMPLE, "SENDSS: CSendSSHandler::DispatchSsAdditionalInfo exit" )

    }

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

// From class MSatCommand.

// Response from the client.

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

//

void CSendSSHandler::ClientResponse()

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::ClientResponse calling" )

    if ( iQueryRsp.iAccepted && !iNotificationSent )

        {

        LOG( NORMAL, 

        "SENDSS: CSendSSHandler::ClientResponse Sending notification" )

        iNotificationSent = ETrue;

        // Register service request

        TRAP_IGNORE( iUtils->RegisterServiceRequestL(

            ESatSProactiveNotification,

            ESatSProactiveNotificationResponse,

            this ) )

        // Send notification

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

            &iNotificationDataPckg,

            &iNotificationRspPckg,

            ESatSProactiveNotification );

        }

    else if ( iNotificationRsp.iAccepted && iNotificationSent )

        {

        LOG( NORMAL, 

        "SENDSS: CSendSSHandler::ClientResponse Notification response" )

        }

    else // User reject

        {

        iUserAccepted = EFalse;

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

        iSendSsRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iSendSsRsp.iInfoType = RSat::KMeProblem;

        iSendSsRsp.iAdditionalInfo.SetLength( 1 );

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

        if ( iQueryRsp.iSessionTerminatedByUser )

            {

            LOG( NORMAL, "SENDSS: CSendSSHandler::ClientResponse \

            ESessionTerminatedByUser" )

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

            // should close the ui session.

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            }

        SendTerminalResponse();

        }

    // Release Wait

    if ( iSendWait.IsStarted() )

        {

        LOG( NORMAL, "SENDSS: CSendSSHandler::ClientResponse stop iSendWait" )

        iSendWait.AsyncStop();

        }

    LOG( SIMPLE, "SENDSS: CSendSSHandler::ClientResponse exiting" )

    }

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

// From class CSatCommandHandler.

// Waits for indication of user rejection

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

//

void CSendSSHandler::Event( TInt aEvent )

    {

    LOG2( SIMPLE, "SENDSS: CSendSSHandler::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:

            {

            // Check is there a confirmation on screen

            if ( !iQueryOn || iNotificationSent )

                {

                LOG( SIMPLE, 

                "SENDSS: CSendSSHandler::Event iNotificationSent true" )

                // Cancel notification requests

                iRequestCompleteHandler->Cancel();

                iAdditionalInfoHandler->Cancel();

                iSendSsRsp.iGeneralResult = RSat::KUssdTransactionTerminatedByUser;

                iSendSsRsp.iInfoType = RSat::KNoAdditionalInfo;

                iSendSsRsp.iAdditionalInfo.Zero();

                SendTerminalResponse();

                }

            break;

            }

        default:

            {

            // Move event to base class

            CSatCommandHandler::Event( aEvent );

            }

        }

    LOG( SIMPLE, "SENDSS: CSendSSHandler::Event exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CSendSSHandler::DoCancel()

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySendSsCancel();

    LOG( SIMPLE, "SENDSS: CSendSSHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CSendSSHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::IssueUSATRequest calling" )

    // Clear the IPC package.

    new (&iSendSsData) RSat::TSendSsV1();

    iQueryOn = EFalse;

    iQueryRsp.iAccepted = EFalse; // default

    iNotificationRsp.iAccepted = EFalse;

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

    iSendSsRsp.iInfoType = RSat::KNoAdditionalInfo;

    iSendSsRsp.iAdditionalInfo.Zero();

    iUtils->USatAPI().NotifySendSs( aStatus, iSendSsPckg );

    // Unregister from events

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

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

    LOG( SIMPLE, "SENDSS: CSendSSHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// Precheck before executing the command.

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

//

TBool CSendSSHandler::CommandAllowed()

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::CommandAllowed calling" )

    // Allow this command to send terminal response

    iTerminalRespSent = EFalse;

    RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

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

    TBool commandAllowed( ETrue );

    // icon without alpha id

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

         ( RSat::ESelfExplanatory == iSendSsData.iIconId.iQualifier ||

           RSat::ENotSelfExplanatory == iSendSsData.iIconId.iQualifier ) )

        {

        iSendSsRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        iSendSsRsp.iInfoType = RSat::KNoAdditionalInfo;

        iSendSsRsp.iAdditionalInfo.Zero();

        commandAllowed = EFalse;

        LOG( SIMPLE,

            "SENDSS: CSendSSHandler::CommandAllowed icon without alpha id" )

        }

    else if ( ( RMobilePhone::ERegisteredOnHomeNetwork != registrationStatus ) &&

        ( RMobilePhone::ERegisteredRoaming != registrationStatus ) )

        {

        iSendSsRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iSendSsRsp.iInfoType = RSat::KMeProblem;

        iSendSsRsp.iAdditionalInfo.SetLength( 1 );

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

        commandAllowed = EFalse;

        LOG( SIMPLE,

            "SENDSS: CSendSSHandler::CommandAllowed no service" )

        }

    // 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 ==

        iSendSsData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory ==

        iSendSsData.iIconId.iQualifier ) )

        {

        LOG( SIMPLE,

            "SENDSS: CSendSSHandler::CommandAllowed ENoIconId" )

        iIconCommand = ETrue;

        iSendSsData.iIconId.iQualifier = RSat::ENoIconId;

        }

    else

        {

        LOG( SIMPLE,

            "SENDSS: CSendSSHandler::CommandAllowed others" )

        iIconCommand = EFalse;

        }

    if ( !commandAllowed )

        {

        SendTerminalResponse();

        LOG( SIMPLE, "SENDSS: CSendSSHandler::CommandAllowed not allowed" )

        }

    LOG( SIMPLE, "SENDSS: CSendSSHandler::CommandAllowed exiting" )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Answers for need of UI session.

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

//

TBool CSendSSHandler::NeedUiSession()

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::NeedUiSession calling" )

    iNeedUiSession = !TransparentSsSending();

    // Notify Cover UI if it's supported

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

        {

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ESendSs;

        medEventData.iAlphaId = iSendSsData.iAlphaId;

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

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::NeedUiSession KSatLongDuration" )

            medEventData.iDuration.iNumOfUnits = KSatLongDuration;

            }

        else

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::NeedUiSession KSatDefaultDuration" )

            medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

            }

        medEventData.iDuration.iTimeUnit = RSat::ESeconds;

        medEventData.iIconID = iSendSsData.iIconId;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG2( SIMPLE, "SENDSS: CSendSSHandler::NeedUiSession exiting,\

    iNeedUiSession: %d", iNeedUiSession )

    return iNeedUiSession;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CSendSSHandler::HandleCommand()

    {

    LOG( SIMPLE, "SENDSS: CSendSSHandler::HandleCommand calling" )

    iUtils->NotifyEvent( MSatUtils::ESendSsExecuting );

    // This is true, by default

    iUserAccepted = ETrue;

    if ( iNeedUiSession )

        {

        LOG( SIMPLE, 

        "SENDSS: CSendSSHandler::HandleCommand iNeedUiSession true" )

        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

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

        // GCC warns about the direct cast.

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

            static_cast<TSatIconQualifier>(

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

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

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::HandleCommand EAlphaIdNotPresent" )

            iQueryData.iAlphaIdStatus = ESatAlphaIdNotProvided;

            iNotificationData.iAlphaIdStatus = ESatAlphaIdNotProvided;

            }

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

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::HandleCommand EAlphaIdProvided" )

            iQueryData.iAlphaIdStatus = ESatAlphaIdNotNull;

            iNotificationData.iAlphaIdStatus = ESatAlphaIdNotNull;

            }

        else

            {

            LOG( SIMPLE, 

            "SENDSS: CSendSSHandler::HandleCommand ESatAlphaIdNull" )