// 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 "cmmfaxcalltsy.h"

#include "cmmfaxlinetsy.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 "CMmFaxExtInterface.h" 

#include "cmmcallgsmwcdmaext.h"

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

CMmFaxCallTsy::CMmFaxCallTsy()

    {

    }

CMmFaxCallTsy* CMmFaxCallTsy::NewL( 

    CMmPhoneTsy* aMmPhone, CMmFaxLineTsy* aMmLine,

    RMobilePhone::TMobileService aMode, 

    TDes& aName, 

    CMmMessageManagerBase* aMessageManager )

    {

    CMmFaxCallTsy* mmCall = NULL;

    //check input parameters

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

         aMode == RMobilePhone::EFaxService )

        {

        mmCall = new( ELeave ) CMmFaxCallTsy;

        CleanupClosePushL( *mmCall );

        mmCall->iMmPhone = aMmPhone;

        mmCall->iMmLine = aMmLine;

        mmCall->iCallName = aName;

        mmCall->iCallMode = aMode;

        mmCall->iMessageManager = aMessageManager;

        mmCall->ConstructL( aMode );

        CleanupStack::Pop();

        }

    return mmCall;

    }

CMmFaxCallTsy::~CMmFaxCallTsy()

    {

    // 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 assert that call object recovers dataport

    // if it is loaned.

    CCallBase::SetUnowned();

    // delete Internal Fax call extension object.

    if ( iMmFaxExt )

        {

        delete iMmFaxExt;

        }

    iMmFaxExt = NULL;

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

        }

    // If this is iLastIncomingFaxCall, set iLastIncomingFaxCall

    // of CMmFaxLineTsy to NULL

    if ( this == (reinterpret_cast<CMmFaxLineTsy*>(iMmLine))->iLastIncomingFaxCall )

    	{

        reinterpret_cast<CMmFaxLineTsy*>(iMmLine)->ResetLastIncomingCall();

    	}

    }

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

// CMmFaxCallTsy::InitExtensionModulesL

// Initialises extension modules for CMmFaxCallTsy

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

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

//

void CMmFaxCallTsy::InitExtensionModulesL(

    RMobilePhone::TMobileService aMode )

    {

    CMmCallTsy::InitExtensionModulesL( aMode );

    // Create internal fax call object if this is fax call

    // TODO: what to do when this is faxmodem fax call??

    if ( aMode == RMobilePhone::EFaxService )

        {

        // Internal Fax call extension object creation.

        iMmFaxExt = CMmFaxExtInterface::NewL( this );

        }

    else

        {

        iMmFaxExt = NULL;

        }

    }

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

// CMmFaxCallTsy::InitInternalAttributes

// Initialises miscellaneous internal attributes.

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

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

//

void CMmFaxCallTsy::InitInternalAttributes()

    {

    CMmCallTsy::InitInternalAttributes();

    iCallCaps.iFlags = RCall::KCapsFax | 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;

    //dataport params

    iLoanedCommPort.iCsy.Zero();

    iLoanedCommPort.iPort.Zero();;

    }

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

// CMmFaxCallTsy::OpenNewObjectByNameL

// Creates new Fax object and returns a pointer to it.

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

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

//

CTelObject* CMmFaxCallTsy::OpenNewObjectByNameL(    

    const TDesC& aName )

    {

    CTelObject* telObject = NULL;

    // iMmFaxExt is non null if fax calls are supported

    if ( iMmFaxExt )

        {

        telObject = iMmFaxExt->OpenNewObjectByNameL(aName);

        }

    else

        {

        //Not supported

        User::Leave( KErrNotSupported );

        }

    return telObject;

    }

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

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

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    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 )

        {

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

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

        // Unsupported features

        case EMobileCallDialEmergencyCall:

        case EMobileCallHold:

        case EMobileCallResume:

        case EMobileCallSwap:

        case EMobileCallGoOneToOne:

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

        case EMobileCallSendUUI:

        case EMobileCallReceiveUUI:

        case EMobileCallHangupWithUUI:

        case EMobileCallAnswerWithUUI:

        case EMobileCallNotifyVoiceFallback:

        case EMobileCallDeflect:

        case EMobileCallActivateCCBS:

        case EMobileCallRejectCCBS:

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

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

        case EMobileCallSendUUI:

        case EMobileCallReceiveUUI:

        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:

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

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

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

    }

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

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