diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/commontsy/src/mmgsmwcdma/cmmcallgsmwcdmaext.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/commontsy/src/mmgsmwcdma/cmmcallgsmwcdmaext.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2998 @@ +// 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 +#include "cmmphonetsy.h" +#include "cmmcalllist.h" +#include "cmmconferencecalltsy.h" +#include "cmmconferencecallgsmwcdmaext.h" +#include +#include "cmmmessagemanagerbase.h" +#include + +#include "cmmvoicecalltsy.h" + +//csd includes +#include "cmmdatacalltsy.h" + + #include + +// ======== 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(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(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); + + //Create the SSM Plugin Handler on creation rather than on demand to avoid problems + //with Emergency Calls in Out Of Memory situations. + iSystemStatePluginHandler = CCtsySystemStatePluginHandler::NewL(); + + 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; + + if ( iSystemStatePluginHandler ) + { + delete iSystemStatePluginHandler; + } + iSystemStatePluginHandler = 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(const_cast( 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( + const_cast( 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( + const_cast( 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( + const_cast( 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(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 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 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 ); + } + + // Clear possible old caps + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsAnswer | + RCall::KCapsHangUp ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsHold | + RMobileCall::KCapsResume | + RMobileCall::KCapsSwap | + RMobileCall::KCapsDeflect | + RMobileCall::KCapsTransfer | + RMobileCall::KCapsJoin | + RMobileCall::KCapsOneToOne | + RMobileCall::KCapsSwitchAlternatingCall ); + + if ( conferenceGoingOn ) + { + //reset the enable Join flag + iEnableJoinFlag = EFalse; + CMmCallGsmWcdmaExt* mmCallGsmWcdmaExt = NULL; + + //loop through all call objects updating GoOneToOne caps + for ( TInt i = 0; i < callList->GetNumberOfObjects(); i++ ) + { + mmCall = callList->GetMmCallByIndex( i ); + + if ( mmCall->MobileCallStatus() == RMobileCall::EStatusConnected + && mmConference) + { + if ( mmConference->IsGoOneToOneSupported( mmCall->CallId() ) ) + { + // Fetch the active call extension + mmCallGsmWcdmaExt = REINTERPRET_CAST( + CMmCallGsmWcdmaExt*, mmCall->ActiveCallExtension() ); + + //add GoOneToOne caps + mmCallGsmWcdmaExt->AddGSMCallCaps( + RMobileCall::KCapsOneToOne ); + + //complete caps change notification + mmCall->CompleteNotifyMobileCallCapsChange( KErrNone ); + } + } + } + } + break; + case RMobileCall::EStatusDialling: + //activate HangUp caps + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsHangUp; + + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsDial | RCall::KCapsConnect ); + + break; + case RMobileCall::EStatusRinging: + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsHangUp; + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsDeflect; + + //if there is no held and active calls + if ( !( ( callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) != NULL ) && + ( callList->GetMmCallByStatus( + RMobileCall::EStatusConnected ) != NULL ) ) ) + { + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsAnswer; + } + + if ( RMobilePhone::ECircuitDataService == iSymbianCallMode ) + { + if ( ( callList->GetMmCallByStatus( + RMobileCall::EStatusConnected ) == NULL ) && + ( callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) == NULL ) && + ( callList->GetMmCallByStatus( + RMobileCall::EStatusDisconnecting ) == NULL ) && + ( callList->GetMmCallByStatus( + RMobileCall::EStatusDisconnectingWithInband ) == NULL ) ) + { + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsAnswer; + // Set call caps + TUint32 callCaps = iMmCallTsy->CallCaps(); + callCaps |= RCall::KCapsAnswer; + iMmCallTsy->SetCallCaps( callCaps ); + } + } + else + { + if ( !( ( callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) != NULL ) && + ( callList->GetMmCallByStatus( + RMobileCall::EStatusConnected ) != NULL ) ) ) + { + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsAnswer; + } + } + + //disable Dial caps + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsDial | RCall::KCapsConnect ); + + break; + case RMobileCall::EStatusAnswering: + //activate hangup caps. EStatusRinging may have been missed + //so this needs to be activated. + iMobileCallCaps.iCallControlCaps |= RCall::KCapsHangUp; + + //remove dial, answer and deflect caps + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsDial | + RCall::KCapsAnswer ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsDeflect ); + + //if conference call is going on + if ( conferenceGoingOn ) + { + //enable Join flag when call enters the connected state + iEnableJoinFlag = ETrue; + } + break; + case RMobileCall::EStatusConnecting: + //if conference call is going on + if ( conferenceGoingOn ) + { + //enable Join flag when call enters the connected state + iEnableJoinFlag = ETrue; + + //loop through all call objects searching held calls + for ( TInt i = 0; i < callList->GetNumberOfObjects(); i++ ) + { + mmCall = callList->GetMmCallByIndex( i ); + + if ( mmCall->MobileCallStatus() == + RMobileCall::EStatusHold ) + { + //If status is Hold, disable GoOneToOne and Dial caps + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsDial ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsOneToOne ); + } + } + } + else if ( twoCallsGoingOn ) + { + //if there is a call on Hold state + if ( callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) != NULL ) + { + //enable transfer caps + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsTransfer; + } + } + break; + case RMobileCall::EStatusDisconnecting: + case RMobileCall::EStatusDisconnectingWithInband: + //disable some caps + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsHold | + RMobileCall::KCapsResume | + RMobileCall::KCapsSwap | + RMobileCall::KCapsDeflect | + RMobileCall::KCapsTransfer | + RMobileCall::KCapsJoin | + RMobileCall::KCapsOneToOne | + RMobileCall::KCapsSwitchAlternatingCall | + RMobileCall::KCapsActivateCCBS ); + // Remove dataport caps. + if ( RMobilePhone::ECircuitDataService == iSymbianCallMode ) + { + iMobileCallCaps.iCallControlCaps &= ~(RCall::KCapsLoanDataPort); + } + break; + case RMobileCall::EStatusReconnectPending: + case RMobileCall::EStatusWaitingAlternatingCallSwitch: + //Clear useless caps + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsHangUp ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsHold | + RMobileCall::KCapsResume | + RMobileCall::KCapsSwap | + RMobileCall::KCapsDeflect | + RMobileCall::KCapsTransfer | + RMobileCall::KCapsJoin | + RMobileCall::KCapsOneToOne | + RMobileCall::KCapsSwitchAlternatingCall ); + break; + case RMobileCall::EStatusUnknown: + case RMobileCall::EStatusConnected: + case RMobileCall::EStatusHold: + case RMobileCall::EStatusTransferring: + case RMobileCall::EStatusTransferAlerting: + // Default: do nothing + default: + if ( singleCallGoingOn ) + { + UpdateSingleCallControlCaps( aCallStatus ); + } + else if ( twoCallsGoingOn ) + { + UpdateDoubleCallControlCaps( aCallStatus ); + } + else if ( conferenceGoingOn ) + { + UpdateMultipleCallControlCaps( + aCallStatus ); + } + break; + } + + if ( oldControlCaps == iMobileCallCaps.iCallControlCaps ) + { + ret = KErrNotFound; + } + else + { + ret = KErrNone; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::UpdateMultipleCallControlCaps +// This method updates call capabilities in case that conference call is going +// on. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::UpdateMultipleCallControlCaps( + RMobileCall::TMobileCallStatus aCallStatus ) + { + // Get CMmPhone for information gathering + CMmPhoneTsy* mmPhone = iMmCallTsy->Phone(); + // Get CallList + CMmCallList* callList = mmPhone->CallList(); + + TInt numberOfCallsInConfererence = + mmPhone->ConferenceCall()->NumberOfCallsInConference(); + + // Set Mobile Call Control + Core Caps + // Switch according to the call status + switch ( aCallStatus ) + { + // Enable caps for an active call + case RMobileCall::EStatusConnected: + //Clear useless caps + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsDial | + RCall::KCapsAnswer ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsTransfer | + RMobileCall::KCapsHold | + RMobileCall::KCapsResume | + RMobileCall::KCapsDeflect ); + + if ( NULL == callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) ) + { + //Go one to one is possible + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsOneToOne; + } + + //This is a case where conference call is going on and a new call + //has entered the connected state -> Join and Swap caps might be + //enabled in this situation + if ( iEnableJoinFlag ) + { + //if there are calls on hold status and more participants can + //be added to conference call + if ( callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) != NULL && + numberOfCallsInConfererence < KMaxCallsInConference ) + { + //This call is not part of conference call, Join flag can + //be enabled. Only the call that is not part of conference + //can have Swap caps enabled. + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsJoin; + } + //reset the flag + iEnableJoinFlag = EFalse; + } + break; + case RMobileCall::EStatusHold: + //GoOneToOne is not possible in Hold state, disable it. + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsOneToOne ); + break; + case RMobileCall::EStatusUnknown: + case RMobileCall::EStatusIdle: + case RMobileCall::EStatusDialling: + case RMobileCall::EStatusRinging: + case RMobileCall::EStatusAnswering: + case RMobileCall::EStatusConnecting: + case RMobileCall::EStatusDisconnecting: + case RMobileCall::EStatusDisconnectingWithInband: + case RMobileCall::EStatusReconnectPending: + case RMobileCall::EStatusWaitingAlternatingCallSwitch: + case RMobileCall::EStatusTransferring: + case RMobileCall::EStatusTransferAlerting: + // Default: do nothing + default: + break; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::UpdateDoubleCallControlCaps +// This method updates call capabilities in case that there are two calls in +// non-idle state and they are not in a conference. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::UpdateDoubleCallControlCaps( + RMobileCall::TMobileCallStatus aCallStatus ) + { + // Get CMmPhone for information gathering + CMmPhoneTsy* mmPhone = iMmCallTsy->Phone(); + // Get CallList + CMmCallList* callList = mmPhone->CallList(); + + // Set Mobile Call Control + Core Caps + // Switch according to the call status + switch ( aCallStatus ) + { + // Enable caps for an active call + case RMobileCall::EStatusConnected: + //Clear useless caps + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsAnswer | + RCall::KCapsDial ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsTransfer | + RMobileCall::KCapsJoin | + RMobileCall::KCapsResume | + RMobileCall::KCapsSwap | + RMobileCall::KCapsDeflect | + RMobileCall::KCapsHold ); + + //if there is a call on hold + if ( callList->GetMmCallByStatus( + RMobileCall::EStatusHold ) != NULL ) + { + //enable swap, join and transfer caps + iMobileCallCaps.iCallControlCaps |= ( + RMobileCall::KCapsSwap | + RMobileCall::KCapsJoin | + RMobileCall::KCapsTransfer ); + } + //if there is waiting call + else if ( callList->GetMmCallByStatus( + RMobileCall::EStatusRinging ) != NULL ) + { + //enable swap, join and transfer caps + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsHold; + } + + break; + case RMobileCall::EStatusHold: + //clear useless caps + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsOneToOne | + RMobileCall::KCapsTransfer | + RMobileCall::KCapsSwap | + RMobileCall::KCapsHold | + RMobileCall::KCapsJoin | + RMobileCall::KCapsResume ); + + //if there is a call on Connected state + if ( callList->GetMmCallByStatus( + RMobileCall::EStatusConnected ) != NULL ) + { + //enable swap, join and transfer caps + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsSwap | + RMobileCall::KCapsJoin | + RMobileCall::KCapsTransfer; + } + //if there is waiting call + else if ( callList->GetMmCallByStatus( + RMobileCall::EStatusRinging ) != NULL ) + { + //enable swap, join and transfer caps + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsResume; + } + + //if there is a call on Connecting state + if ( callList->GetMmCallByStatus( + RMobileCall::EStatusConnecting ) != NULL ) + { + //enable transfer caps + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsTransfer; + } + break; + case RMobileCall::EStatusUnknown: + case RMobileCall::EStatusIdle: + case RMobileCall::EStatusDialling: + case RMobileCall::EStatusRinging: + case RMobileCall::EStatusAnswering: + case RMobileCall::EStatusConnecting: + case RMobileCall::EStatusDisconnecting: + case RMobileCall::EStatusDisconnectingWithInband: + case RMobileCall::EStatusReconnectPending: + case RMobileCall::EStatusWaitingAlternatingCallSwitch: + case RMobileCall::EStatusTransferring: + case RMobileCall::EStatusTransferAlerting: + // Default do nothing + default: + break; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::UpdateSingleCallControlCaps +// This method updates call capabilities in case that there is only one +// non-idle call +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::UpdateSingleCallControlCaps( + RMobileCall::TMobileCallStatus aCallStatus ) + { + // Set Mobile Call Control + Core Caps + // Switch according to the call status + switch ( aCallStatus ) + { + case RMobileCall::EStatusConnected: + //Disable some caps for an active call + //Caps are set in 2 phases because defined in different + //classes (lint complains about different types) + iMobileCallCaps.iCallControlCaps &= ~( + RCall::KCapsAnswer | + RCall::KCapsDial ); + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsTransfer | + RMobileCall::KCapsResume | + RMobileCall::KCapsSwap | + RMobileCall::KCapsDeflect | + RMobileCall::KCapsJoin | + RMobileCall::KCapsOneToOne ); + + //activate HangUp caps + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsHangUp; + + // Data call can't be controlled with swap, resume & join + if ( RMobilePhone::ECircuitDataService != iSymbianCallMode + && RMobilePhone::EFaxService != iSymbianCallMode ) + { + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsHold; + } + break; + case RMobileCall::EStatusHold: + //disable some caps first + iMobileCallCaps.iCallControlCaps &= ~( + RMobileCall::KCapsOneToOne | + RMobileCall::KCapsTransfer | + RMobileCall::KCapsSwap | + RMobileCall::KCapsHold | + RMobileCall::KCapsJoin | + RMobileCall::KCapsOneToOne | + RMobileCall::KCapsResume ); + + //activate HangUp caps + iMobileCallCaps.iCallControlCaps |= + RCall::KCapsHangUp; + + // Data call can't be controlled with swap, resume & join + if ( RMobilePhone::ECircuitDataService != iSymbianCallMode + && RMobilePhone::EFaxService != iSymbianCallMode ) + { + iMobileCallCaps.iCallControlCaps |= + RMobileCall::KCapsResume; + } + break; + case RMobileCall::EStatusUnknown: + case RMobileCall::EStatusIdle: + case RMobileCall::EStatusDialling: + case RMobileCall::EStatusRinging: + case RMobileCall::EStatusAnswering: + case RMobileCall::EStatusConnecting: + case RMobileCall::EStatusDisconnecting: + case RMobileCall::EStatusDisconnectingWithInband: + case RMobileCall::EStatusReconnectPending: + case RMobileCall::EStatusWaitingAlternatingCallSwitch: + case RMobileCall::EStatusTransferring: + case RMobileCall::EStatusTransferAlerting: + // Default do nothing + default: + break; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::GetCallParams +// Returns the GSM specific call parameters in parameter. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::GetCallParams( + TDes8* aParams ) + { + RCall::TCallParamsPckg* callParamsPckg = + reinterpret_cast( aParams ); + RCall::TCallParams& callParams = ( *callParamsPckg )(); + + TInt extensionId( callParams.ExtensionId() ); + + if ( RMobilePhone::ECircuitDataService != iSymbianCallMode ) + { + if ( RMobileCall::KETelMobileCallParamsV1 == extensionId || + RMobileCall::KETelMobileDataCallParamsV1 == extensionId || + RMobileCall::KETelMobileDataCallParamsV2 == extensionId || + RMobileCall::KETelMobileDataCallParamsV8 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId ) + { + RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileCallParamsV1& params = ( *paramsPckgV1 )(); + + + //Parameter of base class TMobileCallParamsV1 + params.iIdRestrict = iCallParams.iIdRestrict; + params.iCug = iCallParams.iCug; + params.iAutoRedial = iCallParams.iAutoRedial; + } + else if ( RMobileCall::KETelMobileCallParamsV2 == extensionId ) + { + RMobileCall::TMobileCallParamsV2Pckg* paramsPckgV2 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileCallParamsV2& params = ( *paramsPckgV2 )(); + + //Parameter of base class TMobileCallParamsV1 + params.iIdRestrict = iCallParams.iIdRestrict; + params.iCug = iCallParams.iCug; + params.iAutoRedial = iCallParams.iAutoRedial; + //Parameter of class TMobileCallParamsV2 + params.iBearerMode = iCallParams.iBearerMode; + } + else if ( RMobileCall::KETelMobileCallParamsV7 == extensionId ) + { + + RMobileCall::TMobileCallParamsV7Pckg* paramsPckgV7 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileCallParamsV7& params = ( *paramsPckgV7 )(); + + //Parameter of base class TMobileCallParamsV1 + params.iIdRestrict = iCallParams.iIdRestrict; + params.iCug = iCallParams.iCug; + params.iAutoRedial = iCallParams.iAutoRedial; + + //Parameter of class TMobileCallParamsV2 + params.iBearerMode = iCallParams.iBearerMode; + + //Paremeters of class TMobileCallParamsV7 + params.iCallParamOrigin = iCallParams.iCallParamOrigin; + params.iSubAddress = iCallParams.iSubAddress; + params.iBearerCap1 = iCallParams.iBearerCap1; + params.iBearerCap2 = iCallParams.iBearerCap2; + params.iBCRepeatIndicator = iCallParams.iBCRepeatIndicator; + params.iIconId.iQualifier = iCallParams.iIconId.iQualifier; + params.iIconId.iIdentifier = iCallParams.iIconId.iIdentifier; + params.iAlphaId = iCallParams.iAlphaId; + + } + else + { + TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::GetCallParams callparams version unknown"); + } + + } + else + { + if ( RMobileCall::KETelMobileCallParamsV1 == extensionId || + RMobileCall::KETelMobileCallParamsV2 == extensionId || + RMobileCall::KETelMobileCallParamsV7 == extensionId || + RMobileCall::KETelMobileDataCallParamsV1 == extensionId || + RMobileCall::KETelMobileDataCallParamsV2 == extensionId || + RMobileCall::KETelMobileDataCallParamsV8 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId ) + { + RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileCallParamsV1& params = ( *paramsPckgV1 )(); + + //Parameter of base class TMobileCallParamsV1 + params.iIdRestrict = iCSDParams->iIdRestrict; + params.iCug = iCSDParams->iCug; + params.iAutoRedial = iCSDParams->iAutoRedial; + + } + + if ( RMobileCall::KETelMobileDataCallParamsV1 == extensionId || + RMobileCall::KETelMobileDataCallParamsV2 == extensionId || + RMobileCall::KETelMobileDataCallParamsV8 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId ) + { + RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileDataCallParamsV1& dataParams = ( *paramsPckgV1 )(); + + CopyMobileDataCallParams( dataParams, *iCSDParams ); + + } + + if ( RMobileCall::KETelMobileDataCallParamsV2 == extensionId || + RMobileCall::KETelMobileDataCallParamsV8 == extensionId) + { + RMobileCall::TMobileDataCallParamsV2Pckg* paramsPckgV2 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileDataCallParamsV2& dataParams2 = ( *paramsPckgV2 )(); + + RMobileCall::TMobileDataCallParamsV2* dataCallParamsV2 = static_cast(iCSDParams); + + //Parameter of class TMobileDataCallParamsV2 + dataParams2.iBearerMode = dataCallParamsV2->iBearerMode; + } + + if ( RMobileCall::KETelMobileDataCallParamsV8 == extensionId ) + { + RMobileCall::TMobileDataCallParamsV8Pckg* paramsPckgV8 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileDataCallParamsV8& dataParams8 = ( *paramsPckgV8 )(); + + RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast(iCSDParams); + + //Parameters of class TMobileDataCallParamsV8 + dataParams8.iSubAddress = dataCallParamsV8->iSubAddress; + dataParams8.iBearerCap1 = dataCallParamsV8->iBearerCap1; + dataParams8.iBearerCap2 = dataCallParamsV8->iBearerCap2; + dataParams8.iBCRepeatIndicator = dataCallParamsV8->iBCRepeatIndicator; + dataParams8.iCallParamOrigin = dataCallParamsV8->iCallParamOrigin; + dataParams8.iIconId.iQualifier = dataCallParamsV8->iIconId.iQualifier; + dataParams8.iIconId.iIdentifier = dataCallParamsV8->iIconId.iIdentifier; + dataParams8.iAlphaId = dataCallParamsV8->iAlphaId; + + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId) + { + RMobileCall::TMobileHscsdCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileHscsdCallParamsV1& hscsdParams = + ( *paramsPckgV1 )(); + + //Parameter of base class TMobileHscsdCallParamsV1 + hscsdParams.iWantedAiur = iHSCSDParams->iWantedAiur; + hscsdParams.iWantedRxTimeSlots = iHSCSDParams->iWantedRxTimeSlots; + hscsdParams.iMaxTimeSlots = iHSCSDParams->iMaxTimeSlots; + hscsdParams.iCodings = iHSCSDParams->iCodings; + hscsdParams.iAsymmetry = iHSCSDParams->iAsymmetry; + hscsdParams.iUserInitUpgrade = iHSCSDParams->iUserInitUpgrade; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId) + { + RMobileCall::TMobileHscsdCallParamsV2Pckg* paramsPckgV2 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileHscsdCallParamsV2& hscsdParams2 = + ( *paramsPckgV2 )(); + + //Parameter of class TMobileHscsdCallParamsV2 + RMobileCall::TMobileHscsdCallParamsV2* hscsdCallParamsV2 = static_cast(iHSCSDParams); + hscsdParams2.iBearerMode = hscsdCallParamsV2->iBearerMode; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId || + RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId) + { + RMobileCall::TMobileHscsdCallParamsV7Pckg* paramsPckgV7 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileHscsdCallParamsV7& hscsdParams7 = + ( *paramsPckgV7 )(); + + RMobileCall::TMobileHscsdCallParamsV7* hscsdCallParamsV7 = static_cast(iHSCSDParams); + + //Parameter of class TMobileHscsdCallParamsV7 + hscsdParams7.iCallParamOrigin = hscsdCallParamsV7->iCallParamOrigin; + hscsdParams7.iIconId.iQualifier = hscsdCallParamsV7->iIconId.iQualifier; + hscsdParams7.iIconId.iIdentifier = hscsdCallParamsV7->iIconId.iIdentifier; + hscsdParams7.iAlphaId = hscsdCallParamsV7->iAlphaId; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId ) + { + RMobileCall::TMobileHscsdCallParamsV8Pckg* paramsPckgV8 = + reinterpret_cast( + aParams ); + RMobileCall::TMobileHscsdCallParamsV8& hscsdParams8 = + ( *paramsPckgV8 )(); + + RMobileCall::TMobileHscsdCallParamsV8* hscsdCallParamsV8 = static_cast(iHSCSDParams); + + //Parameter of class TMobileHscsdCallParamsV8 + hscsdParams8.iSubAddress = hscsdCallParamsV8->iSubAddress; + hscsdParams8.iBearerCap1 = hscsdCallParamsV8->iBearerCap1; + hscsdParams8.iBearerCap2 = hscsdCallParamsV8->iBearerCap2; + hscsdParams8.iBCRepeatIndicator = hscsdCallParamsV8->iBCRepeatIndicator; + + } + TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::GetCallParams callparams version unknown"); + + } + + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::DialEmergencyCallL +// GSM specific DialEmergencyCall method. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::DialEmergencyCall( + TCtsySsmCallbackData& aCallbackData ) + { + // store stateInfo and Emergency number + // to have access to them inside callback + TRfStateInfo stateInfo = iMmCallTsy->Phone()->GetRfStateInfo(); + + if( stateInfo != ERfsStateInfoNormal ) + { + //the method in callTsy has already checked that + // emergency calls in offline are enabled + //otherwise this code woulnd't be reached + + //set the RF to normal state so the emergency call can be dialed + SetRfState( ERfsStateInfoNormal, this, aCallbackData ); + } + else + { + // if there is no need to change RF state + // then call SsmPluginCallback immediately + SsmPluginCallback(KErrNone, aCallbackData); + } + + return KErrNone; + } + + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::HoldL +// This method can be used to hold an active call. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::HoldL( + TInt aCallId ) + { + TInt ret( KErrNone ); + + CMmConferenceCallTsy* mmConference = + iMmCallTsy->Phone()->ConferenceCall(); + + if ( NULL != mmConference ) + { + if ( RMobileConferenceCall::EConferenceIdle != + mmConference->Status() ) + { + ret = KErrNotReady; + } + } + + if ( KErrNone == ret ) + { + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( aCallId, iSymbianCallMode ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( EMobileCallHold, &package ); + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::ResumeL +// This method can be used to resume a held call. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::ResumeL( + TInt aCallId ) + { + TInt ret( KErrNone ); + + CMmConferenceCallTsy* mmConference = + iMmCallTsy->Phone()->ConferenceCall(); + + if ( NULL != mmConference ) + { + + if ( RMobileConferenceCall::EConferenceIdle != + mmConference->Status() ) + { + ret = KErrNotReady; + } + } + + if ( KErrNone == ret ) + { + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( aCallId, iSymbianCallMode ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( EMobileCallResume, &package ); + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::SwapL +// This method can be used to swap between active and held calls. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +#ifndef USING_CTSY_DISPATCHER +TInt CMmCallGsmWcdmaExt::SwapL( + TInt aCallId ) + { + TInt ret( KErrNone ); + + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( aCallId, iSymbianCallMode ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( EMobileCallSwap, &package ); + + return ret; + } +#endif //USING_CTSY_DISPATCHER + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::GoOneToOneL +// This method requests a private communication to the remote party of one +// call within a conference call. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::GoOneToOneL( + TInt aCallId ) + { + TInt ret( KErrNotSupported ); + + CMmConferenceCallTsy* mmConference = + iMmCallTsy->Phone()->ConferenceCall(); + + if ( mmConference ) + { + //Check if GoOneToOne is supported + TBool isSupported = mmConference->IsGoOneToOneSupported( aCallId ); + + //if GoOneToOne is possible + if ( isSupported ) + { + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( aCallId, iSymbianCallMode ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( + EMobileCallGoOneToOne, &package ); + + // Inform the Conference Call GSM extension about pending + // GoOneToOne operation + if ( KErrNone == ret ) + { + CMmConferenceCallExtInterface* confCallExt = + mmConference->GetActiveConferenceCallExtension(); + if ( confCallExt ) + { + // This cast is safe: As we are here in GSM/WCDMA Call + // extension, we know that the active Conference Call + // extension is also GSM/WCDMA + static_cast( confCallExt )-> + SetGoOneToOneHandlingStarted( ETrue, aCallId ); + } + } + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::DeflectL +// This method deflects incoming call to another destination. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::DeflectL( + const TDataPackage& aData ) + { + TInt ret( KErrNone ); + + RMobileCall::TMobileCallDeflect* deflectType = + reinterpret_cast( aData.Ptr1() ); + RMobilePhone::TMobileAddress* destination = + reinterpret_cast( aData.Ptr2() ); + + if ( ( ( RMobileCall::EDeflectUnspecified == *deflectType ) || + ( RMobileCall::EDeflectSuppliedNumber == *deflectType ) ) && + ( 0 < destination->iTelNumber.Length() ) ) + // Type EDeflectUnspecified is accepted if destination number is + // supplied + { + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( iMmCallTsy->CallId(), iSymbianCallMode ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( EMobileCallDeflect, &package ); + } + else + { + // other deflect types (EDeflectRegisteredNumber and EDeflectVoicemail) + // are not supported + ret = KErrNotSupported; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::TransferL +// This method transfers call to another destination. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +#ifndef USING_CTSY_DISPATCHER +TInt CMmCallGsmWcdmaExt::TransferL() + { + TInt ret( KErrNone ); + + // Retrieve possible held call + CMmCallTsy* mmCall = iMmCallTsy->Phone()->CallList()->GetMmCallByStatus( + RMobileCall::EStatusHold ); + + if ( mmCall ) + { + // Held call Id +TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::Transfer, CallId: %d", \ + mmCall->CallId() ); + + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( mmCall->CallId(), iSymbianCallMode ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( + EMobileCallTransfer, &package ); + } + else + { + ret = KErrNotReady; + } + + return ret; + } +#endif //USING_CTSY_DISPATCHER + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::FillMobileCallInfo +// Fills the GSM specific Mobile Call Information in the +// RMobileCall::TMobileCallInfoV1 given as parameter. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::FillMobileCallInfo( + RMobileCall::TMobileCallInfoV1* aInfoV1) + { + aInfoV1->iAlternatingCall = iMobileCallInfo.iAlternatingCall; + aInfoV1->iRemoteParty = iMobileCallInfo.iRemoteParty; + aInfoV1->iForwarded = iMobileCallInfo.iForwarded; + aInfoV1->iDialledParty = iMobileCallInfo.iDialledParty; + aInfoV1->iService = iMobileCallInfo.iService; + aInfoV1->iValid |= iMobileCallInfo.iValid; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::FillMobileCallInfoV3 +// Fills the GSM specific Mobile Call Information in the +// RMobileCall::TMobileCallInfoV3 given as parameter. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::FillMobileCallInfoV3( + RMobileCall::TMobileCallInfoV3* aInfoV3 ) + { +TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::FillMobileCallInfoV3 - extensionid=%d", aInfoV3->ExtensionId() ); + + // V3 info parameters + aInfoV3->iSecurity = iMobileCallInfo.iSecurity; + + return KErrNone; + } +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::FillMobileCallInfoV7 +// Fills the GSM specific Mobile Call Information in the +// RMobileCall::TMobileCallInfoV7 given as parameter. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::FillMobileCallInfoV7( + RMobileCall::TMobileCallInfoV7* aInfoV7 ) + { +TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::FillMobileCallInfoV7 - extensionid=%d", aInfoV7->ExtensionId() ); + + // V7 info parameters + // TCallParamOrigin iCallParamOrigin; + aInfoV7->iCallParamOrigin = iMobileCallInfo.iCallParamOrigin; + // TIconId iIconId; + aInfoV7->iIconId.iIdentifier = iMobileCallInfo.iIconId.iIdentifier; + aInfoV7->iIconId.iQualifier = iMobileCallInfo.iIconId.iQualifier; + // TAlphaIdBuf iAlphaId; + aInfoV7->iAlphaId = iMobileCallInfo.iAlphaId; + // TBool iParamsCallControlModified; + aInfoV7->iParamsCallControlModified = iMobileCallInfo.iParamsCallControlModified; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::FillMobileCallInfoV8 +// Fills the GSM specific Mobile Call Information in the +// RMobileCall::TMobileCallInfoV8 given as parameter. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::FillMobileCallInfoV8( + RMobileCall::TMobileCallInfoV8* aInfoV8 ) + { +TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::FillMobileCallInfoV8 - extensionid=%d", aInfoV8->ExtensionId() ); + + // V8 info parameters + aInfoV8->iSubAddress = iMobileCallInfo.iSubAddress; + aInfoV8->iBearerCap1 = iMobileCallInfo.iBearerCap1; + aInfoV8->iBearerCap2 = iMobileCallInfo.iBearerCap2; + aInfoV8->iBCRepeatIndicator = iMobileCallInfo.iBCRepeatIndicator; + + return KErrNone; + } + + + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::GetRemotePartyInfo +// Gets remote party information +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::GetRemotePartyInfo( + RMobileCall::TMobileCallRemotePartyInfoV1Pckg* aInfoV1Pckg ) + { + RMobileCall::TMobileCallRemotePartyInfoV1Pckg* infoPckgV1 = + reinterpret_cast( aInfoV1Pckg ); + RMobileCall::TMobileCallRemotePartyInfoV1& infoV1 = ( *infoPckgV1 )(); + + infoV1 = iMobileCallInfo.iRemoteParty; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::SetRfState +// This method sets RF state +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::SetRfState( + TRfStateInfo aMtcState, + MCtsySsmPluginCallback* aSsmPluginCallback, + TCtsySsmCallbackData& aCallbackData ) + { +TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::SetRfState - state=%d", aMtcState ); + + TInt err ( KErrNotSupported ); + if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KEmergencyCallsEnabledInOfflineMode ) == KFeatureSupported) ) + { + if (!iSystemStatePluginHandler) + { + TRAP(err, iSystemStatePluginHandler = CCtsySystemStatePluginHandler::NewL()); + if(KErrNone != err) + { + // pass this error to callback + SsmPluginCallback(err, aCallbackData); + return; + } + } + + if ( ERfsStateInfoNormal == aMtcState ) + { + iSystemStatePluginHandler->ActivateRfForEmergencyCall(aSsmPluginCallback, aCallbackData); + } + else if ( ERfsStateInfoInactive == aMtcState ) + { + iSystemStatePluginHandler->DeactivateRfAfterEmergencyCall(); + } + else + { + TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::SetRfState - bad state"); + // pass this error to callback + SsmPluginCallback (KErrArgument, aCallbackData); + } + } + else + { + SsmPluginCallback (KErrNotSupported, aCallbackData); + } + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::SetMobileCallData +// This method sets GSM specific mobile call information +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::SetMobileCallData( + CMmDataPackage* aDataPackage, + RMobileCall::TMobileCallDirection aCallDirection ) + { + RMobileCall::TMobileCallInfoV1* mobileCallInfo; + aDataPackage->UnPackData( &mobileCallInfo ); + + // get extensionid from the recieved data + TInt extensionId( mobileCallInfo->ExtensionId() ); + + //Set call direction info + iMobileCallInfo.iRemoteParty.iDirection = aCallDirection; + + //call mode should be always available + iMobileCallInfo.iService = mobileCallInfo->iService; + + //is this an emergency call + if ( RMobileCall::KCallEmergency & mobileCallInfo->iValid ) + { + iMobileCallInfo.iEmergency = mobileCallInfo->iEmergency; + } + + if ( 0 < mobileCallInfo->iRemoteParty.iRemoteNumber.iTelNumber.Length() && + ( RMobilePhone::KMaxMobileTelNumberSize >= + mobileCallInfo->iRemoteParty.iRemoteNumber.iTelNumber.Length() ) ) + { + iMobileCallInfo.iRemoteParty.iRemoteNumber.iTelNumber.Zero(); + iMobileCallInfo.iRemoteParty.iRemoteNumber.iTelNumber.Copy( + mobileCallInfo->iRemoteParty.iRemoteNumber.iTelNumber ); + + iMobileCallInfo.iRemoteParty.iRemoteNumber.iNumberPlan = + mobileCallInfo->iRemoteParty.iRemoteNumber.iNumberPlan; + iMobileCallInfo.iRemoteParty.iRemoteNumber.iTypeOfNumber = + mobileCallInfo->iRemoteParty.iRemoteNumber.iTypeOfNumber; + + iMobileCallInfo.iRemoteParty.iRemoteIdStatus = + mobileCallInfo->iRemoteParty.iRemoteIdStatus; + } + + if ( RMobileCall::KCallRemoteParty & mobileCallInfo->iValid ) + { + iMobileCallInfo.iRemoteParty.iRemoteIdStatus = + mobileCallInfo->iRemoteParty.iRemoteIdStatus; + } + + if ( 0 < mobileCallInfo->iRemoteParty.iCallingName.Length() && + ( RMobileCall::KCallingNameSize >= + mobileCallInfo->iRemoteParty.iCallingName.Length() ) ) + { + iMobileCallInfo.iRemoteParty.iCallingName.Zero(); + iMobileCallInfo.iRemoteParty.iCallingName.Copy( + mobileCallInfo->iRemoteParty.iCallingName ); + + iMobileCallInfo.iRemoteParty.iRemoteIdStatus = + mobileCallInfo->iRemoteParty.iRemoteIdStatus; + } + + if ( 0 < mobileCallInfo->iDialledParty.iTelNumber.Length() && + ( RMobilePhone::KMaxMobileTelNumberSize >= + mobileCallInfo->iDialledParty.iTelNumber.Length() ) ) + { + iMobileCallInfo.iDialledParty.iTelNumber.Zero(); + iMobileCallInfo.iDialledParty.iTelNumber.Copy( + mobileCallInfo->iDialledParty.iTelNumber ); + + iMobileCallInfo.iDialledParty.iNumberPlan = + mobileCallInfo->iDialledParty.iNumberPlan; + iMobileCallInfo.iDialledParty.iTypeOfNumber = + mobileCallInfo->iDialledParty.iTypeOfNumber; + } + + if ( RMobileCall::KCallForwarded & mobileCallInfo->iValid ) + { + iMobileCallInfo.iForwarded = mobileCallInfo->iForwarded; + } + + if ( RMobileCall::KCallAlternating & mobileCallInfo->iValid ) + { + iMobileCallInfo.iAlternatingCall = mobileCallInfo->iAlternatingCall; + } + + + // TMobileCallInfoV3 + if ( (KETelExtMultimodeV3 == extensionId) || + (KEtelExtMultimodeV7 == extensionId) || + (KEtelExtMultimodeV8 == extensionId)) + { + + RMobileCall::TMobileCallInfoV3* mobileCallInfoV3 = static_cast(mobileCallInfo); + + if(RMobileCall::KCallSecurity & mobileCallInfo->iValid) + { + // V3 parameters + iMobileCallInfo.iSecurity = mobileCallInfoV3->iSecurity; +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::SetMobileCallData V3 params copied"); + } + } + + // TMobileCallInfoV7 + if ( (KEtelExtMultimodeV7 == extensionId) || (KEtelExtMultimodeV8 == extensionId)) + { + + // TMobileCallInfoV7 params + + RMobileCall::TMobileCallInfoV7* mobileCallInfoV7 = static_cast(mobileCallInfo); + + if(RMobileCall::KCallParamOrigin & mobileCallInfo->iValid) + { + // TCallParamOrigin iCallParamOrigin; + iMobileCallInfo.iCallParamOrigin = mobileCallInfoV7->iCallParamOrigin; + } + + if(RMobileCall::KCallIconId & mobileCallInfo->iValid) + { + // TIconId iIconId; + iMobileCallInfo.iIconId.iIdentifier = mobileCallInfoV7->iIconId.iIdentifier; + iMobileCallInfo.iIconId.iQualifier = mobileCallInfoV7->iIconId.iQualifier; + } + + if(RMobileCall::KCallAlphaId & mobileCallInfo->iValid) + { + // TAlphaIdBuf iAlphaId; + iMobileCallInfo.iAlphaId.Zero(); + iMobileCallInfo.iAlphaId.Copy( mobileCallInfoV7->iAlphaId ); + } + + if(RMobileCall::KCallParamsCallControlModified & mobileCallInfo->iValid) + { + // TBool iParamsCallControlModified; + iMobileCallInfo.iParamsCallControlModified = mobileCallInfoV7->iParamsCallControlModified; + } + + +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::SetMobileCallData V7 params copied"); + } + + // TMobileCallInfoV8 + if ( KEtelExtMultimodeV8 == extensionId ) + { + // TMobileCallInfoV8 params + + RMobileCall::TMobileCallInfoV8* mobileCallInfoV8 = static_cast(mobileCallInfo); + + + if(RMobileCall::KCallSubAddress & mobileCallInfo->iValid) + { + iMobileCallInfo.iSubAddress = mobileCallInfoV8->iSubAddress; + } + + if(RMobileCall::KCallBearerCap1 & mobileCallInfo->iValid) + { + iMobileCallInfo.iBearerCap1 = mobileCallInfoV8->iBearerCap1; + } + + if(RMobileCall::KCallBearerCap2 & mobileCallInfo->iValid) + { + iMobileCallInfo.iBearerCap2 = mobileCallInfoV8->iBearerCap2; + } + + if(RMobileCall::KCallBCRepeatIndicator & mobileCallInfo->iValid) + { + iMobileCallInfo.iBCRepeatIndicator = mobileCallInfoV8->iBCRepeatIndicator; + } + +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::SetMobileCallData V8 params copied"); + } + + //update validity flags + iMobileCallInfo.iValid |= mobileCallInfo->iValid; + + } + +// CSD related methods + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::GetMobileDataCallCapsV1 +// Return GSM specific data call capabilities (V1). +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::GetMobileDataCallCapsV1( + RMobileCall::TMobileCallDataCapsV1& aCallDataCapsV1 ) + { + aCallDataCapsV1 = *iDataCallCaps; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::ReceivedMobileDataCallCaps +// Received GSM specific data call capabilities. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::ReceivedMobileDataCallCaps( + RMobileCall::TMobileCallDataCapsV1* aCaps ) + { + *iDataCallCaps = *aCaps; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::GetBearerServiceInfo +// Return GSM specific bearer service info. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::GetBearerServiceInfo( + RCall::TBearerService* aBearerService ) + { + *aBearerService = iBearerService; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::ReceivedBearerServiceInfo +// Copy received bearer service info. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::ReceivedBearerServiceInfo( + RCall::TBearerService aBearerService ) + { + iBearerService = aBearerService; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::SetDynamicHscsdParamsL +// Sets GSM specific HSCSD parameters into extension. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::SetDynamicHscsdParamsL( + RMobileCall::TMobileCallAiur* aAiur, + TInt* aRxTimeslots ) + { + TInt ret( KErrNone ); + + // Check if the HSCSD call is ok + if ( iHSCSDParams ) + { + iHSCSDParams->iWantedAiur = *aAiur; + iHSCSDParams->iWantedRxTimeSlots = *aRxTimeslots; + + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( + iMmCallTsy->CallId(), iSymbianCallMode ); + //Pack call parameters and mobile call info + package.PackData( iHSCSDParams ); + //Send request to the Domestic OS layer. + ret = iMessageManager->HandleRequestL( + EMobileCallSetDynamicHscsdParams, &package ); + + iInformationReceived = EFalse; + } + else + { + ret = KErrNotFound; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::GetCurrentHscsdInfo +// Return GSM specific current HSCSD info. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::GetCurrentHscsdInfo( + TDes8* aHSCSDInfo ) + { + TInt ret( KErrNone ); + + if ( iInformationReceived ) + { + // Check if current HSCSD info is valid! + if ( EDataCallModeHscsd == iDataCallMode && + iCurrentHSCSDInfo != NULL ) + { + // Check if aHSCSDInfo parameter descriptor size is valid + if ( sizeof(RMobilePhone::TMultimodeTypePckg) <= aHSCSDInfo->Length() ) + { + // using base class to solve correct info version + RMobilePhone::TMultimodeTypePckg* infoParamsPckg = + reinterpret_cast( + aHSCSDInfo ); + + RMobilePhone::TMultimodeType& infoParams = ( *infoParamsPckg )(); + + // get extensionid from the recieved data + TInt extensionId( infoParams.ExtensionId() ); + + if (KETelExtMultimodeV1 == extensionId ) + { +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::GetCurrentHscsdInfo - KETelMobileHscsdCallParamsV1"); + RMobileCall::TMobileCallHscsdInfoV1Pckg* hscsdInfoPckg = + REINTERPRET_CAST( RMobileCall::TMobileCallHscsdInfoV1Pckg*, + aHSCSDInfo ); + RMobileCall::TMobileCallHscsdInfoV1& hscsdInfo = + ( *hscsdInfoPckg )(); + + // Fill V1 information + hscsdInfo.iAiur = iCurrentHSCSDInfo->iAiur; + hscsdInfo.iCodings = iCurrentHSCSDInfo->iCodings; + hscsdInfo.iRxTimeSlots = iCurrentHSCSDInfo->iRxTimeSlots; + hscsdInfo.iTxTimeSlots = iCurrentHSCSDInfo->iTxTimeSlots; + } + + else if (KEtelExtMultimodeV7 == extensionId ) + { +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::GetCurrentHscsdInfo - KETelMobileHscsdCallParamsV7"); + RMobileCall::TMobileCallHscsdInfoV7Pckg* hscsdInfoPckg7 = + ( RMobileCall::TMobileCallHscsdInfoV7Pckg* )aHSCSDInfo; + RMobileCall::TMobileCallHscsdInfoV7& hscsdInfoV7 = + ( *hscsdInfoPckg7 )(); + + // Fill V1 information + hscsdInfoV7.iAiur = iCurrentHSCSDInfo->iAiur; + hscsdInfoV7.iCodings = iCurrentHSCSDInfo->iCodings; + hscsdInfoV7.iRxTimeSlots = iCurrentHSCSDInfo->iRxTimeSlots; + hscsdInfoV7.iTxTimeSlots = iCurrentHSCSDInfo->iTxTimeSlots; + + // Fill V7 information + hscsdInfoV7.iAlphaId = iCurrentHSCSDInfo->iAlphaId; + hscsdInfoV7.iCallParamOrigin = iCurrentHSCSDInfo->iCallParamOrigin; + hscsdInfoV7.iIconId.iIdentifier = + iCurrentHSCSDInfo->iIconId.iIdentifier; + hscsdInfoV7.iIconId.iQualifier = + iCurrentHSCSDInfo->iIconId.iQualifier; + hscsdInfoV7.iParamsCallControlModified = + iCurrentHSCSDInfo->iParamsCallControlModified; + } + + else if (KEtelExtMultimodeV8 == extensionId ) + { +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::GetCurrentHscsdInfo - KETelMobileHscsdCallParamsV8"); + RMobileCall::TMobileCallHscsdInfoV8Pckg* hscsdInfoPckg8 = + ( RMobileCall::TMobileCallHscsdInfoV8Pckg* )aHSCSDInfo; + RMobileCall::TMobileCallHscsdInfoV8& hscsdInfoV8 = + ( *hscsdInfoPckg8 )(); + + // Fill V1 information + hscsdInfoV8.iAiur = iCurrentHSCSDInfo->iAiur; + hscsdInfoV8.iCodings = iCurrentHSCSDInfo->iCodings; + hscsdInfoV8.iRxTimeSlots = iCurrentHSCSDInfo->iRxTimeSlots; + hscsdInfoV8.iTxTimeSlots = iCurrentHSCSDInfo->iTxTimeSlots; + + // Fill V7 information + hscsdInfoV8.iAlphaId = iCurrentHSCSDInfo->iAlphaId; + hscsdInfoV8.iCallParamOrigin = iCurrentHSCSDInfo->iCallParamOrigin; + hscsdInfoV8.iIconId.iIdentifier = + iCurrentHSCSDInfo->iIconId.iIdentifier; + hscsdInfoV8.iIconId.iQualifier = + iCurrentHSCSDInfo->iIconId.iQualifier; + hscsdInfoV8.iParamsCallControlModified = + iCurrentHSCSDInfo->iParamsCallControlModified; + + // Fill V8 information + hscsdInfoV8.iBCRepeatIndicator = iCurrentHSCSDInfo->iBCRepeatIndicator; + hscsdInfoV8.iBearerCap1 = iCurrentHSCSDInfo->iBearerCap1; + hscsdInfoV8.iBearerCap2 = iCurrentHSCSDInfo->iBearerCap2; + hscsdInfoV8.iSubAddress = iCurrentHSCSDInfo->iSubAddress; + } + else + { + ret = KErrArgument; + } + } + else + { + ret = KErrArgument; + } + } + + // Not found, return error! + else + { + ret = KErrEtelCallNotActive; + } + } + else + { + ret = KErrNotReady; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::DialDataCallL +// Dial method for data calls! +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::DialDataCallL( + RMobilePhone::TMobileService aCallMode, + const TDesC8* aCallParams, + const TDesC* aTelNumber ) + { +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialDataCallL"); +TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::DialDataCallL aCallMode: %d", aCallMode); + + 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; + TBool defaultParams(false); + if(aCallParams->Length() != 0) + { + RCall::TCallParamsPckg* paramsPckg = + reinterpret_cast( + const_cast( aCallParams ) ); + + RCall::TCallParams& dataParams = (*paramsPckg)(); + + if ( ( RMobileCall::KETelMobileDataCallParamsV1 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileDataCallParamsV2 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileDataCallParamsV8 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV1 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV2 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV7 == + dataParams.ExtensionId() )|| + ( RMobileCall::KETelMobileHscsdCallParamsV8 == + dataParams.ExtensionId())) + { + // Normal data call + iDataCallMode = EDataCallModeNormal; + RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + const_cast( aCallParams ) ); + + RMobileCall::TMobileDataCallParamsV1& dataParamsV1 = (*paramsPckgV1)(); + //Parameter of base class TMobileCallParamsV1 + iCSDParams->iIdRestrict = dataParamsV1.iIdRestrict; + iCSDParams->iCug = dataParamsV1.iCug; + iCSDParams->iAutoRedial = dataParamsV1.iAutoRedial; + + CopyMobileDataCallParams( *iCSDParams, dataParamsV1 ); + // Set iHscsdSupport initially to EFalse. + // Normal CSD does not support HSCSD features. + iDataCallCaps->iHscsdSupport = EFalse; + } + else + { + defaultParams = true; + //default unknown values + iCSDParams->iIdRestrict = RMobileCall::EIdRestrictDefault; + iCSDParams->iCug.iExplicitInvoke = EFalse; + iCSDParams->iCug.iCugIndex = 0xFFFF; + iCSDParams->iCug.iSuppressPrefCug = EFalse; + iCSDParams->iCug.iSuppressOA = EFalse; + iCSDParams->iAutoRedial = EFalse; + + // Normal data call + iDataCallMode = EDataCallModeNormal; + + // Set iHscsdSupport initially to EFalse. + // Normal CSD does not support HSCSD features. + iDataCallCaps->iHscsdSupport = EFalse; + } + + if ( RMobileCall::KETelMobileDataCallParamsV2 == + dataParams.ExtensionId()|| + RMobileCall::KETelMobileDataCallParamsV8 == + dataParams.ExtensionId()) + { + + RMobileCall::TMobileDataCallParamsV2Pckg* paramsPckgV2 = + reinterpret_cast( + const_cast( aCallParams ) ); + + RMobileCall::TMobileDataCallParamsV2& dataParams2 = (*paramsPckgV2)(); + + RMobileCall::TMobileDataCallParamsV2* dataCallParamsV2 = static_cast(iCSDParams); + + + dataCallParamsV2->iBearerMode = dataParams2.iBearerMode; + } + + if ( RMobileCall::KETelMobileDataCallParamsV8 == dataParams.ExtensionId()) + { + + RMobileCall::TMobileDataCallParamsV8Pckg* paramsPckgV8 = + reinterpret_cast( + const_cast( aCallParams ) ); + + RMobileCall::TMobileDataCallParamsV8& dataParams8 = (*paramsPckgV8)(); + + RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast(iCSDParams); + + + dataCallParamsV8->iCallParamOrigin = dataParams8.iCallParamOrigin; + dataCallParamsV8->iSubAddress = dataParams8.iSubAddress; + dataCallParamsV8->iBearerCap1 = dataParams8.iBearerCap1; + dataCallParamsV8->iBearerCap2 = dataParams8.iBearerCap2; + dataCallParamsV8->iBCRepeatIndicator = dataParams8.iBCRepeatIndicator; + dataCallParamsV8->iIconId.iQualifier = dataParams8.iIconId.iQualifier; + dataCallParamsV8->iIconId.iIdentifier = dataParams8.iIconId.iIdentifier; + dataCallParamsV8->iAlphaId = dataParams8.iAlphaId; + + if ( dataParams8.iAlphaId.Length() > 0 ) + { + iMobileCallInfo.iAlphaId.Copy(dataParams8.iAlphaId); + iMobileCallInfo.iValid |= RMobileCall::KCallAlphaId; + } + + if ( dataParams8.iIconId.iQualifier != RMobileCall::EIconQualifierNotSet ) + { + iMobileCallInfo.iIconId.iIdentifier = dataParams8.iIconId.iIdentifier; + iMobileCallInfo.iIconId.iQualifier = dataParams8.iIconId.iQualifier; + iMobileCallInfo.iValid |= RMobileCall::KCallIconId; + } + + if ( dataParams8.iCallParamOrigin != RMobileCall::EOriginatorUnknown) + { + iMobileCallInfo.iCallParamOrigin = dataParams8.iCallParamOrigin; + iMobileCallInfo.iValid |= RMobileCall::KCallParamOrigin; + } + + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV1 == dataParams.ExtensionId() || + RMobileCall::KETelMobileHscsdCallParamsV2 == dataParams.ExtensionId() || + RMobileCall::KETelMobileHscsdCallParamsV7 == dataParams.ExtensionId() || + RMobileCall::KETelMobileHscsdCallParamsV8 == dataParams.ExtensionId()) + { + // HSCSD data call + iDataCallMode = EDataCallModeHscsd; + RMobileCall::TMobileHscsdCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV1& hscsdParams = + (*paramsPckgV1)(); + *(static_cast(iHSCSDParams)) = hscsdParams; + // Set iHscsdSupport to ETrue. + // This call is HSCSD call and features are supported. + iDataCallCaps->iHscsdSupport = ETrue; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV2 == dataParams.ExtensionId() || + RMobileCall::KETelMobileHscsdCallParamsV7 == dataParams.ExtensionId() || + RMobileCall::KETelMobileHscsdCallParamsV8 == dataParams.ExtensionId()) + { + + RMobileCall::TMobileHscsdCallParamsV2Pckg* paramsPckgV2 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV2& hscsdParams2 = + (*paramsPckgV2)(); + RMobileCall::TMobileHscsdCallParamsV2* hscsdCallParamsV2 = static_cast(iHSCSDParams); + + hscsdCallParamsV2->iBearerMode = hscsdParams2.iBearerMode; + + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV7 == dataParams.ExtensionId() || + RMobileCall::KETelMobileHscsdCallParamsV8 == dataParams.ExtensionId()) + { + + RMobileCall::TMobileHscsdCallParamsV7Pckg* paramsPckgV7 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV7& hscsdParams7 = + (*paramsPckgV7)(); + + RMobileCall::TMobileHscsdCallParamsV7* hscsdCallParamsV7 = static_cast(iHSCSDParams); + + hscsdCallParamsV7->iCallParamOrigin = hscsdParams7.iCallParamOrigin; + hscsdCallParamsV7->iIconId.iIdentifier = hscsdParams7.iIconId.iIdentifier; + hscsdCallParamsV7->iIconId.iQualifier = hscsdParams7.iIconId.iQualifier; + hscsdCallParamsV7->iAlphaId = hscsdParams7.iAlphaId; + + if ( hscsdParams7.iAlphaId.Length() > 0 ) + { + iMobileCallInfo.iAlphaId.Copy(hscsdParams7.iAlphaId); + iMobileCallInfo.iValid |= RMobileCall::KCallAlphaId; + } + + if ( hscsdParams7.iIconId.iQualifier != RMobileCall::EIconQualifierNotSet ) + { + iMobileCallInfo.iIconId.iIdentifier = hscsdParams7.iIconId.iIdentifier; + iMobileCallInfo.iIconId.iQualifier = hscsdParams7.iIconId.iQualifier; + iMobileCallInfo.iValid |= RMobileCall::KCallIconId; + } + + if ( hscsdParams7.iCallParamOrigin != RMobileCall::EOriginatorUnknown) + { + iMobileCallInfo.iCallParamOrigin = hscsdParams7.iCallParamOrigin; + iMobileCallInfo.iValid |= RMobileCall::KCallParamOrigin; + } + } + if ( RMobileCall::KETelMobileHscsdCallParamsV8 == dataParams.ExtensionId() ) + { + + RMobileCall::TMobileHscsdCallParamsV8Pckg* paramsPckgV8 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV8& hscsdParams8 = + (*paramsPckgV8)(); + + RMobileCall::TMobileHscsdCallParamsV8* hscsdCallParamsV8 = static_cast(iHSCSDParams); + + hscsdCallParamsV8->iSubAddress = hscsdParams8.iSubAddress; + hscsdCallParamsV8->iBearerCap1 = hscsdParams8.iBearerCap1; + hscsdCallParamsV8->iBearerCap2 = hscsdParams8.iBearerCap2; + hscsdCallParamsV8->iBCRepeatIndicator = hscsdParams8.iBCRepeatIndicator; + + + } + } + SetDataCaps( aCallParams ); + + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( iMmCallTsy->CallId(), aCallMode ); + if(defaultParams) + { + TPckg pckgToSend(*iCSDParams); + package.PackData( &pckgToSend , &iMobileCallInfo ); + + } + else + { + //Pack call parameters and mobile call info + package.PackData( const_cast( aCallParams ), &iMobileCallInfo ); + } + + if( KMultimodeCallTypeIDNoFdnCheck == iMmCallTsy->GetDialTypeId() ) + { +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialDataCallL: EMobileCallDialNoFdnCheck"); + //Send request to the Domestic OS layer. + return iMessageManager->HandleRequestL( EMobileCallDialNoFdnCheck, &package ); + } + else + { +TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialDataCallL: EEtelCallDial"); + //Send request to the Domestic OS layer. + return iMessageManager->HandleRequestL( EEtelCallDial, &package ); + } + + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::AnswerIncomingDataCallL +// Answer incoming data call. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCallGsmWcdmaExt::AnswerIncomingDataCallL( + TInt aCallId ) + { + // Set data call caps for incoming call. The caps are unknown at this + // point and they are set when the call is connected! + iDataCallCaps->iServiceCaps = 0x00; +// iDataCallCaps->iProtocolCaps = 0x00; + iDataCallCaps->iQoSCaps = 0x00; + iDataCallCaps->iSpeedCaps = 0x00; + iDataCallCaps->iHscsdSupport = EFalse; + + // Initially always normal, will be set later to HSCSD if call is HSCSD + iDataCallMode = EDataCallModeNormal; + + //Create package + CCallDataPackage package; + //Set call id and call mode + package.SetCallIdAndMode( aCallId, iSymbianCallMode ); + + //Send request to the Domestic OS layer. + return iMessageManager->HandleRequestL( EEtelCallAnswer, &package ); + } +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::Connect +// Sets correct data call attributes, depending on parameter extension. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::Connect( + const TDesC8* aCallParams ) + { + RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileDataCallParamsV1& dataParams = ( *paramsPckgV1 )(); + + if ( ( RMobileCall::KETelMobileDataCallParamsV1 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV1 == + dataParams.ExtensionId() )|| + ( RMobileCall::KETelMobileDataCallParamsV2 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV2 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV7 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileHscsdCallParamsV8 == + dataParams.ExtensionId() ) || + ( RMobileCall::KETelMobileDataCallParamsV8 == + dataParams.ExtensionId() )) + + { + // Normal data call + iDataCallMode = EDataCallModeNormal; + CopyMobileDataCallParams( *iCSDParams, dataParams ); + // Set iHscsdSupport initially to EFalse. + // Normal CSD does not support HSCSD features. + iDataCallCaps->iHscsdSupport = EFalse; + } + + if ((RMobileCall::KETelMobileDataCallParamsV2 == dataParams.ExtensionId())|| + (RMobileCall::KETelMobileDataCallParamsV8 == dataParams.ExtensionId())) + { + RMobileCall::TMobileDataCallParamsV2Pckg* dataParamsPckgV2 = (RMobileCall::TMobileDataCallParamsV2Pckg*)aCallParams; + RMobileCall::TMobileDataCallParamsV2& dataParamsV2 = (*dataParamsPckgV2)(); + + RMobileCall::TMobileDataCallParamsV2* dataCallParamsV2 = static_cast(iCSDParams); + + dataCallParamsV2->iBearerMode = dataParamsV2.iBearerMode; + } + + if (RMobileCall::KETelMobileDataCallParamsV8 == dataParams.ExtensionId()) + { + RMobileCall::TMobileDataCallParamsV8Pckg* dataParamsPckgV8 = (RMobileCall::TMobileDataCallParamsV8Pckg*)aCallParams; + RMobileCall::TMobileDataCallParamsV8& dataParamsV8 = (*dataParamsPckgV8)(); + + RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast(iCSDParams); + + dataCallParamsV8->iCallParamOrigin = dataParamsV8.iCallParamOrigin; + dataCallParamsV8->iSubAddress = dataParamsV8.iSubAddress; + dataCallParamsV8->iBearerCap1 = dataParamsV8.iBearerCap1; + dataCallParamsV8->iBearerCap2 = dataParamsV8.iBearerCap2; + dataCallParamsV8->iBCRepeatIndicator = dataParamsV8.iBCRepeatIndicator; + dataCallParamsV8->iIconId.iQualifier = dataParamsV8.iIconId.iQualifier; + dataCallParamsV8->iIconId.iIdentifier = dataParamsV8.iIconId.iIdentifier; + dataCallParamsV8->iAlphaId = dataParamsV8.iAlphaId; + + + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV1 == + dataParams.ExtensionId() ) + { + // HSCSD data call + iDataCallMode = EDataCallModeHscsd; + RMobileCall::TMobileHscsdCallParamsV1Pckg* hscsdParamsPckgV1 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV1& hscsDataParams = + ( *hscsdParamsPckgV1 )(); + *(static_cast(iHSCSDParams)) = hscsDataParams; + // Set iHscsdSupport to ETrue. + // This call is HSCSD call and features are supported. + iDataCallCaps->iHscsdSupport = ETrue; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV2 == + dataParams.ExtensionId() ) + { + // HSCSD data call + iDataCallMode = EDataCallModeHscsd; + RMobileCall::TMobileHscsdCallParamsV2Pckg* hscsdParamsPckgV2 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV2& hscsDataParams2 = + ( *hscsdParamsPckgV2 )(); + *(static_cast(iHSCSDParams)) = hscsDataParams2; + // Set iHscsdSupport to ETrue. + // This call is HSCSD call and features are supported. + iDataCallCaps->iHscsdSupport = ETrue; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV7 == + dataParams.ExtensionId() ) + { + // HSCSD data call + iDataCallMode = EDataCallModeHscsd; + RMobileCall::TMobileHscsdCallParamsV7Pckg* hscsdParamsPckgV7 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV7& hscsDataParams7 = + ( *hscsdParamsPckgV7)(); + *(static_cast(iHSCSDParams)) = hscsDataParams7; + // Set iHscsdSupport to ETrue. + // This call is HSCSD call and features are supported. + iDataCallCaps->iHscsdSupport = ETrue; + } + + if ( RMobileCall::KETelMobileHscsdCallParamsV8 == + dataParams.ExtensionId() ) + { + // HSCSD data call + iDataCallMode = EDataCallModeHscsd; + RMobileCall::TMobileHscsdCallParamsV8Pckg* hscsdParamsPckgV8 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileHscsdCallParamsV8& hscsDataParams8 = + ( *hscsdParamsPckgV8 )(); + *iHSCSDParams = hscsDataParams8; + // Set iHscsdSupport to ETrue. + // This call is HSCSD call and features are supported. + iDataCallCaps->iHscsdSupport = ETrue; + } + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::ReceivedCallParams +// Stores new CALL/CSD parameters. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::ReceivedCallParams( + const CMmDataPackage* aDataPackage ) + { + TDesC8* callParamsDes = NULL; + + aDataPackage->UnPackData( &callParamsDes ); + + RCall::TCallParamsPckg* callParamsPckg = + reinterpret_cast( callParamsDes ); + RCall::TCallParams& callParams = ( *callParamsPckg )(); + + TInt extensionId( callParams.ExtensionId() ); + + if ( iCSDParams && + (( RMobileCall::KETelMobileDataCallParamsV1 == extensionId) || + ( RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId ))) + { + RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileDataCallParamsV1& dataParams = ( *paramsPckgV1 )(); + + // Save all the CSD parameters here + *(static_cast(iCSDParams)) = dataParams; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + if ( iCSDParams && ( RMobileCall::KETelMobileDataCallParamsV2 == extensionId)) + { + RMobileCall::TMobileDataCallParamsV2Pckg* paramsPckgV2 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileDataCallParamsV2& dataParams2 = ( *paramsPckgV2 )(); + + // Save all the CSD parameters here + *(static_cast(iCSDParams)) = dataParams2; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + if ( iCSDParams &&( RMobileCall::KETelMobileDataCallParamsV8 == extensionId)) + { + RMobileCall::TMobileDataCallParamsV8Pckg* paramsPckgV8 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileDataCallParamsV8& dataParams8 = ( *paramsPckgV8)(); + + // Save all the CSD parameters here + *iCSDParams = dataParams8; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId ) ) + { + RMobileCall::TMobileHscsdCallParamsV1Pckg* hscsdParamsPckgV1 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileHscsdCallParamsV1& hscsdDataParams = ( *hscsdParamsPckgV1 )(); + + // Save all the CSD parameters here + *(static_cast(iHSCSDParams)) = hscsdDataParams; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId ) ) + { + RMobileCall::TMobileHscsdCallParamsV2Pckg* hscsdParamsPckgV2 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileHscsdCallParamsV2& hscsdDataParams2 = ( *hscsdParamsPckgV2 )(); + + // Save all the CSD parameters here + *(static_cast(iHSCSDParams)) = hscsdDataParams2; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId ) ) + { + RMobileCall::TMobileHscsdCallParamsV7Pckg* hscsdParamsPckgV7 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileHscsdCallParamsV7& hscsdDataParams7 = ( *hscsdParamsPckgV7 )(); + + // Save all the CSD parameters here + *(static_cast(iHSCSDParams)) = hscsdDataParams7; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId ) ) + { + RMobileCall::TMobileHscsdCallParamsV8Pckg* hscsdParamsPckgV8 = + reinterpret_cast( + callParamsDes ); + RMobileCall::TMobileHscsdCallParamsV8& hscsdDataParams8 = ( *hscsdParamsPckgV8 )(); + + // Save all the CSD parameters here + *iHSCSDParams = hscsdDataParams8; + // Update data call caps + SetDataCaps( callParamsDes ); + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::SetDataCaps +// Sets data call service, protocol and QoS caps. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::SetDataCaps( + const TDesC8* aCallParams ) + { + iDataCallCaps->iSpeedCaps = 0x00; + iDataCallCaps->iProtocolCaps = 0x00; + iDataCallCaps->iQoSCaps = 0x00; + iDataCallCaps->iServiceCaps = 0x00; + if(aCallParams->Length() < sizeof(RMobileCall::TMobileDataCallParamsV1) ) + { + return; + } + RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 = + reinterpret_cast( + const_cast( aCallParams ) ); + RMobileCall::TMobileDataCallParamsV1& dataParams = ( *paramsPckgV1 )(); + + // NOTE: Service and QoS values are set to only supported value in + // ResetInternalAttributes. If there will be more supported caps in for + // example continuation projects, then do Service and QoS here the same + // way as Speed and Protocol are done. + + // Change the speed caps + switch ( dataParams.iSpeed ) + { + case RMobileCall::ESpeedAutobauding: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeedAutobauding; + break; + case RMobileCall::ESpeed9600: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed9600; + break; + case RMobileCall::ESpeed14400: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed14400; + break; + case RMobileCall::ESpeed19200: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed19200; + break; + case RMobileCall::ESpeed28800: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed28800; + break; + case RMobileCall::ESpeed38400: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed38400; + break; + case RMobileCall::ESpeed43200: + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed43200; + break; + // For Multimedia call + case RMobileCall::ESpeed64000: + if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KCsVideoTelephony ) == KFeatureSupported) ) + { + iDataCallCaps->iSpeedCaps = + RMobileCall::KCapsSpeed64000; + } + break; + case RMobileCall::ESpeed2400: + case RMobileCall::ESpeed4800: + case RMobileCall::ESpeed32000: + case RMobileCall::ESpeed33600: + case RMobileCall::ESpeed48000: + case RMobileCall::ESpeed56000: + case RMobileCall::ESpeed57600: + case RMobileCall::ESpeedUnspecified: + default: + // already set iDataCallCaps->iSpeedCaps = 0x00; + break; + } + + // Change the protocol caps + switch ( dataParams.iProtocol ) + { + case RMobileCall::EProtocolV32: + iDataCallCaps->iProtocolCaps = + RMobileCall::KCapsProtocolV32; + break; + case RMobileCall::EProtocolV34: + iDataCallCaps->iProtocolCaps = + RMobileCall::KCapsProtocolV34; + break; + case RMobileCall::EProtocolV110: + iDataCallCaps->iProtocolCaps = + RMobileCall::KCapsProtocolV110; + break; + case RMobileCall::EProtocolV120: + iDataCallCaps->iProtocolCaps = + RMobileCall::KCapsProtocolV120; + break; + // For Multimedia call + case RMobileCall::EProtocolPstnMultimedia: + if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KCsVideoTelephony ) == KFeatureSupported) ) + { + iDataCallCaps->iProtocolCaps = + RMobileCall::KCapsPstnMultimedia; + } + break; + case RMobileCall::EProtocolIsdnMultimedia: + if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KCsVideoTelephony ) == KFeatureSupported) ) + { + iDataCallCaps->iProtocolCaps = + RMobileCall::KCapsIsdnMultimedia; + } + break; + case RMobileCall::EProtocolUnspecified: + case RMobileCall::EProtocolV22bis: + case RMobileCall::EProtocolX31FlagStuffing: + case RMobileCall::EProtocolPIAFS: + case RMobileCall::EProtocolBitTransparent: + case RMobileCall::EProtocolPstnMultimediaVoiceFallback: + default: + // aldready set iDataCallCaps->iProtocolCaps = 0x00; + break; + } + + // Change the QoS caps + switch ( dataParams.iQoS ) + { + case RMobileCall::EQoSTransparent: + iDataCallCaps->iQoSCaps = + RMobileCall::KCapsTransparent; + break; + case RMobileCall::EQoSNonTransparent: + iDataCallCaps->iQoSCaps = + RMobileCall::KCapsNonTransparent; + break; + case RMobileCall::EQosTransparentPreferred: + iDataCallCaps->iQoSCaps = + RMobileCall::KCapsTransparentPreferred; + break; + case RMobileCall::EQosNonTransparentPreferred: + iDataCallCaps->iQoSCaps = + RMobileCall::KCapsNonTransparentPreferred; + break; + case RMobileCall::EQoSUnspecified: + default: + // aldready set iDataCallCaps->iQoSCaps = 0x00; + break; + } + + // Change the service caps + switch ( dataParams.iService ) + { + case RMobileCall::EServiceDataCircuitAsync: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsDataCircuitAsynchronous; + break; + case RMobileCall::EServiceDataCircuitAsyncRdi: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsDataCircuitAsynchronousRDI; + break; + case RMobileCall::EServiceDataCircuitSync: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsDataCircuitSynchronous; + break; + case RMobileCall::EServiceDataCircuitSyncRdi: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsDataCircuitSynchronousRDI; + break; + case RMobileCall::EServicePADAsyncUDI: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsPADAsyncUDI; + break; + case RMobileCall::EServicePADAsyncRDI: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsPADAsyncRDI; + break; + case RMobileCall::EServicePacketAccessSyncUDI: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsPacketAccessSyncUDI; + break; + case RMobileCall::EServicePacketAccessSyncRDI: + iDataCallCaps->iServiceCaps = + RMobileCall::KCapsPacketAccessSyncRDI; + break; + case RMobileCall::EServiceUnspecified: + default : + // aldready set iDataCallCaps->iServiceCaps = 0x00; + break; + } + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::CopyMobileDataCallParams +// Copies data call parameters to another variable without extension id. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::CopyMobileDataCallParams( + RMobileCall::TMobileDataCallParamsV1& aDestination, + const RMobileCall::TMobileDataCallParamsV1& aSource ) const + { + aDestination.iService = aSource.iService; + aDestination.iSpeed = aSource.iSpeed; + aDestination.iProtocol = aSource.iProtocol; + aDestination.iQoS = aSource.iQoS; + aDestination.iRLPVersion = aSource.iRLPVersion; + aDestination.iModemToMSWindowSize = aSource.iModemToMSWindowSize; + aDestination.iMSToModemWindowSize = aSource.iMSToModemWindowSize; + aDestination.iAckTimer = aSource.iAckTimer; + aDestination.iRetransmissionAttempts = aSource.iRetransmissionAttempts; + aDestination.iResequencingPeriod = aSource.iResequencingPeriod; + aDestination.iV42bisReq = aSource.iV42bisReq; + aDestination.iV42bisCodewordsNum = aSource.iV42bisCodewordsNum; + aDestination.iV42bisMaxStringLength = aSource.iV42bisMaxStringLength; + aDestination.iUseEdge = aSource.iUseEdge; + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::HscsdInfoReceived +// Set extension specific HSCSD info. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::ReceivedHscsdInfo( + CMmDataPackage* aDataPackage ) + { + RMobileCall::TMobileCallHscsdInfoV8* newHscsdInfo; + RMobileCall::TMobileCallDataCapsV1* newDataCallCaps; + + aDataPackage->UnPackData( &newHscsdInfo, &newDataCallCaps ); + + iInformationReceived = ETrue; + + if ( newDataCallCaps->iHscsdSupport ) + { + iDataCallMode = EDataCallModeHscsd; + } + else + { + iDataCallMode = EDataCallModeNormal; + } + + if ( newHscsdInfo->iCodings != iCurrentHSCSDInfo->iCodings || + newHscsdInfo->iAiur != iCurrentHSCSDInfo->iAiur || + newHscsdInfo->iTxTimeSlots != iCurrentHSCSDInfo->iTxTimeSlots || + newHscsdInfo->iRxTimeSlots != iCurrentHSCSDInfo->iRxTimeSlots || + newHscsdInfo->iCallParamOrigin != iCurrentHSCSDInfo->iCallParamOrigin || + newHscsdInfo->iIconId.iIdentifier != iCurrentHSCSDInfo->iIconId.iIdentifier || + newHscsdInfo->iIconId.iQualifier != iCurrentHSCSDInfo->iIconId.iQualifier || + newHscsdInfo->iParamsCallControlModified != iCurrentHSCSDInfo->iParamsCallControlModified || + newHscsdInfo->iSubAddress != iCurrentHSCSDInfo->iSubAddress || + newHscsdInfo->iBearerCap1 != iCurrentHSCSDInfo->iBearerCap1 || + newHscsdInfo->iBearerCap2 != iCurrentHSCSDInfo->iBearerCap2 || + newHscsdInfo->iBCRepeatIndicator != iCurrentHSCSDInfo->iBCRepeatIndicator) + { + + + *iCurrentHSCSDInfo = *newHscsdInfo; + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyHscsdInfoChange(); + } + + if ( newDataCallCaps->iMaxRxTimeSlots != iDataCallCaps->iMaxRxTimeSlots || + newDataCallCaps->iMaxTxTimeSlots != iDataCallCaps->iMaxTxTimeSlots || + newDataCallCaps->iHscsdSupport != iDataCallCaps->iHscsdSupport || + newDataCallCaps->iSpeedCaps != iDataCallCaps->iSpeedCaps ) + { + //Update the caps for speed + iDataCallCaps->iSpeedCaps = newDataCallCaps->iSpeedCaps; + iDataCallCaps->iHscsdSupport = newDataCallCaps->iHscsdSupport; + iDataCallCaps->iMaxRxTimeSlots = newDataCallCaps->iMaxRxTimeSlots; + iDataCallCaps->iMaxTxTimeSlots = newDataCallCaps->iMaxTxTimeSlots; + + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + } + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::ReceivedMobileDataCallCaps +// Set extension specific data call capabilities. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::ReceivedMobileDataCallCaps( + CMmDataPackage* aDataPackage ) + { + RMobileCall::TMobileCallDataCapsV1* newDataCallCaps; + + aDataPackage->UnPackData( &newDataCallCaps ); + + *iDataCallCaps = *newDataCallCaps; + + reinterpret_cast( iMmCallTsy )-> + CompleteNotifyMobileDataCallCapsChange(); + } + + +// --------------------------------------------------------------------------- +// CMmCallGsmWcdmaExt::SsmPluginCallback +// This is callback +// This method is called from System State Manager (or from CMmCallGsmWcdmaExt, if there +// is no reason to change RF state), after RF state changing +// --------------------------------------------------------------------------- +// +void CMmCallGsmWcdmaExt::SsmPluginCallback(TInt aResult, TCtsySsmCallbackData& aCallbackData) + { + TInt result (aResult); + + if ( KErrNone == aResult ) + { + TFLOGSTRING ("TSY:CMmCallGsmWcdmaExt::SsmPluginCallback: Dialing..."); + + //at this point the RF should be enabled in all cases + TRAPD(err, result = iMessageManager->HandleRequestL( + EMobileCallDialEmergencyCall, &aCallbackData.iNumberPackage )); + if (KErrNone != err) + { + result = err; + } + + //if the RF state was inactive prior dialing the emergency call + //change the status of the RF in phone to EEmergencyCallMade + //this will enable that RF is set back to off when emergency call + //is finished + TRfStateInfo stateInfo = iMmCallTsy->Phone()->GetRfStateInfo(); + if ( result == KErrNone && stateInfo != ERfsStateInfoNormal ) + { + iMmCallTsy->Phone()->SetRfStatus( EEmergencyCallMade ); + } + + } + + //pass answer from SSM further to CMmVoiceCallTsy::SsmPluginCallback() + ((CMmVoiceCallTsy*)iMmCallTsy)->SsmPluginCallback(result, aCallbackData); + + } + +// End of File