/*

* 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 SendSm command

*

*/

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatSystemState.h"

#include    "MSatUiSession.h"

#include    "SatSTypes.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSatSSendMessageNoLoggingHandler.h"

#include    "CSendSmHandler.h"

#include    "SatLog.h"

#include    "gsmerror.h"

#include    <exterror.h>

#include    "TSatExtErrorUtils.h"

const TUint8 KPlus = 0x2b; // '+' character

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

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

// Two-phased constructor.

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

//

CSendSmHandler* CSendSmHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::NewL calling" )

    CSendSmHandler* self = new( ELeave ) CSendSmHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SENDSM: CSendSmHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CSendSmHandler::~CSendSmHandler()

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::~CSendSmHandler calling" )

    delete iMsgSender;

    Cancel();

    LOG( SIMPLE, "SENDSM: CSendSmHandler::~CSendSmHandler exiting" )

    }

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

// From class MSatCommand.

// Query response.

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

//

void CSendSmHandler::ClientResponse()

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::ClientResponse calling" )

    // Query response from client.

    if ( iQueryRsp.iAccepted && !iNotificationSent )

        {

        LOG( SIMPLE, "SENDSM: CSendSmHandler::ClientResponse Query response" )

        // Send notification to UI

        // Register notification observer

        TRAP_IGNORE( iUtils->RegisterServiceRequestL(

            ESatSProactiveNotification,

            ESatSProactiveNotificationResponse,

            this ) )

        // Get UISession.

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

        // Send command to SatClient.

        uiSession->SendCommand( &iNotificationDataPckg,

            &iNotificationRspPckg, ESatSProactiveNotification );

        iNotificationSent = ETrue;

        }

    else if ( iNotificationRsp.iAccepted && iNotificationSent )

        {

        LOG( SIMPLE, "SENDSM: CSendSmHandler::ClientResponse get response" )

        // Then we can proceed with the msg sending

        if ( !iMsgSender->IsActive() )

            {

            LOG( SIMPLE, 

            "SENDSM: CSendSmHandler::ClientResponse start iMsgSender" )

            iMsgSender->Start( iSendSmData );

            }

        }

    else

        {

        if ( iQueryRsp.iSessionTerminatedByUser )

            {

            LOG( SIMPLE, 

            "SENDSM: CSendSmHandler::ClientResponse close ui session" )

            // Next SimSession end will close the ui session

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            }

        iSendSmRsp.iGeneralResult = RSat::KPCmdNotAcceptedByUser;

        iSendSmRsp.iInfoType = RSat::KNoAdditionalInfo;

        iSendSmRsp.iAdditionalInfo.Zero();

        iSendSmRsp.SetPCmdNumber( iSendSmData.PCmdNumber() );

        TerminalRsp( RSat::ESendSm, iSendSmRspPckg );

        }

    LOG( SIMPLE, "SENDSM: CSendSmHandler::ClientResponse exiting" )

    }

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

// From class MSatEventObserver.

// Event notification.

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

//

void CSendSmHandler::Event( TInt aEvent )

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::Event calling" )

    if ( MSatUtils::EMoSmControlExecuting == aEvent )

        {

        LOG( NORMAL, "SENDSM:   Event EMoSmControlExecuting" )

        iMoSmControlActive = ETrue;

        }

    else if ( MSatUtils::EMoSmControlDone == aEvent )

        {

        LOG( NORMAL, "SENDSM:   Event EMoSmControlDone" )

        iMoSmControlActive = EFalse;

        // Check if Sendsm is waiting.

            {

            LOG( SIMPLE, "SENDSM: CSendSmHandler::Event sendsm" )

            // Do the Sendsm.

            HandleCommand();

            }

        }

    CSatCommandHandler::Event( aEvent );

    LOG( SIMPLE, "SENDSM: CSendSmHandler::Event exiting" )

    }

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

// From class MSatEventObserver.

// Notification that sms was sent.

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

//

void CSendSmHandler::SmsSent( TInt aErrorCode )

    {

    LOG2( SIMPLE, "SENDSM: CSendSmHandler::SmsSent calling, &d", aErrorCode )

    // Ui session is listening for sms sent event.

    iUtils->NotifyUiEvent( ESatSSmEndEvent, ESatEventNone, aErrorCode );

    iSendSmRsp.iInfoType = RSat::KNoAdditionalInfo;

    iSendSmRsp.iAdditionalInfo.Zero();

    iSendSmRsp.SetPCmdNumber( iSendSmData.PCmdNumber() );

    if ( KErrSatMoSmControlModified == aErrorCode )

        {

        LOG( SIMPLE, "SENDSM:   KErrSatMoSmControlModified" )

        iSendSmRsp.iGeneralResult = RSat::KSuccess;

        }

    else if ( KErrSatMoSmControlBarred == aErrorCode )

        {

        LOG( SIMPLE, "SENDSM:   KErrSatMoSmControlBarred" )

        iSendSmRsp.iGeneralResult = RSat::KInteractionWithCCPermanentError;

        // Additional info field contains extra info.

        iSendSmRsp.iInfoType = RSat::KControlInteraction;

        // Lower byte contains the SMS error cause.

        iSendSmRsp.iAdditionalInfo.SetLength( 1 );

        iSendSmRsp.iAdditionalInfo[0] =

            static_cast<TUint16>( RSat::KActionNotAllowed );

        }

    else if ( TSatExtErrorUtils::IsExtendedError( aErrorCode ) )

        {

        LOG( SIMPLE, "SENDSM:   Error code < KErrGsmSmsBase" )

        // Map error value

        TUint8 addInfo( 0 );

        if ( TSatExtErrorUtils::IsNetworkError( aErrorCode ) )

            {

            LOG( SIMPLE, "SENDSM:   NetworkError" )

            // Map extended error

            addInfo = TSatExtErrorUtils::MapError( aErrorCode );

            // Error utils found the correct response

            iSendSmRsp.iGeneralResult = RSat::KNetworkUnableToProcessCmd;

            // Additional info field contains extra info.

            iSendSmRsp.iInfoType = RSat::KSatNetworkErrorInfo;

            }

        else

            {

            LOG( SIMPLE, "SENDSM:   MeError" )

            // No need to modify mapped value

            addInfo = TSatExtErrorUtils::MapError( aErrorCode, EFalse );

            // Return GSM Error specific value.

            iSendSmRsp.iGeneralResult = RSat::KSmsRpError;

            // Additional info field contains extra info.

            iSendSmRsp.iInfoType = RSat::KMeProblem;

            }

        // Add additional info into terminal response

        iSendSmRsp.iAdditionalInfo.SetLength( 1 );

        iSendSmRsp.iAdditionalInfo[0] = static_cast<TUint16>( addInfo );

        }

    else if ( ( KErrGsmSMSNoNetworkService == aErrorCode ) ||

              ( KErrGsmSSNotAvailable == aErrorCode ) )

        {

        LOG( SIMPLE, "SENDSM:     UnableToProcessCmd" )

        iSendSmRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iSendSmRsp.iInfoType = RSat::KMeProblem;

        iSendSmRsp.iAdditionalInfo.SetLength( 1 );

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

        }

    else if ( KErrGeneral == aErrorCode )

        {

        LOG( SIMPLE, "SENDSM:   KErrGeneral" )

        iSendSmRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        }

    else if ( KErrTimedOut == aErrorCode )

        {

        LOG( SIMPLE, "SENDSM:   KErrTimedOut" )

        iSendSmRsp.iGeneralResult = RSat::KNetworkUnableToProcessCmd;

        }

    else

        {

        if ( !iPartialComprehension )

            {

            if ( !iNotificationRsp.iRequestedIconDisplayed &&  // No icon displayed

                ( RSat::ESelfExplanatory ==             // Only icon

                    iSendSmData.iIconId.iQualifier ||

                  RSat::ENotSelfExplanatory ==          // Icon and text

                    iSendSmData.iIconId.iQualifier ) )

                {

                LOG( SIMPLE, "SENDSM:   KSuccessRequestedIconNotDisplayed" )

                iSendSmRsp.iGeneralResult =

                    RSat::KSuccessRequestedIconNotDisplayed;

                }

            else

                {

                LOG( SIMPLE, "SENDSM:   Succeed" )

                iSendSmRsp.iGeneralResult = RSat::KSuccess;

                }

            }

        else

            {

            LOG( SIMPLE, "SENDSM:   KPartialComprehension" )

            iPartialComprehension = EFalse;

            iSendSmRsp.iGeneralResult = RSat::KPartialComprehension;

            }

        }

    // If command had icon data and was done succesfully, report that icon

    // was not shown

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

    if ( ( RSat::KSuccess == iSendSmRsp.iGeneralResult ) &&

        iIconCommand )

        {

        LOG( SIMPLE, 

        "SENDSM: CSendSmHandler::SmsSent KSuccessRequestedIconNotDisplayed" )

        iSendSmRsp.iGeneralResult =

                    RSat::KSuccessRequestedIconNotDisplayed;

        }

    TerminalRsp( RSat::ESendSm, iSendSmRspPckg );

    LOG( SIMPLE, "SENDSM: CSendSmHandler::SmsSent exiting" )

    }

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

// Sets the sca number and also sets the numbering plan and the type of number.

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

//

TBool CSendSmHandler::SetScaNumber( const RSat::TSatTelNumber& aScaNumber )

    {

    LOG2( SIMPLE,

        "SENDSM: CSendSmHandler::SetScaNumber calling, aScaNumber :%S",

        &aScaNumber )

    TBool scaAvailable ( EFalse );

    iSendSmData.iAddress.iTelNumber = aScaNumber;

    if ( aScaNumber.Length() > 0 )

        {

        LOG2( SIMPLE, "SENDSM:   aScaNumber.Length: %d", aScaNumber.Length() )

        const RSat::TAddress address = iSendSmData.iAddress;

        scaAvailable = ETrue;

        // Is the number in international format, ie first character is '+'.

        if ( KPlus == address.iTelNumber[0] )

            {

            const RSat::TTypeOfNumber ton = address.iTypeOfNumber;

            // Set the type of number, if it is not known.

            if ( ( RSat::ETypeOfNumberNotSet == ton ) ||

                 ( RSat::EUnknownNumber == ton ) )

                {

                LOG( SIMPLE, "SENDSM:   International Number" )

                iSendSmData.iAddress.iTypeOfNumber =

                    RSat::EInternationalNumber;

                }

            const RSat::TNumberingPlan npi = address.iNumberPlan;

            // Set the numbering plan if it is not known.

            if ( ( RSat::ENumberingPlanNotSet == npi ) ||

                 ( RSat::EUnknownNumberingPlan == npi ) )

                {

                LOG( SIMPLE, "SENDSM:   Isdn Number Plan" )

                iSendSmData.iAddress.iNumberPlan = RSat::EIsdnNumberPlan;

                }

            }

        }

    LOG2( SIMPLE,

        "SENDSM: CSendSmHandler::SetScaNumber exiting, scaAvailable:%i",

        scaAvailable )

    return scaAvailable;

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CSendSmHandler::DoCancel()

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySendSmCancel();

    LOG( SIMPLE, "SENDSM: CSendSmHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CSendSmHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::IssueUSATRequest calling" )

    // Clear the IPC package.

    new (&iSendSmData) RSat::TSendSmV1();

    iNeedUiSession = ETrue;

    iQueryRsp.iAccepted = EFalse; // default

    iNotificationRsp.iAccepted = EFalse;

    iUtils->USatAPI().NotifySendSm( aStatus, iSendSmPckg );

    LOG( SIMPLE, "SENDSM: CSendSmHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// SendSm command is not allowed in following situations:

//   - Phone is not registered to homenetwork and roaming.

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

//

TBool CSendSmHandler::CommandAllowed()

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::CommandAllowed calling" )

    TBool commandAllowed( ETrue );

    RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

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

    // Check the PC Suite backup / restore status. If it is ongoing, SendSm is

    // not allowed.

    const TBool backupOngoing(

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

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

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

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

        {

        commandAllowed = EFalse;

        iSendSmRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        iSendSmRsp.iInfoType = RSat::KNoAdditionalInfo;

        iSendSmRsp.iAdditionalInfo.Zero();

        LOG( SIMPLE, "SENDSM:   Not allowed data not understood" )

        }

    else if ( ( RMobilePhone::ERegisteredOnHomeNetwork !=

        registrationStatus ) &&

        ( RMobilePhone::ERegisteredRoaming != registrationStatus ) ||

        backupOngoing )

        {

        commandAllowed = EFalse;

        iSendSmRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iSendSmRsp.iInfoType = RSat::KMeProblem;

        iSendSmRsp.iAdditionalInfo.SetLength( 1 );

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

        LOG( SIMPLE, "SENDSM:   Not allowed Me unable to process" )

        }

    else if ( !IsSCAAvailable() )

        {

        LOG( SIMPLE, "SENDSM:   Not allowed !IsSCAAvailable()" )

        commandAllowed = EFalse;

        iSendSmRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

        iSendSmRsp.iInfoType = RSat::KMeProblem;

        iSendSmRsp.iAdditionalInfo.SetLength( 1 );

        iSendSmRsp.iAdditionalInfo[0] = RSat::KNoSpecificMeProblem;

        }

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

        iSendSmData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory ==

        iSendSmData.iIconId.iQualifier ) )

        {

        LOG( SIMPLE, "SENDSM:   ENoIconId" )

        iIconCommand = ETrue;

        iSendSmData.iIconId.iQualifier = RSat::ENoIconId;

        }

    else

        {

        LOG( SIMPLE, "SENDSM:   others" )

        iIconCommand = EFalse;

        }

    //lint -e{961} else block not needed.

    if ( !commandAllowed )

        {

        iSendSmRsp.SetPCmdNumber( iSendSmData.PCmdNumber() );

        TerminalRsp( RSat::ESendSm, iSendSmRspPckg );

        }

    LOG2( SIMPLE, "SENDSM: CSendSmHandler::CommandAllowed exiting,\

          commandAllowed: %d", commandAllowed )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Need for ui session.

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

//

TBool CSendSmHandler::NeedUiSession()

    {

    LOG( NORMAL, "SENDSM: CSendSmHandler::NeedUiSession calling" )

    // Check do we need UI

    // Store the result for later use

    iNeedUiSession = !TransparentSmsSending();

    // Notify Cover UI if it's supported

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

        {

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ESendSm;

        medEventData.iAlphaId =  iSendSmData.iAlphaId;

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

            {

            LOG( NORMAL, 

            "SENDSM: CSendSmHandler::NeedUiSession KSatLongDuration" )

            medEventData.iDuration.iNumOfUnits = KSatLongDuration;

            }

        else

            {

            LOG( NORMAL, 

            "SENDSM: CSendSmHandler::NeedUiSession KSatDefaultDuration" )

            medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

            }

        medEventData.iDuration.iTimeUnit = RSat::ESeconds;

        medEventData.iIconID = iSendSmData.iIconId;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG2( NORMAL, "SENDSM: CSendSmHandler::NeedUiSession exiting, \

          iNeedUiSession: %d", iNeedUiSession )

    return iNeedUiSession;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CSendSmHandler::HandleCommand()

    {

    LOG( SIMPLE, "SENDSM: CSendSmHandler::HandleCommand calling" )

    // If mo sm control is active, command waits for the EMoSmControlDone event

    // and sends the command then.

    if ( !iMoSmControlActive )

        {

        iUtils->NotifyEvent( MSatUtils::ESendSmExecuting );

        if ( !iNeedUiSession )