// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
// INCLUDE FILES
#include "cmmvoicecalltsy.h"
#include <featmgr/featurecontrol.h>
#include <featureuids.h>
#include "cmmvoicelinetsy.h"
#include "cmmphonetsy.h"
#include "cmmtsyreqhandlestore.h"
#include "cmmcalllist.h"
#include "CMmCommonStaticUtility.h"
#include "MmTsy_numberOfSlots.h"
#include "MmTsy_timeoutdefs.h"
#include "cmmmessagemanagerbase.h"
#include <ctsy/pluginapi/cmmdatapackage.h>
#include <ctsy/serviceapi/gsmerror.h>
#include "cmmcallgsmwcdmaext.h"
#include "cmmdtmftsy.h"
#include "cmmconferencecalltsy.h"
#include "CMmCustomTsy.h"
#include "cmmconferencecallgsmwcdmaext.h"
#include <etelmmerr.h>
#include <ctsy/pluginapi/mtelephonyaudiocontrol.h>
// ======== MEMBER FUNCTIONS ========
CMmVoiceCallTsy::CMmVoiceCallTsy()
{
}
CMmVoiceCallTsy* CMmVoiceCallTsy::NewL(
CMmPhoneTsy* aMmPhone, CMmVoiceLineTsy* aMmLine,
RMobilePhone::TMobileService aMode,
TDes& aName,
CMmMessageManagerBase* aMessageManager,
MTelephonyAudioControl* aTelephonyAudioControl )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::NewL. Call name: %S", &aName);
CMmVoiceCallTsy* mmCall = NULL;
//check input parameters
if ( aMmPhone != NULL && aMmLine != NULL && (
aMode == RMobilePhone::EVoiceService ||
aMode == RMobilePhone::EAuxVoiceService ) )
{
mmCall = new( ELeave ) CMmVoiceCallTsy;
CleanupClosePushL( *mmCall );
mmCall->iMmPhone = aMmPhone;
mmCall->iMmLine = aMmLine;
mmCall->iCallName = aName;
mmCall->iCallMode = aMode;
mmCall->iMessageManager = aMessageManager;
mmCall->iTelephonyAudioControl = aTelephonyAudioControl;
mmCall->iTelephonyAudioControlSetup = EFalse;
mmCall->ConstructL( aMode );
CleanupStack::Pop();
}
return mmCall;
}
CMmVoiceCallTsy::~CMmVoiceCallTsy()
{
TFLOGSTRING3("TSY: CMmVoiceCallTsy::~CMmVoiceCallTsy. Call deleted iCallId:%d iCallName:%S", iCallId, &iCallName);
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::InitInternalAttributes
// Initialises miscellaneous internal attributes.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::InitInternalAttributes()
{
//initialise internal attributes of base class
CMmCallTsy::InitInternalAttributes();
//set call capabilities
iCallCaps.iFlags = RCall::KCapsVoice | RCall::KCapsDial;
//not yet an emergency call
iEmergencyCall = EFalse;
i3rdPartyEmergencyNumberCheckDone = EFalse;
iISVCallParams = NULL;
iIsDialISV = EFalse;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::DoExtFuncL
// DoExtFuncL is called by the Etel server when it has an "extended", i.e.
// non-core ETel request for the TSY. To process a request handle, request
// type and request data are passed to the TSY.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::DoExtFuncL(
const TTsyReqHandle aTsyReqHandle,
const TInt aIpc,
const TDataPackage& aPackage )
{
TFLOGSTRING3("TSY: CMmVoiceCallTsy::DoExtFuncL. IPC:%d Handle:%d", aIpc, aTsyReqHandle);
TInt ret( KErrNone );
TAny* dataPtr = aPackage.Ptr1();
// The request data has to extracted from TDataPackage and the TAny*
// pointers have to be "cast" to the expected request data type
// NOTE! Do not put any Cancel methods here.
switch ( aIpc )
{
// Emergency Calls
// Dial Emergency Call
case EMobileCallDialEmergencyCall:
ret = DialEmergencyCall( aTsyReqHandle, aPackage );
break;
// Call Status
// Get Call Status
case EMobileCallGetMobileCallStatus:
ret = GetMobileCallStatus( aTsyReqHandle,
reinterpret_cast<RMobileCall::TMobileCallStatus*>( dataPtr ) );
break;
// Notify Call Status Change
case EMobileCallNotifyMobileCallStatusChange:
ret = NotifyMobileCallStatusChange(
reinterpret_cast<RMobileCall::TMobileCallStatus*>( dataPtr ) );
break;
// Place Call on Hold
case EMobileCallHold:
ret = HoldL( aTsyReqHandle );
break;
// Resume a Held Call
case EMobileCallResume:
ret = ResumeL( aTsyReqHandle );
break;
// Swap Between an On-going and an Held Call
case EMobileCallSwap:
ret = SwapL( aTsyReqHandle );
break;
// Transfer One Call to Remote Party of Another Call
case EMobileCallTransfer:
ret = TransferL( aTsyReqHandle );
break;
// Go "One-to-One" within a Conference Call
case EMobileCallGoOneToOne:
ret = GoOneToOneL( aTsyReqHandle );
break;
// Notify Call Event
case EMobileCallNotifyCallEvent:
ret = NotifyCallEvent(
reinterpret_cast<RMobileCall::TMobileCallEvent*>( dataPtr ) );
break;
// Call Control
// Get Call Capabilities
case EMobileCallGetMobileCallCaps:
ret = GetMobileCallCaps( aTsyReqHandle, aPackage.Des1n() );
break;
//Notify Call Capabilities Change
case EMobileCallNotifyMobileCallCapsChange:
ret = NotifyMobileCallCapsChange(aPackage.Des1n() );
break;
// Call Information
// Get Mobile Call Information
case EMobileCallGetMobileCallInfo:
ret = GetMobileCallInfo( aTsyReqHandle, aPackage.Des1n() );
break;
// Notify Change of Remote Party Information
case EMobileCallNotifyRemotePartyInfoChange:
ret = NotifyRemotePartyInfoChange(
reinterpret_cast<
RMobileCall::TMobileCallRemotePartyInfoV1Pckg*>(
aPackage.Des1n()) );
break;
// Order to notify if privacy is confirmed
case EMobileCallNotifyPrivacyConfirmation:
ret = NotifyPrivacyConfirmation(
reinterpret_cast<RMobilePhone::TMobilePhonePrivacy*>(
dataPtr ) );
break;
//AnswerIncomingCall ( by 3rd Party client )
case EMobileCallAnswerISV:
ret = AnswerIncomingCall( aTsyReqHandle, aPackage.Des1n() );
break;
//Dial a call ( by 3rd Party client )
case EMobileCallDialISV:
i3rdPartyEmergencyNumberCheckDone = EFalse;
iIsDialISV = ETrue;
ret = Dial( aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u() );
break;
// Activate User-To-User Signalling service
case EMobileCallActivateUUS:
ret = ActivateUUS( aTsyReqHandle,
REINTERPRET_CAST( RMobileCall::TMobileCallUUSRequestV1Pckg*,
aPackage.Des1n()) );
break;
// Receive User-To-User Information, TDes16 descriptor pointer
case EMobileCallReceiveUUI:
ret = ReceiveUUI( aTsyReqHandle,
REINTERPRET_CAST( RMobileCall::TMobileCallUUI*,
aPackage.Des1u() ) );
break;
// Dial a call ( DialNoFdnCheck )
case EMobileCallDialNoFdnCheck:
ret = DialNoFdnCheck( aTsyReqHandle, aPackage.Des1n(),
aPackage.Des2u() );
break;
// Unsupported features
case EMobileCallGetMobileDataCallCaps:
case EMobileCallNotifyMobileDataCallCapsChange:
case EMobileCallGetMobileDataCallRLPRange:
case EMobileCallSetDynamicHscsdParams:
case EMobileCallGetCurrentHscsdInfo:
case EMobileCallNotifyHscsdInfoChange:
case EMobileCallSwitchAlternatingCall:
case EMobileCallNotifyAlternatingCallSwitch:
case EMobileCallSetPrivacy:
case EMobileCallSetTrafficChannel:
case EMobileCallNotifyTrafficChannelConfirmation:
case EMobileCallGetUUSCaps:
case EMobileCallNotifyUUSCapsChange:
case EMobileCallSendUUI:
case EMobileCallHangupWithUUI:
case EMobileCallAnswerWithUUI:
case EMobileCallNotifyVoiceFallback:
case EMobileCallDeflect:
case EMobileCallActivateCCBS:
case EMobileCallRejectCCBS:
default:
ret = KErrNotSupported;
break;
}
return ret;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::ReqModeL
// ReqModeL is called from the ETel server's CTelObject::ReqAnalyserL in order
// to check the type of request it has.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
CTelObject::TReqMode CMmVoiceCallTsy::ReqModeL(
const TInt aIpc )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::ReqModeL. IPC:%d",aIpc);
CTelObject::TReqMode ret( 0 ); // default return value
switch ( aIpc )
{
// No Flow Control
// All disabled
// TSYs wishing to implement their own buffering algorithm will
// place all requests in this category.
// Get methods that do not use DOS and return immediately.
// Flow control not required.
case EEtelCallGetInfo:
case EEtelCallGetStatus:
case EEtelCallGetCaps:
case EEtelCallGetBearerServiceInfo:
case EEtelCallGetOwnershipStatus:
case EEtelCallGetCallParams:
case EEtelCallGetCallDuration:
case EEtelCallGetFaxSettings:
case EMobileCallGetMobileCallStatus:
case EMobileCallGetMobileCallInfo:
case EMobileCallGetMobileDataCallCaps:
case EMobileCallGetMobileCallCaps:
case EMobileCallGetCurrentHscsdInfo:
case EMobileCallGetMobileDataCallRLPRange:
case EMobileCallGetUUSCaps:
case EMobileCallSendUUI:
case EMobileCallHangupWithUUI:
case EMobileCallAnswerWithUUI:
//Other methods that do not use DOS and return immediately.
//Flow control not required.
case EEtelCallAcquireOwnership:
case EEtelCallTransferOwnership:
case EEtelCallSetFaxSettings:
//Methods that can propably take a long time and cannot therefore be
//flow controlled. Solution: All these methods must check req handle
//table before handling the request. In case that the request table
//indicates that same method has been called and has not been
//completed, the method should return KErrServerBusy.
case EMobileCallTransfer:
//This is also included here due to the fact that Emergency call
//should never be blocked by flow control. KErrServerBusy returned
//when already already dialing.
case EMobileCallDialEmergencyCall:
//HangUp cannot be flow controlled. Client should for example be able
//to terminate a call while another call is e.g. in Dialling state.
case EEtelCallHangUp:
//Answer was mixed with Hangup.
//Therefore this is also No flow control type.
case EEtelCallAnswer:
case EMobileCallAnswerISV:
// dial is not flow controlled as compeltion may take a while and that
// blocks for example PS data activation in 3G while dialing.
case EEtelCallDial:
break;
// Flow Controlled Services
// KReqModeFlowControlObeyed
// Commands that change the state of the phone, e.g. clearing the
// AoC counter; are commands that the TSY should only deal with
// one at a time.
//Voice call related methods that should be handled one at the time.
case EEtelCallConnect:
case EMobileCallHold:
case EMobileCallResume:
case EMobileCallSwap:
case EMobileCallDeflect:
case EMobileCallGoOneToOne:
case EMobileCallActivateUUS:
//Data call related methods that should be handled one at the time.
case EEtelCallLoanDataPort:
case EEtelCallRecoverDataPort:
case EMobileCallSwitchAlternatingCall:
case EMobileCallSetDynamicHscsdParams:
case EMobileCallSetPrivacy:
case EMobileCallSetTrafficChannel:
case EMobileCallDialISV:
case EMobileCallDialNoFdnCheck:
ret = KReqModeFlowControlObeyed;
break;
//ReqModePostImmediately
//Requests that notify a client about a change of state, where
//the TSY needs to distinguish between different clients.
//ret = KReqModeRePostImmediately;
//KReqModeMultipleCompletionEnabled
//(a) commands that may take some time, but which the TSY can
// handle more than one of concurrently, or
//(b) notifications that the TSY does not wish to be re-posted
// immediately, so the server does no buffering.
//ret = KReqModeMultipleCompletionEnabled;
//KReqModeMultipleCompletionEnabled | KReqModeFlowControlObeyed
//A command that may take some time and which the TSY can only
//deal with one at a time.
//ret = KReqModeMultipleCompletionEnabled |
// KReqModeFlowControlObeyed;
//break;
//Notifications
//KReqModeMultipleCompletionEnabled | ReqModePostImmediately
//Requests that notify a client about a change of state.
//Since these requests do not require the issuing of any modem
//commands, they do not have to obey flow control.
//The TSY never gets more than one of these outstanding per CTelObject
case EEtelCallNotifyHookChange:
case EEtelCallNotifyStatusChange:
case EEtelCallNotifyDurationChange:
case EEtelCallCapsChangeNotification:
case EMobileCallNotifyCallEvent:
case EMobileCallNotifyMobileCallStatusChange:
case EMobileCallNotifyRemotePartyInfoChange:
case EMobileCallNotifyPrivacyConfirmation:
case EMobileCallNotifyTrafficChannelConfirmation:
case EMobileCallNotifyHscsdInfoChange:
case EMobileCallNotifyMobileDataCallCapsChange:
case EMobileCallNotifyAlternatingCallSwitch:
case EMobileCallNotifyMobileCallCapsChange:
case EMobileCallNotifyVoiceFallback:
case EMobileCallNotifyUUSCapsChange:
case EMobileCallReceiveUUI:
ret = KReqModeMultipleCompletionEnabled |
KReqModeRePostImmediately;
break;
// Cancel Requests
// It is not necessary to include the Cancel methods in ReqModeL.
// The ETel server never calls ReqModeL with a Cancel IPC.
// Other variations of return values are unusable
// Default: Call CCallBase's ReqModeL.
default:
//Direct the request to the CCallBase
ret = CCallBase::ReqModeL( aIpc );
break;
}
return ret;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::NumberOfSlotsL
// NumberOfSlotsL is called by the server when it is registering a new
// NOTIFICATION. It enables the TSY to tell the server how many buffer slots
// to allocate for "repost immediately" notifications that may trigger before
// clients collect them.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::NumberOfSlotsL(
const TInt aIpc )
{
// There is a buffer in the ETel server for each type of NOTIFICATION and
// the size of the buffer is determined by the TSY. When the ETel server
// discovers that a request is "repost immediately" it will ask the TSY
// how big a buffer it wants by calling CTelObject::NumberOfSlotsL( ).
//
// It is up to the TSY developer's judgement how many buffer slots this
// method returns for each notification. If there is a danger that a
// particular notification could trigger frequently and in rapid
// succession (e.g. call group change notification) then at least 10 or
// 20 slots may be required. For a notification that triggers rarely,
// perhaps 1 or 2 slots is enough.
//
// So if the ETel server has stored a few occurrences of a particular
// notification, when a client subsequently calls that notification
// request, the ETel server will complete the client's request with
// the saved data.
TInt numberOfSlots( 1 );
switch ( aIpc )
{
case EEtelCallNotifyHookChange:
numberOfSlots = KMmCallHookChangeSlots;
break;
case EEtelCallNotifyStatusChange:
numberOfSlots = KMmCallStatusChangeSlots;
break;
case EEtelCallNotifyDurationChange:
numberOfSlots = KMmCallDurationChangeSlots;
break;
case EEtelCallCapsChangeNotification:
numberOfSlots = KMmCallCapsChangeSlots;
break;
case EMobileCallNotifyCallEvent:
numberOfSlots = KMmCallCallEventSlots;
break;
case EMobileCallNotifyMobileCallStatusChange:
numberOfSlots = KMmCallMobileCallStatusChangeSlots;
break;
case EMobileCallNotifyRemotePartyInfoChange:
numberOfSlots = KMmCallRemotePartyInfoChangeSlots;
break;
case EMobileCallNotifyPrivacyConfirmation:
numberOfSlots = KMmCallPrivacyConfirmationSlots;
break;
case EMobileCallNotifyTrafficChannelConfirmation:
numberOfSlots = KMmCallTrafficChannelConfirmationSlots;
break;
case EMobileCallNotifyHscsdInfoChange:
numberOfSlots = KMmCallHscsdInfoChangeSlots;
break;
case EMobileCallNotifyMobileDataCallCapsChange:
numberOfSlots = KMmCallMobileDataCallCapsChangeSlots;
break;
case EMobileCallNotifyAlternatingCallSwitch:
numberOfSlots = KMmCallAlternatingCallSwitchSlots;
break;
case EMobileCallNotifyMobileCallCapsChange:
numberOfSlots = KMmCallMobileCallCapsChangeSlots;
break;
case EMobileCallNotifyVoiceFallback:
numberOfSlots = KMmCallVoiceFallbackSlots;
break;
case EMobileCallNotifyUUSCapsChange:
numberOfSlots = KMmCallUUSCapsChangeSlots;
break;
case EMobileCallReceiveUUI:
numberOfSlots = KMmCallReceiveUUISlots;
break;
default:
// Unknown or invalid Call IPC
User::Leave( KErrNotSupported );
break;
}
return numberOfSlots;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CancelService
// CancelService is called by the ETel server when it is "cleaning-up" any
// still outstanding asynchronous requests before closing a client's
// sub-session. This will happen if a client closes its R-class handle without
// cancelling outstanding asynchronous requests. Only Mobile API requests are
// handled here.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::CancelService(
const TInt aIpc,
const TTsyReqHandle aTsyReqHandle )
{
TFLOGSTRING3("TSY: CMmVoiceCallTsy::CancelService. IPC: %d, Req handle: %d", aIpc, aTsyReqHandle);
TInt ret( KErrNone );
//When the clients close their sub-sessions (eg. by calling RPhone::Close)
//they may not have cancelled all their outstanding asynchronous requests
//before closing. It is up to the ETel server to clean up in this
//situation, so the server will find the list of outstanding requests
//related to that sub-session object and pass these outstanding IPC
//request numbers,one at a time,to the CancelService function in the TSY.
switch ( aIpc )
{
//TSY has started a request and it is not possible to then cancel this
//request. The best thing for the TSY to do in this case is to proceed
//as though the Cancel never happened. The server's call to the TSY
//cancel function will return synchronously. The TSY then continues to
//wait for the original acknowledgement and when it receives it,
//the TSY will complete the original request.
case EMobileCallHold:
case EMobileCallResume:
case EMobileCallSwap:
case EMobileCallGoOneToOne:
case EMobileCallDeflect:
case EMobileCallTransfer:
case EMobileCallNotifyTrafficChannelConfirmation:
break;
//Cancel methods that are not supported
case EMobileCallSetDynamicHscsdParams:
case EMobileCallNotifyMobileDataCallCapsChange:
case EMobileCallNotifyHscsdInfoChange:
case EMobileCallSwitchAlternatingCall:
case EMobileCallNotifyAlternatingCallSwitch:
case EMobileCallGetMobileDataCallRLPRange:
case EMobileCallNotifyVoiceFallback:
case EMobileCallNotifyUUSCapsChange:
case EMobileCallActivateUUS:
case EMobileCallSendUUI:
case EMobileCallHangupWithUUI:
case EMobileCallAnswerWithUUI:
ret = KErrNotSupported;
break;
//Notification Cancels, no special requirements.
case EMobileCallNotifyMobileCallCapsChange:
ret = NotifyMobileCallCapsChangeCancel( aTsyReqHandle );
break;
case EMobileCallNotifyMobileCallStatusChange:
ret = NotifyMobileCallStatusChangeCancel( aTsyReqHandle );
break;
case EMobileCallNotifyCallEvent:
ret = NotifyCallEventCancel( aTsyReqHandle );
break;
case EMobileCallNotifyRemotePartyInfoChange:
ret = NotifyRemotePartyInfoChangeCancel( aTsyReqHandle );
break;
case EMobileCallNotifyPrivacyConfirmation:
ret = NotifyPrivacyConfirmationCancel( aTsyReqHandle );
break;
case EMobileCallReceiveUUI:
ret = ReceiveUUICancel( aTsyReqHandle );
break;
//Everything is taken care in the method implementation.
//Just direct the request to the method.
case EMobileCallDialEmergencyCall:
ret = DialEmergencyCallCancel( aTsyReqHandle );
break;
case EMobileCallDialISV:
iMmPhone->GetCustomTsy()->SetObjectForISVDialNumberCheck( NULL );
i3rdPartyEmergencyNumberCheckDone = EFalse;
ret = DialCancel( aTsyReqHandle );
break;
case EMobileCallDialNoFdnCheck:
ret = DialCancel( aTsyReqHandle );
break;
case EMobileCallAnswerISV:
ret = AnswerIncomingCallCancel( aTsyReqHandle );
break;
//Default case
default:
//call CCallBase
ret = CCallBase::CancelService( aIpc, aTsyReqHandle );
break;
}
return ret;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteNotifyStatusChange
// Complete notification when status changes. If the new status requires,
// this method will ask call protocol extension to update it's status and
// capabilities and line owning this call to update it's status.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteNotifyStatusChange(
TInt aResult,
CMmDataPackage* aDataPackage )
{
if ( iGhostCall )
{
HandleGhostCallStatusChange( aResult, aDataPackage );
}
else
{
TInt callId( -1 );
TInt callIndex( 0 );
TInt extendedError(
CMmCommonStaticUtility::ExtendedErrorCode( aResult) );
TInt ret( KErrNone );
TBool timerStarted( EFalse );
TBool statusChanged ( EFalse );
TBool mobileStatusChanged ( EFalse );
CMmVoiceCallTsy* mmCall = NULL;
RMobileCall::TMobileCallStatus callStatus( RMobileCall::EStatusIdle );
RMobilePhone::TMobileService callMode( RMobilePhone::EVoiceService );
CCallDataPackage* callDataPackage =
reinterpret_cast<CCallDataPackage*>(aDataPackage);
callDataPackage->GetCallIdAndMode( callId, callMode );
callDataPackage->UnPackData( callStatus );
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. aResult:%d", aResult );
TFLOGSTRING3("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. Call status:%d Call name:%S", callStatus, &iCallName);
TTsyReqHandle holdHandle =
iTsyReqHandleStore->GetTsyReqHandle( EMultimodeMobileCallHold );
TTsyReqHandle resumeHandle =
iTsyReqHandleStore->GetTsyReqHandle( EMultimodeMobileCallResume );
TTsyReqHandle swapHandle =
iTsyReqHandleStore->GetTsyReqHandle( EMultimodeMobileCallSwap );
TBool localSwapRequested =
IsServiceLocallyRequested( EMultimodeMobileCallSwap );
switch( callStatus )
{
case RMobileCall::EStatusIdle:
{
RFeatureControl featureControl;
TInt err = featureControl.Open();
if ( (err == KErrNone) && (featureControl.FeatureSupported(NFeature::KEmergencyCallsEnabledInOfflineMode) == KFeatureSupported) && EEmergencyCallMade == iMmPhone->GetRfStatus())
{
CMmCallList* callList = iMmPhone->CallList();
TInt numberOfEmergencyCalls( 0 );
for( TInt i=0; i< callList->GetNumberOfObjects();i++)
{
CMmVoiceCallTsy* call =
reinterpret_cast<CMmVoiceCallTsy*>(
iMmPhone->CallList()->GetMmCallByIndex( i ) );
if( call->IsEmergencyCall() )
{
numberOfEmergencyCalls++;
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. numberOfEmergencyCalls:%d", numberOfEmergencyCalls );
}
}
// There might be another emergency call Dial started and
// iEmergencyCall flag is updated to false in
// CompleteHangUp, thus only if there is one emergency call
// flag indicating ETrue, RF's should be set off.
if( 1 == numberOfEmergencyCalls )
{
TCtsySsmCallbackData dummyData;
reinterpret_cast<CMmCallGsmWcdmaExt*>
( iMmCallExtInterface )->SetRfState(ERfsStateInfoInactive,
reinterpret_cast<CMmCallGsmWcdmaExt*>( iMmCallExtInterface ),
dummyData);
//set the rf status in phone
iMmPhone->SetRfStatus( ERfsInActive );
}
}
//reset caps.
iCallCaps.iFlags &= ~(
RCall::KCapsHangUp | RCall::KCapsAnswer );
iCallCaps.iFlags |= RCall::KCapsDial;
//stop the call duration timer
timerStarted = iCallTimer->Stop();
//Check air time timer only if call was in active state
//(call timer was started)
if ( timerStarted )
{
iMmPhone->AirTimeTimerCheckStop();
UpdateLifeTimer();
}
if ( iTelephonyAudioControl && iTelephonyAudioControlSetup )
{
//Inform call routing control if there were error or cancelling in dial
if ( RMobileCall::EStatusDialling == iMobileCallStatus )
{
iTelephonyAudioControl->CallStateChange(
iCallName, RMobileCall::EStatusDisconnecting );
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. Call routing state changed to EStatusDisconnecting: Call name:%S", &iCallName );
}
iTelephonyAudioControl->TeardownTelephonyAudio(
iCallName, aResult );
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. Call routing teared down: Call name:%S", &iCallName);
iTelephonyAudioControlSetup = EFalse;
}
iCallStatus = RCall::EStatusIdle;
iMobileCallStatus = RMobileCall::EStatusIdle;
ClearCallStatus();
statusChanged = ETrue;
if ( KErrNone != aResult )
{
if ( KErrGsmReleaseByUser == aResult ||
KErrGsmBusyUserRequest == aResult )
{
//aResult must be KErrNone to indicate the client that
//HangUp has successfully completed
CompleteHangUp( KErrNone );
CompleteAnswerIncomingCall( KErrGsmBusyUserRequest );
}
else
{
//set last exit code
iLastExitCode = aResult;
CompleteHangUp( aResult );
CompleteAnswerIncomingCall( aResult );
}
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - CompleteDial's called");
CompleteDial( aResult );
CompleteDialNoFdn( aResult );
CompleteDialEmergencyCall( aResult );
}
// Try to complete Dial and HangUp; If completes happens from
// here, something has gone wrong. Done to prevent TSY from
// hanging.
else
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - Try to complete Dial and HangUp");
iLastExitCode = KErrGeneral;
TInt errorValue = CMmCommonStaticUtility::EpocErrorCode(
KErrNotReady, KErrNotFound );
CompleteDial( errorValue );
CompleteDialNoFdn( errorValue );
CompleteDialEmergencyCall( errorValue );
CompleteHangUp( errorValue );
CompleteAnswerIncomingCall( errorValue );
}
//save last id. Required by Conference call implementation
SetPreviousCallId( iCallId );
//reset call id
iCallId = -1;
//update DTMF capabilities.
iMmPhone->GetDtmfTsy()->CompleteNotifyDTMFCaps();
//Check if call capability KCapsHangup still exists
//If it does, remove it and return the KCapsDial capability.
//If call mode is data, then return also KCapsConnect
//capability
if ( RCall::KCapsHangUp ==
( iCallCaps.iFlags & RCall::KCapsHangUp ) )
{
// Remove KCapsHangUp if it exists
iCallCaps.iFlags &= ~( RCall::KCapsHangUp );
// return the KCapsDial capability.
iCallCaps.iFlags |= RCall::KCapsDial;
CompleteNotifyCapsChange();
}
//Call Transfer handling
if ( ServiceRequested( EMultimodeCallTransfer ) )
{
//Complete Transfer
CompleteTransfer( KErrNone );
}
}
break;
//End of case KCallStatusIdle
case RMobileCall::EStatusDialling:
#ifdef REQHANDLE_TIMER
if ( KETelExt3rdPartyV1 != GetExtensionId() )
{
//non 3rd party client
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - StopTimeOuts");
iTsyReqHandleStore->StopTimeout( EMultimodeCallDial );
iTsyReqHandleStore->StopTimeout(
EMultimodeMobileCallDialEmergencyCall );
iTsyReqHandleStore->StopTimeout(
EMultimodeCallDialNoFdnCheck );
}
else
{
//3rd party client
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - StopTimeOut EMultimodeCallDialISV");
iTsyReqHandleStore->StopTimeout( EMultimodeCallDialISV );
}
#endif // REQHANDLE_TIMER
iCallStatus = RCall::EStatusDialling;
iMobileCallStatus = RMobileCall::EStatusDialling;
statusChanged = ETrue;
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
if ( iDialCancelFlag != CMmCallTsy::EDialCancelNotCalled )
{
TTsyReqHandle dialCancelHandle =
iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDial );
TTsyReqHandle dialEmergCancelHandle =
iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeMobileCallDialEmergencyCall );
// 3rd party client
TTsyReqHandle dialCancelHandleISV =
iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDialISV );
// DialNoFdnCheck
TTsyReqHandle dialCancelHandleNoFdn =
iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDialNoFdnCheck );
if ( 0 < dialCancelHandle )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - HangUp - EMultimodeCallDial");
HangUp( dialCancelHandle );
}
else if ( 0 < dialCancelHandleISV )
{
//3rd party client
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - HangUp - EMultimodeCallDialISV");
HangUp( dialCancelHandleISV );
}
else if ( 0 < dialEmergCancelHandle )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - HangUp - EMultimodeMobileCallDialEmergencyCall");
HangUp( dialEmergCancelHandle );
}
else if ( 0 < dialCancelHandleNoFdn )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - HangUp - EMultimodeCallDialNoFdn");
HangUp( dialCancelHandleNoFdn );
}
else
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - iDialCancelFlag = CMmCallTsy::EDialCancelNotCalled");
iDialCancelFlag = CMmCallTsy::EDialCancelNotCalled;
}
}
break;
case RMobileCall::EStatusConnecting:
iCallStatus = RCall::EStatusConnecting;
iMobileCallStatus = RMobileCall::EStatusConnecting;
statusChanged = ETrue;
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
break;
case RMobileCall::EStatusRinging:
iCallStatus = RCall::EStatusRinging;
iMobileCallStatus = RMobileCall::EStatusRinging;
statusChanged = ETrue;
break;
case RMobileCall::EStatusAnswering:
iCallStatus = RCall::EStatusAnswering;
iMobileCallStatus = RMobileCall::EStatusAnswering;
statusChanged = ETrue;
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
break;
case RMobileCall::EStatusConnected:
if ( KErrMMEtelCallForbidden == aResult )
{
CMmCallList* callList = iMmPhone->CallList();
for( TInt i=0; i< callList->GetNumberOfObjects();i++)
{
CMmVoiceCallTsy* call =
reinterpret_cast<CMmVoiceCallTsy*>(
iMmPhone->CallList()->GetMmCallByIndex( i ) );
// if there is call with status Answering, complete
// it with CALL_CAUSE_NOT_ALLOWED
if( RCall::EStatusAnswering == call->Status() )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange Answering not allowed!");
TInt errorValue =
CMmCommonStaticUtility::EpocErrorCode(
KErrAccessDenied, KErrMMEtelCallForbidden );
call->CompleteAnswerIncomingCall( errorValue );
}
}
}
//check previous status. If status is answering
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. - EStatusConnected");
if ( RCall::EStatusAnswering == iCallStatus )
{
// don't start timers if error occurred
if ( KErrNone == aResult )
{
//Start call duration monitoring
iCallTimer->Start();
//Check if start the air time duration monitoring
iMmPhone->AirTimeTimerCheckStart();
}
//complete answer incoming call
CompleteAnswerIncomingCall( aResult );
}
//if it was connecting and dial cancel has not been activated
else if ( ( iCallStatus == RCall::EStatusConnecting ||
iCallStatus == RCall::EStatusDialling ) &&
CMmCallTsy::EDialCancelNotCalled == iDialCancelFlag )
{
//Start call duration monitoring
iCallTimer->Start();
//start air time duration monitoring
iMmPhone->AirTimeTimerCheckStart();
//if emergency call has been made, complete it
if ( iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeMobileCallDialEmergencyCall ) )
{
//CompleteDialEmergencyCall
CompleteDialEmergencyCall( aResult );
}
//if normal call has been made (by 3rd party client or not
//complete it
if ( ( iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDial ) )
|| ( iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDialISV ) ) )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange.EStatusConnected - Before CompleteDial");
CompleteDial( aResult );
}
if( iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDialNoFdnCheck ) )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange.EStatusConnected - Before CompleteDialNoFdn");
CompleteDialNoFdn( aResult );
}
}
//if status was Hold (-> resume or swap has been asked)
else if ( iMobileCallStatus == RMobileCall::EStatusHold )
{
//local resume has been requested
CompleteNotifyCallEvent( RMobileCall::ELocalResume );
//complete resume but not if swap is going on
if ( swapHandle == 0 && resumeHandle != 0 )
{
//complete resume
CompleteResume( aResult );
}
else if ( localSwapRequested )
{
(reinterpret_cast<CMmVoiceLineTsy*>( iMmLine ))->
IsSwapReady( callStatus );
}
}
//Don't update status if it has not changed.
if ( RCall::EStatusConnected != iCallStatus ||
RMobileCall::EStatusConnected != iMobileCallStatus )
{
if(RMobileCall::EStatusConnecting != iMobileCallStatus)
{
// RMobileCall::EStatusConnected without RMobileCall::EStatusConnecting
if ( KErrNone == iMmCallExtInterface->
CompleteNotifyStatusChange( RMobileCall::EStatusConnecting ) )
{
CompleteNotifyMobileCallCapsChange( KErrNone );
}
}
UpdateCallRoutingControl( iCallName, RMobileCall::EStatusConnected );
iCallStatus = RCall::EStatusConnected;
iMobileCallStatus = RMobileCall::EStatusConnected;
statusChanged = ETrue;
}
//update DTMF capabilities.
iMmPhone->GetDtmfTsy()->CompleteNotifyDTMFCaps();
break;
case RMobileCall::EStatusDisconnecting:
//Core status
iCallStatus = RCall::EStatusHangingUp;
statusChanged = ETrue;
// Mobile status
iMobileCallStatus = RMobileCall::EStatusDisconnecting;
mobileStatusChanged = ETrue;
//update DTMF capabilities.
iMmPhone->GetDtmfTsy()->CompleteNotifyDTMFCaps();
if ( iCallDirection == RMobileCall::EMobileTerminated )
{
if( KMultimodeCallTypeIDNoFdnCheck == GetDialTypeId() )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. RMobileCall::EStatusDisconnecting - Before CompleteDialNoFdn");
//CompleteDialNoFdn in case remote user is busy
CompleteDialNoFdn( aResult );
}
else
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. RMobileCall::EStatusDisconnecting - Before CompleteDial");
//CompleteDial in case remote user is busy
CompleteDial( aResult );
}
}
//Set last exit code
if ( KErrGsmReleaseByUser == aResult ||
KErrGsmBusyUserRequest == aResult ||
KErrNone == aResult )
{
iLastExitCode = KErrNone;
}
else
{
//set last exit code
iLastExitCode = aResult;
}
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
break;
case RMobileCall::EStatusDisconnectingWithInband:
//Core status
iCallStatus = RCall::EStatusHangingUp;
statusChanged = ETrue;
// Mobile status
iMobileCallStatus =
RMobileCall::EStatusDisconnectingWithInband;
mobileStatusChanged = ETrue;
if( KMultimodeCallTypeIDNoFdnCheck == GetDialTypeId() )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. RMobileCall::EStatusDisconnectingWithInband - Before CompleteDialNoFdn");
//CompleteDialNoFdn in case remote user is busy
CompleteDialNoFdn( aResult );
}
else
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::CompleteNotifyStatusChange. RMobileCall::EStatusDisconnectingWithInband - Before CompleteDial");
//CompleteDial in case remote user is busy
CompleteDial( aResult );
}
//update DTMF capabilities.
iMmPhone->GetDtmfTsy()->CompleteNotifyDTMFCaps();
//Set last exit code
if ( KErrGsmReleaseByUser == aResult ||
KErrGsmBusyUserRequest == aResult ||
KErrGsmCCNormalUnspecified == extendedError ||
KErrNone == aResult )
{
iLastExitCode = KErrNone;
}
else
{
//set last exit code
iLastExitCode = aResult;
}
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
break;
case RMobileCall::EStatusHold:
if ( iMobileCallStatus != RMobileCall::EStatusHold )
{
UpdateCallRoutingControl( iCallName, RMobileCall::EStatusHold );
//remote party requested this
CompleteNotifyCallEvent( RMobileCall::ELocalHold );
}
//complete hold but not if swap is going on
if ( swapHandle == 0 && holdHandle != 0 )
{
CompleteHold ( aResult );
}
else if ( localSwapRequested )
{
(reinterpret_cast<CMmVoiceLineTsy*>( iMmLine ) )->
IsSwapReady( callStatus );
}
// Mobile API state
iMobileCallStatus = RMobileCall::EStatusHold;
mobileStatusChanged = ETrue;
//update DTMF capabilities.
iMmPhone->GetDtmfTsy()->CompleteNotifyDTMFCaps();
break;
case RMobileCall::EStatusUnknown:
case RMobileCall::EStatusReconnectPending:
case RMobileCall::EStatusWaitingAlternatingCallSwitch:
case RMobileCall::EStatusTransferring:
case RMobileCall::EStatusTransferAlerting:
default:
//nothing to do
break;
}
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallNotifyStatusChange );
if ( ( EMultimodeCallReqHandleUnknown != reqHandle ) && statusChanged )
{
*iRetStatus = iCallStatus;
//reset req handle.
iTsyReqHandleStore->ResetTsyReqHandle(
EMultimodeCallNotifyStatusChange );
ReqCompleted( reqHandle, ret );
}
//reset req handle. Returns the deleted req handle
reqHandle = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallNotifyMobileCallStatusChange );
if ( ( EMultimodeCallReqHandleUnknown != reqHandle ) &&
(statusChanged || mobileStatusChanged) )
{
*iRetMobileCallStatus = iMobileCallStatus;
//reset req handle.
iTsyReqHandleStore->ResetTsyReqHandle(
EMultimodeCallNotifyMobileCallStatusChange );
ReqCompleted( reqHandle, ret );
}
//Update also line's status
if ( statusChanged || mobileStatusChanged )
{
iMmLine->CompleteNotifyStatusChange();
}
//Inform extension dll about the current status. Enables dynamic
//capability updates. Must be done before Notifying caps change
if ( KErrNone == iMmCallExtInterface->
CompleteNotifyStatusChange( iMobileCallStatus ) )
{
CompleteNotifyMobileCallCapsChange( KErrNone );
}
mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
iMmPhone->CallList()->GetMmCallByIndex( callIndex ) );
while ( mmCall )
{
if ( RMobileCall::EStatusIdle != mmCall->MobileCallStatus() &&
this != mmCall )
{
if ( KErrNone == mmCall->ActiveCallExtension()->
CompleteNotifyStatusChange( mmCall->MobileCallStatus() ) )
{
mmCall->CompleteNotifyMobileCallCapsChange( KErrNone );
}
}
callIndex++;
mmCall = reinterpret_cast<CMmVoiceCallTsy*>(
iMmPhone->CallList()->GetMmCallByIndex( callIndex ) );
}
// Inform Conference Call Tsy about status indication of
// a single call, might cause change of conference status
CMmConferenceCallTsy* confCall = iMmPhone->ConferenceCall();
if ( confCall )
{
if ( RMobileCall::EStatusIdle == callStatus )
{
// if the call has gone to idle state, iPreviousCallId must
// be used instead of iCallId, because iCallId has already
// been reset
confCall->CallStatusChanged( callStatus, iPreviousCallId );
}
else
{
confCall->CallStatusChanged( callStatus, iCallId );
}
}
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::Dial
// This CORE API method dials to the given number.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::Dial(
const TTsyReqHandle aTsyReqHandle,
const TDesC8* aCallParams,
TDesC* aTelNumber )
{
TFLOGSTRING3("TSY: CMmVoiceCallTsy::Dial. Req handle: %d, Call name: %S", aTsyReqHandle, &iCallName);
TBool isDialISV = iIsDialISV;
iIsDialISV = EFalse;
if ( aCallParams->Length()!= 0 )
{
if ( sizeof( RMobileCall::TCallParams ) > aCallParams->Length() )
{
TFLOGSTRING ("TSY: CMmVoiceCallTsy::Dial bad size argument");
// Complete the request with appropiate error
return KErrArgument;
}
}
CMmCallList* callList = iMmPhone->CallList();
TBool dialFlag( EFalse );
for ( TInt i = 0; i < callList->GetNumberOfObjects(); i++ )
{
CMmCallTsy* call = callList->GetMmCallByIndex( i );
if ( call->GetDialFlag() )
{
dialFlag = ETrue;
i = callList->GetNumberOfObjects();
}
}
if ( !dialFlag )
{
TInt ret( KErrNone );
SetDialFlag( ETrue );
TInt trapError( KErrNone );
//Default value
TInt extensionId ( -1 );
TTsyReqHandle dialHandle =
iTsyReqHandleStore->GetTsyReqHandle( EMultimodeCallDial );
TTsyReqHandle dialHandleISV =
iTsyReqHandleStore->GetTsyReqHandle( EMultimodeCallDialISV );
RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = NULL;
if ( 0 < aCallParams->Length() )
{
paramsPckgV1 =
reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
}
else
{
iCallParams.iSpeakerControl =
RCall::EMonitorSpeakerControlOnUntilCarrier;
iCallParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
iCallParams.iInterval = 0;
iCallParams.iWaitForDialTone = RCall::EDialToneWait;
iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
iCallParams.iCug.iExplicitInvoke = EFalse;
iCallParams.iCug.iCugIndex = 0xFFFF;
iCallParams.iCug.iSuppressPrefCug = EFalse;
iCallParams.iCug.iSuppressOA = EFalse;
iCallParams.iAutoRedial = EFalse;
paramsPckgV1 = &iCallParamsPckg;
}
RMobileCall::TMobileCallParamsV1& paramsV1 = ( *paramsPckgV1 )();
//Retrieve the extensionId of the call
extensionId = paramsV1.ExtensionId();
//Set the private member variable iExtensionId
SetExtensionId( extensionId );
//Check if there is already an active call
CMmCallTsy* activeCall = iMmPhone->CallList()->
GetMmCallByStatus( RMobileCall::EStatusConnected );
//reset exit code
iLastExitCode = KErrNone;
if ( KETelExt3rdPartyV1 == extensionId && !isDialISV )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - KErrArgument");
//Complete the request with appropiate error
ReqCompleted ( aTsyReqHandle, KErrArgument );
SetDialFlag( EFalse );
}
else if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )
{
TFLOGSTRING("TSY: Offline mode ON, Dial request is not allowed" );
ret = CMmCommonStaticUtility::EpocErrorCode(
KErrGeneral, KErrGsmOfflineOpNotAllowed );
//Complete the request with appropiate error
ReqCompleted ( aTsyReqHandle, ret );
SetDialFlag( EFalse );
}
//check that status is Idle
else if ( RMobileCall::EStatusIdle != iMobileCallStatus )
{
//The request cannot be forwarded since this call object
//is still in use.
//Complete request with status value informing the client about
//the situation.
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - KErrNotReady");
ReqCompleted( aTsyReqHandle, KErrNotReady );
SetDialFlag( EFalse );
}
else if ( ( 0 < dialHandle ) || ( ( KETelExt3rdPartyV1 == extensionId )
&& ( 0 < dialHandleISV ) && !i3rdPartyEmergencyNumberCheckDone ) )
{
//The request is already processing because of previous request
//Complete request with status value informing the client about
//the situation.
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - KErrServerBusy");
ReqCompleted( aTsyReqHandle, KErrServerBusy );
SetDialFlag( EFalse );
}
else if ( ( activeCall ) && ( KETelExt3rdPartyV1 == extensionId )
&& ( KETelExt3rdPartyV1 != activeCall->GetExtensionId() ) )
{
//a 3rd party client call cannot put on Hold a "normal" call
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - KErrServerBusy");
ReqCompleted( aTsyReqHandle, KErrServerBusy );
SetDialFlag( EFalse );
}
//3rd party client is not allowed to call to a emergency call number
//Number check for 3rd clients must be done always
else if ( extensionId == KETelExt3rdPartyV1 &&
!i3rdPartyEmergencyNumberCheckDone )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - For 3rd party client number check must be done every time ");
TInt ret( KErrGeneral );
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - 3rd party client number check iNumberCheckMode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal ");
iNumberCheckMode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal;
iNumberCheckMode.iNumber.Copy( *aTelNumber );
//Save parameter for Dial req after number check
iISVCallParams = aCallParams;
CMmDataPackage package;
package.PackData( &iNumberCheckMode );
CMmCustomTsy* mmCustom = iMmPhone->GetCustomTsy();
if ( NULL == mmCustom )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::Dial - CustomTSY is not yet created!");
ReqCompleted( aTsyReqHandle, KErrNotReady );
SetDialFlag( EFalse );
}
else
{
//Save call object pointer to Customtsy for completion
mmCustom->SetObjectForISVDialNumberCheck( this );
TRAP( trapError, ret = mmCustom->CheckEmergencyNumberL( 0,
&iNumberCheckMode, &i3rdPartyEmergencyNumberCheckDone );
);
if ( KErrNone == ret )
{
//Set dial flag to false because of ISV dial waits
//number check to be completed
SetDialFlag( EFalse );
#ifdef REQHANDLE_TIMER
//Set timer for the request if 3rd party client
SetTypeOfResponse( EMultimodeCallDialISV, aTsyReqHandle );
#else
//Set timer if 3rd party client
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeCallDialISV, aTsyReqHandle );
#endif
}
else
{
ReqCompleted( aTsyReqHandle, KErrServerBusy );
}
}
}
else
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::Dial - UUS services: %u", iUUSRequest.iServiceReq );
// UUS1 will be embedded within the call set-up message
if ( iUUSRequest.iServiceReq & RMobileCall::KUUS1Implicit )
{
// Create package
CCallDataPackage package;
// Set call id and call mode
package.SetCallIdAndMode( CallId(), CallMode() );
package.PackData( &iUUSRequest );
// Send UUS request to the Domestic OS layer.
TRAPD(err, ret = iMessageManager->HandleRequestL(
EMobileCallActivateUUS, &package ));
// clear/empty the UUS request buffer
iUUSRequest.iServiceReq = 0;
iUUSRequest.iUUI.Zero();
if( err != KErrNone)
{
ret = err;
}
// in case the LTSY does not support required UUS,
// complete the dial with error value
if ( KErrNone != ret )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::Dial - UUS ERROR:%d", ret );
// Complete the request with appropiate error
ReqCompleted ( aTsyReqHandle, KErrGsmCCResourceNotAvailable );
ClearCallStatus();
return KErrNone;
}
}
//save call params
iCallParams.iSpeakerControl = paramsV1.iSpeakerControl;
iCallParams.iSpeakerVolume = paramsV1.iSpeakerVolume;
iCallParams.iInterval = paramsV1.iInterval;
iCallParams.iWaitForDialTone = paramsV1.iWaitForDialTone;
//set call direction
iCallDirection = RMobileCall::EMobileOriginated;
// Dial
TRAP( trapError,
ret = iMmCallExtInterface->DialL(
iCallMode, paramsPckgV1, aTelNumber, extensionId );
);
if ( KErrNone == ret && KErrNone == trapError )
{
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
//update core status
iCallCaps.iFlags &= ~( RCall::KCapsDial );
iCallCaps.iFlags |= RCall::KCapsHangUp;
//complete core caps change
CompleteNotifyCapsChange();
#ifdef REQHANDLE_TIMER
if ( KETelExt3rdPartyV1 != extensionId )
{
//set timer for the request if 3rd party client
SetTypeOfResponse( EMultimodeCallDial, aTsyReqHandle );
}
#else
if ( KETelExt3rdPartyV1 != extensionId )
{
//set timer if 3rd party client
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeCallDial, aTsyReqHandle );
}
#endif
}
else
{
if ( KErrNone != trapError )
{
//Error Handling.DialL() leaves
ret = trapError;
}
ReqCompleted( aTsyReqHandle, ret );
ClearCallStatus();
}
}
return KErrNone;
}
else // if dialFlag set
{
return KErrServerBusy;
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::AnswerIncomingCall
// This CORE API method is used for answering to an incoming call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::AnswerIncomingCall(
const TTsyReqHandle aTsyReqHandle,
const TDesC8* aCallParams )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::AnswerIncomingCall. \n\t\t\t Handle:%d", aTsyReqHandle);
TInt trapError( KErrNone );
//ExtensionId unknown.Set to -1
TInt extensionId ( -1 );
TTsyReqHandle answerCallHandle( iTsyReqHandleStore->
GetTsyReqHandle( EMultimodeCallAnswer ) );
//3rd party client
TTsyReqHandle answerCallHandleISV( iTsyReqHandleStore->
GetTsyReqHandle( EMultimodeCallAnswerISV ) );
if (NULL != aCallParams )
{
RMobileCall::TMobileCallParamsV1Pckg* mmParamsPckgV1 =
reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>(
const_cast<TDesC8*> ( aCallParams ) );
RMobileCall::TMobileCallParamsV1& callParams =
(*mmParamsPckgV1)();
//Retrieve information about the extensionId
extensionId = callParams.ExtensionId();
//Set the private member variable iExtensionId
SetExtensionId( extensionId );
}
/*no else*/
// check if there is an active and a held call already
CMmCallTsy* activeCall = iMmPhone->CallList()->
GetMmCallByStatus( RMobileCall::EStatusConnected );
CMmCallTsy* heldCall = iMmPhone->CallList()->
GetMmCallByStatus( RMobileCall::EStatusHold );
if ( 0 < answerCallHandle )
{
//The request is already in processing because of previous request
//Complete request with status value informing the client about
//the situation.
ReqCompleted( aTsyReqHandle, KErrServerBusy );
}
//if 3rd party client
else if ( 0 < answerCallHandleISV )
{
//The request is already in processing because of previous request
//Complete request with status value informing the client about
//the situation.
ReqCompleted( aTsyReqHandle, KErrServerBusy );
}
else if ( activeCall && heldCall )
{
// if there is an active and a held call, we cannot answer
// yet another one
ReqCompleted( aTsyReqHandle, KErrGsmNotAllowed );
}
else if( activeCall &&
( !( KETelExt3rdPartyV1 == activeCall->GetExtensionId() ) &&
( KETelExt3rdPartyV1 == extensionId ) ) )
{
//if the active call is handled by a non 3rd party client and that this
//AnswerIncomingCall is handled by a 3rd party client
//=> a 3rd party call cannot put on hold a non 3rd party one.
ReqCompleted( aTsyReqHandle, KErrGsmNotAllowed );
}
else
{
TInt ret( KErrNone );
//reset exit code
iLastExitCode = KErrNone;
// Check that call object is same as object created for last
// incoming call
if ( RMobileCall::EMobileTerminated == iCallDirection &&
RMobileCall::EStatusRinging == iMobileCallStatus )
{
//Answer incoming call
TRAP( trapError,
ret = iMmCallExtInterface->
AnswerIncomingCallL( iCallId, extensionId );
);
if ( KErrNone != trapError )
{
//Object cannot be created.
ret = trapError;
}
if ( KErrNone == ret )
{
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
iCallCaps.iFlags |= RCall::KCapsHangUp;
iCallCaps.iFlags &= ~(
RCall::KCapsAnswer | RCall::KCapsDial );
CompleteNotifyCapsChange();
}
}
else
{
ret = KErrNotSupported;
}
//error handling
if ( KErrNone != ret )
{
ReqCompleted( aTsyReqHandle, ret );
ClearCallStatus();
}
else
{
#ifdef REQHANDLE_TIMER
//set timer for the request
if ( KETelExt3rdPartyV1 == extensionId )
{
//3rd party client
SetTypeOfResponse( EMultimodeCallAnswerISV, aTsyReqHandle );
}
else
{
SetTypeOfResponse( EMultimodeCallAnswer, aTsyReqHandle );
}
#else
//timer set
if ( KETelExt3rdPartyV1 == extensionId )
{
//3rd party client
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeCallAnswerISV, aTsyReqHandle );
}
else
{
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeCallAnswer, aTsyReqHandle );
}
#endif
}
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::HangUp
// This CORE API method disconnects the call. Used with normal voice calls,
// emergency calls as well as data calls. DialCancel also uses this method.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::HangUp(
const TTsyReqHandle aTsyReqHandle )
{
TFLOGSTRING3("TSY: CMmVoiceCallTsy::HangUp. Req handle: %d, Call name: %S", aTsyReqHandle, &iCallName);
TInt ret( KErrNone );
TInt trapError( KErrNone );
TInt hangUpCause( KErrNone );
TTsyReqHandle hangUpHandle = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallHangUp );
TTsyReqHandle dialHandle = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDial );
TTsyReqHandle dialEmergencyHandle = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeMobileCallDialEmergencyCall );
// 3rd party client
TTsyReqHandle dialHandleISV = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDialISV );
// Dial NoFdnCheck
TTsyReqHandle dialHandleNoFdnCheck = iTsyReqHandleStore->GetTsyReqHandle(
EMultimodeCallDialNoFdnCheck );
if ( 0 < hangUpHandle || iHangUpFlag )
{
//The request is already in processing because of previous request
//Complete request with status value informing the client about
//the situation.
ReqCompleted( aTsyReqHandle, KErrServerBusy );
}
else if ( RCall::EStatusIdle == iCallStatus &&
( EMultimodeCallReqHandleUnknown == dialHandle ||
EMultimodeCallReqHandleUnknown == dialEmergencyHandle
|| EMultimodeCallReqHandleUnknown == dialHandleISV
|| EMultimodeCallReqHandleUnknown == dialHandleNoFdnCheck ) )
{
//Call object is already in idle state.
//Complete HangUp request with error.
ReqCompleted( aTsyReqHandle, KErrNotReady );
}
else
{
// If this was not called by DialCancel or AnswerIncomingCallCancel
if ( CMmCallTsy::EDialCancelNotCalled == iDialCancelFlag &&
!iAnswerCancelFlag )
{
#ifdef REQHANDLE_TIMER
//set timer for the request
SetTypeOfResponse( EMultimodeCallHangUp, aTsyReqHandle );
#else
//save HangUp request handle, set timer
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeCallHangUp, aTsyReqHandle );
#endif
}
//decide the hangup cause
if ( RCall::EStatusRinging == iCallStatus )
{
iLastExitCode = KErrGsmCallRejected;
hangUpCause = KErrGsmBusyUserRequest;
}
else
{
hangUpCause = KErrGsmReleaseByUser;
}
// Avoid held call from automatically becoming active call
TBool autoStChangeDisable = ETrue;
//Create package
CCallDataPackage package;
//Set call id and call mode
package.SetCallIdAndMode( iCallId, RMobilePhone::EVoiceService );
//Pack call parameters and mobile call info
package.PackData( &hangUpCause, &autoStChangeDisable );
//Send request to the Domestic OS layer.
TRAP( trapError,
ret = iMessageManager->HandleRequestL(
EEtelCallHangUp, &package );
);
//send failure
if ( KErrNone != ret || KErrNone != trapError )
{
iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeCallHangUp );
//in case of memory error
if ( KErrNone != trapError )
{
// Object cannot be created.
ret = trapError;
}
ReqCompleted( aTsyReqHandle, ret );
}
else
{
//update core status - hangup not possible now.
//remove also dataport caps
iCallCaps.iFlags &= ~(
RCall::KCapsHangUp |
RCall::KCapsLoanDataPort |
RCall::KCapsRecoverDataPort );
//complete core caps change
CompleteNotifyCapsChange();
// set hangup flag to ongoing
iHangUpFlag = ETrue;
}
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteHangUp
// Completes call hangup (both normal and emergency calls). If the cause value
// is different than the sent one, the call release requset has failed. In
// this case the causeValue describes the fail cause. Otherwise the call
// releasing has succeeded.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteHangUp(
TInt aResult )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CompleteHangUp.\n \t\t\t Result:%d", aResult );
TFLOGSTRING3("TSY: CMmVoiceCallTsy::CompleteHangUp. Call Id:%d Call name:%S", iCallId, &iCallName);
TInt ret( KErrNone );
// Complete for HangUp request
// (not to DialCancel or AnswerIncomingCallCancel )
if ( CMmCallTsy::EDialCancelNotCalled == iDialCancelFlag &&
!iAnswerCancelFlag )
{
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle =
iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeCallHangUp );
if ( EMultimodeCallReqHandleUnknown != reqHandle )
{
//if hangup request failed
if ( KErrNone != aResult )
{
//Hangup failed, it should be still possible to carry out
iCallCaps.iFlags |= RCall::KCapsHangUp;
//Call status is not idle. HangUp request failed, complete
//HangUp request with error.
if ( RCall::EStatusIdle != iCallStatus )
{
// ignore KErrGsmReleaseByUser, which means that the call ended
// because the local user released the call, and must be treated
// as a normal return code from the LTSY
ret = ( (aResult == KErrGsmReleaseByUser) ? KErrNone : aResult );
}
}
else
{
//Dial hangup has succeeded, update core status -
//dial possible again
iCallCaps.iFlags |= RCall::KCapsDial;
if ( KErrGsmCallRejected != iLastExitCode )
{
iLastExitCode = KErrNone;
}
//If client refuses to answer, remove the answering capability
iCallCaps.iFlags &= ~( RCall::KCapsAnswer );
}
ReqCompleted( reqHandle, ret );
//complete caps change notification
CompleteNotifyCapsChange();
iEmergencyCall = EFalse;
}
}
// Complete for DialCancel or AnswerIncomingCallCancel, success
else if ( KErrNone == aResult )
{
// Find out if this is cancelling of Dial or DialEmergencyCall
TTsyReqHandle cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallDial );
TTsyReqHandle dialEmergCancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeMobileCallDialEmergencyCall );
if ( ( NULL == cancelHandle ) && ( NULL == dialEmergCancelHandle ) )
{
// Find out if this is cancelling of AnswerIncomingCall
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallAnswer );
if ( NULL == cancelHandle )
{
// Find out if this is cancelling of DialISV
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallDialISV );
if ( NULL == cancelHandle )
{
// Find out if this is cancelling of AnswerIncomingCallISV
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallAnswerISV );
// Find out if this is cancelling DialNoFdnCheck
if ( NULL == cancelHandle )
{
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallDialNoFdnCheck );
}
}
}
}
if ( 0 < cancelHandle )
{
// Complete with error value KErrCancel
ReqCompleted( cancelHandle, KErrCancel );
// Cancel has succeeded, update core status -
// dial possible again
iCallCaps.iFlags |= RCall::KCapsDial;
// If client refuses to answer, remove the answering capability
iCallCaps.iFlags &= ~( RCall::KCapsAnswer );
// Complete caps change notification
CompleteNotifyCapsChange();
}
// Cancel to DialEmergencyCall
else if ( 0 < dialEmergCancelHandle )
{
// Complete DialEmergencyCall with error value KErrCancel
ReqCompleted( dialEmergCancelHandle, KErrCancel );
// Update last exit code
iLastExitCode = KErrCancel;
// Dial cancel has succeeded,
// update core status - dial possible again
iCallCaps.iFlags |= RCall::KCapsDial;
// Complete caps change notification
CompleteNotifyCapsChange();
iEmergencyCall = EFalse;
}
}
// Cancel failed and the request succeeded (connected)
else if ( RCall::EStatusConnected == iCallStatus )
{
// Find out if this is cancelling of Dial
TTsyReqHandle cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallDial );
// Find out if this is cancelling of DialEmergencyCall
TTsyReqHandle dialEmergCancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeMobileCallDialEmergencyCall );
if ( ( NULL == cancelHandle ) && ( NULL == dialEmergCancelHandle ) )
{
// Find out if this is cancelling of AnswerIncomingCall
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallAnswer );
if ( NULL == cancelHandle )
{
// Find out if this is cancelling of DialISV
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallDialISV );
if ( NULL == cancelHandle )
{
// Find out if this is cancelling of AnswerIncomingCallISV
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallAnswerISV );
if (NULL == cancelHandle )
{
// Find out if this is cancelling DialNoFdnCheck
cancelHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallDialNoFdnCheck );
}
}
}
}
// Cancel to Dial(ISV) or AnswerIncomingCall(ISV)
if ( 0 < cancelHandle )
{
// Complete Dial or AnswerIncomingCall with success (KErrNone)
ReqCompleted( cancelHandle, KErrNone );
// Succeeded, update core status - hangup possible again
iCallCaps.iFlags |= RCall::KCapsHangUp;
// Complete caps change notification
CompleteNotifyCapsChange();
}
// Cancel to DialEmergencyCall
else if ( 0 < dialEmergCancelHandle )
{
// Complete DialEmergencyCall with success (KErrNone)
ReqCompleted( dialEmergCancelHandle, KErrNone );
// Dial has succeeded, update core status - hangup possible again
iCallCaps.iFlags |= RCall::KCapsHangUp;
// Complete caps change notification
CompleteNotifyCapsChange();
}
}
// Reset cancel flags
iDialCancelFlag = CMmCallTsy::EDialCancelNotCalled;
iAnswerCancelFlag = EFalse;
// reset hangup flag
iHangUpFlag = EFalse;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::RegisterNotification
// RegisterNotification is called when the server recognises that this
// notification is being posted for the first time on this sub-session object.
// It enables the TSY to "turn on" any regular notification messages that it
// may receive from DOS. Currently does not really do anything but returns
// KErrNone to ETel server in case of known notification request type.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::RegisterNotification(
const TInt aIpc )
{
TInt ret( KErrNone );
switch ( aIpc )
{
case EEtelCallNotifyHookChange:
case EEtelCallNotifyStatusChange:
case EEtelCallNotifyDurationChange:
case EEtelCallCapsChangeNotification:
case EMobileCallNotifyCallEvent:
case EMobileCallNotifyMobileCallStatusChange:
case EMobileCallNotifyRemotePartyInfoChange:
case EMobileCallNotifyPrivacyConfirmation:
case EMobileCallNotifyTrafficChannelConfirmation:
case EMobileCallNotifyHscsdInfoChange:
case EMobileCallNotifyMobileDataCallCapsChange:
case EMobileCallNotifyAlternatingCallSwitch:
case EMobileCallNotifyMobileCallCapsChange:
case EMobileCallNotifyVoiceFallback:
case EMobileCallNotifyUUSCapsChange:
case EMobileCallReceiveUUI:
ret = KErrNone;
break;
default:
// Unknown or invalid IPC
ret = KErrNotSupported;
break;
}
return ret;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::DeregisterNotification
// DeregisterNotification is called when the server recognises that this
// notification will not be posted again because the last client to have a
// handle on this sub-session object has just closed the handle. It enables
// the TSY to "turn off" any regular notification messages that it may receive
// from DOS. Currently does not really do anything but returns KErrNone to
// ETel server in case of known notification request type.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::DeregisterNotification(
const TInt aIpc )
{
TInt ret ( KErrNone );
switch ( aIpc )
{
case EEtelCallNotifyHookChange:
case EEtelCallNotifyStatusChange:
case EEtelCallNotifyDurationChange:
case EEtelCallCapsChangeNotification:
case EMobileCallNotifyCallEvent:
case EMobileCallNotifyMobileCallStatusChange:
case EMobileCallNotifyRemotePartyInfoChange:
case EMobileCallNotifyPrivacyConfirmation:
case EMobileCallNotifyTrafficChannelConfirmation:
case EMobileCallNotifyHscsdInfoChange:
case EMobileCallNotifyMobileDataCallCapsChange:
case EMobileCallNotifyAlternatingCallSwitch:
case EMobileCallNotifyMobileCallCapsChange:
case EMobileCallNotifyVoiceFallback:
case EMobileCallNotifyUUSCapsChange:
case EMobileCallReceiveUUI:
ret = KErrNone;
break;
default:
// Unknown or invalid IPC
ret = KErrNotSupported;
break;
}
return ret;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::HoldL
// This method can be used to hold an active call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::HoldL(
const TTsyReqHandle aTsyReqHandle )
{
//Call hold from extension
TInt ret = iMmCallExtInterface->HoldL( iCallId );
//request failed
if ( ret != KErrNone )
{
ReqCompleted( aTsyReqHandle, ret );
}
else //success in sending to Phonet
{
// Store the request handle
iReqHandleType = EMultimodeMobileCallHold;
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::ResumeL
// Resumes a held call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::ResumeL(
const TTsyReqHandle aTsyReqHandle )
{
//Call resume from extension
TInt ret = iMmCallExtInterface->ResumeL( iCallId );
//if failed
if ( ret != KErrNone )
{
ReqCompleted( aTsyReqHandle, ret );
}
else //success in sending to Phonet
{
// Store the request handle
iReqHandleType = EMultimodeMobileCallResume;
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::SwapL
// Swaps between active and held call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::SwapL(
const TTsyReqHandle aTsyReqHandle )
{
//direct request to extension
TInt ret = iMmCallExtInterface->SwapL( iCallId );
//request failed
if ( ret != KErrNone )
{
ReqCompleted( aTsyReqHandle, ret );
}
else //success in sending to Phonet
{
// Store the request handle
iReqHandleType = EMultimodeMobileCallSwap;
//inform Line that swap handling has started
(reinterpret_cast<CMmVoiceLineTsy*>( iMmLine ))->
SetSwapStatus( CMmVoiceLineTsy::EWaitingHoldAndResumeOk );
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::DialEmergencyCallL
// Dials an emergency call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::DialEmergencyCall(
const TTsyReqHandle aTsyReqHandle,
const TDataPackage& aNumber )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::DialEmergencyCall number %S", aNumber.Des1u());
if(aNumber.Des1u()->MaxLength() > RMobileENStore::KEmergencyNumberSize)
{
// The emergency call number is too big
ReqCompleted( aTsyReqHandle, KErrArgument);
}
else
{
SetDialFlag(ETrue);
//check that status is Idle
if ( iMobileCallStatus != RMobileCall::EStatusIdle )
{
//The request cannot be forwarded since this call object
//is still in use.
//Complete request with status value informing the client
//about the situation.
ReqCompleted( aTsyReqHandle, KErrNotReady );
SetDialFlag(EFalse);
}
// If dial already proceeding,
else if ( NULL != iTsyReqHandleStore->GetTsyReqHandle(EMultimodeCallDial) ||
NULL != iTsyReqHandleStore->GetTsyReqHandle(EMultimodeMobileCallDialEmergencyCall ) )
{
ReqCompleted( aTsyReqHandle, KErrServerBusy );
SetDialFlag(EFalse);
}
// Because the Phone Application is the first client that is started,
// it will always be the priority client. 3rd party applications are
// now allowed to make emergency calls too.
else
{
iLastExitCode = KErrNone;
iCallDirection = RMobileCall::EMobileOriginated;
// Prepare data to pass throught all loop
TCtsySsmCallbackData callbackData;
callbackData.iNumberPackage.SetPacketData(&aNumber);
callbackData.iReqHandle = aTsyReqHandle;
iMmCallExtInterface->DialEmergencyCall(callbackData );
}
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteDialEmergencyCall
// Completes emergency call dialling.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteDialEmergencyCall(
TInt aResult )
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CompleteDialEmergencyCall. Result:%d", aResult );
TFLOGSTRING3("TSY: CMmVoiceCallTsy::CompleteDialEmergencyCall. Call Id:%d Call name:%S", iCallId, &iCallName);
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeMobileCallDialEmergencyCall );
if ( EMultimodeCallReqHandleUnknown != reqHandle )
{
if ( aResult != KErrNone )
{
iLastExitCode = aResult;
//clear flag indicating that this is a emergency call
iEmergencyCall = EFalse;
ClearCallStatus();
}
ReqCompleted( reqHandle, aResult );
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::DialEmergencyCallCancel
// Cancels DialEmergencyCall request.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::DialEmergencyCallCancel(
const TTsyReqHandle aTsyReqHandle )
{
// Let callback to handle canceling
TCtsySsmCallbackData callbackData;
callbackData.iReqHandle = aTsyReqHandle;
SsmPluginCallback(KErrCancel,callbackData);
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::FillMobileCallInfo
// The method fills a current snapshot of the call information described in
// the TMobileCallInfoVx class to the aInfo. The mode specific fields will be
// filled by the extension.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::FillMobileCallInfo(
TDes8* aInfo )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::FillMobileCallInfo");
TInt ret = KErrArgument;
TInt extensionId = 0;
if ( sizeof ( RMobilePhone::TMultimodeType ) <= aInfo->MaxLength() )
{
RMobilePhone::TMultimodeTypePckg* infoParamsPckg =
reinterpret_cast<RMobilePhone::TMultimodeTypePckg*>(
aInfo );
RMobilePhone::TMultimodeType& callInfo = ( *infoParamsPckg )();
// get extensionid from the recieved data
extensionId = callInfo.ExtensionId();
TFLOGSTRING2("TSY: CMmVoiceCallTsy::FillMobileCallInfo - extensionid=%d",callInfo.ExtensionId());
}
//TMobileCallInfoV1
if ( KETelExtMultimodeV1 == extensionId ||
KETelExtMultimodeV3 == extensionId ||
KEtelExtMultimodeV7 == extensionId ||
KEtelExtMultimodeV8 == extensionId )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::FillMobileCallInfo - V1");
// Set ret to KErrNone. We can fill this parameter class.
ret = KErrNone;
RMobileCall::TMobileCallInfoV1Pckg* paramsPckgV1 =
reinterpret_cast<RMobileCall::TMobileCallInfoV1Pckg*>( aInfo );
RMobileCall::TMobileCallInfoV1& info = ( *paramsPckgV1 )();
// set mobilecallinfo default values
FillMobileCallInfoDefaults( &info );
// fill specific data
iMmCallExtInterface->FillMobileCallInfo( &info );
}
// TMobileCallInfoV3
if ( KETelExtMultimodeV3 == extensionId ||
KEtelExtMultimodeV7 == extensionId ||
KEtelExtMultimodeV8 == extensionId )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::FillMobileCallInfo - V3");
RMobileCall::TMobileCallInfoV3Pckg* paramsPckgV3 =
reinterpret_cast<RMobileCall::TMobileCallInfoV3Pckg*>( aInfo );
RMobileCall::TMobileCallInfoV3& info = ( *paramsPckgV3 )();
// fill specific data
iMmCallExtInterface->FillMobileCallInfoV3( &info );
}
// TMobileCallInfoV7
if ( KEtelExtMultimodeV7 == extensionId ||
KEtelExtMultimodeV8 == extensionId )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::FillMobileCallInfo - V7");
RMobileCall::TMobileCallInfoV7Pckg* paramsPckgV7 =
reinterpret_cast<RMobileCall::TMobileCallInfoV7Pckg*>( aInfo );
RMobileCall::TMobileCallInfoV7& info = ( *paramsPckgV7 )();
// fill specific data
iMmCallExtInterface->FillMobileCallInfoV7( &info );
}
// TMobileCallInfoV8
if ( KEtelExtMultimodeV8 == extensionId )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::FillMobileCallInfo - V8");
RMobileCall::TMobileCallInfoV8Pckg* paramsPckgV8 =
reinterpret_cast<RMobileCall::TMobileCallInfoV8Pckg*>( aInfo );
RMobileCall::TMobileCallInfoV8& info = ( *paramsPckgV8 )();
// fill specific data
iMmCallExtInterface->FillMobileCallInfoV8( &info );
}
TFLOGSTRING2("TSY: CMmVoiceCallTsy::FillMobileCallInfo end. ret=%d",ret);
return ret;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::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 CMmVoiceCallTsy::GoOneToOneL(
const TTsyReqHandle aTsyReqHandle )
{
//direct request to the extension
TInt ret( iMmCallExtInterface->GoOneToOneL( iCallId ) );
if ( ret != KErrNone )
{
ReqCompleted( aTsyReqHandle, ret );
}
else
{
//save tsy req handle type
iReqHandleType = EMultimodeCallGoOneToOne;
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteGoOneToOne
// This method completes an outstanding asynchronous GoOneToOne request.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteGoOneToOne(
TInt aErrorCode )
{
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeCallGoOneToOne );
if (KErrNone != aErrorCode)
{
CMmConferenceCallTsy* mmConference = iMmPhone->ConferenceCall();
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( EFalse, iCallId );
}
}
if ( EMultimodeCallReqHandleUnknown != reqHandle )
{
ReqCompleted( reqHandle, aErrorCode );
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteHold
// Complete the ongoing hold request.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteHold(
TInt aResult )
{
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeMobileCallHold );
if ( EMultimodeCallReqHandleUnknown != reqHandle )
{
ReqCompleted( reqHandle, aResult );
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteResume
// Complete the ongoing resume request.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteResume(
TInt aResult )
{
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeMobileCallResume );
if ( EMultimodeCallReqHandleUnknown != reqHandle )
{
// The Call Server has rejected the retrieve request
ReqCompleted( reqHandle, aResult );
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::CompleteResume
// Complete the ongoing swap request.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::CompleteSwap(
TInt aResult )
{
//reset req handle. Returns the deleted req handle
TTsyReqHandle reqHandle = iTsyReqHandleStore->
ResetTsyReqHandle( EMultimodeMobileCallSwap );
if ( EMultimodeCallReqHandleUnknown != reqHandle )
{
TFLOGSTRING2("TSY: Swap complete, Call ID: %d", iCallId );
ReqCompleted( reqHandle, aResult );
}
(reinterpret_cast<CMmVoiceLineTsy*>( iMmLine ))->
SetSwapStatus( CMmVoiceLineTsy::EStatusSwapNotRequested );
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::SetEmergencyMode
// Call mode may change during call creation.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::SetEmergencyMode(
TBool aIsEmergency )
{
//Call mode may change during call creation.
iEmergencyCall = aIsEmergency;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::IsEmergencyCall
// Is this call an emergency call.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TBool CMmVoiceCallTsy::IsEmergencyCall() const
{
//TRUE if emergency call, otherwise FALSE
return iEmergencyCall;
}
#ifdef REQHANDLE_TIMER
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::SetTypeOfResponse
// Sets the type of response for a given Handle. Automatic mode includes an
// automatic response in case of non response from the Domestic OS Layer in a
// specified time.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::SetTypeOfResponse(
const TInt aReqHandleType,
const TTsyReqHandle aTsyReqHandle )
{
//Sets the type of response for a given Handle. Automatic mode includes an
//automatic response in case of non response from the DOS in a specified
//time.
TInt timeOut( 0 );
//example switch
switch ( aReqHandleType )
{
case EMultimodeCallDial:
case EMultimodeCallDialISV:
case EMultimodeCallDialNoFdnCheck:
timeOut = KMmCallDialTimeOut;
break;
case EMultimodeCallAnswer:
case EMultimodeCallAnswerISV:
timeOut = KMmCallAnswerTimeOut;
break;
case EMultimodeCallHangUp:
timeOut = KMmCallHangUpTimeOut;
break;
case EMultimodeMobileCallHold:
timeOut = KMmCallHoldTimeOut;
break;
case EMultimodeMobileCallResume:
timeOut = KMmCallResumeTimeOut;
break;
case EMultimodeMobileCallSwap:
timeOut = KMmCallSwapTimeOut;
break;
case EMultimodeMobileCallDeflectCall:
timeOut = KMmCallSwapTimeOut;
break;
case EMultimodeMobileCallDialEmergencyCall:
timeOut = KMmCallDialEmergencyCallTimeOut;
break;
case EMultimodeCallTransfer:
timeOut = KMmCallTransferTimeOut;
break;
case EMultimodeCallGoOneToOne:
timeOut = KMmCallGoOneToOneTimeOut;
break;
//Can't use timer:
// - all notifications
//case EMultimodeCallNotifyStatusChange:
//case EMultimodeCallNotifyDurationChange:
//case EMultimodeCallCapsChangeNotification:
//case EMultimodeCallNotifyMobileCallStatusChange:
//case EMultimodeCallNotifyCallEvent:
//case EMultimodeCallNotifyRemotePartyInfoChange:
//case EMultimodeCallNotifyMobileCallCapsChange:
//case EMultimodeCallNotifyDataCallCapsChange:
//case EMultimodeCallNotifyHscsdInfoChange:
//case EMultimodeCallNotifyPrivacyConfirmation:
//case EMobileCallReceiveUUI:
case EMultimodeCallSetDynamicHscsdParams:
default:
//does not use timer
iTsyReqHandleStore->SetTsyReqHandle(
aReqHandleType, aTsyReqHandle );
break;
}
if ( timeOut > 0 )
{
//the timeout parameter is given in seconds.
iTsyReqHandleStore->SetTsyReqHandle(
aReqHandleType, aTsyReqHandle, timeOut );
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::Complete
// Completes the request due timer expiration
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::Complete(
TInt aReqHandleType,
TInt aError )
{
//All possible TSY req handle types are listed in the
//switch case below.
switch( aReqHandleType )
{
//cases handled with automatic completion
case EMultimodeMobileCallHold:
CompleteHold( aError );
break;
case EMultimodeMobileCallResume:
CompleteResume( aError );
break;
case EMultimodeMobileCallSwap:
CompleteSwap( aError );
break;
case EMultimodeMobileCallDialEmergencyCall:
CompleteDialEmergencyCall( aError );
break;
case EMultimodeCallGoOneToOne:
CompleteGoOneToOne( aError );
break;
//Can't use timer:
// - all notifications
//case EMultimodeCallNotifyStatusChange:
//case EMultimodeCallNotifyDurationChange:
//case EMultimodeCallCapsChangeNotification:
//case EMultimodeCallNotifyMobileCallStatusChange:
//case EMultimodeCallNotifyCallEvent:
//case EMultimodeCallNotifyRemotePartyInfoChange:
//case EMultimodeCallNotifyMobileCallCapsChange:
//case EMultimodeCallNotifyDataCallCapsChange:
//case EMultimodeCallNotifyHscsdInfoChange:
//case EMultimodeCallNotifyPrivacyConfirmation:
//case EMobileCallReceiveUUI:
case EMultimodeCallDial:
case EMultimodeCallDialNoFdnCheck:
case EMultimodeCallDialISV:
case EMultimodeCallAnswer:
case EMultimodeCallAnswerISV:
case EMultimodeCallHangUp:
case EMultimodeMobileCallDeflectCall:
case EMultimodeCallTransfer:
case EMultimodeCallSetDynamicHscsdParams:
default:
{
CMmCallTsy::Complete( aReqHandleType, aError );
break;
}
}
}
#endif
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::GetBearerServiceInfo
// Get bearer service info.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::GetBearerServiceInfo(
const TTsyReqHandle,
RCall::TBearerService* )
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::Connect
// Set correct data call attributes, depending on parameter extension.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::Connect(
const TTsyReqHandle,
const TDesC8* )
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::ConnectChancel
// Cancels connecting of a (data) call (Not Supported).
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::ConnectCancel(
const TTsyReqHandle )
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::LoanDataPort
// This CORE API method loans dataport to client.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::LoanDataPort(
const TTsyReqHandle,
RCall::TCommPort* )
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::LoanDataPortCancel
// Cancels dataport loaning to client. LoanDataPort always
// completes immediately, this is never used.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::LoanDataPortCancel(
const TTsyReqHandle )
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::RecoverDataPort
// This CORE API method recovers dataport from client.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::RecoverDataPort(
const TTsyReqHandle )
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::RecoverDataPortAndRelinquishOwnership
// Recovers dataport from client and relinquishes ownership.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::RecoverDataPortAndRelinquishOwnership()
{
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::Complete3rdPartyCallNbrCheck
// Completes emergency number check for 3rd party clients
// Decides if dial can be done
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::Complete3rdPartyCallNbrCheck( TBool aIsEmergencyNbr )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::Complete3rdPartyCallNbrCheck " );
if( i3rdPartyEmergencyNumberCheckDone )
{
if( aIsEmergencyNbr )
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::Complete3rdPartyCallNbrCheck - Emergency number" );
CompleteDial( KErrNotSupported );
i3rdPartyEmergencyNumberCheckDone = EFalse;
}
else
{
TFLOGSTRING("TSY: CMmVoiceCallTsy::Complete3rdPartyCallNbrCheck - NOT Emergency nbr - DIAL" );
i3rdPartyEmergencyNumberCheckDone = ETrue;
iIsDialISV = ETrue;
TTsyReqHandle reqHandle = iTsyReqHandleStore->
GetTsyReqHandle( EMultimodeCallDialISV );
TInt ret = Dial( reqHandle, iISVCallParams,
&iNumberCheckMode.iNumber );
if( KErrNone == ret )
{
//Dial is made reset
i3rdPartyEmergencyNumberCheckDone = EFalse;
iISVCallParams = NULL;
}
}
}
else
{
CompleteDial( KErrGeneral );
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::DialNoFdnCheck
// This method makes a call without fdn check
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmVoiceCallTsy::DialNoFdnCheck(
const TTsyReqHandle aTsyReqHandle,
const TDesC8* aCallParams,
TDesC* aTelNumber )
{
TFLOGSTRING3("TSY: CMmVoiceCallTsy::DialNoFdnCheck. Req handle: %d, Call name: %S", aTsyReqHandle, &iCallName );
TInt ret( KErrGeneral );
// Check that there is no dial on going for another call
CMmCallList* callList = iMmPhone->CallList();
TBool dialFlag( EFalse );
for ( TInt i=0; i< callList->GetNumberOfObjects();i++ )
{
CMmCallTsy* call = callList->GetMmCallByIndex( i );
if( call->GetDialFlag() )
{
dialFlag = ETrue;
i = callList->GetNumberOfObjects();
}
}
if( !dialFlag )
{
ret = KErrNone;
SetDialFlag( ETrue );
RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = NULL;
if ( 0 < aCallParams->Length() )
{
paramsPckgV1 =
reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>(
const_cast<TDesC8*>( aCallParams ) );
}
else
{
iCallParams.iSpeakerControl =
RCall::EMonitorSpeakerControlOnUntilCarrier;
iCallParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
iCallParams.iInterval = 0;
iCallParams.iWaitForDialTone = RCall::EDialToneWait;
iCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
iCallParams.iCug.iExplicitInvoke = EFalse;
iCallParams.iCug.iCugIndex = 0xFFFF;
iCallParams.iCug.iSuppressPrefCug = EFalse;
iCallParams.iCug.iSuppressOA = EFalse;
iCallParams.iAutoRedial = EFalse;
paramsPckgV1 = &iCallParamsPckg;
}
RMobileCall::TMobileCallParamsV1& paramsV1 = ( *paramsPckgV1 )();
SetDialTypeId( KMultimodeCallTypeIDNoFdnCheck );
if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )
{
TFLOGSTRING("TSY: Offline mode ON, DialNoFdnCheck request is not allowed" );
ret = CMmCommonStaticUtility::EpocErrorCode(
KErrGeneral, KErrGsmOfflineOpNotAllowed );
// Complete the request with appropiate error
ReqCompleted ( aTsyReqHandle, ret );
SetDialFlag(EFalse);
}
// Check that status is Idle
else if ( RMobileCall::EStatusIdle != iMobileCallStatus )
{
//The request cannot be forwarded since this call object
//is still in use.
//Complete request with status value informing the client about
//the situation.
TFLOGSTRING("TSY: CMmVoiceCallTsy::DialNoFdnCheck - KErrNotReady");
ReqCompleted( aTsyReqHandle, KErrNotReady );
SetDialFlag(EFalse);
}
else
{
// Save call params
iCallParams.iSpeakerControl = paramsV1.iSpeakerControl;
iCallParams.iSpeakerVolume = paramsV1.iSpeakerVolume;
iCallParams.iInterval = paramsV1.iInterval;
iCallParams.iWaitForDialTone = paramsV1.iWaitForDialTone;
// Set call direction
iCallDirection = RMobileCall::EMobileOriginated;
// Dial
TRAPD(err, ret = iMmCallExtInterface->DialL(
iCallMode, paramsPckgV1, aTelNumber,
KMultimodeCallTypeIDNoFdnCheck ));
TFLOGSTRING2("TSY: CMmVoiceCallTsy::DialNoFdnCheck ret = %d", ret);
if(err != KErrNone)
{
ret = err;
}
if ( KErrNone == ret )
{
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
// Update core status
iCallCaps.iFlags &= ~( RCall::KCapsDial );
iCallCaps.iFlags |= RCall::KCapsHangUp;
// Complete core caps change
CompleteNotifyCapsChange();
#ifdef REQHANDLE_TIMER
// Set timer for the dialnofdncheck request
SetTypeOfResponse( EMultimodeCallDialNoFdnCheck,
aTsyReqHandle );
#else
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeCallDialNoFdnCheck, aTsyReqHandle );
#endif
}
else
{
TFLOGSTRING2("TSY: CMmVoiceCallTsy::DialNoFdnCheck Before ReqCompleted ret = %d", ret);
ReqCompleted( aTsyReqHandle, ret );
ClearCallStatus();
SetDialFlag(EFalse);
}
}
}
else
return KErrServerBusy;
return KErrNone;
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::SsmPluginCallback
// This is callback
// This method is called from CMmCallGsmWcdmaExt, after
// sendinig request to LTSY
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::SsmPluginCallback(TInt aResult, TCtsySsmCallbackData& aCallbackData)
{
if ( KErrNone != aResult )
{
// first of all cancel
// possible request to SSM. It will do nothing if there is no request to SSM
TRfStateInfo stateInfo = Phone()->GetRfStateInfo();
if (ERfsStateInfoNormal != stateInfo)
{
TCtsySsmCallbackData dummyData;
reinterpret_cast<CMmCallGsmWcdmaExt*>
( iMmCallExtInterface )->SetRfState(ERfsStateInfoInactive,
reinterpret_cast<CMmCallGsmWcdmaExt*>( iMmCallExtInterface ),
dummyData);
}
// Then we should check if iReqHandleType was sent
TTsyReqHandle tsyReqHandle = iTsyReqHandleStore->GetTsyReqHandle( EMultimodeMobileCallDialEmergencyCall );
if (EMultimodeCallReqHandleUnknown != tsyReqHandle)
{
//here it means that there do was successful request to LTSY
// and we have to cancel request to LTSY (following code is from DialEmergencyCallCancel)
// it means that we have to cancel request to LTSY
iDialCancelFlag = CMmCallTsy::EDialCancelCallCalled;
// ??? 3 what about tsyReqHandle?
if ( iCallId > 0 || (GetDialFlag()&& iCallStatus!=RMobileCall::EStatusIdle) )
{
HangUp(tsyReqHandle);
}
}
else
{
// we here. It means that there was no successful request to LTSY
iEmergencyCall = EFalse;
// It looks like some error occurs in synchronous branch
// complete request, using regHandle from aCallbackData
if (EMultimodeCallReqHandleUnknown != aCallbackData.iReqHandle)
{
ReqCompleted( aCallbackData.iReqHandle, aResult );
}
aCallbackData.iReqHandle = EMultimodeCallReqHandleUnknown;
ClearCallStatus();
}
}
else
{
// if we here it means that request to LTSY was sent successfully
iEmergencyCall = ETrue;
UpdateCallRoutingControl( iCallName, iMobileCallStatus );
//update core status
iCallCaps.iFlags &= ~( RCall::KCapsDial );
iCallCaps.iFlags |= RCall::KCapsHangUp;
//complete core caps change
CompleteNotifyCapsChange();
// store reqHandle here, just in case of successful sending request to LTSY
#ifdef REQHANDLE_TIMER
SetTypeOfResponse( EMultimodeMobileCallDialEmergencyCall, aCallbackData.iReqHandle );
#else
iTsyReqHandleStore->SetTsyReqHandle(
EMultimodeMobileCallDialEmergencyCall, aCallbackData.iReqHandle );
#endif
}
}
// ---------------------------------------------------------------------------
// CMmVoiceCallTsy::UpdateCallRoutingControl
// Establishes call routing control and updates its state
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmVoiceCallTsy::UpdateCallRoutingControl(
const TName& aCallName,
RMobileCall::TMobileCallStatus aMobileCallStatus )
{
if ( iTelephonyAudioControl )
{
if ( iTelephonyAudioControlSetup )
{
iTelephonyAudioControl->CallStateChange( aCallName,
aMobileCallStatus );
TFLOGSTRING2("TSY: CMmVoiceCallTsy::UpdateCallRoutingControl. Call routing state changed to EStatusDialling: Call name:%S", &iCallName );
}
else
{
iTelephonyAudioControl->SetupTelephonyAudio(
aCallName,
MTelephonyAudioControl::ECallTypeVoice,
iEmergencyCall,
iCallDirection );
TFLOGSTRING2("TSY: CMmVoiceCallTsy::CMmVoiceCallTsy::UpdateCallRoutingControl. Call routing setup: Call name:%S", &iCallName );
iTelephonyAudioControlSetup = ETrue;
}
}
}
// End of File