/*

* Copyright (c) 2002-2008 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 SendDtmf command

*

*/

#include    "MSatApi.h"

#include    "MSatUtils.h"

#include    "MSatSystemState.h"

#include    "MSatUiSession.h"

#include    "SatSOpcodes.h"

#include    "MSatSUiClientHandler.h"

#include    "CSendDtmfHandler.h"

#include    "csatdtmfsender.h"

#include    "msatmultimodeapi.h"

#include    "SatLog.h"

const TUint KBcdZero      = 0x00;

const TUint KBcdOne       = 0x01;

const TUint KBcdTwo       = 0x02;

const TUint KBcdThree     = 0x03;

const TUint KBcdFour      = 0x04;

const TUint KBcdFive      = 0x05;

const TUint KBcdSix       = 0x06;

const TUint KBcdSeven     = 0x07;

const TUint KBcdEight     = 0x08;

const TUint KBcdNine      = 0x09;

const TUint KBcdStar      = 0x0A;

const TUint KBcdHash      = 0x0B;

const TUint KBcdPause     = 0x0C;

const TUint KBcdWild      = 0x0D;

const TUint KBcdExpansion = 0x0E;

const TUint KBcdEnd       = 0x0F;

const TUint KUcs2Zero     = 0x30; // '0'

const TUint KUcs2Star     = 0x2A; // '*'

const TUint KUcs2Hash     = 0x23; // '#'

const TUint KUcs2Pause    = 0x70; // 'p'

const TUint KHighNibble   = 0xF0;

const TUint KLowNibble    = 0x0F;

const TUint KBitsInNibble = 4;

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

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

// Two-phased constructor.

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

//

CSendDtmfHandler* CSendDtmfHandler::NewL( MSatUtils* aUtils )

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::NewL calling" )

    CSendDtmfHandler* self = new( ELeave ) CSendDtmfHandler;

    CleanupStack::PushL( self );

    self->BaseConstructL( aUtils );

    self->ConstructL();

    CleanupStack::Pop( self );

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::NewL exiting" )

    return self;

    }

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

// Destructor.

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

//

CSendDtmfHandler::~CSendDtmfHandler()

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::~CSendDtmfHandler calling" )

    Cancel();

    if ( iDtmfSender )

        {

        delete iDtmfSender;

        }

    if ( iDtmfStringUcs2 )

        {

        delete iDtmfStringUcs2;

        iDtmfStringUcs2 = NULL;

        }

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::~CSendDtmfHandler exiting" )

    }

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

// Gets the result of DTMF sending.

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

//

void CSendDtmfHandler::SendDtmfComplete( const TInt aErrCode )

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::SendDtmfComplete calling" )

    iDtmfResult = aErrCode;

    // Handles result and sends terminal response.

    HandleResult();

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::SendDtmfComplete exiting" )

    }

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

// From class MSatCommand.

// Response from the client

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

//

void CSendDtmfHandler::ClientResponse()

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::ClientResponse calling" )

    iClientResponseReceived = ETrue;

    if( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::ClientResponse exiting" )

    }

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

// From class CSatCommandHandler.

// Waits for indication of user rejection

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

//

void CSendDtmfHandler::Event( TInt aEvent )

    {

    LOG2( SIMPLE,

        "SENDTMF: CSendDtmfHandler::Event calling, aEvent:%d", aEvent )

    switch ( aEvent )

        {

        case MSatUtils::ECommandCancelled:

            {

            // Cancel DTMF sending

            if ( iDtmfSender )

                {

                LOG( SIMPLE, 

                "SENDTMF: CSendDtmfHandler::Event Cancel DTMF sending" )

                iDtmfSender->Cancel();

                }

            // Cancel key pressed. Send terminal response.

            iSendDtmfRsp.iGeneralResult = RSat::KPSessionTerminatedByUser;

            iSendDtmfRsp.iInfoType = RSat::KNoAdditionalInfo;

            iSendDtmfRsp.iAdditionalInfo.Zero();

            SendTerminalResponse();

            break;

            }

        case MSatUtils::ECancelledUsingEndKey:

            {

            // Cancel DTMF sending

            if ( iDtmfSender )

                {

                LOG( SIMPLE, 

                "CSendDtmfHandler::Event Cancel DTMF sending by endkey" )

                iDtmfSender->Cancel();

                }

            // End key pressed. Send terminal response.

            iSendDtmfRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            iSendDtmfRsp.iInfoType = RSat::KMeProblem;

            iSendDtmfRsp.iAdditionalInfo.Zero();

            iSendDtmfRsp.iAdditionalInfo.Append( RSat::KNotInSpeechCall );

            // Next SimSession end will close the ui session

            iUtils->NotifyEvent( MSatUtils::ESessionTerminatedByUser );

            SendTerminalResponse();

            break;

            }

        default:

            {

            // Move event to base class

            CSatCommandHandler::Event( aEvent );

            }

        }

    LOG( SIMPLE, "SENDTMF: CSendDtmfHandler::Event exiting" )

    }

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

// From class CActive.

// Cancels the sat request.

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

//

void CSendDtmfHandler::DoCancel()

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::DoCancel calling" )

    iUtils->USatAPI().NotifySendDtmfCancel();

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::DoCancel exiting" )

    }

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

// From class CSatCommandHandler.

// Requests the command notification.

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

//

void CSendDtmfHandler::IssueUSATRequest( TRequestStatus& aStatus )

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::IssueUSATRequest calling" )

    // Clear the IPC package.

    new (&iSendDtmfData) RSat::TSendDtmfV1();

    if ( iDtmfStringUcs2 )

        {

        LOG( SIMPLE, 

        "CSendDtmfHandler::IssueUSATRequest iDtmfStringUcs2 true" )

        delete iDtmfStringUcs2;

        iDtmfStringUcs2 = NULL;

        }

    iUtils->USatAPI().NotifySendDtmf( aStatus, iSendDtmfPckg );

    // Unregister from events

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

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

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::IssueUSATRequest exiting" )

    }

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

// From class CSatCommandHandler.

// SendDtmf command is not allowed if there is not active speech call.

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

//

TBool CSendDtmfHandler::CommandAllowed()

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::CommandAllowed calling" )

    // By default, this is true

    TBool commandAllowed( ETrue );

    // Allow next terminal response to be sent

    iTerminalRespSent = EFalse;

    // This is needed every time

    iSendDtmfRsp.SetPCmdNumber( iSendDtmfData.PCmdNumber() );

    // Call has to be established, otherwise DTMF cannot be sent.

#ifdef SAT_USE_DUMMY_TSY

    TInt firstChar( ' ' );

    if ( iSendDtmfData.iAlphaId.iStatus == RSat::EAlphaIdProvided )

        {

        firstChar = iSendDtmfData.iAlphaId.iAlphaId[0];

        }

    const TBool callIsOngoing( firstChar != 'T' );

#else

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

#endif

    const TInt dtmfLength( iSendDtmfData.iDtmfString.Length() );

    // DTMF string shall have at least one BCD character.

    // Otherwise, minimum set of data objects is not complete,

    // and command has to be rejected with 'Error, required

    // values are missing'.

    const TBool dtmfStringHasContent( dtmfLength > 0 );

    // DTMF string shall not be longer than is possible

    // according to TS 11.14, clause 6.6.24. If the string is

    // longer than this, the DTMF String data object is not valid,

    // which means that the minimum set of data objects

    // is not complete, and the command has to be rejected

    // with 'Error, required values are missing'.

    const TBool dtmfStringNotTooLong( dtmfLength <= RSat::KDtmfStringMaxSize );

    // If icon data without alpha id.

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

        ( ( RSat::ESelfExplanatory == iSendDtmfData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory == iSendDtmfData.iIconId.iQualifier ) ) )

        {

        commandAllowed = EFalse;

        iSendDtmfRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

        iSendDtmfRsp.iInfoType = RSat::KNoAdditionalInfo;

        iSendDtmfRsp.iAdditionalInfo.Zero();

        LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::CommandAllowed data not \

            understood" )

        }

    else if ( !( dtmfStringHasContent && callIsOngoing && dtmfStringNotTooLong ) )

        { // Handle the error cases.

        if ( !dtmfStringHasContent || !dtmfStringNotTooLong )

            {

            LOG( SIMPLE,

                "SENDDTMF: !dtmfStringHasContent || !dtmfStringNotTooLong" )

            iSendDtmfRsp.iInfoType = RSat::KNoAdditionalInfo;

            iSendDtmfRsp.iAdditionalInfo.Zero();

            iSendDtmfRsp.iGeneralResult = RSat::KErrorRequiredValuesMissing;

            }

        else // No callIsOngoing

            {

            LOG( SIMPLE, "SENDDTMF: !callIsOngoing" )

            // ME is not in speech call and dtmf string cannot be sent.

            iSendDtmfRsp.iInfoType = RSat::KMeProblem;

            iSendDtmfRsp.iAdditionalInfo.Zero();

            iSendDtmfRsp.iAdditionalInfo.Append( RSat::KNotInSpeechCall );

            iSendDtmfRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            }

        // Command is not allowed

        commandAllowed = EFalse;

        }

    else

        {

        // Convert DTMF string. This is done here, so UI is not launched.

        // for no reason.

        // At the ETel interface level, the DTMF string uses a TBuf where each

        // buffer character represents two DTMF digits coded as BCD characters.

        const TUint KDtmfStringETelNumberOfBcdPerBufferCharacter = 2;

        // The DTMF string uses a TBuf where each buffer character represents

        // one DTMF digit.

        const TUint KDtmfStringMaxLength =

            KDtmfStringETelNumberOfBcdPerBufferCharacter *

                RSat::KDtmfStringMaxSize;

        TRAPD( noMemory, iDtmfStringUcs2 =

            HBufC16::NewL( KDtmfStringMaxLength ) )

        if ( KErrNone != noMemory )

            {

            LOG( SIMPLE, 

            "SENDDTMF: CSendDtmfHandler::CommandAllowed KErrNone != noMemory" )

            iSendDtmfRsp.iInfoType = RSat::KNoAdditionalInfo;

            iSendDtmfRsp.iAdditionalInfo.Zero();

            iSendDtmfRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            // Command is not allowed

            commandAllowed = EFalse;

            }

        else

            {

            TPtr ptr = iDtmfStringUcs2->Des();

            if ( ! ConvertDtmfStringToUcs2( ptr ) )

                {

                LOG( SIMPLE, 

                "CSendDtmfHandler::CommandAllowed not allowed" )

                // DTMF string contains illegal characters

                iSendDtmfRsp.iGeneralResult = RSat::KCmdDataNotUnderstood;

                iSendDtmfRsp.iInfoType = RSat::KNoAdditionalInfo;

                iSendDtmfRsp.iAdditionalInfo.Zero();

                // Command is not allowed

                commandAllowed = EFalse;

                }

            }

        }

    if ( !commandAllowed )

        {

        LOG( SIMPLE, 

        "CSendDtmfHandler::CommandAllowed commandAllowed false" )

        SendTerminalResponse();

        }

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

        iSendDtmfData.iIconId.iQualifier ) ||

        ( RSat::ENotSelfExplanatory ==

        iSendDtmfData.iIconId.iQualifier ) )

        {

        LOG( SIMPLE, 

        "CSendDtmfHandler::CommandAllowed ENoIconId" )

        iIconCommand = ETrue;

        iSendDtmfData.iIconId.iQualifier = RSat::ENoIconId;

        }

    else

        {

        iIconCommand = EFalse;

        }

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::CommandAllowed exiting" )

    return commandAllowed;

    }

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

// From class CSatCommandHandler.

// Need for ui session.

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

//

TBool CSendDtmfHandler::NeedUiSession()

    {

    LOG( NORMAL, "SENDDTMF: CSendDtmfHandler::NeedUiSession calling" )

    iNeedUiSession = ETrue;

    if ( RSat::EAlphaIdNull == iSendDtmfData.iAlphaId.iStatus )

        {

        LOG( NORMAL, "SENDDTMF: CSendDtmfHandler::NeedUiSession EAlphaIdNull" )

        iNeedUiSession = EFalse;

        }

    // Notify Cover UI if it's supported

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

        {

        LOG( NORMAL, 

        "SENDDTMF: CSendDtmfHandler::NeedUiSession CoverUiSupported" )

        TSatCommandData medEventData;

        medEventData.iPCmdNumber = RSat::ESendDtmf;

        medEventData.iAlphaId =  iSendDtmfData.iAlphaId;

        medEventData.iDuration.iNumOfUnits = KSatDefaultDuration;

        medEventData.iDuration.iTimeUnit = RSat::ESeconds;

        medEventData.iIconID = iSendDtmfData.iIconId;

        TSatCommandPckg tPckg( medEventData );

        iUtils->RaiseSatEvent( tPckg );

        }

    LOG2( NORMAL, 

    "SENDDTMF: CSendDtmfHandler::NeedUiSession exiting,iNeedUiSession: %d",

    iNeedUiSession )

    return iNeedUiSession;

    }

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

// From class CSatCommandHandler.

// Called when USAT API notifies that command.

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

//

void CSendDtmfHandler::HandleCommand()

    {

    LOG( SIMPLE, "SENDDTMF: CSendDtmfHandler::HandleCommand calling" )

    iUtils->NotifyEvent( MSatUtils::ESendDtmfExecuting );

    // Lower error granularity. This helps for mapping error cases

    iUtils->MultiModeApi().LowerErrorGranularity();

    // Pointer to converted DTMF string

    TPtr ptr = iDtmfStringUcs2->Des();

    iClientResponseReceived = EFalse;

    // First, send DTMF string

    iDtmfSender->SendToneString( ptr );

    if ( iNeedUiSession )

        {

        TRAPD( regErr,

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

        // Then send notification to UI

        // Register notification observer

        iUtils->RegisterServiceRequestL(

            ESatSProactiveNotification,

            ESatSProactiveNotificationResponse,

            this )

            ); // TRAPD

        LOG2( NORMAL, 

        "CSendDtmfHandler::HandleCommand regErr: %d", regErr )

        if ( KErrNone != regErr )

            {

            iDtmfSender->Cancel();

            // Raise error granularity back to extended errors

            iUtils->MultiModeApi().RaiseErrorGranularity();

            iSendDtmfRsp.iGeneralResult = RSat::KMeUnableToProcessCmd;

            iSendDtmfRsp.iInfoType = RSat::KMeProblem;

            iSendDtmfRsp.iAdditionalInfo.Zero();

            iSendDtmfRsp.iAdditionalInfo.Append( RSat::KNoSpecificMeProblem );

            SendTerminalResponse();

            }

        else

            {

            TSatAlphaIdStatus alphaIdStatus;

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

                {

                LOG( SIMPLE, 

                "SENDDTMF: CSendDtmfHandler::HandleCommand EAlphaIdNotPresent" )

                // If AlphaID is not provided, show DTMF string in note.

                // Deliver empty text if DTMF string is bigger than it is

                // capable to deliver to SAT UI.

                alphaIdStatus = ESatAlphaIdNotProvided;

                LOG2( NORMAL, 

                "SENDDTMF: CSendDtmfHandler::HandleCommand ptr.Length: %d", 

                ptr.Length() )

                if ( RSat::KAlphaIdMaxSize >= ptr.Length() )

                    {

                    iNotificationData.iText = ptr;

                    }

                else

                    {

                    iNotificationData.iText.Zero();

                    }

                }

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

                {

                LOG( SIMPLE, 

                "SENDDTMF: CSendDtmfHandler::HandleCommand EAlphaIdProvided" )

                alphaIdStatus = ESatAlphaIdNotNull;

                iNotificationData.iText = iSendDtmfData.iAlphaId.iAlphaId;

                }

            else

                {

                LOG( SIMPLE, 

                "SENDDTMF: CSendDtmfHandler::HandleCommand others" )

                alphaIdStatus = ESatAlphaIdNull;

                iNotificationData.iText.Zero();

                }

            // Build notification data

            iNotificationData.iAlphaIdStatus = alphaIdStatus;

            iNotificationData.iCommand = ESatSSendDtmfNotify;

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

            // because GCC warns about the direct cast.