/*

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

*

*/

#include    <etelpckt.h>

#include    <etelmmerr.h>

#include    "COpenChannelHandler.h"

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatUiSession.h"

#include    "MSatSystemState.h"

#include    "MSatApnHandler.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "SatLog.h"

#include    "extendedconnpref.h"

const TUint8 KChannelStatusLength( 2 );

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

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

// Two-phased constructor.

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

//

COpenChannelHandler* COpenChannelHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::NewL calling" )

    COpenChannelHandler* self = new( ELeave ) COpenChannelHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::NewL exiting" )

    return self;

    }

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

// Destructor

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

//

COpenChannelHandler::~COpenChannelHandler()

    {

    LOG( SIMPLE,

        "OPENCHANNEL: COpenChannelHandler::~COpenChannelHandler calling" )

    Cancel();

    iDataChannel = NULL;

    LOG( SIMPLE,

        "OPENCHANNEL: COpenChannelHandler::~CCloseChannelHandler exiting" )

    }

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

// From class MSatCommand.

// Response from the client.

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

//

void COpenChannelHandler::ClientResponse()

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::ClientResponse calling" )

    // Query response from client.

    if ( !iQueryRsp.iAccepted ) // Not accepted by user

        {

        // Close data channel

        CloseChannel();

        if ( iQueryRsp.iSessionTerminatedByUser ) // Terminated by user

            {

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::ClientResponse \

                Session terminated by user" )

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

            // should close the ui session.

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            // Terminal response, SimSessionTerminatedByUser

            iOpenChannelRsp.iGeneralResult = RSat::KPSessionTerminatedByUser;

            }

        else

            {

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::ClientResponse \

                User not accept command" )

            // Send terminal response -> User not accepted

            iOpenChannelRsp.iGeneralResult = RSat::KPCmdNotAcceptedByUser;

            }

        iOpenChannelRsp.iInfoType = RSat::KNoAdditionalInfo;

        iOpenChannelRsp.iAdditionalInfo.Zero();

        iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

        TerminalRsp( iPCmd, iOpenChannelRspPckg );

        }

    else // Accepted by user

        {

        LOG( NORMAL,

            "OPENCHANNEL: COpenChannelHandler::ClientResponse User accepted" )

        // User accepted

        const TInt linkEst( iOpenChannelData.iLinkEst );

        // SetUp channel if activation is on demand

        if ( ( RSat::EOnDemand == linkEst ) && ( KErrNone != SetUpChannel() ) )

            {

            // Close channel and send error if setup failed

            CloseChannel();

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::ClientResponse \

                SetUp failed" )

            iOpenChannelRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            iOpenChannelRsp.iInfoType = RSat::KNoAdditionalInfo;

            iOpenChannelRsp.iAdditionalInfo.Zero();

            iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

            TerminalRsp( iPCmd, iOpenChannelRspPckg );

            }

        else

            {

            // Send terminal response

            SendSuccessTerminalRsp();

            }

        }

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::ClientResponse exiting" )

    }

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

// From class MSatConnectionObserver.

// Notification from the connection.

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

//

void COpenChannelHandler::ConnectionNotification( TInt aError )

    {

    LOG2( SIMPLE, "OPENCHANNEL: COpenChannelHandler::ConnectionNotification\

         calling with code %i", aError )

    // Check connection status

    if ( KErrNone == aError )

        {

        // If information indication to the user is needed, show it now.

        if ( iNeedUiSession )

            {

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::HandleCommand \

                Sending UI Notification" )

            // Send confirmation to UI and wait for client response

            SendConfirmToUi();

            }

        else

            {

            // Send successfull terminal response

            SendSuccessTerminalRsp();

            }

        }

    else

        {

        // Activation failed, Close channel and send error

        LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::ConnectionNotification \

            Channel activation failed" )

        // Close channel

        CloseChannel();

        // PDP Activation failed

        iOpenChannelRsp.iGeneralResult = RSat::KBearerIndepProtocolError;

        iOpenChannelRsp.iInfoType = RSat::KMeProblem;

        iOpenChannelRsp.iAdditionalInfo.SetLength( 1 );

        iOpenChannelRsp.iAdditionalInfo[0] = RSat::KNoSpecificBIPError;

        iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

        TerminalRsp( iPCmd, iOpenChannelRspPckg );

        }

    LOG( SIMPLE,

        "OPENCHANNEL: COpenChannelHandler::ConnectionNotification exiting" )

    }

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

// From class CSatCommandHandler.

// Event notification.

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

//

void COpenChannelHandler::Event( TInt aEvent )

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::Event calling" )

    // Check event

    if ( MSatUtils::ESatUiLaunched == aEvent )

        {

        LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::Event ESatUiLaunched" )

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

        // Send confirm to UI

        SendConfirmToUi();

        }

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::Event exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void COpenChannelHandler::DoCancel()

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::DoCancel calling" )

    iUtils->USatAPI().NotifyOpenChannelCancel();

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void COpenChannelHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::IssueUSATRequest calling" )

    // Reset values

    iDataChannel = NULL;

    iSetUpWithModifications = EFalse;

    iNeedUiSession = EFalse;

    // Reset open channel data.

    new (&iOpenChannelData) RSat::TOpenGprsChannelV4();

    new (&iQueryData) TSatQueryV1();

    iUtils->USatAPI().NotifyOpenChannel( aStatus, iOpenChannelPckg );

    iUtils->NotifyEvent( MSatUtils::EBipCommandDoneExecuting );

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// OpenChannel command is not allowed in following situations:

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

//      - phone is ringing, alerting or call is on and OpenChannel command

//        is "make call only if not busy", "make call only if not busy wiht

//        redial" or "Call type not set".

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

//

TBool COpenChannelHandler::CommandAllowed()

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::CommandAllowed calling" )

    // Define the PCmd here since this is the first place after notification

    iPCmd = RSat::EOpenChannelGprs; // Other possible values

                                    // RSat::EOpenChannelCs

                                    // RSat::EOpenChannelLocal

    // Check parameters here, because every terminal response must contain info

    // about Bearer Set and BufferSize.

    TBool result( CheckParameters() );

    // Indicates channel activation type

    const TBool activateImmediately(

        RSat::EImmediate == iOpenChannelData.iLinkEst );

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

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

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

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

        {

        iOpenChannelRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        iOpenChannelRsp.iInfoType = RSat::KNoAdditionalInfo;

        iOpenChannelRsp.iAdditionalInfo.Zero();

        result = EFalse;

        LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

            icon received without alpha id" )

        }

    // If parameters are OK, check rest.

    else if ( result && activateImmediately )

        {

        // Set result to False. If checks goes OK, this is set to ETrue.

        result = EFalse;

        RMobilePhone::TMobilePhoneRegistrationStatus registrationStatus(

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

        // Indicates is there service on network

        const TBool noService(

            ( RMobilePhone::ERegisteredOnHomeNetwork != registrationStatus ) &&

            ( RMobilePhone::ERegisteredRoaming != registrationStatus ) );

        if ( RMobilePhone::ERegistrationUnknown == registrationStatus )

            {

            LOG( NORMAL,

                "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

                NetworkRegStatus not available" )

            iOpenChannelRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            iOpenChannelRsp.iInfoType = RSat::KMeProblem;

            iOpenChannelRsp.iAdditionalInfo.SetLength( 1 );

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

            }

        // Check registration status

        else if ( noService )

            {

            // No service

            LOG( NORMAL,

                "OPENCHANNEL: COpenChannelHandler::CommandAllowed No service" )

            iOpenChannelRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            iOpenChannelRsp.iInfoType = RSat::KMeProblem;

            iOpenChannelRsp.iAdditionalInfo.SetLength( 1 );

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

            }

        else

            {

            // Command allowed

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

                Command is allowed Immediate activation" )

            result = ETrue;

            }

        }

    if ( !result ) // Send Terminal response, if result is not OK

        {

        LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

        result not OK" )

        iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

        TerminalRsp( iPCmd, iOpenChannelRspPckg );

        }

    else

        {

        // Register to handle UI commands.

        TRAPD( err, iUtils->RegisterServiceRequestL( ESatSProactiveQuery,

            ESatSProactiveQueryResponse, this ) );

        LOG2( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

        err: %d", err )

        // Above function leaves only when there is not enough memory to

        // allocate new object. So this case is very rare.

        if ( KErrNone != err )

            {

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

                 Error while registering service request" )

            // Send general terminal response (no BIP specific)

            iOpenChannelRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            iOpenChannelRsp.iInfoType = RSat::KMeProblem;

            iOpenChannelRsp.iAdditionalInfo.SetLength( 1 );

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

            iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

            TerminalRsp( iPCmd, iOpenChannelRspPckg );

            // Cannot complete, there are some major memory problems

            result = EFalse;

            }

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

            iOpenChannelData.iIconId.iQualifier ) ||

            ( RSat::ENotSelfExplanatory ==

            iOpenChannelData.iIconId.iQualifier ) )

            {

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

                 ENoIconId" )

            iIconCommand = ETrue;

            iOpenChannelData.iIconId.iQualifier = RSat::ENoIconId;

            }

        else

            {

            LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::CommandAllowed \

                 others" )

            iIconCommand = EFalse;

            }

        }

    LOG2( SIMPLE, "OPENCHANNEL: COpenChannelHandler::CommandAllowed exiting,\

    result: %d", result )

    return result;

    }

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

// From class CSatCommandHandler.

// Need for ui session.

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

//

TBool COpenChannelHandler::NeedUiSession()

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::NeedUiSession calling" )

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

    iNeedUiSession =

        !( RSat::EAlphaIdNull == iOpenChannelData.iAlphaId.iStatus );

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::NeedUiSession exiting" )

    // We do not need UI session at this point, but we will launch it by

    // ourselves when we do.

    return EFalse;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void COpenChannelHandler::HandleCommand()

    {

    LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::HandleCommand calling" )

    // Notify others

    iUtils->NotifyEvent( MSatUtils::EOpenChannelExecuting );

    iUtils->NotifyEvent( MSatUtils::EBipCommandExecuting );

    TInt error( MSatBIPUtils::ESatBIPNoChannelAvail ); // By default, negative

    // Create data channel

    TRAPD( leaveErr,

        iDataChannel = iUtils->BipUtils().CreateChannelL(

            iBearerType, error ) );

    // Check the channel creation

    if ( ( MSatBIPUtils::ESatBIPSuccess != error ) || 

         ( KErrNone != leaveErr ) )

        {

        LOG( NORMAL, "OPENCHANNEL: COpenChannelHandler::HandleCommand\

            Channel creation failed" )

        // Channel creation failed -> Send terminal response

        iOpenChannelRsp.iGeneralResult = RSat::KBearerIndepProtocolError;

        iOpenChannelRsp.iInfoType = RSat::KMeProblem;

        iOpenChannelRsp.iAdditionalInfo.SetLength( 1 );

        iOpenChannelRsp.iAdditionalInfo[0] = RSat::KNoChannelAvailable;

        iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

        TerminalRsp( iPCmd, iOpenChannelRspPckg );

        LOG( SIMPLE, "OPENCHANNEL: COpenChannel::HandleCommand exiting" )

        return;

        }

    LOG( NORMAL,

        "OPENCHANNEL: COpenChannelHandler::HandleCommand Channel creation OK" )

    // Open channel or request confirmation from user

    const TInt linkEst( iOpenChannelData.iLinkEst );

    // If not confirmation to user or immediate activation, open channel

    if ( ( !iNeedUiSession || RSat::EImmediate == linkEst )

           && KErrNone != SetUpChannel() )

        {

        // Setup failed, close channel and send error

        LOG( NORMAL,

            "OPENCHANNEL: COpenChannelHandler::HandleCommand SetUp failed" )

        // Close channel, there was an error

        CloseChannel();

        // Channel setup failed

        iOpenChannelRsp.iGeneralResult = RSat::KBearerIndepProtocolError;

        iOpenChannelRsp.iInfoType = RSat::KMeProblem;

        iOpenChannelRsp.iAdditionalInfo.SetLength( 1 );

        iOpenChannelRsp.iAdditionalInfo[0] = RSat::KNoSpecificBIPError;

        iOpenChannelRsp.SetPCmdNumber( iOpenChannelData.PCmdNumber() );

        TerminalRsp( iPCmd, iOpenChannelRspPckg );

        LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::HandleCommand \

            exiting" )

        return;

        }

    // If immediate activation, activate.

    if ( RSat::EImmediate == linkEst )

        {

        LOG( SIMPLE, "OPENCHANNEL: COpenChannelHandler::HandleCommand \

             immediate activation" )

        // Check activation

        TInt activateError = ActivateChannel();

        if ( KErrNone != activateError )

            {

            // Activation failed, Close channel and send error

            LOG2( NORMAL, "OPENCHANNEL: COpenChannelHandler::HandleCommand \

                Channel activation failed error = %i", activateError )

            // Close channel

            CloseChannel();

            // Check is there a call ongoing

            const TBool callIsOngoing( iUtils->SystemState().IsCallActive() ||

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

            iOpenChannelRsp.iGeneralResult = RSat::KBearerIndepProtocolError;

            // Map the error to correct response

            if ( KErrGprsUserAuthenticationFailure == activateError )

                {

                LOG( DETAILED, 

                "OPENCHANNEL: COpenChannelHandler::HandleCommand Security \

                error" )

                activateError = RSat::KSecurityError;

                }

            else if ( KErrGprsServicesNotAllowed == activateError || callIsOngoing )

                {

                LOG( DETAILED, 

                "OPENCHANNEL: COpenChannelHandler::HandleCommand Busy on \

                call or CC on GPRS" )

                activateError = RSat::KMeBusyOnCall;

                iOpenChannelRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

                }

            else if ( ( KErrMMEtelActivationBlockedByCallControlNoText ==

                            activateError ) ||

                      ( KErrMMEtelActivationBlockedByCallControlWithText ==

                            activateError ) )

                {

                iOpenChannelRsp.iGeneralResult = RSat::KInteractionWithCCPermanentError;

                activateError = RSat::KActionNotAllowed;

                LOG( DETAILED,