// Copyright (c) 2006-2009 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:

//

// INCLUDE FILES

#include "cmmvoicecalltsy.h"

#include <featmgr/featurecontrol.h>

#include <featureuids.h>

#include "cmmvoicelinetsy.h"

#include "cmmphonetsy.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmcalllist.h"

#include "CMmCommonStaticUtility.h"

#include "MmTsy_numberOfSlots.h"

#include "MmTsy_timeoutdefs.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/gsmerror.h>

#include "cmmcallgsmwcdmaext.h"

#include "cmmdtmftsy.h"

#include "cmmconferencecalltsy.h"

#include "CMmCustomTsy.h"

#include "cmmconferencecallgsmwcdmaext.h"

#include <etelmmerr.h>

#include <ctsy/pluginapi/mtelephonyaudiocontrol.h>

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

CMmVoiceCallTsy::CMmVoiceCallTsy()

    {

    }

CMmVoiceCallTsy* CMmVoiceCallTsy::NewL( 

    CMmPhoneTsy* aMmPhone, CMmVoiceLineTsy* aMmLine,

    RMobilePhone::TMobileService aMode, 

    TDes& aName, 

    CMmMessageManagerBase* aMessageManager,

    MTelephonyAudioControl* aTelephonyAudioControl )

    {

TFLOGSTRING2("TSY: CMmVoiceCallTsy::NewL. Call name: %S", &aName);

    CMmVoiceCallTsy* mmCall = NULL;

    //check input parameters

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

        aMode == RMobilePhone::EVoiceService ||

        aMode == RMobilePhone::EAuxVoiceService ) )

        {

        mmCall = new( ELeave ) CMmVoiceCallTsy;

        CleanupClosePushL( *mmCall );

        mmCall->iMmPhone = aMmPhone;

        mmCall->iMmLine = aMmLine;

        mmCall->iCallName = aName;

        mmCall->iCallMode = aMode;

        mmCall->iMessageManager = aMessageManager;

        mmCall->iTelephonyAudioControl = aTelephonyAudioControl;

        mmCall->iTelephonyAudioControlSetup = EFalse;

        mmCall->ConstructL( aMode );

        CleanupStack::Pop();

        }

    return mmCall;

    }

CMmVoiceCallTsy::~CMmVoiceCallTsy()

    {

TFLOGSTRING3("TSY: CMmVoiceCallTsy::~CMmVoiceCallTsy. Call deleted iCallId:%d iCallName:%S", iCallId, &iCallName);

    }

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

// CMmVoiceCallTsy::InitInternalAttributes

// Initialises miscellaneous internal attributes.

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

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

//

void CMmVoiceCallTsy::InitInternalAttributes()

    {

    //initialise internal attributes of base class

    CMmCallTsy::InitInternalAttributes();

    //set call capabilities

    iCallCaps.iFlags = RCall::KCapsVoice | RCall::KCapsDial;

    //not yet an emergency call

    iEmergencyCall = EFalse;

    i3rdPartyEmergencyNumberCheckDone = EFalse;

    iISVCallParams = NULL;

    iIsDialISV = EFalse;

    }

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

// CMmVoiceCallTsy::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 CMmVoiceCallTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

TFLOGSTRING3("TSY: CMmVoiceCallTsy::DoExtFuncL. IPC:%d Handle:%d", aIpc, aTsyReqHandle);

    TInt ret( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

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

        {

      // Emergency Calls

        // Dial Emergency Call

        case EMobileCallDialEmergencyCall:

            ret = DialEmergencyCall( aTsyReqHandle, aPackage );

            break;

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

        // Place Call on Hold

        case EMobileCallHold:

            ret = HoldL( aTsyReqHandle );

            break;

        // Resume a Held Call

        case EMobileCallResume:

            ret = ResumeL( aTsyReqHandle );

            break;

        // Swap Between an On-going and an Held Call

        case EMobileCallSwap:

            ret = SwapL( aTsyReqHandle );

            break;

        // Transfer One Call to Remote Party of Another Call

        case EMobileCallTransfer:

            ret = TransferL( aTsyReqHandle );

            break;

        // Go "One-to-One" within a Conference Call

        case EMobileCallGoOneToOne:

            ret = GoOneToOneL( 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;

        // Order to notify if privacy is confirmed

        case EMobileCallNotifyPrivacyConfirmation:

            ret = NotifyPrivacyConfirmation(

                reinterpret_cast<RMobilePhone::TMobilePhonePrivacy*>(

                    dataPtr ) );

            break;

        //AnswerIncomingCall ( by 3rd Party client )

        case EMobileCallAnswerISV:

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

                break;

        //Dial a call ( by 3rd Party client )

        case EMobileCallDialISV:

            i3rdPartyEmergencyNumberCheckDone = EFalse;

            iIsDialISV = ETrue;

            ret = Dial( aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u() );

            break;       

        // Activate User-To-User Signalling service

        case EMobileCallActivateUUS:

            ret = ActivateUUS( aTsyReqHandle, 

                REINTERPRET_CAST( RMobileCall::TMobileCallUUSRequestV1Pckg*,

                aPackage.Des1n()) );

            break;

        // Receive User-To-User Information, TDes16 descriptor pointer

        case EMobileCallReceiveUUI:

            ret = ReceiveUUI( aTsyReqHandle, 

                REINTERPRET_CAST( RMobileCall::TMobileCallUUI*,

                aPackage.Des1u() ) );

            break;            

        // Dial a call ( DialNoFdnCheck )

        case EMobileCallDialNoFdnCheck:

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

    		    aPackage.Des2u() ); 

    		break;

        // Unsupported features

        case EMobileCallGetMobileDataCallCaps: 

        case EMobileCallNotifyMobileDataCallCapsChange: 

        case EMobileCallGetMobileDataCallRLPRange:

        case EMobileCallSetDynamicHscsdParams:

        case EMobileCallGetCurrentHscsdInfo:

        case EMobileCallNotifyHscsdInfoChange:

        case EMobileCallSwitchAlternatingCall:

        case EMobileCallNotifyAlternatingCallSwitch:

        case EMobileCallSetPrivacy:

        case EMobileCallSetTrafficChannel:

        case EMobileCallNotifyTrafficChannelConfirmation:

        case EMobileCallGetUUSCaps:

        case EMobileCallNotifyUUSCapsChange:

        case EMobileCallSendUUI:

        case EMobileCallHangupWithUUI:

        case EMobileCallAnswerWithUUI:

        case EMobileCallNotifyVoiceFallback:

        case EMobileCallDeflect:

        case EMobileCallActivateCCBS:

        case EMobileCallRejectCCBS:

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmVoiceCallTsy::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 CMmVoiceCallTsy::ReqModeL(

    const TInt aIpc )

    {

TFLOGSTRING2("TSY: CMmVoiceCallTsy::ReqModeL. IPC:%d",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.

        // Get methods that do not use DOS 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 EMobileCallSendUUI:

        case EMobileCallHangupWithUUI:

        case EMobileCallAnswerWithUUI:

        //Other methods that do not use DOS 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:

        case EMobileCallAnswerISV:

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

            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:

        case EMobileCallActivateUUS:

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

        case EEtelCallLoanDataPort:

        case EEtelCallRecoverDataPort:

        case EMobileCallSwitchAlternatingCall:

        case EMobileCallSetDynamicHscsdParams:

        case EMobileCallSetPrivacy:

        case EMobileCallSetTrafficChannel:

        case EMobileCallDialISV:

        case EMobileCallDialNoFdnCheck:

            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:

        case EMobileCallReceiveUUI:

            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;

    }

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

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

        case EMobileCallReceiveUUI:

            numberOfSlots = KMmCallReceiveUUISlots;

            break;

        default:

            // Unknown or invalid Call IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmVoiceCallTsy::CancelService

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

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

// sub-session. This will happen if a client closes its R-class handle without 

// cancelling outstanding asynchronous requests. Only Mobile API requests are 

// handled here.

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

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

//

TInt CMmVoiceCallTsy::CancelService(

    const TInt aIpc,

    const TTsyReqHandle aTsyReqHandle )

    {

TFLOGSTRING3("TSY: CMmVoiceCallTsy::CancelService. IPC: %d, Req handle: %d", aIpc, aTsyReqHandle); 

    TInt ret( KErrNone );

    //When the clients close their sub-sessions (eg. by calling RPhone::Close)

    //they may not have cancelled all their outstanding asynchronous requests

    //before closing.  It is up to the ETel server to clean up in this

    //situation, so the server will find the list of outstanding requests

    //related to that sub-session object and pass these outstanding IPC 

    //request numbers,one at a time,to the CancelService function in the TSY.

    switch ( aIpc )

        {

        //TSY has started a request and it is not possible to then cancel this

        //request. The best thing for the TSY to do in this case is to proceed

        //as though the Cancel never happened. The server's call to the TSY

        //cancel function will return synchronously. The TSY then continues to