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

#include <featureuids.h>

#include "cmmphonetsy.h"

#include "cmmcalllist.h"

#include "cmmconferencecalltsy.h"

#include "cmmconferencecallgsmwcdmaext.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include "cmmmessagemanagerbase.h"

#include <ctsy/tflogger.h>

#include "cmmvoicecalltsy.h"

//csd includes

#include "cmmdatacalltsy.h"

 #include <et_tsy.h>

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

CMmCallGsmWcdmaExt::CMmCallGsmWcdmaExt()

    {

    }

void CMmCallGsmWcdmaExt::ConstructL()

    {

    // Create  normal and HSCSD data call related pointers!

    iDataCallCaps = new ( ELeave ) RMobileCall::TMobileCallDataCapsV1();

    iCSDParams = new ( ELeave ) RMobileCall::TMobileDataCallParamsV8();

    iHSCSDParams = new ( ELeave ) RMobileCall::TMobileHscsdCallParamsV8();

    iCurrentHSCSDInfo = new ( ELeave ) RMobileCall::TMobileCallHscsdInfoV8();

    // iCSDParams, iHSCSDParams and iCurrentHSCSDInfo:

    // Service and QoS values are set to only supported value (MO, defined in

    // MmTsy_Defaults.h). If there will be more supported caps in for example

    // continuation projects, then set here Service and QoS to Unspecified.

    iCSDParams->iService = RMobileCall::RMobileCall::EServiceDataCircuitAsync;;

    iCSDParams->iQoS = RMobileCall::EQoSNonTransparent;

    iCSDParams->iSpeed = RMobileCall::ESpeedUnspecified;

    iCSDParams->iProtocol = RMobileCall::EProtocolUnspecified;

    iCSDParams->iRLPVersion = RMobileCall::ERLPNotRequested;

    iCSDParams->iModemToMSWindowSize = 0x00;

    iCSDParams->iMSToModemWindowSize = 0x00;

    iCSDParams->iAckTimer = 0x00;

    iCSDParams->iRetransmissionAttempts = 0x00;

    iCSDParams->iResequencingPeriod = 0x00;

    iCSDParams->iV42bisReq = RMobileCall::EV42bisNeitherDirection;

    iCSDParams->iV42bisCodewordsNum = 0x00;

    iCSDParams->iV42bisMaxStringLength = 0x00; 

    RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast<RMobileCall::TMobileDataCallParamsV8*>(iCSDParams);

    dataCallParamsV8->iBearerMode = RMobileCall::EMulticallNotSupported;

    dataCallParamsV8->iCallParamOrigin = RMobileCall::EOriginatorUnknown;

    dataCallParamsV8->iBCRepeatIndicator = RMobileCall::EBCAlternateMode;

    iHSCSDParams->iWantedAiur = RMobileCall::EAiurBpsUnspecified;

    iHSCSDParams->iWantedRxTimeSlots = 0x00;

    iHSCSDParams->iMaxTimeSlots = 0x00;

    iHSCSDParams->iCodings = 0x00;

    iHSCSDParams->iAsymmetry = RMobileCall::EAsymmetryNoPreference;

    iHSCSDParams->iUserInitUpgrade = KMultimodeTsyDataUserInitUpgrade;

    RMobileCall::TMobileHscsdCallParamsV8* hscsdCallParamsV8 = static_cast<RMobileCall::TMobileHscsdCallParamsV8*>(iHSCSDParams);

    hscsdCallParamsV8->iBearerMode = RMobileCall::EMulticallNotSupported;

    hscsdCallParamsV8->iCallParamOrigin = RMobileCall::EOriginatorUnknown;

    hscsdCallParamsV8->iIconId.iQualifier = RMobileCall::EIconQualifierNotSet;

    hscsdCallParamsV8->iIconId.iIdentifier = 0x00;

    hscsdCallParamsV8->iBCRepeatIndicator = RMobileCall::EBCAlternateMode;

    iCurrentHSCSDInfo->iAiur = RMobileCall::EAiurBpsUnspecified;

    iCurrentHSCSDInfo->iRxTimeSlots = 0x00;

    iCurrentHSCSDInfo->iTxTimeSlots = 0x00;

    iCurrentHSCSDInfo->iCodings = RMobileCall::ETchCodingUnspecified;

    iCurrentHSCSDInfo->iCallParamOrigin = RMobileCall::EOriginatorUnknown;

    iCurrentHSCSDInfo->iIconId.iIdentifier = 0x00;

    iCurrentHSCSDInfo->iIconId.iQualifier = RMobileCall::EIconQualifierNotSet;

    iCurrentHSCSDInfo->iParamsCallControlModified = EFalse;

    iCurrentHSCSDInfo->iBCRepeatIndicator = RMobileCall::EBCAlternateMode;

    iMobileCallCaps.iCallControlCaps = 0x00000000 | RCall::KCapsDial;

    if ( RMobilePhone::EVoiceService == iSymbianCallMode )

        {

        iMobileCallCaps.iCallControlCaps |= RCall::KCapsVoice;

        }

    else if ( RMobilePhone::ECircuitDataService == iSymbianCallMode )

        {

        iMobileCallCaps.iCallControlCaps |=

            RCall::KCapsData | RCall::KCapsConnect;

        }

    else if ( RMobilePhone::EFaxService == iSymbianCallMode )

        {

        iMobileCallCaps.iCallControlCaps |= RCall::KCapsFax;

        }

    else

        {

        iMobileCallCaps.iCallControlCaps = 0x00000000;

        }

    iMobileCallCaps.iCallEventCaps = 0x000000ff;

    iMobileCallInfo.iForwarded = EFalse;

    iMobileCallInfo.iBCRepeatIndicator = RMobileCall::EBCAlternateMode;

    TInt err = iFeatureControl.Open();

	iUsingFeatureManager = (err == KErrNone);

	ResetInternalAttributes();

    }

CMmCallGsmWcdmaExt* CMmCallGsmWcdmaExt::NewL(

    CMmCallTsy* aMmCallTsy,

    RMobilePhone::TMobileService aMode,

    CMmMessageManagerBase* aMessageManager )

    {

    CMmCallGsmWcdmaExt* callGsmWcdmaExt = new( ELeave ) CMmCallGsmWcdmaExt();

    CleanupStack::PushL( callGsmWcdmaExt );

    callGsmWcdmaExt->iMmCallTsy = aMmCallTsy;

    callGsmWcdmaExt->iSymbianCallMode = aMode;

    callGsmWcdmaExt->iMessageManager = aMessageManager;

    callGsmWcdmaExt->ConstructL();

    CleanupStack::Pop();

    return callGsmWcdmaExt;

    }

CMmCallGsmWcdmaExt::~CMmCallGsmWcdmaExt()

    {

    iFeatureControl.Close();

    if ( iDataCallCaps )

        {

        delete iDataCallCaps;

        }

    iDataCallCaps = NULL;

    if ( iCSDParams )

        {

        delete iCSDParams;

        }

    iCSDParams = NULL;

    if ( iHSCSDParams )

        {

        delete iHSCSDParams;

        }

    iHSCSDParams = NULL;

    if ( iCurrentHSCSDInfo )

        {

        delete iCurrentHSCSDInfo;

        }

    iCurrentHSCSDInfo = NULL;

    iMmCallTsy = NULL;

    iMessageManager = NULL;

    }

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

// CMmCallGsmWcdmaExt::ResetInternalAttributes

// Resets GSM call internal attributes.

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

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

//

void CMmCallGsmWcdmaExt::ResetInternalAttributes()

    {

    // Add only attributes that can be set in call object construction 

    // (during ConstructL), in HangUp or in call object destruction 

    // (during ~CMmCallGsmWcdmaExt).

    iDataCallMode = EDataCallModeUnknown;

    iBearerService.iBearerCaps =

        RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown;

    iBearerService.iBearerSpeed = RCall::EBearerDataUnknown;

    // Set data call caps to default

    // Supported capabilities defined in MmTsy_Defaults.h, see also etelmm.h 

    iDataCallCaps->iSpeedCaps = KMultimodeTsyDataSpeedCaps;

    iDataCallCaps->iProtocolCaps = KMultimodeTsyDataProtocolCaps;

    iDataCallCaps->iServiceCaps = KMultimodeTsyDataServiceCaps;

    iDataCallCaps->iQoSCaps = KMultimodeTsyDataQoSCaps;

    iDataCallCaps->iHscsdSupport = KMultimodeTsyDataHscsdSupport;

    // additional flags for videotelephony

	if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KCsVideoTelephony) == KFeatureSupported) )

		{

		iDataCallCaps->iSpeedCaps |= KMultimodeTsyDataSpeedCapsVT;

	    iDataCallCaps->iProtocolCaps |= KMultimodeTsyDataProtocolCapsVT;

    	iDataCallCaps->iServiceCaps |= KMultimodeTsyDataServiceCapsVT;

		}

    // If Hscsd support is false, all the following iDataCallCaps are invalid

    // Detailed in GSM 05.02 V8.10.0 Appendix B

    // Multislot class

    iDataCallCaps->iMClass = KMultimodeTsyDataMClassDefValue;

    // Max number of Rx slots

    iDataCallCaps->iMaxRxTimeSlots = KMultimodeTsyDataMaxRxTSDefValue;

    // Max number of Tx slots

    iDataCallCaps->iMaxTxTimeSlots = KMultimodeTsyDataMaxTxTSDefValue;

    // Max number of Sum slots

    iDataCallCaps->iTotalRxTxTimeSlots = KMultimodeTsyDataTotalRxTxTSDefValue;

    iDataCallCaps->iCodingCaps = KMultimodeTsyDataTchCodingsCaps;

    iDataCallCaps->iAsymmetryCaps = KMultimodeTsyDataAsymmetryCaps;

    // Not supporting automatic service level upgrading

    iDataCallCaps->iUserInitUpgrade = KMultimodeTsyDataUserInitUpgrade;  

    iDataCallCaps->iRLPVersionCaps = KMultimodeTsyDataRLPVersionCaps;

    iDataCallCaps->iV42bisCaps = KMultimodeTsyDataV42bisCaps; 

    }

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

// CMmCallGsmWcdmaExt::DialL

// GSM specific Dial method for outgoing call

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

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

//

TInt CMmCallGsmWcdmaExt::DialL(

    RMobilePhone::TMobileService aCallMode,

    const TDesC8* aCallParams,

    const TDesC* aTelNumber,

    TInt aExtensionId )

    {

TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::DialL extensionid %d", aExtensionId );

    //use base class to determine callparam version

    RCall::TCallParamsPckg* callParamsPckg = 

        reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>( aCallParams ) ); 

    RCall::TCallParams& callParams = ( *callParamsPckg )();

    TInt extensionId( callParams.ExtensionId() );

TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::DialL callParams.extensionId %d ", extensionId);

    if( ( RMobileCall::KETelMobileCallParamsV1 == extensionId ) || 

    		( RMobileCall::KETelMobileCallParamsV2 == extensionId ))

        {

TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams V1, V2");

        iCallParams.iSpeakerControl = callParams.iSpeakerControl;

        iCallParams.iSpeakerVolume = callParams.iSpeakerVolume;

        iCallParams.iInterval = callParams.iInterval;

        iCallParams.iWaitForDialTone = callParams.iWaitForDialTone;

        RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = 

            reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>( 

            const_cast<TDesC8*>( aCallParams ) );

        RMobileCall::TMobileCallParamsV1& params1 = (*paramsPckgV1)();

        iCallParams.iIdRestrict = params1.iIdRestrict;

        iCallParams.iAutoRedial = params1.iAutoRedial;

        iCallParams.iCug.iExplicitInvoke = params1.iCug.iExplicitInvoke;

        iCallParams.iCug.iCugIndex = params1.iCug.iCugIndex;

        iCallParams.iCug.iSuppressOA = params1.iCug.iSuppressOA;

        iCallParams.iCug.iSuppressPrefCug = params1.iCug.iSuppressPrefCug;        

        if ( RMobileCall::KETelMobileCallParamsV2 == extensionId ) 

            {

    TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams V2");

            RMobileCall::TMobileCallParamsV2Pckg* paramsPckgV2 = 

                reinterpret_cast<RMobileCall::TMobileCallParamsV2Pckg*>( 

                const_cast<TDesC8*>( aCallParams ) );

            RMobileCall::TMobileCallParamsV2& params2 = (*paramsPckgV2)();

            iCallParams.iBearerMode = params2.iBearerMode;

            }

        }

    else if( RMobileCall::KETelMobileCallParamsV7 == extensionId )

        {

TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams V7");        

        RMobileCall::TMobileCallParamsV7Pckg* paramsPckgV7 = 

            reinterpret_cast<RMobileCall::TMobileCallParamsV7Pckg*>( 

            const_cast<TDesC8*>( aCallParams ) );

        iCallParams = ( *paramsPckgV7 )();

        }

    else

        {

TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams version unknown");

        iCallParams.iSpeakerControl = callParams.iSpeakerControl;

        iCallParams.iSpeakerVolume = callParams.iSpeakerVolume;

        iCallParams.iInterval = callParams.iInterval;

        iCallParams.iWaitForDialTone = callParams.iWaitForDialTone;

        //default unknown values

        iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

        iCallParams.iCug.iExplicitInvoke = EFalse;

        iCallParams.iCug.iCugIndex = 0xFFFF;

        iCallParams.iCug.iSuppressPrefCug = EFalse;

        iCallParams.iCug.iSuppressOA = EFalse;

        iCallParams.iAutoRedial = EFalse;

        }

    iMobileCallInfo.iDialledParty.iTelNumber.Copy( *aTelNumber );

    iMobileCallInfo.iDialledParty.iNumberPlan = 

        RMobilePhone::EUnknownNumberingPlan;

    iMobileCallInfo.iDialledParty.iTypeOfNumber = 

        RMobilePhone::EUnknownNumber;

    iMobileCallInfo.iService = aCallMode;

    iMobileCallInfo.iValid |= RMobileCall::KCallDialledParty;

    iMobileCallInfo.iValid |= RMobileCall::KCallAlternating;

    iMobileCallInfo.iAlternatingCall = 

        RMobilePhone::EAlternatingModeUnspecified;

    //Create package

    CCallDataPackage package;

    //Set call id and call mode

    package.SetCallIdAndMode( iMmCallTsy->CallId(), aCallMode );

    //Send request to the Domestic OS layer.

    if ( KETelExt3rdPartyV1 == aExtensionId )

    	{

        //Pack call parameters and mobile call info

        // Use argument parameters since TMobileCallParamsV7 does not inherit from 3rd party params.

        package.PackData(const_cast<TDesC8*>(aCallParams), &iMobileCallInfo);

TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL: KETelExt3rdPartyV1");

    	//if it is a 3rd party client

    	return iMessageManager->HandleRequestL( EMobileCallDialISV, 

            &package );

    	}

//if not a 3rd party client and dial no fdn check used    	

    else if ( KMultimodeCallTypeIDNoFdnCheck == aExtensionId )

        {

        //Pack call parameters and mobile call info

        TPckg<RMobileCall::TMobileCallParamsV7> pckgToSend(iCallParams); 

        package.PackData(  &pckgToSend , &iMobileCallInfo );

TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL: KMultimodeCallTypeIDNoFdnCheck");

        return iMessageManager->HandleRequestL( 

            EMobileCallDialNoFdnCheck, &package );

        }    

    else

        {

        //Pack call parameters and mobile call info

        TPckg<RMobileCall::TMobileCallParamsV7> pckgToSend(iCallParams); 

        package.PackData(  &pckgToSend , &iMobileCallInfo );

TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL: EEtelCallDial");    	    

    	return iMessageManager->HandleRequestL( EEtelCallDial, &package );

    	}

    }

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

// CMmCallGsmWcdmaExt::AnswerIncomingCallL

// Answers incoming call.

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

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

//

TInt CMmCallGsmWcdmaExt::AnswerIncomingCallL(

    TInt aCallId,

    TInt aExtensionId )

    {

    //Create package

    CCallDataPackage package;

    //Set call id and call mode

    package.SetCallIdAndMode( aCallId, iSymbianCallMode );

	//Send request to the Domestic OS layer.

	if ( KETelExt3rdPartyV1 == aExtensionId )

		{

		//if it is a 3rd party client

		return iMessageManager->HandleRequestL( EMobileCallAnswerISV, 

            &package );			

		}

	else

		{

		//if not a 3rd party client

		return iMessageManager->HandleRequestL( EEtelCallAnswer, &package );		

		}

    }

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

// CMmCallGsmWcdmaExt::GetMobileCallCapsV1

// Return GSM specific mobile call capabilities (V1).

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

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

//

void CMmCallGsmWcdmaExt::GetMobileCallCapsV1(

    RMobileCall::TMobileCallCapsV1& aCallCapsV1 )

    {

    aCallCapsV1 = iMobileCallCaps;  

    }

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

// CMmCallGsmWcdmaExt::SetGSMCallCaps

// Set GSM specific mobile call caps

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

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

//

void CMmCallGsmWcdmaExt::SetGSMCallCaps(

    const RMobileCall::TMobileCallCapsV1* aCaps )

    {

    iMobileCallCaps = *aCaps;

    }

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

// CMmCallGsmWcdmaExt::AddGSMCallCaps

// Adds requested caps to GSM specific mobile call caps

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

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

//

void CMmCallGsmWcdmaExt::AddGSMCallCaps(

    TUint32 aCaps )

    {

    iMobileCallCaps.iCallControlCaps |= aCaps;

    }

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

// CMmCallGsmWcdmaExt::RemoveGSMCallCaps

// Removes requested caps from GSM specific mobile call caps

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

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

//

void CMmCallGsmWcdmaExt::RemoveGSMCallCaps(

    TUint32 aCaps )

    {

    iMobileCallCaps.iCallControlCaps &= ~aCaps;

    }

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

// CMmCallGsmWcdmaExt::CompleteNotifyStatusChange

// Updates the dynamic capabilities of the GSM extension

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

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

//

TInt CMmCallGsmWcdmaExt::CompleteNotifyStatusChange(

    RMobileCall::TMobileCallStatus aCallStatus )

    {

    TInt ret( KErrNone );

    TBool singleCallGoingOn( EFalse );

    TBool twoCallsGoingOn( EFalse );

    TBool conferenceGoingOn( EFalse );

    TInt numberOfNonIdleCallObjects( 0 );

    // Get CMmPhone for information gathering

    CMmPhoneTsy* mmPhone = iMmCallTsy->Phone();

    // Get CallList

    CMmCallList* callList = mmPhone->CallList();

    // Get Conference call object

    CMmConferenceCallTsy* mmConference = mmPhone->ConferenceCall();

    // Create a pointer for call object

    CMmCallTsy* mmCall = NULL;

    //Save previous caps

    TUint32 oldControlCaps = iMobileCallCaps.iCallControlCaps;

    //Count number of call objects that are not in idle state

    for ( TInt i = 0; i < callList->GetNumberOfObjects(); i++ )

        {

        mmCall = callList->GetMmCallByIndex( i );

        if ( RMobileCall::EStatusIdle != mmCall->MobileCallStatus() )

            {

            numberOfNonIdleCallObjects++;

            }

        }

    //if there is only one non-idle call

    if ( numberOfNonIdleCallObjects == 1 )

        {

        singleCallGoingOn = ETrue;

        }

    //multicall situation

    else

        {

        TBool confInUse( EFalse );

        //if conference call object exists

        if ( mmConference )

            {

            //if conference call is not in idle state

            //or if CreateConference has been requested

            if ( ( mmConference->Status() !=

                    RMobileConferenceCall::EConferenceIdle ) ||

                mmConference->ServiceRequested(

                    CMmConferenceCallTsy::EMultimodeConferenceCallCreateConference ) )

                {

                //conference is going on, act according the situation

                conferenceGoingOn = ETrue;

                confInUse = ETrue;

                }

            }

        //if conference call is not active

        if ( !confInUse )

            {

            //conference call is not in use. There are 2 calls in different

            //states.

            twoCallsGoingOn = ETrue;

            }

        }

    // Set Mobile Call Control + Core Caps

    // Switch according to the call status

    switch ( aCallStatus )

        {

        // Clear caps for idle status

        case RMobileCall::EStatusIdle:

            iMobileCallInfo.iValid = 0x00000000;

            // Set Idle caps

            iMobileCallCaps.iCallControlCaps |= 

                RCall::KCapsDial;

            // Data call has also connect.

            // Remove dataport caps.

            if ( RMobilePhone::ECircuitDataService == iSymbianCallMode )

                {

                iMobileCallCaps.iCallControlCaps |= 

                    RCall::KCapsConnect;

                iMobileCallCaps.iCallControlCaps &= ~(

                    RCall::KCapsLoanDataPort | 

                    RCall::KCapsRecoverDataPort );

                }