/*

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

*

*/

#include    <e32std.h>

#include    <etelmmerr.h>

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatSystemState.h"

#include    "MSatBIPUtils.h"

#include    "MSatBIPDataChannel.h"

#include    "MSatApnHandler.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSendDataHandler.h"

#include    "SatLog.h"

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

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

// Two-phased constructor.

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

//

CSendDataHandler* CSendDataHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::NewL calling" )

    CSendDataHandler* self = new( ELeave ) CSendDataHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SendData: CSendDataHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CSendDataHandler::~CSendDataHandler()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::~CSendDataHandler calling" )

    Cancel();

    iDataChannel = NULL;

    LOG( SIMPLE, "SendData: CSendDataHandler::~CSendDataHandler exiting" )

    }

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

// From class MSatCommand.

// Response from the client.

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

//

void CSendDataHandler::ClientResponse()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::ClientResponse calling-exiting" )

    // Don't send terminal response, already sent in HandleCommand

    }

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

// From class MSatSendDataObserver.

// Notification of data has been sent.

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

//

void CSendDataHandler::DataSentNotification(

    const TInt aError, const TInt aLength )

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::DataSentNotification calling" )

    if ( MSatBIPUtils::ESatBIPSuccess != aError )

        {

        LOG( SIMPLE, "SendData: CSendDataHandler::DataSentNotification Error" )

        iSendDataRspData.iGeneralResult = RSat::KBearerIndepProtocolError;

        }

    else

        {

        iSendDataRspData.iGeneralResult = RSat::KSuccess;

        iFreeBuffSize = aLength;

        }

    SendTerminalResponse( aError );

    LOG( SIMPLE, "SendData: CSendDataHandler::DataSentNotification exiting" )

    }

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

// From class MSatSendDataObserver.

// Notfication from the connection.

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

//

void CSendDataHandler::ConnectionNotification( TInt aError )

    {

    LOG2( SIMPLE, "SENDDATA: CSendDataHandler::ConnectionNotification\

         calling with code %i", aError )

    if ( KErrNone == aError )

        {

        // Connection established, send data

        SendData();

        }

    else

        {

        // Get connection info and remove APN from CommDB, if created during

        // OpenChannel command

        TUint32 apnId( iDataChannel->ConnInfo().iCreatedApnId );

        LOG2( SIMPLE, "SENDDATA: CSendDataHandler::ConnectionNotification \

        apnId: %i", apnId )

        if ( apnId > 0 )

            {

            TRAP_IGNORE( iUtils->BipUtils().ApnHandler().DeleteApnL( apnId ) )

            }

        // Connection failed

        iSendDataRspData.iGeneralResult = RSat::KBearerIndepProtocolError;

        SendTerminalResponse( MSatBIPUtils::ESatBIPChannelClosed );

        }

    LOG( SIMPLE, "SENDDATA: CSendDataHandler::ConnectionNotification exiting" )

    }

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

// From class CSatCommandHandler.

// Waits for indication of user wanting to close the BIP session.

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

//

void CSendDataHandler::Event( TInt aEvent )

    {

    LOG2( SIMPLE, "CSendDataHandler::Event calling, aEvent:%d", aEvent )

    switch ( aEvent )

        {

        case MSatUtils::ECommandCancelled:

        case MSatUtils::ECancelledUsingEndKey:

            {

            // Check Channel activation status

            if ( iUtils->BipUtils().IsContextActive() )

                {

                LOG( SIMPLE, "CSendDataHandler::Event IsContextActive" )

                // Next command is rejected

                iUserCancelled = ETrue;

                SendTerminalResponse(); // If command is executing, send.

                }

            break;

            }

        case MSatUtils::EOpenChannelExecuting:

            {

            // New channel, reset user cancel flag.

            iUserCancelled = EFalse;

            break;

            }

        default:

            {

            // Move event to base class

            CSatCommandHandler::Event( aEvent );

            }

        }

    LOG( SIMPLE, "CSendDataHandler::Event exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CSendDataHandler::DoCancel()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySendDataCancel();

    LOG( SIMPLE, "SendData: CSendDataHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CSendDataHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::IssueUSATRequest calling" )

    // Empty previously recevied data.

    new (&iSendDataData) RSat::TSendDataV2();

    iUtils->USatAPI().NotifySendData( aStatus, iSendDataPckg );

    iUtils->NotifyEvent( MSatUtils::EBipCommandDoneExecuting );

    LOG( SIMPLE, "SendData: CSendDataHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// Precheck before executing the command.

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

//

TBool CSendDataHandler::CommandAllowed()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::CommandAllowed calling" )

    TBool commandAllowed( ETrue );

    if ( iUserCancelled )

        {

        LOG( SIMPLE, "SendData: CSendDataHandler::CommandAllowed \

        UserCancelled" )

        SendTerminalResponse();

        commandAllowed = EFalse;

        }

    else

        {

        // Proceed with the command

        const TInt channelId( iSendDataData.iDestination );

        if ( ( RSat::KChannel1 > channelId || RSat::KChannel7 < channelId ) ||

            // If icon data without alpha id

            ( ( RSat::EAlphaIdProvided !=

                iSendDataData.iAlphaId.iStatus ) &&

            ( ( RSat::ESelfExplanatory ==

                iSendDataData.iIconId.iQualifier ) ||

            ( RSat::ENotSelfExplanatory ==

                iSendDataData.iIconId.iQualifier ) ) ) )

            {

            LOG( NORMAL, "SendData: CSendDataHandler::CommandAllowed Unknown \

                channel identifier or icon without alpha id - Not allowed" )

            // Create the response IPC package

            iSendDataRspData.iGeneralResult = RSat::KCmdDataNotUnderstood;

            iSendDataRspData.iInfoType = RSat::KNoAdditionalInfo;

            iSendDataRspData.iAdditionalInfo.Zero();

            commandAllowed = EFalse;

            }

        else

            {

            RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

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

            if ( ( RMobilePhone::ERegisteredOnHomeNetwork !=

                    registrationStatus ) &&

                 ( RMobilePhone::ERegisteredRoaming != registrationStatus ) )

                {

                iSendDataRspData.iInfoType = RSat::KMeProblem;

                iSendDataRspData.iAdditionalInfo.SetLength( 1 );

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

                iSendDataRspData.iGeneralResult = RSat::KMeUnableToProcessCmd;

                commandAllowed = EFalse;

                LOG( NORMAL,

                    "SendData: CSendDataHandler::CommandAllowed Not allowed" )

                }

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

                iSendDataData.iIconId.iQualifier ) ||

                ( RSat::ENotSelfExplanatory ==

                iSendDataData.iIconId.iQualifier ) )

                {

                LOG( NORMAL,

                    "SendData: CSendDataHandler::CommandAllowed ENoIconId" )

                iIconCommand = ETrue;

                iSendDataData.iIconId.iQualifier = RSat::ENoIconId;

                }

            else

                {

                LOG( NORMAL,

                    "SendData: CSendDataHandler::CommandAllowed others" )

                iIconCommand = EFalse;

                }

            }

        if ( !commandAllowed )

            {

            LOG( NORMAL,

            "SendData: CSendDataHandler::CommandAllowed command not allowed" )

            iSendDataRspData.SetPCmdNumber( iSendDataData.PCmdNumber() );

            TerminalRsp( RSat::ESendData, iSendDataRspPckg );

            }

        }

    LOG2( SIMPLE, 

    "SendData: CSendDataHandler::CommandAllowed exiting, commandAllowed: %d", 

    commandAllowed )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Need for ui session.

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

//

TBool CSendDataHandler::NeedUiSession()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::NeedUiSession calling" )

    // UI is NOT needed in case where AlphaID is provided and it is a NULL

    // If information indication to the user is needed and data is not

    // stored in Tx Buffer, show it now.

    iNeedUiSession = ( !( RSat::EAlphaIdNull ==

                          iSendDataData.iAlphaId.iStatus ) &&

                       !( RSat::EAlphaIdNotPresent ==

                          iSendDataData.iAlphaId.iStatus ) &&

                       !( RSat::EStoreDataInTxBuffer ==

                          iSendDataData.iMode ) );

    // Send notification to Mediator client if Cover UI is supported

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

        {

        LOG( SIMPLE, 

            "SendData: CSendDataHandler::NeedUiSession CoverUiSupported" )

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ESendData;

        medEventData.iAlphaId = iSendDataData.iAlphaId;

        medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

        medEventData.iIconID = iSendDataData.iIconId;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG2( SIMPLE, 

    "SendData: CSendDataHandler::NeedUiSession exiting,iNeedUiSession: %d",

    iNeedUiSession )

    return iNeedUiSession;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CSendDataHandler::HandleCommand()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::HandleCommand calling" )

    // Notify other's about this command executiuon

    iUtils->NotifyEvent( MSatUtils::ESendDataExecuting );

    iUtils->NotifyEvent( MSatUtils::EBipCommandExecuting );

    TInt uiError( KErrNone );

    if ( iNeedUiSession )

        {

        LOG( NORMAL, "SendData: CSendDataHandler::HandleCommand \

            Sending UI Notification" )

        uiError = SendUiNotification();

        }

    LOG2( NORMAL, "SendData: CSendDataHandler::HandleCommand \

          uiError: %i", uiError )

    if ( KErrNone == uiError )

        {

        iFreeBuffSize = 0;

        TInt err( MSatBIPUtils::ESatBIPSuccess );

        // Get Data Channel

        iDataChannel = iUtils->BipUtils().DataChannel(

            iSendDataData.iDestination, err );

        // Check the SendData mode. If Store, no need for active channel

        if ( ( iDataChannel ) &&

             ( RSat::EStoreDataInTxBuffer == iSendDataData.iMode ) )

            {

            LOG( NORMAL, "SendData: CSendDataHandler::HandleCommand \

                 send data" )

            SendData();

            }

        //Check if ch was found and if not active, try to activate

        else if ( ( iDataChannel ) &&

                  ( MSatBIPUtils::ESatBIPChannelClosed == err ) )

            {

            LOG( NORMAL, "SendData: CSendDataHandler::HandleCommand \

                Inactive channel found, try to activate" )

            TRAP( err, iDataChannel->ActivateConnectionL( this ) );

            if ( err != KErrNone )

                {

                LOG2( NORMAL, "SendData: CSendDataHandler::HandleCommand \

                 Channel activation Failed Error %i", err )

                // Get connection info and remove APN from CommDB, if created

                // during OpenChannel command

                TUint32 apnId( iDataChannel->ConnInfo().iCreatedApnId );

                LOG2( NORMAL, "SendData: CSendDataHandler::HandleCommand \

                apnId: %i", apnId )

                if ( apnId > 0 )

                    {

                    TRAP_IGNORE(

                        iUtils->BipUtils().ApnHandler().DeleteApnL( apnId ) )

                    }

                if ( ( KErrMMEtelActivationBlockedByCallControlNoText == err ) ||

                     ( KErrMMEtelActivationBlockedByCallControlWithText == err ) )

                    {

                    err = RSat::KActionNotAllowed;

                    iSendDataRspData.iGeneralResult = 

                        RSat::KInteractionWithCCPermanentError;

                    LOG( DETAILED, "  CC on GPRS not allowed" )

                    }

                else

                    {

                    err = MSatBIPUtils::ESatBIPChannelClosed;

                    iSendDataRspData.iGeneralResult =

                        RSat::KBearerIndepProtocolError;

                    }

                SendTerminalResponse( err );

                }

            }

        // SendImmediate, Only if Active channel exists

        else if ( MSatBIPUtils::ESatBIPSuccess == err )

            {

            LOG( NORMAL, "SendData: CSendDataHandler::HandleCommand \

                 SendImmediate" )

            SendData();

            }

        // Active channel doesn't exist

        else

            {

            LOG2( NORMAL, "SendData: CSendData::HandleCommand \

                    Error %i", err )

            iSendDataRspData.iGeneralResult = RSat::KBearerIndepProtocolError;

            SendTerminalResponse( err );

            }

        }

    LOG( SIMPLE, "SendData: CSendDataHandler::HandleCommand exiting" )

    }

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

// From class CSatCommandHandler.

// Indicates the failure of launching ui client.

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

//

void CSendDataHandler::UiLaunchFailed()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::UiLaunchFailed calling" )

    iSendDataRspData.iGeneralResult = RSat::KMeUnableToProcessCmd;

    iSendDataRspData.iInfoType = RSat::KMeProblem;

    iSendDataRspData.iAdditionalInfo.SetLength( 1 );

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

    iSendDataRspData.SetPCmdNumber( iSendDataData.PCmdNumber() );

    TerminalRsp( RSat::ESendData, iSendDataRspPckg );

    LOG( SIMPLE, "SendData: CSendDataHandler::UiLaunchFailed exiting" )

    }

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

//lint -e{1403, 1769} Can not be initialized.

CSendDataHandler::CSendDataHandler() :

    CSatCommandHandler(),

    iSendDataData(),

    iSendDataPckg( iSendDataData ),

    iSendDataRspData(),

    iSendDataRspPckg( iSendDataRspData ),

    iSendDataUiData(),

    iSendDataUiPckg( iSendDataUiData ),

    iSendDataUiRsp(),

    iSendDataUiRspPckg( iSendDataUiRsp ),

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

    iIconCommand( EFalse )

    {

    LOG( SIMPLE,

        "SendData: CSendDataHandler::CSendDataHandler calling - exiting" )

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CSendDataHandler::ConstructL()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::ConstructL calling" )

     // Register to ui service request

     iUtils->RegisterServiceRequestL( ESatSProactiveNotification,

        ESatSProactiveNotificationResponse, this );

    // Register to ui service request

    // Cancel key event from dialog

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

    // End key from dialog

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

    // Open channel execution

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

    LOG( SIMPLE, "SendData: CSendDataHandler::ConstructL exiting" )

    }

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

// Sends data

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

//

void CSendDataHandler::SendData()

    {

    LOG( SIMPLE, "SendData: CSendDataHandler::SendData calling" )

    // Indicates the send mode.

    TBool sendImmediately( RSat::ESendDataImmediately == iSendDataData.iMode );

    TInt err( MSatBIPUtils::ESatBIPSuccess );