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

//

// INCLUDE FILES

#include "cmmdatacalltsy.h"

#include "cmmdatalinetsy.h"

#include "cmmphonetsy.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmcalllist.h"

#include "CMmCommonStaticUtility.h"

#include "MmTsy_numberOfSlots.h"

#include "cmmlinelist.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/gsmerror.h>

#include "cmmcallgsmwcdmaext.h"

#include <etelmmerr.h>

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

CMmDataCallTsy::CMmDataCallTsy()

    {

    }

CMmDataCallTsy* CMmDataCallTsy::NewL( 

    CMmPhoneTsy* aMmPhone, CMmDataLineTsy* aMmLine,

    RMobilePhone::TMobileService aMode, 

    TDes& aName, 

    CMmMessageManagerBase* aMessageManager )

    {

    CMmDataCallTsy* mmCall = NULL;

    //check input parameters

    if ( NULL != aMmPhone && NULL != aMmLine &&

         RMobilePhone::ECircuitDataService == aMode )

        {

        mmCall = new( ELeave ) CMmDataCallTsy;

        CleanupClosePushL( *mmCall );

        mmCall->iMmPhone = aMmPhone;

        mmCall->iMmLine = aMmLine;

        mmCall->iCallName = aName;

        mmCall->iCallMode = aMode;

        mmCall->iMessageManager = aMessageManager;

        mmCall->ConstructL( aMode );        

        CleanupStack::Pop( mmCall );

        }

    return mmCall;

    }

CMmDataCallTsy::~CMmDataCallTsy()

    {

    // If Dial fails, Symbian CSD agent will close the call immediately.

    // This means that TSY has not yet received call status indications, 

    // where call status changes to idle. Thus responses from modem are 

    // passed to call object. 

    // Here we need to recover dataport if it is used.

    CCallBase::SetUnowned();

    // Check if dataport is loaned!

    if ( iLoanedCommPort.iPort.Compare( KNullDesC) != 0 )

        {

        //Create package

        CCallDataPackage package;

        //Set call id and call mode

        package.SetCallIdAndMode( iCallId, iCallMode );

        //Pack commport

        package.PackData( &iLoanedCommPort );

        //Send request to the Domestic OS layer.

        if( iMessageManager )

        	{

        	TRAP_IGNORE( 

            		iMessageManager->HandleRequestL(

                		EEtelCallRecoverDataPort, &package );

            		   );

        	}

        iLoanedCommPort.iCsy.Zero();

        iLoanedCommPort.iPort.Zero();

        }

    iRetDataCallCaps = NULL;

    iRetHscsdInfo = NULL;

    }

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

// CMmDataCallTsy::InitInternalAttributes

// Initialises miscellaneous internal attributes.

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

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

//

void CMmDataCallTsy::InitInternalAttributes()

    {

    CMmCallTsy::InitInternalAttributes();

    //set call capabilities

    iCallCaps.iFlags =

        RCall::KCapsData | RCall::KCapsDial | RCall::KCapsConnect;

    // Boolean that indicates if this call object is finished data call.

    // Required as Symbian CSD agent in situation where first data call

    // fails due wrong number and it then opens second data call, which

    // dials correct number. Call status notifications go to wrong call

    // object (the first one) and causes problems for clients.

    iIsFinishedDataCall = EFalse;

    //data call params

    iRetDataCallCaps = NULL;

    iLoanedCommPort.iCsy.Zero();

    iLoanedCommPort.iPort.Zero();

    }

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

// CMmDataCallTsy::DoExtFuncL

// DoExtFuncL is called by the Etel server when it has an "extended", i.e. 

// non-core ETel request for the TSY. To process a request handle, request  

// type and request data are passed to the TSY. 

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

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

//

TInt CMmDataCallTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    // The request data has to extracted from TDataPackage and the TAny* 

    // pointers have to be "cast" to the expected request data type

    // NOTE! Do not put any Cancel methods here.

    switch ( aIpc )

        {

      // Call Status

        // Get Call Status

        case EMobileCallGetMobileCallStatus:

            ret = GetMobileCallStatus( aTsyReqHandle,

                reinterpret_cast<RMobileCall::TMobileCallStatus*>(dataPtr) );

            break;

        // Notify Call Status Change

        case EMobileCallNotifyMobileCallStatusChange:

            ret = NotifyMobileCallStatusChange(

                reinterpret_cast<RMobileCall::TMobileCallStatus*>(dataPtr) );

            break;

        // Transfer One Call to Remote Party of Another Call

        case EMobileCallTransfer:

            ret = TransferL( aTsyReqHandle );

            break;

        // Notify Call Event

        case EMobileCallNotifyCallEvent:

            ret = NotifyCallEvent(

                reinterpret_cast<RMobileCall::TMobileCallEvent*>( dataPtr) );

            break;

        // Call Control

        // Get Call Capabilities

        case EMobileCallGetMobileCallCaps: 

             ret = GetMobileCallCaps( aTsyReqHandle, aPackage.Des1n() );

			 break;

	    //Notify Call Capabilities Change

        case EMobileCallNotifyMobileCallCapsChange:

             ret =  NotifyMobileCallCapsChange(aPackage.Des1n());

             break;

	    // Call Information

        // Get Mobile Call Information

        case EMobileCallGetMobileCallInfo:

            ret = GetMobileCallInfo( aTsyReqHandle, aPackage.Des1n() );

            break;

        // Notify Change of Remote Party Information

        case EMobileCallNotifyRemotePartyInfoChange:

            ret = NotifyRemotePartyInfoChange(

            reinterpret_cast<RMobileCall::TMobileCallRemotePartyInfoV1Pckg*>(

                    aPackage.Des1n()) );

            break;

        // Data Call Capabilities

        // Get Data Call Capabilities

        case EMobileCallGetMobileDataCallCaps: 

            ret = GetMobileDataCallCaps( aTsyReqHandle, aPackage.Des1n() );

            break;

        // Notify Change of Data Call Capabilities

        case EMobileCallNotifyMobileDataCallCapsChange:

            ret = NotifyMobileDataCallCapsChange( aTsyReqHandle,

                aPackage.Des1n() );

            break;

        // Data Call RLP Parameters

        // Get Data Call RLP Range

        case EMobileCallGetMobileDataCallRLPRange:

            ret = GetMobileDataCallRLPRange( aTsyReqHandle, 

                reinterpret_cast<TInt*>(dataPtr),

                reinterpret_cast<RMobileCall::TMobileDataRLPRangesV1Pckg*>(

                    dataPtr2) );

            break;

        // High Speed Circuit Switched Data (HCSCD)

        // Set Dynamic HSCSD Call Parameters

        case EMobileCallSetDynamicHscsdParams:

            ret = SetDynamicHscsdParams( aTsyReqHandle, 

                reinterpret_cast<RMobileCall::TMobileCallAiur*>(dataPtr),

                reinterpret_cast<TInt*>(dataPtr2) );

            break;

        // Get Current HSCSD Call Information

        case EMobileCallGetCurrentHscsdInfo:

            ret = GetCurrentHscsdInfo( aTsyReqHandle, aPackage.Des1n() );

            break;

        // Notify Change of HSCSD Call Information

        case EMobileCallNotifyHscsdInfoChange:

            ret = NotifyHscsdInfoChange( aTsyReqHandle, aPackage.Des1n() );

            break;

        // Order to notify if privacy is confirmed

        case EMobileCallNotifyPrivacyConfirmation:

            ret = NotifyPrivacyConfirmation(

              reinterpret_cast<RMobilePhone::TMobilePhonePrivacy*>(dataPtr) );

            break;

        // Dial a call ( DialNoFdnCheck )

        case EMobileCallDialNoFdnCheck:

    		ret = DialNoFdnCheck( aTsyReqHandle, aPackage.Des1n(), 

    		    aPackage.Des2u() ); 

    		break;            

        // Unsupported features

        case EMobileCallDialEmergencyCall:

        case EMobileCallHold:

        case EMobileCallResume:

        case EMobileCallSwap:

        case EMobileCallGoOneToOne:

        case EMobileCallSwitchAlternatingCall:

        case EMobileCallNotifyAlternatingCallSwitch:

        case EMobileCallSetPrivacy:

        case EMobileCallSetTrafficChannel:

        case EMobileCallNotifyTrafficChannelConfirmation:

        case EMobileCallGetUUSCaps:

        case EMobileCallNotifyUUSCapsChange:

        case EMobileCallActivateUUS:

        case EMobileCallSendUUI:

        case EMobileCallReceiveUUI:

        case EMobileCallHangupWithUUI:

        case EMobileCallAnswerWithUUI:

        case EMobileCallNotifyVoiceFallback:

        case EMobileCallDeflect:

        case EMobileCallActivateCCBS:

        case EMobileCallRejectCCBS:

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmDataCallTsy::ReqModeL

// ReqModeL is called from the ETel server's CTelObject::ReqAnalyserL in order 

// to check the type of request it has.

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

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

//

CTelObject::TReqMode CMmDataCallTsy::ReqModeL(

    const TInt aIpc )

    {

    CTelObject::TReqMode ret( 0 ); // default return value

    switch ( aIpc )

        {

        // No Flow Control

        // All disabled

        // TSYs wishing to implement their own buffering algorithm will

        // place all requests in this category.

        // This category will also be used by the RecoverDataPort request

        // that must be passed to the TSY to indicate that it may use

        // the communications port after a loan.

        // Get methods that do not use Licencee specific TSY  and return 

        // immediately. Flow control not required.

        case EEtelCallGetInfo:

        case EEtelCallGetStatus:

        case EEtelCallGetCaps:

        case EEtelCallGetBearerServiceInfo:

        case EEtelCallGetOwnershipStatus:

        case EEtelCallGetCallParams:

        case EEtelCallGetCallDuration:

        case EEtelCallGetFaxSettings:

        case EMobileCallGetMobileCallStatus:

        case EMobileCallGetMobileCallInfo:

        case EMobileCallGetMobileDataCallCaps:

        case EMobileCallGetMobileCallCaps:

        case EMobileCallGetCurrentHscsdInfo:

        case EMobileCallGetMobileDataCallRLPRange:

        case EMobileCallGetUUSCaps:

        case EMobileCallActivateUUS:

        case EMobileCallSendUUI:

        case EMobileCallReceiveUUI:

        case EMobileCallHangupWithUUI:

        case EMobileCallAnswerWithUUI:

        // Other methods that do not use Licencee specific TSY and return 

        // immediately.

        // Flow control not required.

        case EEtelCallAcquireOwnership:

        case EEtelCallTransferOwnership:

        case EEtelCallSetFaxSettings:

        // Methods that can propably take a long time and cannot therefore be 

        // flow controlled. Solution: All these methods must check req handle 

        // table before handling the request. In case that the request table 

        // indicates that same method has been called and has not been 

        // completed, the method should return KErrServerBusy.

        case EMobileCallTransfer:

        // This is also included here due to the fact that Emergency call

        // should never be blocked by flow control. KErrServerBusy returned

        // when already already dialing.

        case EMobileCallDialEmergencyCall:

        // HangUp cannot be flow controlled. Client should for example be able

        // to terminate a call while another call is e.g. in Dialling state.

        case EEtelCallHangUp:

        // Answer was mixed with Hangup. Therefore this is also No flow 

        // control type

        case EEtelCallAnswer:

        // dial is not flow controlled as compeltion may take a while and that

        // blocks for example PS data activation in 3G while dialing.

        case EEtelCallDial:

        case EMobileCallDialNoFdnCheck:        

            break;

        // Flow Controlled Services

        // KReqModeFlowControlObeyed

        // Commands that change the state of the phone, e.g. clearing the

        // AoC counter; are commands that the TSY should only deal with

        // one at a time.

        //Voice call related methods that should be handled one at the time.

        case EEtelCallConnect:

        case EMobileCallHold:

        case EMobileCallResume:

        case EMobileCallSwap:

        case EMobileCallDeflect:

        case EMobileCallGoOneToOne:

        //Data call related methods that should be handled one at the time.

        case EEtelCallLoanDataPort:

        case EEtelCallRecoverDataPort:

        case EMobileCallSwitchAlternatingCall:

        case EMobileCallSetDynamicHscsdParams:

        case EMobileCallSetPrivacy:

        case EMobileCallSetTrafficChannel:

            ret = KReqModeFlowControlObeyed;

            break;

        // ReqModePostImmediately

        // Requests that notify a client about a change of state, where

        // the TSY needs to distinguish between different clients.

            //ret=KReqModeRePostImmediately;

        // KReqModeMultipleCompletionEnabled

        // (a) commands that may take some time, but which the TSY can

        //     handle more than one of concurrently, or 

        // (b) notifications that the TSY does not wish to be re-posted

        //     immediately, so the server does no buffering.

            //ret=KReqModeMultipleCompletionEnabled;

        // KReqModeMultipleCompletionEnabled | KReqModeFlowControlObeyed

        // A command that may take some time and which the TSY can only

        // deal with one at a time.

            //ret = KReqModeMultipleCompletionEnabled |

            //      KReqModeFlowControlObeyed;

            //break;

        // Notifications

        // KReqModeMultipleCompletionEnabled | ReqModePostImmediately

        // Requests that notify a client about a change of state.

        // Since these requests do not require the issuing of any modem

        // commands, they do not have to obey flow control.

        // The TSY never gets more than one of these outstanding per 

        // CTelObject

        case EEtelCallNotifyHookChange:        

        case EEtelCallNotifyStatusChange:

        case EEtelCallNotifyDurationChange: 

        case EEtelCallCapsChangeNotification:

        case EMobileCallNotifyCallEvent:

        case EMobileCallNotifyMobileCallStatusChange:

        case EMobileCallNotifyRemotePartyInfoChange:

        case EMobileCallNotifyPrivacyConfirmation:

        case EMobileCallNotifyTrafficChannelConfirmation:

        case EMobileCallNotifyHscsdInfoChange:

        case EMobileCallNotifyMobileDataCallCapsChange:

        case EMobileCallNotifyAlternatingCallSwitch:

        case EMobileCallNotifyMobileCallCapsChange:

        case EMobileCallNotifyVoiceFallback:

        case EMobileCallNotifyUUSCapsChange:

            ret = KReqModeMultipleCompletionEnabled |

                KReqModeRePostImmediately;

            break;

        // Cancel Requests

        // It is not necessary to include the Cancel methods in ReqModeL.

        // The ETel server never calls ReqModeL with a Cancel IPC.

        // Other variations of return values are unusable

        // Default: Call CCallBase's ReqModeL.

        default:

            //Direct the request to the CCallBase

            ret = CCallBase::ReqModeL( aIpc );

            break;

        }

    return ret;

    }

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

// CMmDataCallTsy::NumberOfSlotsL

// NumberOfSlotsL is called by the server when it is registering a new 

// NOTIFICATION. It enables the TSY to tell the server how many buffer slots 

// to allocate for "repost immediately" notifications that may trigger before 

// clients collect them.

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

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

//

TInt CMmDataCallTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    // There is a buffer in the ETel server for each type of NOTIFICATION and

    // the size of the buffer is determined by the TSY. When the ETel server

    // discovers that a request is "repost immediately" it will ask the TSY

    // how big a buffer it wants by calling CTelObject::NumberOfSlotsL( ).

    //

    // It is up to the TSY developer's judgement how many buffer slots this

    // method returns for each notification. If there is a danger that

    // a particular notification could trigger frequently and in rapid

    // succession (e.g. call group change notification) then at least 10 or

    // 20 slots may be required. For a notification that triggers rarely,

    // perhaps 1 or 2 slots is enough.

    //

    // So if the ETel server has stored a few occurrences of a particular

    // notification, when a client subsequently calls that notification

    // request, the ETel server will complete the client's request with

    // the saved data.

    TInt numberOfSlots( 1 );

    switch ( aIpc ) 

        {

        case EEtelCallNotifyHookChange:

            numberOfSlots = KMmCallHookChangeSlots;

            break;

        case EEtelCallNotifyStatusChange:

            numberOfSlots = KMmCallStatusChangeSlots;

            break;

        case EEtelCallNotifyDurationChange: 

            numberOfSlots = KMmCallDurationChangeSlots;

            break;

        case EEtelCallCapsChangeNotification:

            numberOfSlots = KMmCallCapsChangeSlots;

            break;

        case EMobileCallNotifyCallEvent:

            numberOfSlots = KMmCallCallEventSlots;

            break;

        case EMobileCallNotifyMobileCallStatusChange:

            numberOfSlots = KMmCallMobileCallStatusChangeSlots;

            break;

        case EMobileCallNotifyRemotePartyInfoChange:

            numberOfSlots = KMmCallRemotePartyInfoChangeSlots;

            break;

        case EMobileCallNotifyPrivacyConfirmation:

            numberOfSlots = KMmCallPrivacyConfirmationSlots;

            break;

        case EMobileCallNotifyTrafficChannelConfirmation:

            numberOfSlots = KMmCallTrafficChannelConfirmationSlots;

            break;

        case EMobileCallNotifyHscsdInfoChange:

            numberOfSlots = KMmCallHscsdInfoChangeSlots;

            break;

        case EMobileCallNotifyMobileDataCallCapsChange:

            numberOfSlots = KMmCallMobileDataCallCapsChangeSlots;

            break;

        case EMobileCallNotifyAlternatingCallSwitch:

            numberOfSlots = KMmCallAlternatingCallSwitchSlots;

            break;

        case EMobileCallNotifyMobileCallCapsChange:

            numberOfSlots = KMmCallMobileCallCapsChangeSlots;

            break;

        case EMobileCallNotifyVoiceFallback:

            numberOfSlots = KMmCallVoiceFallbackSlots;

            break;

        case EMobileCallNotifyUUSCapsChange:

            numberOfSlots = KMmCallUUSCapsChangeSlots;

            break;

        default:

            // Unknown or invalid Call IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmDataCallTsy::CancelService

// CancelService is called by the ETel server when it is "cleaning-up" any 

// still outstanding asynchronous requests before closing a client's