telephonyserverplugins/common_tsy/commontsy/src/mmgsmwcdma/cmmcallgsmwcdmaext.cpp
// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include "cmmcallgsmwcdmaext.h"
#include <featureuids.h>
#include "cmmphonetsy.h"
#include "cmmcalllist.h"
#include "cmmconferencecalltsy.h"
#include "cmmconferencecallgsmwcdmaext.h"
#include <ctsy/pluginapi/cmmdatapackage.h>
#include "cmmmessagemanagerbase.h"
#include <ctsy/tflogger.h>
#include "cmmvoicecalltsy.h"
//csd includes
#include "cmmdatacalltsy.h"
#include <et_tsy.h>
// ======== MEMBER FUNCTIONS ========
CMmCallGsmWcdmaExt::CMmCallGsmWcdmaExt()
{
}
void CMmCallGsmWcdmaExt::ConstructL()
{
// Create normal and HSCSD data call related pointers!
iDataCallCaps = new ( ELeave ) RMobileCall::TMobileCallDataCapsV1();
iCSDParams = new ( ELeave ) RMobileCall::TMobileDataCallParamsV8();
iHSCSDParams = new ( ELeave ) RMobileCall::TMobileHscsdCallParamsV8();
iCurrentHSCSDInfo = new ( ELeave ) RMobileCall::TMobileCallHscsdInfoV8();
// iCSDParams, iHSCSDParams and iCurrentHSCSDInfo:
// Service and QoS values are set to only supported value (MO, defined in
// MmTsy_Defaults.h). If there will be more supported caps in for example
// continuation projects, then set here Service and QoS to Unspecified.
iCSDParams->iService = RMobileCall::RMobileCall::EServiceDataCircuitAsync;;
iCSDParams->iQoS = RMobileCall::EQoSNonTransparent;
iCSDParams->iSpeed = RMobileCall::ESpeedUnspecified;
iCSDParams->iProtocol = RMobileCall::EProtocolUnspecified;
iCSDParams->iRLPVersion = RMobileCall::ERLPNotRequested;
iCSDParams->iModemToMSWindowSize = 0x00;
iCSDParams->iMSToModemWindowSize = 0x00;
iCSDParams->iAckTimer = 0x00;
iCSDParams->iRetransmissionAttempts = 0x00;
iCSDParams->iResequencingPeriod = 0x00;
iCSDParams->iV42bisReq = RMobileCall::EV42bisNeitherDirection;
iCSDParams->iV42bisCodewordsNum = 0x00;
iCSDParams->iV42bisMaxStringLength = 0x00;
RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast<RMobileCall::TMobileDataCallParamsV8*>(iCSDParams);
dataCallParamsV8->iBearerMode = RMobileCall::EMulticallNotSupported;
dataCallParamsV8->iCallParamOrigin = RMobileCall::EOriginatorUnknown;
dataCallParamsV8->iBCRepeatIndicator = RMobileCall::EBCAlternateMode;
iHSCSDParams->iWantedAiur = RMobileCall::EAiurBpsUnspecified;
iHSCSDParams->iWantedRxTimeSlots = 0x00;
iHSCSDParams->iMaxTimeSlots = 0x00;
iHSCSDParams->iCodings = 0x00;
iHSCSDParams->iAsymmetry = RMobileCall::EAsymmetryNoPreference;
iHSCSDParams->iUserInitUpgrade = KMultimodeTsyDataUserInitUpgrade;
RMobileCall::TMobileHscsdCallParamsV8* hscsdCallParamsV8 = static_cast<RMobileCall::TMobileHscsdCallParamsV8*>(iHSCSDParams);
hscsdCallParamsV8->iBearerMode = RMobileCall::EMulticallNotSupported;
hscsdCallParamsV8->iCallParamOrigin = RMobileCall::EOriginatorUnknown;
hscsdCallParamsV8->iIconId.iQualifier = RMobileCall::EIconQualifierNotSet;
hscsdCallParamsV8->iIconId.iIdentifier = 0x00;
hscsdCallParamsV8->iBCRepeatIndicator = RMobileCall::EBCAlternateMode;
iCurrentHSCSDInfo->iAiur = RMobileCall::EAiurBpsUnspecified;
iCurrentHSCSDInfo->iRxTimeSlots = 0x00;
iCurrentHSCSDInfo->iTxTimeSlots = 0x00;
iCurrentHSCSDInfo->iCodings = RMobileCall::ETchCodingUnspecified;
iCurrentHSCSDInfo->iCallParamOrigin = RMobileCall::EOriginatorUnknown;
iCurrentHSCSDInfo->iIconId.iIdentifier = 0x00;
iCurrentHSCSDInfo->iIconId.iQualifier = RMobileCall::EIconQualifierNotSet;
iCurrentHSCSDInfo->iParamsCallControlModified = EFalse;
iCurrentHSCSDInfo->iBCRepeatIndicator = RMobileCall::EBCAlternateMode;
iMobileCallCaps.iCallControlCaps = 0x00000000 | RCall::KCapsDial;
if ( RMobilePhone::EVoiceService == iSymbianCallMode )
{
iMobileCallCaps.iCallControlCaps |= RCall::KCapsVoice;
}
else if ( RMobilePhone::ECircuitDataService == iSymbianCallMode )
{
iMobileCallCaps.iCallControlCaps |=
RCall::KCapsData | RCall::KCapsConnect;
}
else if ( RMobilePhone::EFaxService == iSymbianCallMode )
{
iMobileCallCaps.iCallControlCaps |= RCall::KCapsFax;
}
else
{
iMobileCallCaps.iCallControlCaps = 0x00000000;
}
iMobileCallCaps.iCallEventCaps = 0x000000ff;
iMobileCallInfo.iForwarded = EFalse;
iMobileCallInfo.iBCRepeatIndicator = RMobileCall::EBCAlternateMode;
TInt err = iFeatureControl.Open();
iUsingFeatureManager = (err == KErrNone);
iSystemStatePluginHandler = iMmCallTsy->Phone()->SystemStatePluginHandler();
ResetInternalAttributes();
}
CMmCallGsmWcdmaExt* CMmCallGsmWcdmaExt::NewL(
CMmCallTsy* aMmCallTsy,
RMobilePhone::TMobileService aMode,
CMmMessageManagerBase* aMessageManager )
{
CMmCallGsmWcdmaExt* callGsmWcdmaExt = new( ELeave ) CMmCallGsmWcdmaExt();
CleanupStack::PushL( callGsmWcdmaExt );
callGsmWcdmaExt->iMmCallTsy = aMmCallTsy;
callGsmWcdmaExt->iSymbianCallMode = aMode;
callGsmWcdmaExt->iMessageManager = aMessageManager;
callGsmWcdmaExt->ConstructL();
CleanupStack::Pop();
return callGsmWcdmaExt;
}
CMmCallGsmWcdmaExt::~CMmCallGsmWcdmaExt()
{
iFeatureControl.Close();
if ( iDataCallCaps )
{
delete iDataCallCaps;
}
iDataCallCaps = NULL;
if ( iCSDParams )
{
delete iCSDParams;
}
iCSDParams = NULL;
if ( iHSCSDParams )
{
delete iHSCSDParams;
}
iHSCSDParams = NULL;
if ( iCurrentHSCSDInfo )
{
delete iCurrentHSCSDInfo;
}
iCurrentHSCSDInfo = NULL;
iMmCallTsy = NULL;
iMessageManager = NULL;
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::ResetInternalAttributes
// Resets GSM call internal attributes.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmCallGsmWcdmaExt::ResetInternalAttributes()
{
// Add only attributes that can be set in call object construction
// (during ConstructL), in HangUp or in call object destruction
// (during ~CMmCallGsmWcdmaExt).
iDataCallMode = EDataCallModeUnknown;
iBearerService.iBearerCaps =
RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown;
iBearerService.iBearerSpeed = RCall::EBearerDataUnknown;
// Set data call caps to default
// Supported capabilities defined in MmTsy_Defaults.h, see also etelmm.h
iDataCallCaps->iSpeedCaps = KMultimodeTsyDataSpeedCaps;
iDataCallCaps->iProtocolCaps = KMultimodeTsyDataProtocolCaps;
iDataCallCaps->iServiceCaps = KMultimodeTsyDataServiceCaps;
iDataCallCaps->iQoSCaps = KMultimodeTsyDataQoSCaps;
iDataCallCaps->iHscsdSupport = KMultimodeTsyDataHscsdSupport;
// additional flags for videotelephony
if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KCsVideoTelephony) == KFeatureSupported) )
{
iDataCallCaps->iSpeedCaps |= KMultimodeTsyDataSpeedCapsVT;
iDataCallCaps->iProtocolCaps |= KMultimodeTsyDataProtocolCapsVT;
iDataCallCaps->iServiceCaps |= KMultimodeTsyDataServiceCapsVT;
}
// If Hscsd support is false, all the following iDataCallCaps are invalid
// Detailed in GSM 05.02 V8.10.0 Appendix B
// Multislot class
iDataCallCaps->iMClass = KMultimodeTsyDataMClassDefValue;
// Max number of Rx slots
iDataCallCaps->iMaxRxTimeSlots = KMultimodeTsyDataMaxRxTSDefValue;
// Max number of Tx slots
iDataCallCaps->iMaxTxTimeSlots = KMultimodeTsyDataMaxTxTSDefValue;
// Max number of Sum slots
iDataCallCaps->iTotalRxTxTimeSlots = KMultimodeTsyDataTotalRxTxTSDefValue;
iDataCallCaps->iCodingCaps = KMultimodeTsyDataTchCodingsCaps;
iDataCallCaps->iAsymmetryCaps = KMultimodeTsyDataAsymmetryCaps;
// Not supporting automatic service level upgrading
iDataCallCaps->iUserInitUpgrade = KMultimodeTsyDataUserInitUpgrade;
iDataCallCaps->iRLPVersionCaps = KMultimodeTsyDataRLPVersionCaps;
iDataCallCaps->iV42bisCaps = KMultimodeTsyDataV42bisCaps;
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::DialL
// GSM specific Dial method for outgoing call
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmCallGsmWcdmaExt::DialL(
RMobilePhone::TMobileService aCallMode,
const TDesC8* aCallParams,
const TDesC* aTelNumber,
TInt aExtensionId )
{
TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::DialL extensionid %d", aExtensionId );
// Reset iCallParams extended members
iCallParams.iAlphaId.Zero();
iCallParams.iIconId.iQualifier = RMobileCall::EIconQualifierNotSet;
iCallParams.iIconId.iIdentifier = 0x00;
iCallParams.iBCRepeatIndicator = RMobileCall::EBCAlternateMode;
iCallParams.iBearerCap2.Zero();
iCallParams.iBearerCap1.Zero();
iCallParams.iSubAddress.Zero();
iCallParams.iCallParamOrigin = RMobileCall::EOriginatorUnknown;
iCallParams.iBearerMode = RMobileCall::EMulticallNotSupported;
iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
iCallParams.iCug.iExplicitInvoke = EFalse;
iCallParams.iCug.iCugIndex = 0xFFFF;
iCallParams.iCug.iSuppressPrefCug = EFalse;
iCallParams.iCug.iSuppressOA = EFalse;
iCallParams.iAutoRedial = EFalse;
//use base class to determine callparam version
RCall::TCallParamsPckg* callParamsPckg =
reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>( aCallParams ) );
RCall::TCallParams& callParams = ( *callParamsPckg )();
TInt extensionId( callParams.ExtensionId() );
TFLOGSTRING2("TSY: CMmCallGsmWcdmaExt::DialL callParams.extensionId %d ", extensionId);
if( ( RMobileCall::KETelMobileCallParamsV1 == extensionId ) ||
( RMobileCall::KETelMobileCallParamsV2 == extensionId ))
{
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams V1, V2");
iCallParams.iSpeakerControl = callParams.iSpeakerControl;
iCallParams.iSpeakerVolume = callParams.iSpeakerVolume;
iCallParams.iInterval = callParams.iInterval;
iCallParams.iWaitForDialTone = callParams.iWaitForDialTone;
RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 =
reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileCallParamsV1& params1 = (*paramsPckgV1)();
iCallParams.iIdRestrict = params1.iIdRestrict;
iCallParams.iAutoRedial = params1.iAutoRedial;
iCallParams.iCug.iExplicitInvoke = params1.iCug.iExplicitInvoke;
iCallParams.iCug.iCugIndex = params1.iCug.iCugIndex;
iCallParams.iCug.iSuppressOA = params1.iCug.iSuppressOA;
iCallParams.iCug.iSuppressPrefCug = params1.iCug.iSuppressPrefCug;
if ( RMobileCall::KETelMobileCallParamsV2 == extensionId )
{
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams V2");
RMobileCall::TMobileCallParamsV2Pckg* paramsPckgV2 =
reinterpret_cast<RMobileCall::TMobileCallParamsV2Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileCallParamsV2& params2 = (*paramsPckgV2)();
iCallParams.iBearerMode = params2.iBearerMode;
}
}
else if( RMobileCall::KETelMobileCallParamsV7 == extensionId )
{
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams V7");
RMobileCall::TMobileCallParamsV7Pckg* paramsPckgV7 =
reinterpret_cast<RMobileCall::TMobileCallParamsV7Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
iCallParams = ( *paramsPckgV7 )();
}
else
{
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL callparams version unknown");
iCallParams.iSpeakerControl = callParams.iSpeakerControl;
iCallParams.iSpeakerVolume = callParams.iSpeakerVolume;
iCallParams.iInterval = callParams.iInterval;
iCallParams.iWaitForDialTone = callParams.iWaitForDialTone;
//default unknown values
iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
iCallParams.iCug.iExplicitInvoke = EFalse;
iCallParams.iCug.iCugIndex = 0xFFFF;
iCallParams.iCug.iSuppressPrefCug = EFalse;
iCallParams.iCug.iSuppressOA = EFalse;
iCallParams.iAutoRedial = EFalse;
}
iMobileCallInfo.iDialledParty.iTelNumber.Copy( *aTelNumber );
iMobileCallInfo.iDialledParty.iNumberPlan =
RMobilePhone::EUnknownNumberingPlan;
iMobileCallInfo.iDialledParty.iTypeOfNumber =
RMobilePhone::EUnknownNumber;
iMobileCallInfo.iService = aCallMode;
iMobileCallInfo.iValid |= RMobileCall::KCallDialledParty;
iMobileCallInfo.iValid |= RMobileCall::KCallAlternating;
iMobileCallInfo.iAlternatingCall =
RMobilePhone::EAlternatingModeUnspecified;
// Reset old info
iMobileCallInfo.iRemoteParty.iDirection = RMobileCall::EDirectionUnknown;
//Create package
CCallDataPackage package;
//Set call id and call mode
package.SetCallIdAndMode( iMmCallTsy->CallId(), aCallMode );
//Send request to the Domestic OS layer.
if ( KETelExt3rdPartyV1 == aExtensionId )
{
//Pack call parameters and mobile call info
// Use argument parameters since TMobileCallParamsV7 does not inherit from 3rd party params.
package.PackData(const_cast<TDesC8*>(aCallParams), &iMobileCallInfo);
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL: KETelExt3rdPartyV1");
//if it is a 3rd party client
return iMessageManager->HandleRequestL( EMobileCallDialISV,
&package );
}
//if not a 3rd party client and dial no fdn check used
else if ( KMultimodeCallTypeIDNoFdnCheck == aExtensionId )
{
//Pack call parameters and mobile call info
TPckg<RMobileCall::TMobileCallParamsV7> pckgToSend(iCallParams);
package.PackData( &pckgToSend , &iMobileCallInfo );
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL: KMultimodeCallTypeIDNoFdnCheck");
return iMessageManager->HandleRequestL(
EMobileCallDialNoFdnCheck, &package );
}
else
{
//Pack call parameters and mobile call info
TPckg<RMobileCall::TMobileCallParamsV7> pckgToSend(iCallParams);
package.PackData( &pckgToSend , &iMobileCallInfo );
TFLOGSTRING("TSY: CMmCallGsmWcdmaExt::DialL: EEtelCallDial");
return iMessageManager->HandleRequestL( EEtelCallDial, &package );
}
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::AnswerIncomingCallL
// Answers incoming call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmCallGsmWcdmaExt::AnswerIncomingCallL(
TInt aCallId,
TInt aExtensionId )
{
//Create package
CCallDataPackage package;
//Set call id and call mode
package.SetCallIdAndMode( aCallId, iSymbianCallMode );
//Send request to the Domestic OS layer.
if ( KETelExt3rdPartyV1 == aExtensionId )
{
//if it is a 3rd party client
return iMessageManager->HandleRequestL( EMobileCallAnswerISV,
&package );
}
else
{
//if not a 3rd party client
return iMessageManager->HandleRequestL( EEtelCallAnswer, &package );
}
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::GetMobileCallCapsV1
// Return GSM specific mobile call capabilities (V1).
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmCallGsmWcdmaExt::GetMobileCallCapsV1(
RMobileCall::TMobileCallCapsV1& aCallCapsV1 )
{
aCallCapsV1 = iMobileCallCaps;
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::SetGSMCallCaps
// Set GSM specific mobile call caps
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmCallGsmWcdmaExt::SetGSMCallCaps(
const RMobileCall::TMobileCallCapsV1* aCaps )
{
iMobileCallCaps = *aCaps;
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::AddGSMCallCaps
// Adds requested caps to GSM specific mobile call caps
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmCallGsmWcdmaExt::AddGSMCallCaps(
TUint32 aCaps )
{
iMobileCallCaps.iCallControlCaps |= aCaps;
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::RemoveGSMCallCaps
// Removes requested caps from GSM specific mobile call caps
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmCallGsmWcdmaExt::RemoveGSMCallCaps(
TUint32 aCaps )
{
iMobileCallCaps.iCallControlCaps &= ~aCaps;
}
// ---------------------------------------------------------------------------
// CMmCallGsmWcdmaExt::CompleteNotifyStatusChange
// Updates the dynamic capabilities of the GSM extension
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmCallGsmWcdmaExt::CompleteNotifyStatusChange(
RMobileCall::TMobileCallStatus aCallStatus )
{
TInt ret( KErrNone );
TBool singleCallGoingOn( EFalse );
TBool twoCallsGoingOn( EFalse );
TBool conferenceGoingOn( EFalse );
TInt numberOfNonIdleCallObjects( 0 );
// Get CMmPhone for information gathering
CMmPhoneTsy* mmPhone = iMmCallTsy->Phone();
// Get CallList
CMmCallList* callList = mmPhone->CallList();
// Get Conference call object
CMmConferenceCallTsy* mmConference = mmPhone->ConferenceCall();
// Create a pointer for call object
CMmCallTsy* mmCall = NULL;
//Save previous caps
TUint32 oldControlCaps = iMobileCallCaps.iCallControlCaps;
//Count number of call objects that are not in idle state
for ( TInt i = 0; i < callList->GetNumberOfObjects(); i++ )
{
mmCall = callList->GetMmCallByIndex( i );
if ( RMobileCall::EStatusIdle != mmCall->MobileCallStatus() )
{
numberOfNonIdleCallObjects++;
}
}
//if there is only one non-idle call
if ( numberOfNonIdleCallObjects == 1 )
{
singleCallGoingOn = ETrue;
}
//multicall situation
else
{
TBool confInUse( EFalse );
//if conference call object exists
if ( mmConference )
{
//if conference call is not in idle state
//or if CreateConference has been requested
if ( ( mmConference->Status() !=
RMobileConferenceCall::EConferenceIdle ) ||
mmConference->ServiceRequested(
CMmConferenceCallTsy::EMultimodeConferenceCallCreateConference ) )
{
//conference is going on, act according the situation
conferenceGoingOn = ETrue;
confInUse = ETrue;
}
}
//if conference call is not active
if ( !confInUse )
{
//conference call is not in use. There are 2 calls in different
//states.
twoCallsGoingOn = ETrue;
}
}
// Set Mobile Call Control + Core Caps
// Switch according to the call status
switch ( aCallStatus )
{
// Clear caps for idle status
case RMobileCall::EStatusIdle:
iMobileCallInfo.iValid = 0x00000000;
// Set Idle caps
iMobileCallCaps.iCallControlCaps |=
RCall::KCapsDial;
// Data call has also connect.
// Remove dataport caps.
if ( RMobilePhone::ECircuitDataService == iSymbianCallMode )
{
iMobileCallCaps.iCallControlCaps |=
RCall::KCapsConnect;
iMobileCallCaps.iCallControlCaps &= ~(
RCall::KCapsLoanDataPort |
RCall::KCapsRecoverDataPort );
}
// 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<RCall::TCallParamsPckg*>( 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<RMobileCall::TMobileCallParamsV1Pckg*>(
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<RMobileCall::TMobileCallParamsV2Pckg*>(
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<RMobileCall::TMobileCallParamsV7Pckg*>(
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<RMobileCall::TMobileCallParamsV1Pckg*>(
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<RMobileCall::TMobileDataCallParamsV1Pckg*>(
aParams );
RMobileCall::TMobileDataCallParamsV1& dataParams = ( *paramsPckgV1 )();
CopyMobileDataCallParams( dataParams, *iCSDParams );
}
if ( RMobileCall::KETelMobileDataCallParamsV2 == extensionId ||
RMobileCall::KETelMobileDataCallParamsV8 == extensionId)
{
RMobileCall::TMobileDataCallParamsV2Pckg* paramsPckgV2 =
reinterpret_cast<RMobileCall::TMobileDataCallParamsV2Pckg*>(
aParams );
RMobileCall::TMobileDataCallParamsV2& dataParams2 = ( *paramsPckgV2 )();
RMobileCall::TMobileDataCallParamsV2* dataCallParamsV2 = static_cast<RMobileCall::TMobileDataCallParamsV2*>(iCSDParams);
//Parameter of class TMobileDataCallParamsV2
dataParams2.iBearerMode = dataCallParamsV2->iBearerMode;
}
if ( RMobileCall::KETelMobileDataCallParamsV8 == extensionId )
{
RMobileCall::TMobileDataCallParamsV8Pckg* paramsPckgV8 =
reinterpret_cast<RMobileCall::TMobileDataCallParamsV8Pckg*>(
aParams );
RMobileCall::TMobileDataCallParamsV8& dataParams8 = ( *paramsPckgV8 )();
RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast<RMobileCall::TMobileDataCallParamsV8*>(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<RMobileCall::TMobileHscsdCallParamsV1Pckg*>(
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<RMobileCall::TMobileHscsdCallParamsV2Pckg*>(
aParams );
RMobileCall::TMobileHscsdCallParamsV2& hscsdParams2 =
( *paramsPckgV2 )();
//Parameter of class TMobileHscsdCallParamsV2
RMobileCall::TMobileHscsdCallParamsV2* hscsdCallParamsV2 = static_cast<RMobileCall::TMobileHscsdCallParamsV2*>(iHSCSDParams);
hscsdParams2.iBearerMode = hscsdCallParamsV2->iBearerMode;
}
if ( RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId ||
RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId)
{
RMobileCall::TMobileHscsdCallParamsV7Pckg* paramsPckgV7 =
reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV7Pckg*>(
aParams );
RMobileCall::TMobileHscsdCallParamsV7& hscsdParams7 =
( *paramsPckgV7 )();
RMobileCall::TMobileHscsdCallParamsV7* hscsdCallParamsV7 = static_cast<RMobileCall::TMobileHscsdCallParamsV7*>(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<RMobileCall::TMobileHscsdCallParamsV8Pckg*>(
aParams );
RMobileCall::TMobileHscsdCallParamsV8& hscsdParams8 =
( *paramsPckgV8 )();
RMobileCall::TMobileHscsdCallParamsV8* hscsdCallParamsV8 = static_cast<RMobileCall::TMobileHscsdCallParamsV8*>(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<CMmConferenceCallGsmWcdmaExt*>( 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<RMobileCall::TMobileCallDeflect*>( aData.Ptr1() );
RMobilePhone::TMobileAddress* destination =
reinterpret_cast<RMobilePhone::TMobileAddress*>( 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<RMobileCall::TMobileCallRemotePartyInfoV1Pckg*>( 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<RMobileCall::TMobileCallInfoV3*>(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<RMobileCall::TMobileCallInfoV7*>(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<RMobileCall::TMobileCallInfoV8*>(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<RMobilePhone::TMultimodeTypePckg*>(
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<RCall::TCallParamsPckg*>(
const_cast<TDesC8*>( 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<RMobileCall::TMobileDataCallParamsV1Pckg*>(
const_cast<TDesC8*>( 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<RMobileCall::TMobileDataCallParamsV2Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileDataCallParamsV2& dataParams2 = (*paramsPckgV2)();
RMobileCall::TMobileDataCallParamsV2* dataCallParamsV2 = static_cast<RMobileCall::TMobileDataCallParamsV2*>(iCSDParams);
dataCallParamsV2->iBearerMode = dataParams2.iBearerMode;
}
if ( RMobileCall::KETelMobileDataCallParamsV8 == dataParams.ExtensionId())
{
RMobileCall::TMobileDataCallParamsV8Pckg* paramsPckgV8 =
reinterpret_cast<RMobileCall::TMobileDataCallParamsV8Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileDataCallParamsV8& dataParams8 = (*paramsPckgV8)();
RMobileCall::TMobileDataCallParamsV8* dataCallParamsV8 = static_cast<RMobileCall::TMobileDataCallParamsV8*>(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<RMobileCall::TMobileHscsdCallParamsV1Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV1& hscsdParams =
(*paramsPckgV1)();
*(static_cast<RMobileCall::TMobileHscsdCallParamsV1*>(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<RMobileCall::TMobileHscsdCallParamsV2Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV2& hscsdParams2 =
(*paramsPckgV2)();
RMobileCall::TMobileHscsdCallParamsV2* hscsdCallParamsV2 = static_cast<RMobileCall::TMobileHscsdCallParamsV2*>(iHSCSDParams);
hscsdCallParamsV2->iBearerMode = hscsdParams2.iBearerMode;
}
if ( RMobileCall::KETelMobileHscsdCallParamsV7 == dataParams.ExtensionId() ||
RMobileCall::KETelMobileHscsdCallParamsV8 == dataParams.ExtensionId())
{
RMobileCall::TMobileHscsdCallParamsV7Pckg* paramsPckgV7 =
reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV7Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV7& hscsdParams7 =
(*paramsPckgV7)();
RMobileCall::TMobileHscsdCallParamsV7* hscsdCallParamsV7 = static_cast<RMobileCall::TMobileHscsdCallParamsV7*>(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<RMobileCall::TMobileHscsdCallParamsV8Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV8& hscsdParams8 =
(*paramsPckgV8)();
RMobileCall::TMobileHscsdCallParamsV8* hscsdCallParamsV8 = static_cast<RMobileCall::TMobileHscsdCallParamsV8*>(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<RMobileCall::TMobileDataCallParamsV1> pckgToSend(*iCSDParams);
package.PackData( &pckgToSend , &iMobileCallInfo );
}
else
{
//Pack call parameters and mobile call info
package.PackData( const_cast<TDesC8*>( 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<RMobileCall::TMobileDataCallParamsV1Pckg*>(
const_cast<TDesC8*>( 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<RMobileCall::TMobileDataCallParamsV2*>(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<RMobileCall::TMobileDataCallParamsV8*>(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<RMobileCall::TMobileHscsdCallParamsV1Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV1& hscsDataParams =
( *hscsdParamsPckgV1 )();
*(static_cast<RMobileCall::TMobileHscsdCallParamsV1*>(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<RMobileCall::TMobileHscsdCallParamsV2Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV2& hscsDataParams2 =
( *hscsdParamsPckgV2 )();
*(static_cast<RMobileCall::TMobileHscsdCallParamsV2*>(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<RMobileCall::TMobileHscsdCallParamsV7Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
RMobileCall::TMobileHscsdCallParamsV7& hscsDataParams7 =
( *hscsdParamsPckgV7)();
*(static_cast<RMobileCall::TMobileHscsdCallParamsV7*>(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<RMobileCall::TMobileHscsdCallParamsV8Pckg*>(
const_cast<TDesC8*>( 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<RCall::TCallParamsPckg*>( callParamsDes );
RCall::TCallParams& callParams = ( *callParamsPckg )();
TInt extensionId( callParams.ExtensionId() );
if ( iCSDParams &&
(( RMobileCall::KETelMobileDataCallParamsV1 == extensionId) ||
( RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId )))
{
RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 =
reinterpret_cast<RMobileCall::TMobileDataCallParamsV1Pckg*>(
callParamsDes );
RMobileCall::TMobileDataCallParamsV1& dataParams = ( *paramsPckgV1 )();
// Save all the CSD parameters here
*(static_cast<RMobileCall::TMobileDataCallParamsV1*>(iCSDParams)) = dataParams;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( iMmCallTsy )->
CompleteNotifyMobileDataCallCapsChange();
}
if ( iCSDParams && ( RMobileCall::KETelMobileDataCallParamsV2 == extensionId))
{
RMobileCall::TMobileDataCallParamsV2Pckg* paramsPckgV2 =
reinterpret_cast<RMobileCall::TMobileDataCallParamsV2Pckg*>(
callParamsDes );
RMobileCall::TMobileDataCallParamsV2& dataParams2 = ( *paramsPckgV2 )();
// Save all the CSD parameters here
*(static_cast<RMobileCall::TMobileDataCallParamsV2*>(iCSDParams)) = dataParams2;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( iMmCallTsy )->
CompleteNotifyMobileDataCallCapsChange();
}
if ( iCSDParams &&( RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
{
RMobileCall::TMobileDataCallParamsV8Pckg* paramsPckgV8 =
reinterpret_cast<RMobileCall::TMobileDataCallParamsV8Pckg*>(
callParamsDes );
RMobileCall::TMobileDataCallParamsV8& dataParams8 = ( *paramsPckgV8)();
// Save all the CSD parameters here
*iCSDParams = dataParams8;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( iMmCallTsy )->
CompleteNotifyMobileDataCallCapsChange();
}
if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId ) )
{
RMobileCall::TMobileHscsdCallParamsV1Pckg* hscsdParamsPckgV1 =
reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV1Pckg*>(
callParamsDes );
RMobileCall::TMobileHscsdCallParamsV1& hscsdDataParams = ( *hscsdParamsPckgV1 )();
// Save all the CSD parameters here
*(static_cast<RMobileCall::TMobileHscsdCallParamsV1*>(iHSCSDParams)) = hscsdDataParams;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( iMmCallTsy )->
CompleteNotifyMobileDataCallCapsChange();
}
if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId ) )
{
RMobileCall::TMobileHscsdCallParamsV2Pckg* hscsdParamsPckgV2 =
reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV2Pckg*>(
callParamsDes );
RMobileCall::TMobileHscsdCallParamsV2& hscsdDataParams2 = ( *hscsdParamsPckgV2 )();
// Save all the CSD parameters here
*(static_cast<RMobileCall::TMobileHscsdCallParamsV2*>(iHSCSDParams)) = hscsdDataParams2;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( iMmCallTsy )->
CompleteNotifyMobileDataCallCapsChange();
}
if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId ) )
{
RMobileCall::TMobileHscsdCallParamsV7Pckg* hscsdParamsPckgV7 =
reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV7Pckg*>(
callParamsDes );
RMobileCall::TMobileHscsdCallParamsV7& hscsdDataParams7 = ( *hscsdParamsPckgV7 )();
// Save all the CSD parameters here
*(static_cast<RMobileCall::TMobileHscsdCallParamsV7*>(iHSCSDParams)) = hscsdDataParams7;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( iMmCallTsy )->
CompleteNotifyMobileDataCallCapsChange();
}
if ( iHSCSDParams && (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId ) )
{
RMobileCall::TMobileHscsdCallParamsV8Pckg* hscsdParamsPckgV8 =
reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV8Pckg*>(
callParamsDes );
RMobileCall::TMobileHscsdCallParamsV8& hscsdDataParams8 = ( *hscsdParamsPckgV8 )();
// Save all the CSD parameters here
*iHSCSDParams = hscsdDataParams8;
// Update data call caps
SetDataCaps( callParamsDes );
reinterpret_cast<CMmDataCallTsy*>( 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<RMobileCall::TMobileDataCallParamsV1Pckg*>(
const_cast<TDesC8*>( 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<CMmDataCallTsy*>( 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<CMmDataCallTsy*>( 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<CMmDataCallTsy*>( 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