/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*

*/

// INCLUDE FILES

#include "cmmcallmesshandler.h"

#include "cmmphonetsender.h"

#include "cmmstaticutility.h"

#include "cmmmessagerouter.h"

#include "tsylogger.h"

#include "cmmdataporthandler.h" // dataport includes

#include "cmmdtmfmesshandler.h" //DTMF includes

#include "osttracedefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmcallmesshandlertraces.h"

#endif

// ISI message coding/decoding functions

#include <call_modemisi.h>

#include <infoisi.h>

#include <gpdsisi.h>

#include <product_profile_definitions.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <csdisi.h>

#include <pipeisi.h>

#include <pipe_sharedisi.h>

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

const TUint8 KCallPadding = 0x00; // Filler byte for ISI messages

// This needs to be distinct from TProductProfileRequestType values

// in cmmcustommesshandler.h

const TUint8 KHsdpaPpTransId = 5;

// Delay for starting the emergency timer, 5 seconds

const TUint KEmergencyTimerInterval = 5000000;

// For shifting by one byte

const TUint8 KShiftByOneByte = 8;

// Preaddress length

const TUint8 KPreAddressLength = 4;

// CBST Data Rates coding

const TUint KRateCodeAuto  = 0;

const TUint KRateCode28800 = 130;

const TUint KRateCode32000 = 131;

const TUint KRateCode33600 = 132;

const TUint KRateCode56000 = 133;

const TUint KRateCode64000 = 134;

//value for information which value is zero

const TUint KZero = 0;

// For call cause no cause

const TUint8 KCallCauseNoCause = 0;

// First PEP

const TUint8 KFirstPepDevice = PN_DEV_HOST;      // Device Id of first PEP

const TUint8 KFirstPepType   = PN_PEP_TYPE_COMM; // First PEP type

// Second PEP

const TUint8 KSecondPepDevice = PN_DEV_MODEM;    // Device Id of second PEP

const TUint8 KSecondPepObject = 54; // PN_OBJ_CSD_SRV // Object Id of second PEP

const TUint8 KSecondPepType   = PN_PEP_TYPE_GPRS; // Second PEP type

// Redirect PEP

const TUint8 KRedirectPepObject = 59; //PN_OBJ_CSD_WTB; // Object Id of redirected PEP

const TUint8 KPipeTransID  = EIscNokiaDataport1;

const TUint8 KInvalidPipeHandle = 0xFF;

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

    // None

// LOCAL FUNCTION PROTOTYPES

    // None

// FORWARD DECLARATIONS

    // None

// ============================= LOCAL FUNCTIONS ===============================

// =============================================================================

// CEmergencyTimer: Used for delaying Emergency call when PDP context deactivate

// is ongoing

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

// CEmergencyTimer::CEmergencyTimer

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

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

//

CEmergencyTimer::CEmergencyTimer(

     CMmCallMessHandler& aCallMsgHandler )

        :CTimer( CActive::EPriorityHigh ),

        iCallMsgHandler( aCallMsgHandler )

    {

TFLOGSTRING("TSY: CEmergencyTimer::CEmergencyTimer");

OstTrace0( TRACE_NORMAL, CEMERGENCYTIMER_CEMERGENCYTIMER, "CEmergencyTimer::CEmergencyTimer" );

    }

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

// CEmergencyTimer::~CEmergencyTimer()

// Destructor, deletes all allocated resources.

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

//

CEmergencyTimer::~CEmergencyTimer()

    {

TFLOGSTRING("TSY: CEmergencyTimer::~CEmergencyTimer");

OstTrace0( TRACE_NORMAL, DUP1_CEMERGENCYTIMER_CEMERGENCYTIMER, "CEmergencyTimer::~CEmergencyTimer" );

    Cancel();

    }

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

// CEmergencyTimer::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CEmergencyTimer::ConstructL()

    {

TFLOGSTRING("TSY: CEmergencyTimer::ConstructL");

OstTrace0( TRACE_NORMAL, CEMERGENCYTIMER_CONSTRUCTL, "CEmergencyTimer::ConstructL" );

    CTimer::ConstructL(); // Must be called

    CActiveScheduler::Add( this );

    }

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

// CEmergencyTimer::RunL()

// Called when timer elapses.

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

//

void CEmergencyTimer::RunL()

    {

TFLOGSTRING("TSY: CEmergencyTimer::RunL - TIMER ELAPSED");

OstTrace0( TRACE_NORMAL, CEMERGENCYTIMER_RUNL, "CEmergencyTimer::RunL" );

    iCallMsgHandler.GpdsContextsClearResp();

    }

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

// CEmergencyTimer::StartEmergencyTimer()

// Start Emergency delay timer.

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

//

void CEmergencyTimer::StartEmergencyTimer()

    {

TFLOGSTRING("TSY: CEmergencyTimer::StartEmergencyTimer");

OstTrace0( TRACE_NORMAL, CEMERGENCYTIMER_STARTEMERGENCYTIMER, "CEmergencyTimer::StartEmergencyTimer" );

    Cancel();

    After( KEmergencyTimerInterval ); // 5 seconds

    }

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

// CEmergencyTimer::StopEmergencyTimer()

// Stop Emergency delay timer.

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

//

void CEmergencyTimer::StopEmergencyTimer()

    {

TFLOGSTRING("TSY: CEmergencyTimer::StopEmergencyTimer");

OstTrace0( TRACE_NORMAL, CEMERGENCYTIMER_STOPEMERGENCYTIMER, "CEmergencyTimer::StopEmergencyTimer" );

    Cancel();

    }

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

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

// CMmCallMessHandler::CMmCallMessHandler

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

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

//

CMmCallMessHandler::CMmCallMessHandler() : iEmergencyTimer( *this )

    {

TFLOGSTRING("TSY: CEmergencyTimer::CMmCallMessHandler");

OstTrace0( TRACE_NORMAL, CMMCALLMESSHANDLER_CMMCALLMESSHANDLER, "CMmCallMessHandler::CMmCallMessHandler" );

    }

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

// CMmCallMessHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmCallMessHandler::ConstructL()

    {

TFLOGSTRING("TSY: CMmCallMessHandler::ConstructL");

OstTrace0( TRACE_NORMAL, CMMCALLMESSHANDLER_CONSTRUCTL, "CMmCallMessHandler::ConstructL" );

    iSubAddress.Zero();

    iBearer.Zero();

    iReceivedUusData.Zero();

    iWaitingCall = KSymbianCallIdNone;

    iFDNErrorAlredyNotified = EFalse;

    iIs3rdPartyDial = EFalse;

    iIs3rdPartyAnswerIncomingCall = EFalse;

    iDataPortHandler = NULL;

    iGsmMmCauseError = KErrNone;

    iDestPostAddress.SetLength( 0 );

    iDtmfPostAddressCallId = 0;

    iDestPostAddressIncluded = EFalse;

    iUusData.iUUI.Zero();

    iUusData.iServiceReq = 0;

    iDataRateCode = KRateCode64000;

    iCallDirection = RMobileCall::EDirectionUnknown;

    iPipeHandle = KInvalidPipeHandle;

    iEmergCallDelayed = EFalse;

    iHSDPADisabledInPp = EFalse;

    iEmergencyTimer.ConstructL();

    // Read "HSDPA Disabled" status from product profile

    InfoPpDataReadReq();

    iSecondPepDeviceId = KSecondPepDevice;

    iSecondPepObjectId = KSecondPepObject;

    iCallOperationID = CSD_CALL_CREATE;

    iVideoCallMtReleased = EFalse;

    }

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

// CMmCallMessHandler::NewL

// Two-phased constructor.

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

//

CMmCallMessHandler* CMmCallMessHandler::NewL(

    CMmPhoNetSender* aPhoNetSender,

    CMmPhoNetReceiver* aPhoNetReceiver,

    CMmDtmfMessHandler* aDtmfMessHandler,

    CMmMessageRouter* aMessageRouter )

    {

TFLOGSTRING("TSY: CMmCallMessHandler::NewL");

OstTrace0( TRACE_NORMAL, CMMCALLMESSHANDLER_NEWL, "CMmCallMessHandler::NewL" );

    CMmCallMessHandler* callMessHandler = new( ELeave ) CMmCallMessHandler();

    CleanupStack::PushL( callMessHandler );

    callMessHandler->iPhoNetSender = aPhoNetSender;

    callMessHandler->iMessageRouter = aMessageRouter;

    callMessHandler->ConstructL();

    aPhoNetReceiver->RegisterL( callMessHandler, PN_MODEM_CALL );

    aPhoNetReceiver->RegisterL(

        callMessHandler,

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

        PN_INFO,

#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

        PN_MODEM_INFO,

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

        INFO_PP_DATA_READ_RESP );

    aPhoNetReceiver->RegisterL(

        callMessHandler,

        PN_GPDS,

        GPDS_CONTEXTS_CLEAR_RESP );

    aPhoNetReceiver->RegisterL( callMessHandler, PN_CSD );

    aPhoNetReceiver->RegisterL( callMessHandler, PN_PIPE, PNS_PIPE_CREATE_RESP );

    aPhoNetReceiver->RegisterL( callMessHandler, PN_PIPE, PNS_PIPE_ENABLE_RESP );

    aPhoNetReceiver->RegisterL( callMessHandler, PN_PIPE, PNS_PIPE_RESET_RESP );

    aPhoNetReceiver->RegisterL( callMessHandler, PN_PIPE, PNS_PIPE_REMOVE_RESP );

    callMessHandler->iDtmfMessHandler = aDtmfMessHandler;

    CleanupStack::Pop( callMessHandler );

    return callMessHandler;

    }

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

// CMmCallMessHandler::~CMmCallMessHandler

// Destructor, deletes all allocated resources.

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

//

CMmCallMessHandler::~CMmCallMessHandler()

    {

TFLOGSTRING("TSY: CMmCallMessHandler::~CMmCallMessHandler");

OstTrace0( TRACE_NORMAL, DUP1_CMMCALLMESSHANDLER_CMMCALLMESSHANDLER, "CMmCallMessHandler::~CMmCallMessHandler" );

    if ( iDataPortHandler )

        {

        delete iDataPortHandler;

        }

    // No else

    }

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

// CMmCallMessHandler::ReceiveMessageL

// Entry point for messages received from Domestic OS. Switches the message

// to the correct method.

// (other items were commented in a header).

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

//

void CMmCallMessHandler::ReceiveMessageL(

    const TIsiReceiveC &aIsiMessage // Received ISI message

    )

    {

    TInt resource (aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ));

    TInt messageId(aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ));

TFLOGSTRING3("TSY: CMmCallMessHandler::ReceiveMessageL. Resource:%d. MsgId:%d", resource, messageId);

OstTraceExt2( TRACE_NORMAL, CMMCALLMESSHANDLER_RECEIVEMESSAGEL, "CMmCallMessHandler::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId );

    // Switch according to the resource

    switch ( resource )

        {

        // Call server messages

        case PN_MODEM_CALL:

           {

            // Switch according to the message id

            // and call the appropriate messagehandler method

            switch( messageId )

                {

                // NOTE: ALL KErrNotFound lines should be removed after the

                // message handlers have been rearranged

                case CALL_MODEM_RELEASE_IND:

                    {

                    CallReleaseInd( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_TERMINATED_IND:

                    {

                    CallTerminatedInd( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_STATUS_IND:

                    {

                    CallStatusIndL( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_CONTROL_IND:

                    {

                    CallControlInd( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_PROPERTY_SET_RESP:

                    {

                    TUint8 transactId( aIsiMessage.Get8bit(

                        ISI_HEADER_OFFSET_TRANSID ) );

TFLOGSTRING2("TSY: CMmCallMessHandler::ReceiveMessageL. CALL_MODEM_PROPERTY_SET_RESP. transactId:%d",transactId);

OstTraceExt1( TRACE_NORMAL, DUP1_CMMCALLMESSHANDLER_RECEIVEMESSAGEL, "CMmCallMessHandler::ReceiveMessageL. CALL_MODEM_PROPERTY_SET_RESP. transactId=%hhu", transactId );

                    if ( KCallTransId == transactId )

                        {

                        CallPropertySetResp( aIsiMessage );

                        }

                    break;

                    }

                case CALL_MODEM_NOTIFICATION_IND:

                    {

                    CallGsmNotificationInd( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_ANSWER_RESP:

                    {

                    CallAnswerResp( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_CONTROL_RESP:

                    {

                    CallControlResp( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_CREATE_RESP:

                    {

                    CallCreateResp( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_RELEASE_RESP:

                    {

                    CallReleaseResp( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_COMING_IND:

                    {

                    CallComingInd( aIsiMessage );

                    break;

                    }

                case CALL_MODEM_SERVICE_DENIED_IND:

                    {

                    CallServiceDeniedInd( aIsiMessage );

                    break;

                    }

                default:

                    {

                    // Needed because call server messages are also handled

                    // by DTMF and conference call message handlers

TFLOGSTRING("TSY: CMmCallMessHandler::ReceiveMessageL, switch resource - case PN_MODEM_CALL, switch messageId - default.\n" );

OstTrace0( TRACE_NORMAL, DUP5_CMMCALLMESSHANDLER_RECEIVEMESSAGEL, "CMmCallMessHandler::ReceiveMessageL, switch resource - case PN_MODEM_CALL, switch messageId - default.\n" );

                    break;

                    }

                }

            break;

            }

        // Info server messages

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

        case PN_INFO:

#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

        case PN_MODEM_INFO:

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

            {

            if ( INFO_PP_DATA_READ_RESP == messageId )

                {

                TUint8 transactId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );

                if ( KHsdpaPpTransId == transactId )

                    {

                    InfoPpDataReadResp( aIsiMessage );

                    }

                }

            break;

            }

        // GPDS server messages

        case PN_GPDS:

            {

            if ( GPDS_CONTEXTS_CLEAR_RESP == messageId )

                {

                GpdsContextsClearResp();

                }

            break;

            }

        // CSD server messages

        case PN_CSD:

            {

            // Switch according to the message id

            // and call the appropriate messagehandler method

            switch( messageId )

                {

                case CSD_CALL_CONTROL_RESP:

                    {

                    CsdCallControlResp( aIsiMessage );

                    break;

                    }

                case CSD_VIDEO_CALL_STATUS_IND:

                    {

                    CsdVideoCallStatusInd( aIsiMessage );

                    break;

                    }

                case CSD_MULTIMEDIA_DATA_RATE_IND:

                    {

                    CsdMultimediaDataRateInd( aIsiMessage );

                    break;

                    }

                default:

                    {

TFLOGSTRING("TSY: CMmCallMessHandler::ReceiveMessageL, switch resource - case PN_CSD, switch messageId - default.\n" );

OstTrace0( TRACE_NORMAL, DUP3_CMMCALLMESSHANDLER_RECEIVEMESSAGEL, "CMmCallMessHandler::ReceiveMessageL, switch resource - case PN_CSD, switch messageId - default." );

                    break;

                    }

                }

            break;

            }

        // ISI messages for Pipe Service

        case PN_PIPE:

            {

            switch( messageId )

                {

                case PNS_PIPE_CREATE_RESP:

                    {

                    PnsPipeCreateResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_ENABLE_RESP:

                    {

                    PnsPipeEnableResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_RESET_RESP:

                    {

                    PnsPipeResetResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_REMOVE_RESP:

                    {

                    PnsPipeRemoveResp( aIsiMessage );

                    break;

                    }

                case PNS_PIPE_REDIRECT_RESP:

                    {

                    PnsPipeRedirectResp( aIsiMessage );

                    }

                default:

                    {

TFLOGSTRING("TSY: CMmCallMessHandler::ReceiveMessageL, switch resource - case PN_PIPE, switch messageId - default.\n" );

OstTrace0( TRACE_NORMAL, DUP2_CMMCALLMESSHANDLER_RECEIVEMESSAGEL, "CMmCallMessHandler::ReceiveMessageL, switch resource - case PN_PIPE, switch messageId - default.\n" );

                    break;

                    }

                }

            break;

            }

        default:

            {

TFLOGSTRING("TSY: CMmCallMessHandler::ReceiveMessageL, switch resource - default.\n" );

OstTrace0( TRACE_NORMAL, DUP4_CMMCALLMESSHANDLER_RECEIVEMESSAGEL, "CMmCallMessHandler::ReceiveMessageL, switch resource - default.\n" );

            break;

            }

        }

    }

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

// CMmCallMessHandler::ExtFuncL

// Entry point for messages received from Symbian OS layer (Message manager)