/*

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

*

*/

#include    <exterror.h>

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatSystemState.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSetUpCallHandler.h"

#include    "TSatExtErrorUtils.h"

#include    "SatLog.h"

const TUint8 KBCDAsterisk( 0x0A );

const TUint8 KBCDDash( 0x0B );

const TUint8 KBCDDTMF( 0x0C );

const TUint8 KBCDWild( 0x0D );

const TUint8 KBCDExpansion( 0x0E );

const TUint8 KAsteriskChar( 0x2A );

const TUint8 KDashChar( 0x23 );

const TUint8 KDTMFChar( 0x70 );

const TUint8 KWildChar( 0x77 );

const TUint8 KExpansionChar( 0x2E );

_LIT( KFixedSimEmergencyNumber, "112" );

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

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

// Two-phased constructor.

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

//

CSetUpCallHandler* CSetUpCallHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::NewL calling" )

    CSetUpCallHandler* self = new( ELeave ) CSetUpCallHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CSetUpCallHandler::~CSetUpCallHandler()

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::~CSetUpCallHandler calling" )

    Cancel();

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::~CSetUpCallHandler exiting" )

    }

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

// From class MSatEventObserver.

// Event notification.

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

//

void CSetUpCallHandler::Event( TInt aEvent )

    {

    LOG2( SIMPLE, "SETUPCALL: CSetUpCallHandler::Event calling,aEvent: %i",

          aEvent )

    if ( MSatUtils::ECallControlExecuting == aEvent )

        {

        LOG( SIMPLE,

            "SETUPCALL: CSetUpCallHandler::Event: ECallControlExecuting" )

        iCallControlActive = ETrue;

        }

    else if ( MSatUtils::ECallControlDone == aEvent )

        {

        LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::Event: ECallControlDone" )

        iCallControlActive = EFalse;

        // Check if SetUpCall command has arrived from SIM during CC execution

        // Emergency call is made immediate regardless of call control.

        if ( !IsActive() && iPCmdPending && !iEmergencyCall )

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::Event: setupcall" )

            iPCmdPending = EFalse;

            // Execute the setupcall.

            DoHandleCommand();

            }

        }

    CSatCommandHandler::Event( aEvent );

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::Event exiting" )

    }

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

// From class MSatCommand.

// Response from the client.

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

//

void CSetUpCallHandler::ClientResponse()

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::ClientResponse calling" )

    if ( iQueryRsp.iAccepted )

        {

        // User accepted the call, make the call

            {

            }

        }

    else

        {

        LOG( NORMAL, 

        "SETUPCALL: CSetUpCallHandler::ClientResponse User Cancel" )

        if ( iQueryRsp.iSessionTerminatedByUser )

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::ClientResponse TerminatedByUser" )

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

            // should close the ui session.

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            }

        // End key is pressed during confirmation or user denied call setup,

        // KPCmdNotAcceptedByUser is an expected response,

        CompleteSetupCall( RSat::KPCmdNotAcceptedByUser );

        }

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::ClientResponse exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CSetUpCallHandler::DoCancel()

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySetUpCallCancel();

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CSetUpCallHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::IssueUSATRequest calling" )

    // Clear the IPC package.

    new (&iSetUpCallData) RSat::TSetUpCallV1();

    iPCmdPending = EFalse;

    iQueryRsp.iAccepted = EFalse;

    iUtils->USatAPI().NotifySetUpCall( aStatus, iSetUpCallPckg );

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// SetUpCall command is not allowed in following situations:

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

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

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

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

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

//

TBool CSetUpCallHandler::CommandAllowed()

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CommandAllowed calling" )

    TBool commandAllowed( ETrue );

    // Emergency call can newer be denied.

    // The usage of constant emergency number is according to ETSI TS 31.111.

    iEmergencyCall =

        ( 0 == iSetUpCallData.iAddress.iTelNumber.Compare(

            KFixedSimEmergencyNumber ) );

    if ( !iEmergencyCall )

        {

        RMobilePhone::TMobilePhoneRegistrationStatus networkStatus(

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

        if ( ( ( RSat::EAlphaIdProvided !=

                     iSetUpCallData.iAlphaIdConfirmationPhase.iStatus ) &&

               ( ( RSat::ESelfExplanatory ==

                       iSetUpCallData.iIconIdConfirmationPhase.iQualifier ) ||

                 ( RSat::ENotSelfExplanatory ==

                       iSetUpCallData.iIconIdConfirmationPhase.iQualifier ) ) )

                 ||

             ( ( RSat::EAlphaIdProvided !=

                     iSetUpCallData.iAlphaIdCallSetUpPhase.iStatus ) &&

               ( ( RSat::ESelfExplanatory ==

                       iSetUpCallData.iIconIdCallSetUpPhase.iQualifier ) ||

                 ( RSat::ENotSelfExplanatory ==

                       iSetUpCallData.iIconIdCallSetUpPhase.iQualifier ) ) ) )

            {

            // Icon data is received without alpha id.

            CompleteSetupCall( RSat::KCmdDataNotUnderstood );

            commandAllowed = EFalse;

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::CommandAllowed Icon received \

            without alpha id" )

            }

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

                  ( RMobilePhone::ERegisteredRoaming != networkStatus ) )

            {

            // Not registered to network.

            CompleteSetupCall( RSat::KMeUnableToProcessCmd, RSat::KNoService );

            commandAllowed = EFalse;

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::CommandAllowed Registration not \

            valid" )

            }

        else

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::CommandAllowed others" )

            // Call type

            const RSat::TSetUpCallType callType( iSetUpCallData.iType );

            // Command does not allow to make a call if busy

            const TBool dontMakeCallIfBusy(

                ( RSat::EOnlyIfNotBusy == callType ) ||

                ( RSat::EOnlyIfNotBusyWithRedial == callType ) ||

                ( RSat::ESetUpCallTypeNotSet == callType ) );

            if ( dontMakeCallIfBusy )

                {

                LOG( SIMPLE, 

                "SETUPCALL: CSetUpCallHandler::CommandAllowed \

                dontMakeCallIfBusy true" )

                // Is the call ongoing

                const TBool callIsOngoing(

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

                // Is the call incoming

                const TBool callIsIncoming(

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

                if ( callIsOngoing || callIsIncoming )

                    {

                    // Set the terminal response info.

                    CompleteSetupCall(

                        RSat::KMeUnableToProcessCmd,

                        RSat::KMeBusyOnCall );

                    commandAllowed = EFalse;

                    LOG( SIMPLE, 

                    "SETUPCALL: CSetUpCallHandler::CommandAllowed Busy" )

                    }

                }

            }

        if ( commandAllowed )

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::CommandAllowed Allowed to call" )

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

            if ( ( RSat::ESelfExplanatory ==

                     iSetUpCallData.iIconIdConfirmationPhase.iQualifier ) ||

                 ( RSat::ENotSelfExplanatory ==

                     iSetUpCallData.iIconIdConfirmationPhase.iQualifier ) ||

                 ( RSat::ESelfExplanatory ==

                     iSetUpCallData.iIconIdCallSetUpPhase.iQualifier ) ||

                 ( RSat::ENotSelfExplanatory ==

                     iSetUpCallData.iIconIdCallSetUpPhase.iQualifier ) )

                {

                LOG( SIMPLE, "SETUPCALL:   ENoIconId" )

                iIconCommand = ETrue;

                iSetUpCallData.iIconIdConfirmationPhase.iQualifier =

                    RSat::ENoIconId;

                iSetUpCallData.iIconIdCallSetUpPhase.iQualifier =

                    RSat::ENoIconId;

                }

            else

                {

                iIconCommand = EFalse;

                }

            }

        }

    else

        {

        LOG( SIMPLE, 

        "SETUPCALL: CSetUpCallHandler::CommandAllowed Emergency call" )

        }

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CommandAllowed exiting" )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Need for ui session.

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

//

TBool CSetUpCallHandler::NeedUiSession()

    {

    LOG( NORMAL, "SETUPCALL: CSetUpCallHandler::NeedUiSession calling" )

    // Notify Cover UI if it's supported

    if ( iUtils->CoverUiSupported() )

        {

        LOG( NORMAL, 

        "SETUPCALL: CSetUpCallHandler::NeedUiSession CoverUiSupported" )

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ESetUpCall;

        medEventData.iAlphaId = iSetUpCallData.iAlphaIdCallSetUpPhase;

        medEventData.iDuration.iTimeUnit = RSat::ESeconds;

        medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

        medEventData.iIconID = iSetUpCallData.iIconIdCallSetUpPhase;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG( NORMAL, "SETUPCALL: CSetUpCallHandler::NeedUiSession exiting" )

    return ETrue;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CSetUpCallHandler::HandleCommand()

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::HandleCommand calling" )

    if ( iEmergencyCall )

        {

        LOG( SIMPLE, 

        "SETUPCALL: CSetUpCallHandler::HandleCommand iEmergencyCall true" )

            {

            iEmergencyCall = EFalse;

            // Set the terminal response info.

            CompleteSetupCall(

                RSat::KMeUnableToProcessCmd,

                RSat::KNoSpecificMeProblem );

            }

        }

    else

        {

        const RSat::TAlphaIdStatus alphaIdStatus(

            iSetUpCallData.iAlphaIdCallSetUpPhase.iStatus );

        // If the alpha id is null, then use SAT name as a alpha identifier.

        if ( ( RSat::EAlphaIdNull == alphaIdStatus )  ||

             ( RSat::EAlphaIdNotPresent == alphaIdStatus ) )

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::HandleCommand set AlphaId" )

            iSetUpCallData.iAlphaIdCallSetUpPhase.iAlphaId =

                iUtils->SatAppName();

            iSetUpCallData.iAlphaIdCallSetUpPhase.iStatus =

                RSat::EAlphaIdProvided;

            }

        // Copy the data to package, which is sent to client.

        iQueryData.iCommand = ESatSSetUpCallQuery;

        iQueryData.iQueryText.Copy(

            iSetUpCallData.iAlphaIdConfirmationPhase.iAlphaId );

        iQueryData.iSimApplicationName.Copy( iUtils->SatAppName() );

        iQueryData.iAlphaIdStatus = ESatAlphaIdNotNull; // Always

        iQueryData.iIconId.iIdentifier =

            iSetUpCallData.iIconIdConfirmationPhase.iIdentifier;

        LOG2( SIMPLE, 

        "SETUPCALL: iSetUpCallData.iIconIdConfirmationPhase.iQualifier: %d",

        iSetUpCallData.iIconIdConfirmationPhase.iQualifier )

        switch ( iSetUpCallData.iIconIdConfirmationPhase.iQualifier )

            {

            case RSat::ESelfExplanatory:

                {

                // Icon qualifier is self explanatory (to display instead

                // of the alpha id or text string).

                iQueryData.iIconId.iIconQualifier = ESatSelfExplanatory;

                break;

                }

            case RSat::ENotSelfExplanatory:

                {

                // Icon qualifier is not self explanatory.

                iQueryData.iIconId.iIconQualifier = ESatNotSelfExplanatory;

                break;

                }

            default:

                {

                // Icon qualifier not present

                iQueryData.iIconId.iIconQualifier = ESatENoIconId;

                break;

                }

            }

        // If call control is active, set up call is made

        // after the call control note is showed in ui ie

        // ECallControlDone event is notified.

        if ( !iCallControlActive )

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::HandleCommand iCallControlActive \

            false" )

            iUtils->NotifyEvent( MSatUtils::ESetUpCallExecuting );

            TRAPD( regErr, iUtils->RegisterServiceRequestL(

                ESatSProactiveQuery,

                ESatSProactiveQueryResponse,

                this ) );

            LOG2( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::HandleCommand regErr: %d", regErr )

            if ( KErrNone != regErr )

                {

                // Possible memory allocation error. Send error terminal

                // response

                UiLaunchFailed();

                }

            else

                {

                // Send query to UI

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

                    &iQueryPckg,

                    &iQueryRspPckg,

                    ESatSProactiveQuery );

                }

            }

        else

            {

            LOG( SIMPLE, 

            "SETUPCALL: CSetUpCallHandler::HandleCommand iCallControlActive \

            true" )

            // Set pending flag on

            iPCmdPending = ETrue;

            }

        }

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::HandleCommand exiting" )

    }

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

// From class CSatCommandHandler.

// Indication that UI lanching failed.

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

//

void CSetUpCallHandler::UiLaunchFailed()

    {

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::UiLaunchFailed calling" )

    CompleteSetupCall( RSat::KMeUnableToProcessCmd, 

                       RSat::KNoSpecificMeProblem );

    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::UiLaunchFailed exiting" )

    }

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