/*
* 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: Handles all common logic for SVP and handles sessions.
*
*/
#include <mcevideostream.h>
#include <mceaudiocodec.h>
#include <mcemediasink.h>
#include <mcemediasource.h>
#include <mceevent.h>
#include <mcesession.h>
#include <mceinrefer.h>
#include <mcesecuresession.h>
#include <mcertpsource.h>
#include <mccpdtmfobserver.h>
#include <sipstrings.h>
#include <sipstrconsts.h>
#include <crcseprofileentry.h>
#include <crcseprofileregistry.h>
#include <wlantrafficstreamparameters.h> // CWlanMgmtClient
#include <ccpdefs.h>
#include <featdiscovery.h>
#include "svpcontroller.h"
#include "svpmosession.h"
#include "svpmtsession.h"
#include "svplogger.h"
#include "svptimer.h"
#include "svputility.h"
#include "svpholdcontext.h"
#include "svpholdcontroller.h"
#include "svpcleanupresetanddestroy.h"
#include "svpaudioutility.h"
#include "svpsipconsts.h"
#include "svpemergencyiapprovider.h"
#include "svprtpobserver.h"
#include "svpsettings.h"
#include "svptransferstatecontext.h"
// ---------------------------------------------------------------------------
// CSVPController::CSVPController
// ---------------------------------------------------------------------------
//
CSVPController::CSVPController() : iSessionUpdateOngoing( EFalse )
{
}
// ---------------------------------------------------------------------------
// CSVPController::ConstructL
// ---------------------------------------------------------------------------
//
void CSVPController::ConstructL()
{
SVPDEBUG1( "CSVPController::ConstructL In" )
iIncomingReferCallIndex = KErrNotFound;
iHoldCallIndex = KErrNotFound;
iSuppServices = CSVPSupplementaryServices::NewL();
iSVPUtility = CSVPUtility::NewL();
iRtpObserver = CSVPRtpObserver::NewL();
TBool wlanSupported = CFeatureDiscovery::IsFeatureSupportedL( KFeatureIdProtocolWlan );
#ifndef __WINS__
if ( wlanSupported )
{
iWlanMgmt = CWlanMgmtClient::NewL();
}
#endif // __WINS__
SVPDEBUG1( "CSVPController::ConstructL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::NewL
// ---------------------------------------------------------------------------
//
CSVPController* CSVPController::NewL()
{
CSVPController* self = new ( ELeave ) CSVPController();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CSVPController::~CSVPController
// ---------------------------------------------------------------------------
//
CSVPController::~CSVPController()
{
SVPDEBUG1( "CSVPController::~CSVPController In" )
#ifndef __WINS__
delete iWlanMgmt;
#endif // __WINS__
delete iSVPUtility;
// clean array that contains SVP sessions.
iSessionArray.ResetAndDestroy();
iSessionArray.Close();
// SVP emergency session
delete iEmergencySession;
iEmergencyProfileIds.Close();
iEmergencyIapIds.Close();
delete iSuppServices;
delete iMceManager;
delete iRtpObserver;
delete iDtmfString;
SVPDEBUG1( "CSVPController::~CSVPController Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::InitializeL
// ---------------------------------------------------------------------------
//
void CSVPController::InitializeL( const TUint32 aServiceId,
const MCCPObserver& aMonitor,
const MCCPSsObserver& aSsObserver )
{
SVPDEBUG2( "CSVPController::InitializeL serviceId = %d", aServiceId )
SVPDEBUG2( "CSVPController::InitializeL iCCPMonitor: 0x%x", iCCPMonitor )
//Find callprovider plugin uid that should be used when registering to MCE
TInt ccpUid = SvpSettings::IntPropertyL( aServiceId,
EPropertyCallProviderPluginId );
SVPDEBUG2( "CSVPController::InitializeL callproviderpluginuid=%d", ccpUid )
// See CConvergedCallProvider API documentation. If already called,
// leave with KErrAlreadyExists.
__ASSERT_ALWAYS( !iCCPMonitor, User::Leave( KErrAlreadyExists ) );
__ASSERT_ALWAYS( !iCCPSsObserver, User::Leave( KErrAlreadyExists ) );
__ASSERT_ALWAYS( iSVPUtility, User::Leave( KErrNotReady ) );
__ASSERT_ALWAYS( iRtpObserver, User::Leave( KErrNotReady ) );
// save CCP monitor
iCCPMonitor = const_cast< MCCPObserver* >( &aMonitor );
// save CCP Supplementary Services observer
iCCPSsObserver = const_cast< MCCPSsObserver* >( &aSsObserver );
// get terminal type and wlan mac address, needed for user agent header
iSVPUtility->GetTerminalTypeL( iTerminalType );
iSVPUtility->GetWlanMACAddressL( iWlanMacAddress );
TUid uid = { ccpUid };
// create Mce Manager, establishes connection to Mce server
iMceManager = CMceManager::NewL( uid, &iContainer );
// set observers for asynchronous events
iMceManager->SetSessionObserver( this );
iMceManager->SetInSessionObserver( this );
iMceManager->SetInReferObserver( this );
iMceManager->SetReferObserver( this );
iMceManager->SetMediaObserver( this );
iMceManager->SetEventObserver( this );
iMceManager->SetDtmfObserver( this );
iMceManager->SetRtpObserver( iRtpObserver );
iTrafficStreamCreated = EFalse;
SVPDEBUG1( "CSVPController::InitializeL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::InitializeL
// ---------------------------------------------------------------------------
//
void CSVPController::InitializeL( const MCCPObserver& aMonitor,
const MCCPSsObserver& aSsObserver )
{
SVPDEBUG2( "CSVPController::InitializeL iCCPMonitor: 0x%x", iCCPMonitor )
SVPDEBUG2( "CSVPController::InitializeL iCCPSsObserver: 0x%x", iCCPSsObserver )
// See CConvergedCallProvider API documentation. If already called,
// leave with KErrAlreadyExists.
__ASSERT_ALWAYS( !iCCPMonitor, User::Leave( KErrAlreadyExists ) );
__ASSERT_ALWAYS( !iCCPSsObserver, User::Leave( KErrAlreadyExists ) );
__ASSERT_ALWAYS( iSVPUtility, User::Leave( KErrNotReady ) );
__ASSERT_ALWAYS( iRtpObserver, User::Leave( KErrNotReady ) );
// save CCP monitor
iCCPMonitor = const_cast< MCCPObserver* >( &aMonitor );
// save CCP Supplementary Services observer
iCCPSsObserver = const_cast< MCCPSsObserver* >( &aSsObserver );
// get terminal type and wlan mac address, needed for user agent header
iSVPUtility->GetTerminalTypeL( iTerminalType );
iSVPUtility->GetWlanMACAddressL( iWlanMacAddress );
// create Mce Manager, establishes connection to Mce server
iMceManager = CMceManager::NewL( KSVPImplementationUid, &iContainer );
// set observers for asynchronous events
iMceManager->SetSessionObserver( this );
iMceManager->SetInSessionObserver( this );
iMceManager->SetInReferObserver( this );
iMceManager->SetReferObserver( this );
iMceManager->SetMediaObserver( this );
iMceManager->SetEventObserver( this );
iMceManager->SetDtmfObserver( this );
iMceManager->SetRtpObserver( iRtpObserver );
iTrafficStreamCreated = EFalse;
SVPDEBUG1( "CSVPController::InitializeL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::NewCallL
// ---------------------------------------------------------------------------
//
MCCPCall* CSVPController::NewCallL(
const CCCPCallParameters& aParameters,
const TDesC& aRecipient,
const MCCPCallObserver& aObserver )
{
SVPDEBUG1( "CSVPController::NewCallL In" )
__ASSERT_ALWAYS( &aParameters, User::Leave( KErrArgument ) );
__ASSERT_ALWAYS( &aRecipient, User::Leave( KErrArgument ) );
__ASSERT_ALWAYS( &aObserver, User::Leave( KErrArgument ) );
#ifndef __WINS__
// Preliminary Call Admission Control implementation, run only if no stream yet open
if ( !iTrafficStreamCreated )
{
SVPDEBUG1( "CSVPController::NewCallL - Creating WLAN traffic stream.." )
TRequestStatus requestStatus;
TUint streamId = 0;
TWlanTrafficStreamParameters streamParams( KSVPWlanTrafficStreamParamUserPriority );
TWlanTrafficStreamStatus streamStatus = EWlanTrafficStreamStatusActive;
// Disabling WLAN traffic stream automation and get stream status
iWlanMgmt->CreateTrafficStream( requestStatus, streamParams, streamId, streamStatus );
User::WaitForRequest( requestStatus );
// Save traffic stream ID, needed for stream deletion
iTrafficStreamId = streamId;
if ( EWlanTrafficStreamStatusInactiveNoBandwidth == streamStatus )
{
SVPDEBUG1( "CSVPController::NewCallL - No bandwidth in traffic stream, leaving with ECCPErrorNetworkBusy" )
// Enabling WLAN traffic stream automation back by deleting used stream
iWlanMgmt->DeleteTrafficStream( requestStatus, iTrafficStreamId );
User::WaitForRequest( requestStatus );
TCCPError err = ECCPErrorNetworkBusy;
User::Leave( err );
}
SVPDEBUG1( "CSVPController::NewCallL - WLAN traffic stream created, continuing with NewCallL" )
iTrafficStreamCreated = ETrue;
}
else
{
SVPDEBUG1( "CSVPController::NewCallL - WLAN traffic stream already created, continuing with NewCallL" )
;
}
#endif // __WINS__
SVPDEBUG2( "CSVPController::NewCallL aRecipient length = %d", aRecipient.Length() )
SVPDEBUG2( "CSVPController::NewCallL aRecipient = %S", &aRecipient )
SVPDEBUG2( "CSVPController::NewCallL Serviceid = %d", aParameters.ServiceId() )
// Prepare and remove possible DTMF suffix
HBufC* parsedRecipient = NULL;
parsedRecipient = ParseRecipientDtmfSuffixL( aRecipient );
// "convert" recpient to 8-bit format
HBufC8* recipient = HBufC8::NewLC( parsedRecipient->Length() ); // CS:1
TPtr8 temp = recipient->Des();
temp.Copy( *parsedRecipient );
// Pointer to parsedRecipient no longer needed
delete parsedRecipient;
parsedRecipient = NULL;
// fetch SIP profile ID from VoIP profiles
RPointerArray< CRCSEProfileEntry > entryArray;
CleanupResetAndDestroy<
RPointerArray<CRCSEProfileEntry> >::PushL( entryArray ); //CS:2
CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC(); // CS:3
// take service id to local variable
TUint32 serviceId = aParameters.ServiceId();
// Get VoIP profile by service id
reg->FindByServiceIdL( serviceId, entryArray );
__ASSERT_ALWAYS( entryArray.Count(), User::Leave( KErrArgument ) );
// Take first entry from array
CRCSEProfileEntry* entry = entryArray[0];
// create new session
MCCPCall* moSessionTemp = CreateNewSessionL( *recipient,
*entry,
aParameters,
aObserver );
CleanupStack::PopAndDestroy( 2, &entryArray ); // CS:1
CleanupStack::PopAndDestroy( recipient ); // CS:0
SVPDEBUG1( "CSVPController::NewCallL Out" )
return moSessionTemp;
}
// ---------------------------------------------------------------------------
// CSVPController::CreateNewSessionL
// ---------------------------------------------------------------------------
//
MCCPCall* CSVPController::CreateNewSessionL(
TDesC8& aRecipient,
CRCSEProfileEntry& aVoipProfile,
const CCCPCallParameters& aParameters,
const MCCPCallObserver& aObserver )
{
SVPDEBUG1( "CSVPController::CreateNewSessionL In" )
// array for provisioned data
CDesC8ArrayFlat* userAgentHeaders = new( ELeave ) CDesC8ArrayFlat( 4 );
CleanupStack::PushL( userAgentHeaders ); // CS:1
// variable for storing security status
TUint32 securityStatus( 0 );
// set provisioning data
SVPDEBUG1( "CSVPController::CreateNewSessionL Set provisioning data..." )
iSVPUtility->SetProvisioningDataL( aVoipProfile,
*userAgentHeaders,
securityStatus,
iTerminalType,
iWlanMacAddress );
SVPDEBUG2( "CSVPController::CreateNewSessionL Security status: %d", securityStatus )
SVPDEBUG2( "CSVPController::CreateNewSessionL UAHeaders count: %d", userAgentHeaders->Count() )
// Creates a SVP Mo session
CSVPMoSession* moSessionTemp = CSVPMoSession::NewL( *iMceManager,
aRecipient,
aVoipProfile,
aParameters,
iContainer,
*this,
*iSVPUtility,
*iRtpObserver,
securityStatus,
userAgentHeaders );
CleanupStack::Pop( userAgentHeaders ); // CS:0, to member data
CleanupStack::PushL( moSessionTemp ); // CS:1
FinalizeSessionCreationL( moSessionTemp );
// set CCP session observer to SVP session
moSessionTemp->AddObserverL( aObserver );
// set CCP supplementary services events observer to SVP session
moSessionTemp->SetSsObserver( *iCCPSsObserver );
CleanupStack::Pop( moSessionTemp ); // CS:0
// session pointer is passed to CCP
SVPDEBUG1( "CSVPController::CreateNewSessionL Out" )
return moSessionTemp;
}
// ---------------------------------------------------------------------------
// Releases call
// ---------------------------------------------------------------------------
//
TInt CSVPController::ReleaseCall( MCCPCall& aCall )
{
SVPDEBUG1( "CSVPController::ReleaseCall In" )
TInt response = KErrNotFound;
// To ensure correct value
iIncomingReferCallIndex = KErrNotFound;
iSessionUpdateOngoing = EFalse;
for ( TInt i = 0; i < iSessionArray.Count(); i++ )
{
if ( iSessionArray[i] == &aCall )
{
if ( iDtmfStringSending )
{
SVPDEBUG1( "CSVPController::ReleaseCall - Abort DTMF Sending" )
// send abort event
iSessionArray[i]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfSequenceAbort,
KErrNone,
iDtmfStringLex.Peek() );
SVPDEBUG1( "CSVPController::ReleaseCall - Complete DTMF" )
// send sequence completed event
iSessionArray[i]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfStringSendingCompleted,
KErrNone,
iDtmfStringLex.Peek() );
// sequence complete, clear flags
iDtmfStringSending = EFalse;
iFirstDtmfSent = EFalse;
delete iDtmfString;
iDtmfString = NULL;
}
iSessionArray[i]->Release();
response = KErrNone;
}
}
#ifndef __WINS__
// Preliminary Call Admission Control implementation, delete only if created in NewCallL
if ( iTrafficStreamCreated )
{
SVPDEBUG1( "CSVPController::ReleaseCall - Deleting WLAN traffic stream" )
TRequestStatus requestStatus;
// Enabling WLAN traffic stream automation back by deleting used stream
iWlanMgmt->DeleteTrafficStream( requestStatus, iTrafficStreamId );
User::WaitForRequest( requestStatus );
iTrafficStreamCreated = EFalse;
SVPDEBUG1( "CSVPController::ReleaseCall - WLAN traffic stream deleted" )
}
else
{
SVPDEBUG1( "CSVPController::ReleaseCall - No WLAN traffic stream to delete" )
;
}
#endif // __WINS__
SVPDEBUG1( "CSVPController::ReleaseCall Out" )
return response;
}
// ---------------------------------------------------------------------------
// Releases emergency call
// ---------------------------------------------------------------------------
//
TInt CSVPController::ReleaseEmergencyCall( MCCPEmergencyCall& /*aCall*/ )
{
SVPDEBUG1( "CSVPController::ReleaseEmergencyCall In" )
// To ensure correct value next time
iIncomingReferCallIndex = KErrNotFound;
iSessionUpdateOngoing = EFalse;
delete iEmergencySession;
iEmergencySession = NULL;
SVPDEBUG1( "CSVPController::ReleaseEmergencyCall Out" )
return KErrNone;
}
// ---------------------------------------------------------------------------
// Releases conference call
// ---------------------------------------------------------------------------
//
TInt CSVPController::ReleaseConferenceCall( MCCPConferenceCall& /*aCall*/ )
{
SVPDEBUG1( "CSVPController::ReleaseConferenceCall In" )
SVPDEBUG1( "CSVPController::ReleaseConferenceCall Out" )
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CSVPController::RemoveFromArray
// ---------------------------------------------------------------------------
//
void CSVPController::RemoveFromArray( CSVPSessionBase& aSession )
{
SVPDEBUG1( "CSVPController::RemoveFromArray In" )
// When Sessions destructor is called object be removed from array
// manually after when data has been deleted.
SVPDEBUG2( "CSVPController::RemoveFromArray aSession: 0x%x", &aSession )
TInt index = FindSVPSession( aSession.Session() );
if ( KErrNotFound != index )
{
SVPDEBUG1( "CSVPController::RemoveFromArray Session found - removing" )
iSessionArray.Remove( index );
iSessionArray.Compress();
}
// Try also to remove it from RTCP observer. Ingore the return code, yet
// again this is "just in case" thing.
iRtpObserver->RemoveSessionFromObserving( &aSession );
SVPDEBUG1( "CSVPController::RemoveFromArray Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::FindSVPSession
// ---------------------------------------------------------------------------
//
TInt CSVPController::FindSVPSession( const CMceSession& aSession ) const
{
SVPDEBUG1( "CSVPController::FindSVPSession In" )
TInt count = iSessionArray.Count();
SVPDEBUG2( "CSVPController::FindSVPSession count = %d", count )
while ( count )
{
count--;
if ( &iSessionArray[count]->Session() == &aSession )
{
SVPDEBUG2( "CSVPController::FindSVPSession Out return: %d", count )
return count;
}
}
SVPDEBUG1( "CSVPController::FindSVPSession Out return: KErrNotFound" )
return KErrNotFound;
}
// ---------------------------------------------------------------------------
// CSVPController::Uid
// ---------------------------------------------------------------------------
//
const TUid& CSVPController::Uid() const
{
SVPDEBUG1( "CSVPController::Uid" )
return KSVPImplementationUid;
}
// ---------------------------------------------------------------------------
// CSVPController::CreateNonSecureSessionL
// ---------------------------------------------------------------------------
//
void CSVPController::CreateNonSecureSessionL( TInt aSessionIndex )
{
SVPDEBUG1( "CSVPController::CreateNonSecureSessionL In" )
// secure session failed -> create non secure Mo session
static_cast< CSVPMoSession* >( iSessionArray[ aSessionIndex ] )->
CreateNonSecureSessionL( *iMceManager );
SVPDEBUG1( "CSVPController::CreateNonSecureSessionL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::CheckIfSecureFailed
// ---------------------------------------------------------------------------
//
TBool CSVPController::CheckIfSecureFailed( TInt aStatusCode ) const
{
SVPDEBUG2( "CSVPController::CheckIfSecureFailed In, aStatusCode: %d", aStatusCode )
// if secure fails with the following response codes
// normal session is tried next
if ( KSVPNotAcceptableHereVal == aStatusCode ||
KSVPNotAcceptableVal == aStatusCode ||
KSVPPreconditionFailureVal == aStatusCode ||
KSVPMethodNotAllowedVal == aStatusCode )
{
SVPDEBUG1( "CSVPController::CheckIfSecureFailed Out ETrue" )
return ETrue;
}
else
{
SVPDEBUG1( "CSVPController::CheckIfSecureFailed Out EFalse" )
return EFalse;
}
}
// ---------------------------------------------------------------------------
// CSVPController::SessionStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::SessionStateChanged( CMceSession& aSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::SessionStateChanged In" )
// Note, getting the status code may reset it in the container. So do it
// only once and be sure that it stays as it should be.
const TInt statusCode = aContainer->GetStatusCode();
SVPDEBUG2( "CSVPController::SessionStateChanged statusCode: %d", statusCode )
// check if this is emergency session
if ( iEmergencySession )
{
SVPDEBUG1( "CSVPController::SessionStateChanged, emergency session" )
if ( CMceSession::EEstablished == aSession.State() )
{
// Rest of the profiles not needed since session is established
iEmergencyProfileIds.Reset();
iEmergencyIapIds.Reset();
}
if ( CMceSession::EEstablished == aSession.State() &&
iEmergencySession->HasHoldController() &&
( ( iEmergencySession->HoldController() ).HoldInProgress() ||
( iEmergencySession->HoldController() ).HoldRolledBack() ) )
{
// Handle hold
TRAPD( error, iEmergencySession->HoldSessionStateChangedL( aSession ) )
if ( error )
{
SVPDEBUG2( "CSVPController::SessionStateChanged, emergency session error %d", error )
}
}
else
{
iEmergencySession->SessionStateChanged( statusCode );
}
}
else if ( iSessionUpdateOngoing )
{
// Non-hold session update, e.g. codec renegotiation ongoing; no actions
// needed until MCE session state is established.
SVPDEBUG1( "CSVPController::SessionStateChanged - MT Session Update" )
if ( CMceSession::EEstablished == aSession.State() )
{
// Session update done (Ack received)
iSessionUpdateOngoing = EFalse;
SVPDEBUG1( "CSVPController::SessionStateChanged - MT Session Updated" )
}
}
else
{
// fetch correct session
const TInt ind = FindSVPSession( aSession );
// KErrNone = status, status had to be error code
if ( KErrNotFound != ind &&
iSessionArray[ ind ]->SecurePreferred() &&
CheckIfSecureFailed( statusCode ) ||
CMceSession::ECancelling == aSession.State() )
{
SVPDEBUG1( "CSVPController::SessionStateChanged - Secure failed, trying normal session" )
// trying normal session after secure session trial failed
TRAPD( err, CreateNonSecureSessionL( ind ) );
if ( err )
{
iSessionArray[ ind ]->GetCCPSessionObserver().
ErrorOccurred( ECCPRedirection, iSessionArray[ ind ] );
iSessionArray[ ind ]->GetCCPSessionObserver().
CallStateChanged( MCCPCallObserver::ECCPStateIdle,
iSessionArray[ ind ]);
}
}
else if ( KErrNotFound != ind )
{
SVPDEBUG1( "CSVPController::SessionStateChanged - Session found" )
CSVPSessionBase* session = iSessionArray[ ind ];
if ( !session->CallId() &&
KSVPMultipleChoicesVal != statusCode &&
KSVPMovedPermanentlyVal != statusCode &&
KSVPMovedTemporarilyVal != statusCode )
{
// CallId not stored yet and not a 3XX case,
// check and store headers data.
CheckHeadersData( session, aContainer );
}
if ( !session->SecurePreferred() )
{
session->ReleaseTempSecure();
}
// Release attended transfer target session index
// if e.g. early stage session terminate
if ( CMceSession::ETerminated == aSession.State() )
{
iHoldCallIndex = KErrNotFound;
}
if ( CMceSession::EProceeding == aSession.State() )
{
SVPDEBUG1( "CSVPController::SessionStateChanged EProceeding" )
if ( KErrNotFound != iHoldCallIndex && iSessionArray.Count() > 1 )
{
SVPDEBUG3( "CSVPController::SessionStateChanged, atte trans target, ind %d, iHCInd %d",
ind, iHoldCallIndex )
CheckCallEventToBeSent( session, iSessionArray[iHoldCallIndex] );
ExecCbIncomingCall( session, *iSessionArray[iHoldCallIndex] );
iHoldCallIndex = KErrNotFound;
}
else if ( session->HasHoldController() &&
( session->HoldController() ).HoldInProgress() )
{
// Do nothing here; this only prevents wrong new call
// callback to CCP.
SVPDEBUG1( "CSVPController::SessionStateChanged - HoldInProgress" )
}
else if ( session->IsEmptyReInvite() )
{
SVPDEBUG1( "CSVPController::SessionStateChanged - Empty re-Invite handling ongoing" )
}
else if ( !session->IsIdle() )
{
SVPDEBUG1( "CSVPController::SessionStateChanged - NOP" )
}
else
{
SVPDEBUG1( "CSVPController::SessionStateChanged Incoming" )
ExecCbIncomingCall( session );
session->SessionStateChanged( statusCode );
}
}
else if ( CMceSession::EEstablished == aSession.State() &&
session->HasHoldController() &&
( ( session->HoldController() ).HoldInProgress() ||
( session->HoldController() ).HoldRolledBack() ) )
{
SVPDEBUG1( "CSVPController::SessionStateChanged EEstablished & HoldController" )
session->HandleSessionStateChanged( aSession );
}
else if ( ( CMceSession::EEstablished == aSession.State() ||
CMceSession::ETerminated == aSession.State() ) &&
KErrNone != statusCode &&
KErrNotFound != iIncomingReferCallIndex &&
iIncomingReferCallIndex < iSessionArray.Count() &&
iSessionArray[ iIncomingReferCallIndex ]->IsIncomingTransfer() )
{
SVPDEBUG1( "CSVPController::SessionStateChanged transferor" )
// Transferor sends notify to original when new session connected/failed.
// If secure is mandatory but path unsecure, attended transfer req must be rejected
if ( session->SecureMandatory() &&
CMceSession::EControlPathUnsecure == aSession.ControlPathSecurityLevel() &&
iSessionArray[ iIncomingReferCallIndex ]->IsAttended() )
{
iSessionArray[ iIncomingReferCallIndex ]->SendNotify( KSVPDeclineVal );
}
else
{
iSessionArray[ iIncomingReferCallIndex ]->SendNotify( statusCode );
}
if ( iSessionArray[ iIncomingReferCallIndex ]->IsAttended() )
{
// remotepartyinfo and/or secure status might have been changed,
// proper event will be sent later on.
CheckCallEventToBeSent( session, iSessionArray[iIncomingReferCallIndex] );
}
iIncomingReferCallIndex = KErrNotFound;
session->SessionStateChanged( statusCode );
}
// 3xx Call forward handling
else if ( KSVPMultipleChoicesVal == statusCode ||
KSVPMovedPermanentlyVal == statusCode ||
KSVPMovedTemporarilyVal == statusCode )
{
HandleCallForward( statusCode, ind, aContainer );
}
else
{
if ( ( aSession.State() == CMceSession::EOffering ||
aSession.State() == CMceSession::ETerminating ||
aSession.State() == CMceSession::ETerminated ) &&
iSessionArray[ ind ]->HasHoldController() &&
( ( iSessionArray[ ind ]->HoldController() ).HoldInProgress() ||
( iSessionArray[ ind ]->HoldController() ).HoldRolledBack() ) )
{
// Failed hold e.g. 408 response
SVPDEBUG1("CSVPController::SessionStateChanged()\
State change: Failed && HoldController");
if ( 491 == statusCode )
{
SVPDEBUG1(
"CSVPController::SessionStateChanged - UpdateFailed()" )
UpdateFailed( aSession, aContainer );
}
else if ( 100 <= statusCode && 200 > statusCode ) // Provisional response
{
// NOP
SVPDEBUG1(
"CSVPController::SessionStateChanged - Provisional - NOP" )
}
else
{
iSessionArray[ ind ]->HandleSessionStateChanged( aSession );
session->SessionStateChanged( statusCode );
}
}
else if ( session->HasHoldController() )
{
// MCE Session Refresh; no actions by the SVP
SVPDEBUG1(
"CSVPController::SessionStateChanged - Session refresh" )
if ( CMceSession::ETerminating == aSession.State() ||
CMceSession::ETerminated == aSession.State() )
{
session->SessionStateChanged( statusCode );
}
}
else if ( !iFailed )
{
SVPDEBUG1(
"CSVPController::SessionStateChanged - Not handled -> Notify session" )
session->SessionStateChanged( statusCode );
}
else
{
// Failed() callback occurred before EEstablished state
// -> No action needed, session termination timer is set
}
}
}
else
{
SVPDEBUG1( "CSVPController::SessionStateChanged else" )
}
}
SVPDEBUG1( "CSVPController::SessionStateChanged Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::SessionConnectionStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::SessionConnectionStateChanged(
CMceSession& aSession,
TBool aActive )
{
SVPDEBUG2("CSVPController::SessionConnectionStateChanged Active ETrue, Inactive EFalse: %d", aActive )
if ( iEmergencySession )
{
iEmergencySession->SessionConnectionStateChanged( aSession, aActive );
}
}
// ---------------------------------------------------------------------------
// CSVPController::Failed
// ---------------------------------------------------------------------------
//
#ifdef _DEBUG
void CSVPController::Failed( CMceSession& aSession, TInt aError )
#else
void CSVPController::Failed( CMceSession& aSession, TInt /*aError*/ )
#endif // _DEBUG
{
SVPDEBUG1("CSVPController::Failed In" )
SVPDEBUG2("CSVPController::Failed With error code: %d", aError )
TInt ind = FindSVPSession( aSession );
if ( KErrNotFound != ind )
{
SVPDEBUG1("CSVPController::Failed() Session found")
if ( &iSessionArray[ ind ]->GetCCPSessionObserver() )
{
iSessionArray[ ind ]->GetCCPSessionObserver().
ErrorOccurred( ECCPErrorConnectionError,
iSessionArray[ ind ] );
// Actually MCE session state should always
// be ETerminated when this method is
// called; but check anyway:
if ( CMceSession::ETerminated == aSession.State() )
{
iFailed = ETrue;
// start termination timer, needed for UI
// to handle Disconnected-bubble
TRAP_IGNORE( iSessionArray[ ind ]->StartTimerL(
KSVPTerminatingTime, KSVPTerminationTimerExpired ) );
iSessionArray[ ind ]->GetCCPSessionObserver().
CallStateChanged( MCCPCallObserver::ECCPStateDisconnecting,
iSessionArray[ ind ] );
SVPDEBUG1("CSVPController::Failed() Session terminating");
}
}
else
{
iCCPMonitor->ErrorOccurred( MCCPObserver::ECCPIncomingCallFailed );
}
}
else
{
SVPDEBUG1("CSVPController::Failed() Session not Found!!");
}
SVPDEBUG1("CSVPController::Failed Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::UpdateFailed
// ---------------------------------------------------------------------------
//
void CSVPController::UpdateFailed(
CMceSession& aSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::UpdateFailed In" )
TInt ind = FindSVPSession( aSession );
TInt statusCode = aContainer->GetStatusCode();
SVPDEBUG2( "CSVPController::UpdateFailed statusCode: %d", statusCode )
if ( KErrNotFound != ind )
{
iSessionArray[ ind ]->UpdateFailed( aSession, statusCode );
}
iSessionUpdateOngoing = EFalse;
SVPDEBUG1( "CSVPController::UpdateFailed Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::EventStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::EventStateChanged(
CMceEvent& aEvent,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController:EventStateChanged In" )
iContainer = *aContainer;
TInt ind = FindSVPSession( *aEvent.AssociatedSession() );
TInt statusCode = iContainer.GetStatusCode();
SVPDEBUG2( "CSVPController:EventStateChanged statusCode: %d", statusCode )
if ( KErrNotFound != ind )
{
SVPDEBUG2( "CSVPController::EventStateChanged ind = %d", ind )
TInt err = iSessionArray[ ind ]->EventStateChanged( aEvent, statusCode );
if ( KSVPOKVal == statusCode &&
iSessionArray[ ind ]->IsAttended() &&
KErrNone == err )
{
SVPDEBUG1( "CSVPController::EventStateChanged Atte transfer cont." )
TRAP( err, CreateNewTransferSessionL( ind, ETrue ) );
if ( err )
{
SVPDEBUG2( "CSVPController::EventStateChanged: err: %d", err )
}
}
}
else
{
SVPDEBUG1( "CSVPController::EventStateChanged Session not Found!!" )
}
SVPDEBUG1("CSVPController:EventStateChanged OUT");
}
// ---------------------------------------------------------------------------
// CSVPController::NotifyReceived
// ---------------------------------------------------------------------------
//
void CSVPController::NotifyReceived(
CMceEvent& aEvent,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::NotifyReceived In" )
TInt ind = FindSVPSession( *aEvent.AssociatedSession() );
if ( KErrNotFound != ind )
{
iSessionArray[ ind ]->NotifyReceived( aEvent, aContainer );
}
else
{
SVPDEBUG1( "CSVPController::NotifyReceived, session not found !" )
}
SVPDEBUG1( "CSVPController::NotifyReceived Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::EventConnectionStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController:: EventConnectionStateChanged(
CMceEvent& /*aEvent*/,
TBool /*aActive*/ )
{
SVPDEBUG1( "CSVPController:: EventConnectionStateChanged In" )
SVPDEBUG1( "CSVPController:: EventConnectionStateChanged Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::Failed
// ---------------------------------------------------------------------------
//
#ifdef _DEBUG
void CSVPController::Failed( CMceEvent& /*aEvent*/, TInt aError )
#else
void CSVPController::Failed( CMceEvent& /*aEvent*/, TInt /*aError*/ )
#endif // _DEBUG
{
SVPDEBUG2("CSVPController::Failed Event failure, error: %d", aError )
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingSession
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingSession(
CMceInSession* aSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::IncomingSession In" )
SVPDEBUG2( "CSVPController::IncomingSession - status code: %d", aContainer->GetStatusCode() )
if ( iEmergencySession )
{
SVPDEBUG1( "CSVPController::IncomingSession - ongoing emergency call - reject incoming call" )
TRAP_IGNORE( aSession->RejectL( KSVPBusyHereReason, KSVPBusyHereVal ) )
// Ownership of aSession is changed, delete it
delete aSession;
aSession = NULL;
return;
}
// IncomingSessionHandlerL is used to handle possible leave
SVPDEBUG1( "CSVPController::IncomingSession IncomingSessionHandlerL" )
TRAPD( err, IncomingSessionHandlerL( aSession, aContainer ) );
if ( err )
{
SVPDEBUG2( "CSVPController::IncomingSession: err: %d", err )
// RejectL must be called in case SVP needs to delete session.
// TRAP is used because of RejectL might contain a leaver.
switch ( err )
{
case KErrNotSupported:
{
TRAP( err, aSession->RejectL( KSVPCallTransactDoesNotExistReason,
KSVPCallDoesNotExistVal ) );
break;
}
case KSVPErrWrongMinSE:
// NOP. Reject has been done as a result of call to
// IncomingSessionHandlerL.
break;
case KSVPErrDnDRejection:
{
// Reject call because of Do not Disturb service active.
TRAP( err, aSession->RejectL( KSVPBusyHereReason,
KSVPBusyHereVal ) );
break;
}
case KSVPErrAnonymousCallRejection:
{
// Reject call because of Anonymous Barring service active.
TRAP( err, aSession->RejectL( KSVPNotAcceptableHereReason,
KSVPNotAcceptableHereVal ) );
break;
}
case KSVPErrCodecMismatch:
{
TRAP( err, aSession->RejectL( KSVPIncompatibleMediaFormatReason,
KSVPNotAcceptableHereVal ) );
break;
}
default:
{
// NOP.
break;
}
}
if ( KErrNotFound == FindSVPSession( *aSession ) )
{
// Leave has occured before CSVPMtSession was created.
delete aSession;
}
else
{
SVPDEBUG1( "CSVPController::IncomingSession IncomingSessionHandlerL leave occurred" )
// clean up session
TerminateSession( *aSession );
}
}
}
// ---------------------------------------------------------------------------
// CSVPController::TerminateSession
// ---------------------------------------------------------------------------
//
void CSVPController::TerminateSession( CMceInSession& aSession )
{
SVPDEBUG1( "CSVPController::TerminateSession In" )
// find correct session
TInt index = FindSVPSession( aSession );
if ( KErrNotFound != index )
{
CSVPSessionBase* tempBase = iSessionArray[ index ];
// remove session pointer from array and compress array
iSessionArray.Remove( index );
iSessionArray.Compress();
// delete session
delete tempBase;
tempBase = NULL;
}
SVPDEBUG1( "CSVPController::TerminateSession Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::CheckMinSessionExpiresL
// ---------------------------------------------------------------------------
//
void CSVPController::CheckMinSessionExpiresL( CMceInSession& aSession,
CDesC8Array& aHeaders,
TInt aMinSE )
{
SVPDEBUG1( "CSVPController::CheckMinSessionExpiresL In" )
TInt count = aHeaders.MdcaCount();
TUint32 sessionExpires = 0;
TInt error = KErrNone;
while ( count-- )
{
TPtrC8 tmpHeader = aHeaders.MdcaPoint( count );
if ( KErrNotFound != tmpHeader.Find( KSVPSessionExpires ) )
{
// "Session-Expires:" found
SVPDEBUG1( "CSVPController::CheckMinSEL: 'Session-Expires:' found" )
TInt offset = tmpHeader.FindF( KSVPRefresher );
if ( KErrNotFound != offset )
{
tmpHeader.Set( tmpHeader.Left( offset ) );
}
TPtrC8 header;
header.Set( tmpHeader );
if ( header.FindF( KSVPCln ) )
{
// 5 digits should be enought for Min-SE
// For example: "Min-SE: 1200"
TLex8 expires( header.Right( 5 ) );
TInt digits = 0;
while ( !expires.Eos() )
{
if ( expires.Peek().IsDigit() )
{
digits++;
}
expires.Inc();
}
TLex8 expiresVal( header.Right( digits ) );
error = expiresVal.Val( sessionExpires, EDecimal );
SVPDEBUG2(" CSVPController::CheckMinSEL sesExp: %d", sessionExpires )
if ( error || aMinSE > sessionExpires )
{
SVPDEBUG2(" CSVPController::CheckMinSEL reject, err: %d", error )
CDesC8ArrayFlat* minSEHeader =
new ( ELeave ) CDesC8ArrayFlat( 1 );
CleanupStack::PushL( minSEHeader ); // CS:0
HBufC8* header = HBufC8::NewL(
KSVPMinExpiresLenght + digits );
CleanupStack::PushL( header ); // CS:1
header->Des().Copy( KSVPMinSessionExpires );
header->Des().AppendNum( aMinSE );
minSEHeader[ 0 ].AppendL( *header );
CleanupStack::PopAndDestroy( header ); // CS:1
aSession.RejectL( KSVPIntervalTooSmallReason,
KSVPSessionIntervalTooSmallVal,
minSEHeader );
// ownership to Mce
CleanupStack::Pop( minSEHeader ); // CS:0
User::Leave( KSVPErrWrongMinSE );
}
}
}
}
SVPDEBUG1( "CSVPController::CheckMinSessionExpiresL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::FetchExpiresTime
// ---------------------------------------------------------------------------
//
void CSVPController::FetchExpiresTime( TUint32& aExpiresTime,
CDesC8Array& aHeaders ) const
{
SVPDEBUG1( "CSVPController::FetchExpiresTime In" )
TBool expiresTaken = EFalse;
for ( TInt i = 0; i < aHeaders.MdcaCount() && !expiresTaken; i++ )
{
TPtrC8 tmpHeader = aHeaders.MdcaPoint( i );
if ( KErrNotFound != tmpHeader.Find( KSVPExpiresHeader ) &&
KErrNotFound == tmpHeader.Find( KSVPSessionExpires ) )
{
// "Expires:" found
SVPDEBUG1(" CSVPController::FetchExpiresTimer: 'Expires:' found")
TInt colonMark = tmpHeader.FindF( KSVPCln );
if ( colonMark )
{
TLex8 expires( tmpHeader.Right( 5 ) ); // three digits max
TInt digits = 0;
while ( !expires.Eos() )
{
if ( expires.Peek().IsDigit() )
{
digits++;
}
expires.Inc();
}
TLex8 expiresVal( tmpHeader.Right( digits ) );
TInt error = expiresVal.Val( aExpiresTime, EDecimal );
if ( error )
{
SVPDEBUG2(" CSVPController::FetchExpiresTimer, set default value\
Val error: %d", error );
// if error occurred, set default time
aExpiresTime = KSVPDefaultExpiresTime;
expiresTaken = ETrue;
}
else if ( KSVPDefaultExpiresTime < aExpiresTime )
{
aExpiresTime = KSVPDefaultExpiresTime;
expiresTaken = ETrue;
}
else
{
SVPDEBUG2(" CSVPController::FetchExpiresTime: %d", aExpiresTime )
expiresTaken = ETrue;
}
}
}
}
SVPDEBUG1( "CSVPController::FetchExpiresTime Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingSessionHandlerL
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingSessionHandlerL( CMceInSession* aSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL In" )
__ASSERT_ALWAYS( aSession, User::Leave( KErrArgument ) );
__ASSERT_ALWAYS( aContainer, User::Leave( KErrArgument ) );
CDesC8Array* headers = aContainer->GetHeaders();
__ASSERT_ALWAYS( headers, User::Leave( KErrArgument ) );
CleanupStack::PushL( headers ); // CS:1
IsTransferTargetCaseL( headers );
// check if Require header contains precondition and that Supported header
// includes option tag 100rel, providing support for PRACK's
iPreconditions = IsPreconditionRequired( *headers );
// Default expiration time (120 s) is set due IOP issue,
// otherwise incoming call would continue eternity in some cases.
TUint32 expireTime = KSVPDefaultExpiresTime;
// check if expires header is present and update expiration time
FetchExpiresTime( expireTime, *headers );
// mt session temp
CSVPMtSession* mtSessionTemp = NULL;
CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC(); // CS:2
RPointerArray< CRCSEProfileEntry > voipProfiles;
CleanupResetAndDestroy< RPointerArray< CRCSEProfileEntry > >::PushL(
voipProfiles ); // CS:3
reg->FindBySIPProfileIdL( aSession->Profile(), voipProfiles );
// Take first profile from the array
const TUint32 voipProfileId = voipProfiles[ 0 ]->iId;
const TUint32 minSE = voipProfiles[ 0 ]->iSIPMinSE;
CheckMinSessionExpiresL( *aSession, *headers, minSE );
SVPDEBUG2("CSVPController::IncomingSessionHandlerL VoIP profile id: %d",
voipProfileId );
// Take first profile from the array
const TUint32 serviceId = voipProfiles[ 0 ]->iServiceProviderId;
SVPDEBUG2("CSVPController::IncomingSessionHandlerL Service id: %d",
serviceId );
// create SIP and ProfileRegistry for profile handling
CSIP* sip = CSIP::NewLC( KSVPUid, *this ); // CS: 4
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL sip CREATED" );
CSIPProfileRegistry* sipProfileRegistry =
CSIPProfileRegistry::NewLC( *sip, *this ); // CS: 5
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL\
profile registry CREATED" );
// retrieve SIP profile by using sip profile id, note ownership transfer
CSIPProfile* profile = sipProfileRegistry->ProfileL( aSession->Profile() );
// Get keep-alive timer value
TUint32 iapId = 0;
TBool found = EFalse;
TInt keepAliveValue;
profile->GetParameter( KSIPAccessPointId, iapId );
TRAPD( errKeepAlive,
found = iSVPUtility->GetKeepAliveByIapIdL( iapId, keepAliveValue ) );
SVPDEBUG3( "CSVPController::IncomingSessionHandlerL\
GetKeepAliveByIapIdL: errKeepAlive = %d found = %d",
errKeepAlive, found );
if ( !found )
{
const TDesC8* aor;
profile->GetParameter( KSIPUserAor, aor );
TRAP( errKeepAlive, found =
iSVPUtility->GetKeepAliveByAORL( *aor, keepAliveValue ) );
SVPDEBUG3( "CSVPController::IncomingSessionHandlerL\
GetKeepAliveByAORL: errKeepAlive = %d found = %d",
errKeepAlive, found );
}
delete profile;
CleanupStack::PopAndDestroy( 2, sip ); // CS:3
CMceRtpSource* rtpSource = NULL;
// modify codecs and codec settings if streams found
if ( aSession->Streams().Count() )
{
const RPointerArray<CMceMediaStream>& streams = aSession->Streams();
SVPDEBUG2("CSVPController::IncomingSessionHandlerL Streamcount: %d",
streams.Count() );
// disable rtp source and speaker sink so that audio is not on
// before session is up signalling-wise
for ( TInt i = 0; i < streams.Count(); i++ )
{
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL disabling" );
CMceMediaStream* stream1 = streams[i];
// if stream is not audio stream -> remove
if ( KMceAudio != stream1->Type() )
{
aSession->RemoveStreamL( *streams[ i ] );
}
else
{
// search for RTP source
if ( stream1->Source() &&
KMceRTPSource == stream1->Source()->Type() )
{
SVPDEBUG1(
"CSVPController::IncomingSessionHandlerL\
RTPSource found" );
rtpSource = static_cast<CMceRtpSource*>(
stream1->Source() );
}
SVPAudioUtility::DisableSpeakerSinkL( stream1->Sinks() );
SVPAudioUtility::DisableMicSourceL( *stream1 );
}
}
// sets MMF priorities and sets codec specific settings
CheckStreamsL( *voipProfiles[ 0 ], *aSession, keepAliveValue );
if ( rtpSource )
{
iSVPUtility->UpdateJitterBufferSizeL( *rtpSource );
}
// create SVP Mt session
mtSessionTemp = CSVPMtSession::NewL( aSession,
iContainer,
serviceId,
voipProfileId,
*this,
*iSVPUtility,
*iRtpObserver,
keepAliveValue,
iPreconditions );
CleanupStack::PushL( mtSessionTemp );
FinalizeSessionCreationL( mtSessionTemp );
CleanupStack::Pop( mtSessionTemp );
}
else
{
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL NO streams!" );
// no streams found, handle streams like in Mo-case
mtSessionTemp = CSVPMtSession::NewL( aSession,
iContainer,
serviceId,
voipProfileId,
*this,
*iSVPUtility,
*iRtpObserver,
keepAliveValue,
iPreconditions );
CleanupStack::PushL( mtSessionTemp );
// construct audio streams
mtSessionTemp->ConstructAudioStreamsL();
FinalizeSessionCreationL( mtSessionTemp );
CleanupStack::Pop( mtSessionTemp );
}
CleanupStack::PopAndDestroy( 3, headers ); // CS:0
// set expires timer
if ( expireTime )
{
SVPDEBUG2( "CSVPController::IncomingSessionHandlerL expireTime: %i s.", expireTime );
mtSessionTemp->StartTimerL( KSVPMilliSecondCoefficient * expireTime,
KSVPExpiresTimeExpired );
}
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL Updating call" );
aSession->UpdateL();
SVPDEBUG2( "CSVPController::IncomingSessionHandlerL, Call state after update: %i",
aSession->State() );
if ( CMceSession::EProceeding == aSession->State() )
{
const TInt ind = FindSVPSession( *aSession );
iCCPMonitor->IncomingCall( iSessionArray[ ind ] );
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL - EProceeding" );
iSessionArray[ ind ]->SessionStateChanged( KErrNone );
}
// reset flag
iPreconditions = EFalse;
SVPDEBUG1( "CSVPController::IncomingSessionHandlerL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::CheckStreamsL
// ---------------------------------------------------------------------------
//
void CSVPController::CheckStreamsL( CRCSEProfileEntry& aVoipProfile,
CMceSession& aInSession,
TInt aKeepAliveValue,
TBool aSessionUpdateOngoing)
{
SVPDEBUG1( "CSVPController::CheckStreamsL In" )
__ASSERT_ALWAYS( &aInSession, User::Leave( KErrArgument ) );
const RPointerArray< CMceMediaStream >& streamArray =
aInSession.Streams();
const TInt streamCount( streamArray.Count() );
SVPDEBUG3("CSVPController::CheckStreamsL aVoIPProfileId: %u streamCount: %d ",
aVoipProfile.iId, streamCount );
// Set codec settings, this also removes unneeded codecs.
for ( TInt i = 0; i < streamCount; i++ )
{
iSVPUtility->SetAudioCodecsMTL( aVoipProfile,
*streamArray[ i ],
aKeepAliveValue,
aSessionUpdateOngoing );
// Set the priorities for the remaining codecs. This will handle also the
// DTMF priorites once correct codecs are set in the streams. Also note
// the downlink/uplink (in/out) discrimination.
if ( KMceAudio == streamArray[i]->Type() &&
streamArray[i]->BoundStream() )
{
SVPDEBUG2( "CSVPController::CheckStreamsL round: %d start", i )
CMceAudioStream* stream = static_cast<CMceAudioStream*>( streamArray[i] );
TBool dtmfMode = EFalse;
if ( SVPAudioUtility::IsDownlinkStream( *stream ) )
{
dtmfMode = SVPAudioUtility::SetPriorityCodecValuesL( *stream,
static_cast<CMceAudioStream&>( stream->BoundStreamL() ) );
}
else
{
dtmfMode = SVPAudioUtility::SetPriorityCodecValuesL(
static_cast<CMceAudioStream&>( stream->BoundStreamL() ),
*stream );
}
iSVPUtility->SetDtmfMode( dtmfMode );
SVPDEBUG2( "CSVPController::CheckStreamsL round: %d done", i )
}
}
SVPDEBUG1( "CSVPController::CheckStreamsL Out" )
}
// -----------------------------------------------------------------------------
// CSVPController::GetCallIdFromUserHeadersL
// Extract call id from user headers
// -----------------------------------------------------------------------------
//
TBool CSVPController::GetCallIdFromUserHeadersL(
const CDesC8Array& aUserHeaders,
TDes8& aCallId )
{
// All variables is used for parser.
TInt tmpMark1 = 0;
TInt tmpMark2 = 0;
TBool found = EFalse;
// Find replaces header descriptor from userheaders array.
for ( TInt m = 0; &aUserHeaders && m < aUserHeaders.Count() && !found; m++ )
{
TPtrC8 tmpHeader = aUserHeaders[m];
if ( KErrNotFound != tmpHeader.FindF( KSVPReplacesColonTxt ) )
{
SVPDEBUG1(" CSVPController::\
GetCallIdFromUserHeadersL: Replaces: found:");
// variables used for parse tags from replaces header.
tmpMark1 = tmpHeader.Locate( KSVPColonMark );
tmpMark2 = tmpHeader.Locate( KSVPSemiColonMark );
if ( KErrNotFound == tmpMark1 ||
KErrNotFound == tmpMark2 )
{
SVPDEBUG3("CSVPController::GetCallIdFromUserHeadersL leave \
tmpMark1: %d, tmpMark2: %d", tmpMark1, tmpMark2 )
User::Leave( KErrArgument );
}
// Call id is between tmpMark1 and tmpMark2 and there is a space
// between Replaces: -text and callid
if ( ( tmpHeader.Mid( tmpMark1+2, tmpMark2 - tmpMark1 - 2 ).Length() < KSVPTempStringlength ) )
{
aCallId.Copy(
tmpHeader.Mid( tmpMark1+2, tmpMark2 - tmpMark1 - 2 ) );
found = ETrue;
}
else
{
SVPDEBUG1(" CSVPController::\
GetCallIdFromUserHeadersL: Replaces: Too long, Leave");
User::Leave( KErrArgument );
}
}
}
SVPDEBUG2( "CSVPController::GetCallIdFromUserHeadersL return %d", found )
return found;
}
// -----------------------------------------------------------------------------
// CSVPController::IsTransferTargetCaseL
// -----------------------------------------------------------------------------
//
void CSVPController::IsTransferTargetCaseL( CDesC8Array* aHeaders )
{
SVPDEBUG1( "CSVPController::IsTransferTargetCaseL In" )
iHoldCallIndex = KErrNotFound;
TBool found = EFalse;
if ( aHeaders && aHeaders->Count() )
{
// Variable to contain callID from replaces header.
TBuf8< KSVPTempStringlength > repCallId( KNullDesC8 );
// This is transfer session if Replaces: text is found from userheader
if ( GetCallIdFromUserHeadersL( *aHeaders, repCallId ) )
{
SVPDEBUG1( " CSVPController::IsTransferTargetCaseL: \
(attended) Transfer target case" )
if ( repCallId.Length() != 0 )
{
// Find from SVP session array a session including same CallId
// that parsed from replace header.
for ( TInt v = 0; v < iSessionArray.Count() && !found; v++ )
{
SVPDEBUG2( " CSVPController::IsTransferTargetCaseL v=%d", v )
TBuf8< KSVPTempStringlength > holdCallId( KNullDesC8 );
TDesC8* callid2 = iSessionArray[v]->CallId();
if ( callid2 )
{
TInt index = callid2->Find( KSVPCallId_replaces );
holdCallId.Append(
callid2->Mid( index + KSVPCallId_replaces().Length() ) );
SVPDEBUG2( "CSVPController::IsTransferTargetCaseL: SesState: %d",
iSessionArray[v]->State() )
if ( repCallId == holdCallId &&
MCCPCallObserver::ECCPStateDisconnecting !=
iSessionArray[v]->State() )
{
iHoldCallIndex = v;
}
}
}
if ( KErrNotFound == iHoldCallIndex )
{
SVPDEBUG1("CSVPController::IsTransferTargetCaseL: \
sessions or CallIds does not match, leave !!!" )
User::Leave( KErrNotSupported );
}
}
else
{
SVPDEBUG1("CSVPController::IsTransferTargetCaseL: \
Transfer session but CallId wasn't found, leave !!!" )
User::Leave( KErrNotSupported );
}
}
else
{
TSupplementaryServicesEvent restrictEvent =
iSuppServices->CheckRestrictionsL( *aHeaders );
if ( ESVPSSDoNotDisturb == restrictEvent )
{
User::Leave( KSVPErrDnDRejection );
}
if ( ESVPSSAnonymousBarring == restrictEvent )
{
User::Leave( KSVPErrAnonymousCallRejection );
}
SVPDEBUG1(" CSVPController::IsTransferTargetCaseL: \
Normal incoming case");
}
}
SVPDEBUG2( "CSVPController::IsTransferTargetCaseL Out iHoldCallIndex: %d",
iHoldCallIndex )
}
// --------------------------------------------------------------------------
// CSVPController::IsPreconditionRequired
// Check if Require header contains precondition and that Supported header
// includes option tag 100rel, providing support for PRACK's
// --------------------------------------------------------------------------
TBool CSVPController::IsPreconditionRequired( CDesC8Array& aHeaders )
{
SVPDEBUG1( "CSVPController::IsPreconditionRequired In" )
TInt count = aHeaders.MdcaCount();
TBool require = EFalse;
TBool supported = EFalse;
while ( count-- )
{
TPtrC8 tmpHeader = aHeaders.MdcaPoint( count );
if ( KErrNotFound != tmpHeader.Find( KSVPRequire ) && !require )
{
// "Require:" found
SVPDEBUG1( "CSVPController::IsPreconditionRequired 'Require-header' found" )
if ( tmpHeader.FindF( KSVPPrecondition ) )
{
// "precondition" found in Require header field
SVPDEBUG1( "CSVPController::IsPreconditionRequired 'precondition' found" )
require = ETrue;
}
}
else if ( KErrNotFound != tmpHeader.Find( KSVPSupported ) && !supported )
{
// "Supported:" found
SVPDEBUG1( "CSVPController::IsPreconditionRequired 'Supported-header' found" )
if ( tmpHeader.FindF( KSVP100rel ) )
{
// "100rel" found in Supported header field
SVPDEBUG1( "CSVPController::IsPreconditionRequired '100rel' found" )
supported = ETrue;
}
}
}
if ( require && supported )
{
SVPDEBUG1( "CSVPController::IsPreconditionRequired return ETrue" )
return ETrue;
}
SVPDEBUG1( "CSVPController::IsPreconditionRequired return EFalse" )
return EFalse;
}
// ---------------------------------------------------------------------------
// CSVPController::CheckHeadersData
// Check and store data (FromHeader, ToHeader, CallId) from the headers
// to the SessionBase.
// ---------------------------------------------------------------------------
//
void CSVPController::CheckHeadersData( CSVPSessionBase* aSVPSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::CheckHeadersData In" )
TRAPD( stringErr, SIPStrings::OpenL() );
if ( KErrNone == stringErr )
{
// get headers
CDesC8Array* headers = aContainer->GetHeaders();
RStringF fromHdr = SIPStrings::StringF(SipStrConsts::EFromHeader);
RStringF fromCompHdr = SIPStrings::StringF(SipStrConsts::EFromHeaderCompact);
RStringF toHdr = SIPStrings::StringF(SipStrConsts::EToHeader);
RStringF toCompHdr = SIPStrings::StringF(SipStrConsts::EToHeaderCompact);
RStringF callidHdr = SIPStrings::StringF(SipStrConsts::ECallIDHeader);
RStringF callidCompHdr = SIPStrings::StringF(SipStrConsts::ECallIDHeaderCompact);
RStringF cSeqHdr = SIPStrings::StringF(SipStrConsts::ECSeqHeader);
if ( headers )
{
TBool fromFound( EFalse );
TBool toFound( EFalse );
TBool callIdFound( EFalse );
TBool cSeqFound( EFalse );
for( TInt i = 0;i < headers->MdcaCount();i++ )
{
TPtrC8 tmpHeader = headers->MdcaPoint( i );
TInt colonMark = tmpHeader.FindF( KSVPCln );
SVPDEBUG2( "CSVPController::CheckHeadersData colonMark=%d", colonMark )
TInt fromHdrPos = tmpHeader.FindF( fromHdr.DesC() );
TInt fromCompHdrPos = tmpHeader.FindF( fromCompHdr.DesC() );
TInt toHdrPos = tmpHeader.FindF( toHdr.DesC() );
TInt toCompHdrPos = tmpHeader.FindF( toCompHdr.DesC() );
TInt callidHdrPos = tmpHeader.FindF( callidHdr.DesC() );
TInt callidCompHdrPos = tmpHeader.FindF( callidCompHdr.DesC() );
TInt cSeqHdrPos = tmpHeader.FindF( cSeqHdr.DesC() );
// Header name is separeted by colonmark from header body.
// There might be space between name and colonmark.
if ( !fromFound &&
( (KErrNotFound < fromHdrPos && fromHdrPos < colonMark) ||
(KErrNotFound < fromCompHdrPos && fromCompHdrPos < colonMark ) ) )
{
fromFound = ETrue;
aSVPSession->SetFromHeader( headers->MdcaPoint( i ) );
}
else if ( !toFound &&
( (KErrNotFound < toHdrPos && toHdrPos < colonMark) ||
(KErrNotFound < toCompHdrPos && toCompHdrPos < colonMark ) ) )
{
toFound = ETrue;
aSVPSession->SetToHeader( headers->MdcaPoint( i ) );
}
else if ( !callIdFound &&
( (KErrNotFound < callidHdrPos && callidHdrPos < colonMark) ||
(KErrNotFound < callidCompHdrPos && callidCompHdrPos < colonMark ) ) )
{
callIdFound = ETrue;
aSVPSession->SetCallId( headers->MdcaPoint( i ) );
}
else if ( !cSeqFound &&
KErrNotFound < cSeqHdrPos && cSeqHdrPos < colonMark )
{
cSeqFound = ETrue;
aSVPSession->SetCSeqHeader( headers->MdcaPoint( i ) );
}
}
}
SIPStrings::Close();
delete headers;
headers = NULL;
}
else
{
SVPDEBUG2( "CSVPController::CheckHeadersData stringErr=%d", stringErr )
}
SVPDEBUG1( "CSVPController::CheckHeadersData Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::CheckContactData
// Check and store contact data from the headers to the MoSession
// ---------------------------------------------------------------------------
//
TInt CSVPController::CheckContactData( CSVPSessionBase* aSVPSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::CheckContactData In" )
TInt count( 0 );
TRAPD( stringErr, SIPStrings::OpenL() );
if ( KErrNone == stringErr && aSVPSession->IsMobileOriginated() )
{
CDesC8Array* headers = aContainer->GetHeaders();
if ( headers )
{
RStringF contactHdr = SIPStrings::StringF(SipStrConsts::EContactHeader);
RStringF contactHdrComp = SIPStrings::StringF(SipStrConsts::EContactHeaderCompact);
CSVPMoSession* moSession = static_cast< CSVPMoSession* >( aSVPSession );
moSession->ResetForwardAddressChoices();
TInt ret( 0 );
for( TInt i( 0 ); i < headers->MdcaCount(); i++ )
{
TPtrC8 tmpHeader = headers->MdcaPoint( i );
TInt colonMark = tmpHeader.FindF( KSVPCln );
TPtrC8 left = tmpHeader.Left( colonMark ); // string until to first colon mark
if ( left.CompareF( contactHdr.DesC() ) == KErrNone ||
left.CompareF( contactHdrComp.DesC() ) == KErrNone )
{
SVPDEBUG1( "CSVPController::CheckContactData - Contact header found" )
// Get the remaining part of the contact header string and
// send it to mo session for parsing
TPtrC8 right = tmpHeader.Right(
tmpHeader.Length() - left.Length() - 1 );
TRAPD( addErr, ret = moSession->AddForwardAddressL( right ) );
if (KErrNone == addErr)
{
count = count + ret;
}
else
{
SVPDEBUG2( "CSVPController::CheckContactData: addErr = %d", addErr )
}
}
}
}
else
{
SVPDEBUG1( "CSVPController::CheckContactData No headers" )
}
SIPStrings::Close();
delete headers;
headers = NULL;
}
else
{
SVPDEBUG2( "CSVPController::CheckContactData stringErr=%d", stringErr )
}
SVPDEBUG2( "CSVPController::CheckContactData Out return=%d", count )
return count;
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingUpdate
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingUpdate(
CMceSession& aOrigSession,
CMceInSession* aUpdatedSession,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::IncomingUpdate In" )
iContainer = *aContainer;
const TInt sessionIndex = FindSVPSession( aOrigSession );
if ( KErrNotFound != sessionIndex )
{
SVPDEBUG1( "CSVPController::IncomingUpdate - Session found" )
// handle RE-INVITE without SDP
if ( !aUpdatedSession->Streams().Count() )
{
SVPDEBUG1( "CSVPController::IncomingUpdate No streams present" )
// this call sets iEmptyReInvite flag to ETrue for session,
// flag prevents "ghots session" to be seen on UI
// when empty Re-Invite is received
iSessionArray[ sessionIndex ]->SetEmptyReInvite();
#ifdef _DEBUG
TRAPD( noSdpErr, IncomingUpdateNoSdpHandlerL( sessionIndex,
aUpdatedSession ) );
SVPDEBUG2( "CSVPController::IncomingUpdate trapped: %d", noSdpErr )
#else // _UREL
TRAP_IGNORE( IncomingUpdateNoSdpHandlerL(
sessionIndex, aUpdatedSession ) )
#endif // _DEBUG
}
else
{
SVPDEBUG1( "CSVPController::IncomingUpdate - Normal case" )
IncomingNormalUpdate( sessionIndex,
aOrigSession, aUpdatedSession );
}
SVPDEBUG1( "CSVPController::IncomingUpdate - Handled" )
}
else if ( iEmergencySession &&
aUpdatedSession &&
aUpdatedSession->Streams().Count() )
{
// Handle emergency hold
TRAPD( error, iEmergencySession->IncomingRequestL(
aUpdatedSession, iContainer ) );
if ( error )
{
SVPDEBUG2( "CSVPController::IncomingUpdate, emergency error=%d",
error )
}
}
SVPDEBUG1( "CSVPController::IncomingUpdate Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingNormalUpdate
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingNormalUpdate( TInt aSessionIndex,
CMceSession& aOrigSession,
CMceInSession* aUpdatedSession )
{
SVPDEBUG1( "CSVPController::IncomingNormalUpdate In" )
TInt err = iSessionArray[ aSessionIndex ]->IncomingRequest(
*aUpdatedSession );
if ( KErrSVPHoldNotHoldRequest == err )
{
SVPDEBUG1( "CSVPController::IncomingNormalUpdate - Not Hold/Resume" )
if ( iSessionArray[ aSessionIndex ]->HasHoldController() &&
KSVPHoldConnectedStateIndex != iSessionArray[ aSessionIndex ]->
HoldController().HoldState() )
{
// Hold is active; must update MCE streams state
// correspondingly
TRAP( err, iSessionArray[ aSessionIndex ]->HoldController().
RefreshHoldStateL() );
SVPDEBUG2( "CSVPController::IncomingNormalUpdate - Err: %d", err )
}
TRAP( err, UpdateSessionL( aOrigSession, *aUpdatedSession ) );
SVPDEBUG2( "CSVPController::IncomingNormalUpdate - Updated err: %d",
err )
}
else if ( iDtmfStringSending )
{
SVPDEBUG1( "CSVPController::IncomingNormalUpdate - Dtmf sending will be stopped" )
// send stop event to the previous character in string
// Default tone char
TChar dtmfToneChar( '0' );
iSessionArray[ aSessionIndex ]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfSequenceStop,
KErrNone,
dtmfToneChar );
// send sequence stop event
iSessionArray[ aSessionIndex ]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfStringSendingCompleted,
KErrNone,
dtmfToneChar );
// sequence complete, clear flags
iDtmfStringSending = EFalse;
iFirstDtmfSent = EFalse;
SVPDEBUG1( "CSVPController::IncomingNormalUpdate - Dtmf sending stopped" )
}
else
{
SVPDEBUG2( "CSVPController::IncomingNormalUpdate - IncomingRequest err: %d", err )
}
iSessionArray[ aSessionIndex ]->SetUpdatedSession( aUpdatedSession );
SVPDEBUG1( "CSVPController::IncomingNormalUpdate Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingUpdateNoSdpHandlerL
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingUpdateNoSdpHandlerL( TInt aSessionIndex,
CMceInSession* aUpdatedSession )
{
SVPDEBUG1( "CSVPController::IncomingUpdateNoSdpHandlerL In" )
if ( iRtpObserver )
{
iRtpObserver->ResetSessionInObserving( iSessionArray[ aSessionIndex ] );
}
// set updated session to SVP, ownership is transferred
// old session is obsolete
iSessionArray[ aSessionIndex ]->SetUpdatedSession( aUpdatedSession );
// construct audio streams again, adding all the supported codecs
iSessionArray[ aSessionIndex ]->ConstructAudioStreamsL();
// finally update the session
aUpdatedSession->UpdateL();
SVPDEBUG1( "CSVPController::IncomingUpdateNoSdpHandlerL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::UpdateSessionL
// ---------------------------------------------------------------------------
//
void CSVPController::UpdateSessionL( CMceSession& aOrigSession,
CMceInSession& aUpdatedSession )
{
SVPDEBUG1( "CSVPController::UpdateSessionL In" )
__ASSERT_ALWAYS( &aOrigSession, User::Leave( KErrArgument ) );
__ASSERT_ALWAYS( &aUpdatedSession, User::Leave( KErrArgument ) );
CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC();
RPointerArray< CRCSEProfileEntry > voipProfiles;
CleanupResetAndDestroy< RPointerArray< CRCSEProfileEntry > >::PushL(
voipProfiles );
reg->FindBySIPProfileIdL( aOrigSession.Profile(), voipProfiles );
TInt keepAliveTime = 0;
TInt index = FindSVPSession( aOrigSession );
if ( KErrNotFound != index )
{
keepAliveTime = iSessionArray[ index ]->GetKeepAliveTime();
__ASSERT_ALWAYS( iRtpObserver, User::Leave( KErrTotalLossOfPrecision ) );
iRtpObserver->ResetSessionInObserving( iSessionArray[ index ] );
}
// flag prevents wrong handling after SessionStateChanged -callback
iSessionUpdateOngoing = ETrue;
// sets MMF priorities and sets codec specific settings
CheckStreamsL( *voipProfiles[ 0 ], aUpdatedSession, keepAliveTime,
iSessionUpdateOngoing );
CleanupStack::PopAndDestroy( 2, reg );
SVPDEBUG1( "CSVPController::UpdateSessionL - Checked" )
aUpdatedSession.UpdateL();
SVPDEBUG1( "CSVPController::UpdateSessionL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingRefer
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingRefer( CMceInRefer* aRefer,
const TDesC8& aReferTo, TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::IncomingRefer In" )
// IncomingReferHandlerL is used to handle possible leave
SVPDEBUG1( "CSVPController::IncomingRefer IncomingReferHandlerL" )
TRAPD( err, IncomingReferHandlerL( aRefer, aReferTo, aContainer ) );
if ( err )
{
SVPDEBUG2("CSVPController::IncomingRefer: err: %d", err )
if ( err == KSVPErrTransferInProgress )
{
SVPDEBUG1( "CSVPController::IncomingRefer - transfer in progress \
-> ignore" )
}
else
{
// TRAP is used because of RejectL might leave.
SVPDEBUG1( "CSVPController::IncomingRefer -> reject" )
TRAP( err, aRefer->RejectL() );
if ( err )
{
SVPDEBUG2("CSspController::IncomingRefer: RejectL err: \
%d", err )
}
}
}
SVPDEBUG1( "CSVPController::IncomingRefer Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingReferHandlerL
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingReferHandlerL( CMceInRefer* aRefer,
const TDesC8& aReferTo, TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::IncomingReferHandlerL In" )
__ASSERT_ALWAYS( aRefer, User::Leave( KErrArgument ) );
iContainer = *aContainer;
TInt sessionIndex = FindSVPSession( *aRefer->AssociatedSession() );
if ( KErrNotFound != sessionIndex )
{
SVPDEBUG2( "CSVPController::InRefHL: AssoSes OK,ind=%d",
sessionIndex )
iSessionArray[ sessionIndex ]->IncomingReferL(
aRefer, aReferTo, aContainer );
if ( iSessionArray[ sessionIndex ]->IsAttended() )
{
SVPDEBUG1( "CSVPController::InRefHL: - Attended case" )
}
else
{
SVPDEBUG1( "CSVPController::InRefHL: - Unattended case" )
// Create a new session
CreateNewTransferSessionL( sessionIndex, EFalse );
}
}
else
{
SVPDEBUG1( "CSVPController::InRefHL: Session not Found!!" )
User::Leave( KErrNotFound );
}
SVPDEBUG1( "CSVPController::IncomingReferHandlerL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::CreateNewTransferSessionL
// ---------------------------------------------------------------------------
//
void CSVPController::CreateNewTransferSessionL( TInt aSessionIndex,
TBool aAttended )
{
SVPDEBUG1( "CSVPController::CreateNewTransferSessionL In" )
iIncomingReferCallIndex = aSessionIndex;
// Create a new session
// fetch SIP profile ID from VoIP profiles
RPointerArray< CRCSEProfileEntry > entryArray;
CleanupResetAndDestroy<
RPointerArray<CRCSEProfileEntry> >::PushL( entryArray ); //CS: 1
CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC(); //CS:2
const CCCPCallParameters& callParams = iSessionArray[ aSessionIndex ]->Parameters();
SVPDEBUG2(" CSVPController::CNTSL: iServiceId = %d", callParams.ServiceId() )
// Get VoIP profile by service id
reg->FindByServiceIdL( callParams.ServiceId(), entryArray );
// Take first entry from array
CRCSEProfileEntry* entry = NULL;
if (entryArray.Count() > 0)
{
entry = entryArray[0];
}
else
{
User::Leave(KErrNotFound);
}
// array for provisioned data
CDesC8ArrayFlat* userAgentHeaders = new( ELeave )CDesC8ArrayFlat( 4 );
CleanupStack::PushL( userAgentHeaders );
// variable for storing security status
TUint32 securityStatus = 0;
// set provisioning data
SVPDEBUG1( "CSVPController::CNTSL: Set provisioning data..." )
TRAP_IGNORE( iSVPUtility->SetProvisioningDataL(
*entry,
*userAgentHeaders,
securityStatus,
iTerminalType,
iWlanMacAddress ) );
// only one sip profile per voip profile
TInt sipProfileId = entry->iIds[ 0 ].iProfileId;
SVPDEBUG2( "CSVPController::CNTSL: sipProfileId=%d", sipProfileId )
if ( KSVPStatusNonSecure != securityStatus )
{
// If preferred sec is 1 or 2, we check also secure mechanism of sip profile.
// create SIP and ProfileRegistry for URI handling
CSIP* sip = CSIP::NewL( KSVPUid, *this );
CleanupStack::PushL( sip );
SVPDEBUG1( "CSVPController::CNTSL: sip CREATED" )
CSIPProfileRegistry* sipProfileRegistry =
CSIPProfileRegistry::NewL( *sip, *this );
CleanupStack::PushL( sipProfileRegistry );
SVPDEBUG1( "CSVPController::CNTSL: sipProfileRegistry CREATED" )
// retrieve SIP profile by using sip profile id
CSIPProfile* profile = sipProfileRegistry->ProfileL( sipProfileId );
CleanupStack::PushL( profile );
// set secure status to 0 if no security mechanism found from SIP profile
iSVPUtility->ResolveSecurityMechanismL( *profile, securityStatus );
CleanupStack::PopAndDestroy( 3, sip ); // profile, sipProfileRegistry, sip
}
// set transfer data
SVPDEBUG1( "CSVPController::CNTSL: Set transfer data..." )
iSessionArray[ aSessionIndex ]->SetTransferDataL(
userAgentHeaders, securityStatus );
SVPDEBUG3( "CSVPController::CNTSL: Header count:%d, sec status:%d",
userAgentHeaders->Count(), securityStatus )
CSVPMoSession* moSessionTemp = NULL;
// In attended and unattended transfer case recipient is solved here
SVPDEBUG1( "CSVPController::CNTSL: (Un)Attended, create new mo session" )
const TDesC& referTo = iSessionArray[ aSessionIndex ]->TransferTarget();
// "convert" recpient to 8-bit format
HBufC8* recipient = HBufC8::NewLC( referTo.Length() );
recipient->Des().Copy( referTo );
moSessionTemp = CSVPMoSession::NewL( *iMceManager,
*recipient,
*entry,
callParams,
iContainer,
*this,
*iSVPUtility,
*iRtpObserver,
securityStatus,
userAgentHeaders );
CleanupStack::PopAndDestroy( recipient );
CleanupStack::PushL( moSessionTemp );
// dtmf and rtp observervers are set
moSessionTemp->SetDtmfObserver( iSessionArray[ aSessionIndex ]->DtmfObserver() );
iRtpObserver->AddSessionForObservingL( moSessionTemp );
// created SVP session is appended to session array
iSessionArray.AppendL( moSessionTemp );
CleanupStack::Pop( moSessionTemp );
CleanupStack::Pop( userAgentHeaders );
CleanupStack::PopAndDestroy( 2, &entryArray );
// set CCP session observer to SVP session
SVPDEBUG1( "CSVPController::CNTSL: AddObserverL" )
moSessionTemp->AddObserverL( iSessionArray[ aSessionIndex ]->GetCCPSessionObserver() );
//set CCP supplementary services events observer to SVP session
SVPDEBUG1( "CSVPController::CNTSL: AddSsObserverL" )
moSessionTemp->SetSsObserver( iSessionArray[ aSessionIndex ]->GetSsObserver() );
SVPDEBUG1( "CSVPController::CNTSL: callcreated, send to CCP" )
ExecCbCallCreated( moSessionTemp, iSessionArray[ aSessionIndex ], aAttended );
SVPDEBUG1( "CSVPController::CreateNewTransferSessionL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::HandleForwardEvent
// ---------------------------------------------------------------------------
//
void CSVPController::HandleCallForward( TInt aStatusCode,
TInt aSessionIndex, TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::HandleForwardEvent In" )
SVPDEBUG2( "CSVPController::HandleForwardEvent aStatusCode=%d", aStatusCode )
if ( !iSessionArray[ aSessionIndex ]->IsMobileOriginated() )
{
iSessionArray[ aSessionIndex ]->
GetCCPSessionObserver().ErrorOccurred( ECCPErrorNotReached,
iSessionArray[ aSessionIndex ] );
}
else
{
CSVPMoSession* session = static_cast< CSVPMoSession* >(
iSessionArray[ aSessionIndex ] );
switch ( aStatusCode )
{
case KSVPMultipleChoicesVal: // 300
case KSVPMovedPermanentlyVal: // 301
{
// Get contact headers and notify
TInt count = CheckContactData( session, aContainer );
if ( 0 < count )
{
session->NotifyForwardEvent( aStatusCode );
}
else
{
session->GetCCPSessionObserver().ErrorOccurred(
ECCPErrorNotReached,
session );
}
break;
}
case KSVPMovedTemporarilyVal: // 302
{
// Just notify, this call forward is handled automatically by mce
session->NotifyForwardEvent( aStatusCode );
session->GetCCPSessionObserver().
CallStateChanged( MCCPCallObserver::ECCPStateForwarding,
session );
break;
}
default:
{
SVPDEBUG1( "CSVPController::HandleForwardEvent: unknown code" )
session->GetCCPSessionObserver().ErrorOccurred(
ECCPErrorNotReached,
session );
}
}
}
SVPDEBUG1( "CSVPController::HandleForwardEvent Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::StreamStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::StreamStateChanged( CMceMediaStream& aStream )
{
SVPDEBUG1("CSVPController::StreamStateChanged In" )
if ( &aStream )
{
if ( !iEmergencySession )
{
const TInt index = FindSVPSession( *aStream.Session() );
if ( KErrNotFound != index )
{
iSessionArray[ index ]->HandleStreamStateChange( aStream );
}
SVPDEBUG2( "CSVPController::StreamStateChanged index: %d", index )
}
else // Emergency session
{
iEmergencySession->StreamStateChanged( aStream );
}
}
else
{
SVPDEBUG1( "CSVPController::StreamStateChanged, faulty arguments" )
}
SVPDEBUG1("CSVPController::StreamStateChanged Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::StreamStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::StreamStateChanged( CMceMediaStream& aStream,
CMceMediaSink& aSink )
{
SVPDEBUG1( "CSVPController::StreamStateChanged SINK In" )
if ( &aStream && &aSink )
{
SVPDEBUG2( "CSVPController::StreamStateChanged SINK Stream State: %d", aStream.State() )
SVPDEBUG2( "CSVPController::StreamStateChanged SINK Sink IsEnabled: %d", aSink.IsEnabled() )
if ( !iEmergencySession )
{
const TInt index = FindSVPSession( *aStream.Session() );
if ( KErrNotFound != index )
{
iSessionArray[ index ]->HandleStreamStateChange( aStream, aSink );
}
SVPDEBUG2( "CSVPController::StreamStateChanged SINK index: %d", index )
}
else // Emergency session
{
iEmergencySession->StreamStateChanged( aStream );
}
}
else
{
SVPDEBUG1( "CSVPController::StreamStateChanged SINK, faulty arguments" )
}
SVPDEBUG1( "CSVPController::StreamStateChanged SINK Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::StreamStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::StreamStateChanged( CMceMediaStream& aStream,
CMceMediaSource& aSource )
{
SVPDEBUG1( "CSVPController::StreamStateChanged SOURCE In" )
if ( &aStream && &aSource )
{
SVPDEBUG2( "CSVPController::StreamStateChanged SOURCE Stream State: %d", aStream.State() )
SVPDEBUG2( "CSVPController::StreamStateChanged SOURCE Source IsEnabled: %d", aSource.IsEnabled() )
if ( !iEmergencySession )
{
const TInt index = FindSVPSession( *aStream.Session() );
if ( KErrNotFound != index )
{
iSessionArray[ index ]->HandleStreamStateChange( aStream, aSource );
}
SVPDEBUG2( "CSVPController::StreamStateChanged SOURCE index: %d", index )
}
else // Emergency session
{
iEmergencySession->StreamStateChanged( aStream );
}
}
SVPDEBUG1( "CSVPController::StreamStateChanged SOURCE Out" )
}
// from ConvergedCallProvider
// ---------------------------------------------------------------------------
// CSVPController::NewEmergencyCallL
// ---------------------------------------------------------------------------
//
MCCPEmergencyCall* CSVPController::NewEmergencyCallL(
const TUint32 /*aServiceId*/,
const TDesC& aAddress,
const MCCPCallObserver& aObserver )
{
SVPDEBUG1( "CSVPController::NewEmergencyCallL In" )
// Retrieve available VoIP and IAP IDs
if ( 0 == iEmergencyProfileIds.Count() && 0 == iEmergencyIapIds.Count() )
{
CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC(); // CS:1
CSIP* sip = CSIP::NewLC( KSVPUid, *this ); // CS:2
CSIPProfileRegistry* sipProfileRegistry = CSIPProfileRegistry::NewLC(
*sip, *this ); // CS:3
// Get all VoIP profile IDs into an array
RArray< TUint32 > voipProfileIds;
CleanupClosePushL( voipProfileIds ); //CS: 4
reg->GetAllIdsL( voipProfileIds );
// Sort the VoIP profile array so that registered profiles are first
for ( TInt i = 0; i < voipProfileIds.Count(); i++ )
{
TBool registered( EFalse );
CRCSEProfileEntry* entry = CRCSEProfileEntry::NewLC(); // CS:5
reg->FindL( voipProfileIds[i], *entry );
// There is only one (or zero) SIP profile per VoIP profile.
// If profileId is not found,
// CSVPEmergencySession::ConstructL will handle the error
if ( 0 < entry->iIds.Count() )
{
SVPDEBUG2( "CSVPController::NewEmergencyCallL, SIP Id count:%d",
entry->iIds.Count() )
CSIPProfile* sipProfile = sipProfileRegistry->ProfileL(
entry->iIds[0].iProfileId );
sipProfile->GetParameter( KSIPProfileRegistered, registered );
delete sipProfile;
}
CleanupStack::PopAndDestroy( entry ); // CS:4
if ( registered )
{
// Move registered VoIP profile IDs to the front
iEmergencyProfileIds.Insert( voipProfileIds[i], 0 );
}
else
{
iEmergencyProfileIds.Append( voipProfileIds[i] );
}
}
CleanupStack::PopAndDestroy( 4, reg );
// CS:0 voipProfileIds, sipProfileRegistry, sip, reg
// Request and wait for IAP IDs
CSVPEmergencyIapProvider* iapProvider =
CSVPEmergencyIapProvider::NewLC(
CActive::EPriorityStandard ); // CS:1
iapProvider->RequestIapIds( iEmergencyIapIds );
CleanupStack::PopAndDestroy( iapProvider ); // CS:0
}
SVPDEBUG2("CSVPController::NewEmergencyCallL, VoIP count:%d",
iEmergencyProfileIds.Count() )
SVPDEBUG2("CSVPController::NewEmergencyCallL, IAP count:%d",
iEmergencyIapIds.Count() )
// Define last try
TBool isLastId( EFalse );
if ( ( 0 == iEmergencyProfileIds.Count() &&
1 == iEmergencyIapIds.Count() ) ||
( 1 == iEmergencyProfileIds.Count() &&
0 == iEmergencyIapIds.Count() )
)
{
isLastId = ETrue;
SVPDEBUG1("CSVPController::NewEmergencyCallL, last ID");
}
// Create session
CSVPEmergencySession* emergencySession = NULL;
if ( iEmergencyProfileIds.Count() )
{
// Create emergency session with VoIP ID
TRAPD( err, emergencySession = CSVPEmergencySession::NewL(
*iMceManager,
iEmergencyProfileIds[0],
aAddress,
aObserver,
*iSVPUtility,
isLastId ) )
if ( err )
{
// Create dummy session for session release
emergencySession = CSVPEmergencySession::NewL(
*iMceManager,
iEmergencyProfileIds[0],
aAddress,
aObserver,
*iSVPUtility,
isLastId,
ETrue );
}
// Update profile array
iEmergencyProfileIds.Remove( 0 );
}
else if ( iEmergencyIapIds.Count() )
{
// Create emergency session with IAP ID
TRAPD( err, emergencySession = CSVPEmergencySession::NewL(
*iMceManager,
aAddress,
aObserver,
*iSVPUtility,
iEmergencyIapIds[0],
isLastId ) )
if ( err )
{
// Create dummy session for session release
emergencySession = CSVPEmergencySession::NewL(
*iMceManager,
aAddress,
aObserver,
*iSVPUtility,
iEmergencyIapIds[0],
isLastId,
ETrue );
}
// Update IAP array
iEmergencyIapIds.Remove( 0 );
}
else
{
User::Leave( KErrNotFound );
}
// save emergency session to controller
iEmergencySession = emergencySession;
if ( iCCPDtmfObserver )
{
SVPDEBUG1( "CSVPController::NewEmergencyCallL setting DTMFObserver" )
iEmergencySession->SetDtmfObserver( *iCCPDtmfObserver );
}
SVPDEBUG1( "CSVPController::NewEmergencyCallL Out" )
// return pointer to CCP emergency call object
return emergencySession;
}
// ---------------------------------------------------------------------------
// CSVPController::NewConferenceL
// ---------------------------------------------------------------------------
//
MCCPConferenceCall* CSVPController::NewConferenceL(
const TUint32 /* aServiceId */,
const MCCPConferenceCallObserver& /*aObserver*/ )
{
return NULL;
}
// ---------------------------------------------------------------------------
// CSVPController::AcceptTransfer
// ---------------------------------------------------------------------------
//
void CSVPController::AcceptTransfer( TBool /*aAccept*/ )
{
SVPDEBUG1( "CSVPController::AcceptTransfer In" )
SVPDEBUG1( "CSVPController::AcceptTransfer Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::ForwardCallToAddressL
// ---------------------------------------------------------------------------
//
TInt CSVPController::ForwardCallToAddressL( const TInt /*aIndex*/ )
{
return NULL;
}
// ---------------------------------------------------------------------------
// CSVPController::Caps
// ---------------------------------------------------------------------------
//
TUint32 CSVPController::Caps() const
{
return 0;
}
// ---------------------------------------------------------------------------
// CSVPController::DTMFProvider
// ---------------------------------------------------------------------------
//
MCCPDTMFProvider* CSVPController::DTMFProviderL(
const MCCPDTMFObserver& aObserver )
{
SVPDEBUG1( "CSVPController::DTMFProviderL In" )
iCCPDtmfObserver = &aObserver;
TInt sessions = iSessionArray.Count();
while ( sessions )
{
sessions--;
iSessionArray[ sessions ]->SetDtmfObserver( aObserver );
SVPDEBUG2( "CSVPController::DTMFProviderL sessions: %d", sessions )
}
if ( iEmergencySession )
{
iEmergencySession->SetDtmfObserver( aObserver );
}
SVPDEBUG1( "CSVPController::DTMFProviderL Out" )
return this;
}
// ---------------------------------------------------------------------------
// CSVPController::ExtensionProvider
// ---------------------------------------------------------------------------
//
MCCPExtensionProvider* CSVPController::ExtensionProviderL(
const MCCPExtensionObserver& /*aObserver*/ )
{
return NULL;
}
// dtmf provider
// ---------------------------------------------------------------------------
// CSVPController::CancelDtmfStringSending
// ---------------------------------------------------------------------------
//
TInt CSVPController::CancelDtmfStringSending()
{
SVPDEBUG1( "CSVPController::CancelDtmfStringSending In" )
TInt err( KErrNotSupported );
// find active session
TInt sesCount = iSessionArray.Count();
CSVPSessionBase* session = NULL;
while ( sesCount )
{
sesCount--;
session = iSessionArray[ sesCount ];
if ( SVPAudioUtility::DtmfActionCapableSession( *session ) )
{
err = session->CancelDtmfStringSending();
}
SVPDEBUG3( "CSVPController::CancelDtmfStringSending sesCount: %d, err: %d",
sesCount, err )
session = NULL;
}
if ( iEmergencySession &&
SVPAudioUtility::DtmfActionCapableSession( *iEmergencySession ) )
{
err = iEmergencySession->CancelDtmfStringSending();
}
SVPDEBUG2("CSVPController::CancelDtmfStringSending Out return=%d", err )
iDtmfStringSending = EFalse;
iFirstDtmfSent = EFalse;
return err;
}
// ---------------------------------------------------------------------------
// CSVPController::StartDtmfTone
// ---------------------------------------------------------------------------
//
TInt CSVPController::StartDtmfTone( const TChar aTone )
{
SVPDEBUG1( "CSVPController::StartDtmfTone In" )
TInt err( KErrNotSupported );
// Save DTMF tone for later use in outband dtmf start/stop events
iDtmfTone = aTone;
// Send the tone to all sessions, but check mute and hold cases where session must
// be in 'connected' state in order to send DTMF's. Session will then
// discriminate between inband and outband DTMF's.
TInt sesCount = iSessionArray.Count();
CSVPSessionBase* session = NULL;
while ( sesCount )
{
sesCount--;
session = iSessionArray[ sesCount ];
// Checking hold and mute status
if ( SVPAudioUtility::DtmfActionCapableSession( *session ) &&
!session->IsSessionMuted() )
{
err = session->StartDtmfTone( aTone );
}
SVPDEBUG3( "CSVPController::StartDtmfTone sesCount: %d, err: %d",
sesCount, err )
session = NULL;
}
if ( iEmergencySession &&
SVPAudioUtility::DtmfActionCapableSession( *iEmergencySession ) )
{
err = iEmergencySession->StartDtmfTone( aTone );
}
SVPDEBUG2("CSVPController::StartDtmfTone Out return=%d", err )
return err;
}
// ---------------------------------------------------------------------------
// CSVPController::StopDtmfTone
// ---------------------------------------------------------------------------
//
TInt CSVPController::StopDtmfTone()
{
SVPDEBUG1( "CSVPController::StopDtmfTone In" )
TInt err( KErrNotSupported );
TInt sesCount = iSessionArray.Count();
CSVPSessionBase* session = NULL;
while ( sesCount )
{
sesCount--;
session = iSessionArray[ sesCount ];
if ( SVPAudioUtility::DtmfActionCapableSession( *session ) )
{
err = session->StopDtmfTone();
}
SVPDEBUG3( "CSVPController::StopDtmfTone sesCount: %d, err: %d",
sesCount, err )
session = NULL;
}
if ( iEmergencySession &&
SVPAudioUtility::DtmfActionCapableSession( *iEmergencySession ) )
{
err = iEmergencySession->StopDtmfTone();
}
SVPDEBUG2("CSVPController::StopDtmfTone Out return=%d", err )
return err;
}
// ---------------------------------------------------------------------------
// CSVPController::SendDtmfToneString
// ---------------------------------------------------------------------------
//
TInt CSVPController::SendDtmfToneString( const TDesC& aString )
{
SVPDEBUG1( "CSVPController::SendDtmfToneString In" )
TInt err( KErrNotSupported );
delete iDtmfString;
iDtmfString = NULL;
TRAPD( errBuf, iDtmfString = HBufC::NewL( aString.Length() ) );
if ( KErrNone != errBuf )
{
return errBuf;
}
// Take local copy of the dtmf string to be sent
// This is needed for outband dtmf sequence start/stop event
*iDtmfString = aString;
iDtmfStringLex.Assign( *iDtmfString );
TInt sesCount = iSessionArray.Count();
CSVPSessionBase* session = NULL;
while ( sesCount )
{
sesCount--;
session = iSessionArray[ sesCount ];
// Checking hold and mute status
if ( SVPAudioUtility::DtmfActionCapableSession( *session ) &&
!session->IsSessionMuted() )
{
err = session->SendDtmfToneString( aString );
if ( KErrNone == err )
{
iDtmfStringSending = ETrue;
iFirstDtmfSent = EFalse;
}
}
SVPDEBUG3( "CSVPController::SendDtmfToneString sesCount: %d, err: %d",
sesCount, err )
session = NULL;
}
if ( iEmergencySession )
{
if ( SVPAudioUtility::DtmfActionCapableSession( *iEmergencySession ) )
{
err = iEmergencySession->SendDtmfToneString( aString );
}
iDtmfStringSending = ETrue;
iFirstDtmfSent = EFalse;
}
SVPDEBUG2("CSVPController::SendDtmfToneString Out return=%d", err )
return err;
}
// ---------------------------------------------------------------------------
// CSVPController::ContinueDtmfStringSending
// ---------------------------------------------------------------------------
//
TInt CSVPController::ContinueDtmfStringSending( const TBool /*aContinue*/ )
{
// SVP sessionbase used to implement this as only returning
// KErrNotSupported, so why not accept the situation here and just
// return KErrNotSupported.
SVPDEBUG1( "CSVPController::ContinueDtmfStringSending KErrNotSupported" )
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// CSVPController::AddObserverL
// ---------------------------------------------------------------------------
//
void CSVPController::AddObserverL( const MCCPDTMFObserver& /*aObserver*/ )
{
SVPDEBUG1( "CSVPController::AddObserverL MCCPDTMFObserver" )
}
// ---------------------------------------------------------------------------
// CSVPController::RemoveObserver
// ---------------------------------------------------------------------------
//
TInt CSVPController::RemoveObserver( const MCCPDTMFObserver& /*aObserver*/ )
{
SVPDEBUG1( "CSVPController::RemoveObserver MCCPDTMFObserver" )
return KErrNotSupported;
}
// refer observer
// ---------------------------------------------------------------------------
// CSVPController::ReferStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::ReferStateChanged( CMceRefer& aRefer,
TMceTransactionDataContainer* aContainer )
{
SVPDEBUG1( "CSVPController::ReferStateChanged In" )
iContainer = *aContainer;
TInt ind = KErrNotFound;
// loop session array and check refer
for ( TInt s = 0; s < iSessionArray.Count() &&
KErrNotFound == ind; s++ )
{
if ( iSessionArray[ s ]->IsMceRefer( aRefer ) )
{
ind = s;
}
}
if ( KErrNotFound != ind )
{
SVPDEBUG2(" CSVPController::ReferStateChanged ind: %d", ind );
TInt statusCode = iContainer.GetStatusCode();
iSessionArray[ ind ]->ReferStateChanged( aRefer, statusCode );
}
SVPDEBUG1( "CSVPController::ReferStateChanged Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::ReferConnectionStateChanged
// ---------------------------------------------------------------------------
//
void CSVPController::ReferConnectionStateChanged( CMceRefer& /*aRefer*/,
TBool /*aActive*/ )
{
SVPDEBUG1( "CSVPController::ReferConnectionStateChanged" )
}
// ---------------------------------------------------------------------------
// CSVPController::Failed
// ---------------------------------------------------------------------------
//
#ifdef _DEBUG
void CSVPController::Failed( CMceRefer& /*aRefer*/, TInt aError )
#else
void CSVPController::Failed( CMceRefer& /*aRefer*/, TInt /*aError*/ )
#endif // _DEBUG
{
SVPDEBUG2( "CSVPController::Failed Refer failed with error: %d", aError )
}
// Mce DMTF observer
// ---------------------------------------------------------------------------
// CSVPController::DtmfToneReceived
// ---------------------------------------------------------------------------
//
void CSVPController::DtmfToneReceived( CMceSession& /*aSession*/,
CMceAudioStream& /*aStream*/, const TChar& /*aTone*/ )
{
// Not supported
SVPDEBUG1( "CSVPController:: DtmfToneReceived - Not supported" )
}
// ---------------------------------------------------------------------------
// CSVPController::DtmfEventReceived
// ---------------------------------------------------------------------------
//
void CSVPController::DtmfEventReceived( CMceSession& aSession,
CMceAudioStream& /*aStream*/,
CMceMediaSource& /*aSource*/,
TMceDtmfEvent aEvent )
{
SVPDEBUG3( "CSVPController::DtmfEventReceived In, aEvent: %d, iDtmfStringSending: %d",
aEvent, iDtmfStringSending )
// find what session received the event
const TInt index = FindSVPSession( aSession );
if ( KErrNotFound != index )
{
// match dtmf event
MCCPDTMFObserver::TCCPDtmfEvent dtmfEvent =
iSVPUtility->GetDtmfEvent( aEvent, iDtmfStringSending );
// dtmf string
if ( iDtmfStringSending )
{
// only start event received from mce
// logic below needed so that stop events can be sent
if ( MCCPDTMFObserver::ECCPDtmfSequenceStart == dtmfEvent )
{
if ( !iFirstDtmfSent )
{
SVPDEBUG1( "CSVPController::DtmfEventReceived FIRST SEND" )
// send start
iFirstDtmfSent = ETrue;
// call back event to application
iSessionArray[ index ]->
DtmfObserver().HandleDTMFEvent( dtmfEvent,
KErrNone,
iDtmfStringLex.Peek() );
}
else
{
SVPDEBUG1( "CSVPController::DtmfEventReceived STOP TO PREVIOUS" )
// send stop event to the previous character in string
iSessionArray[ index ]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfSequenceStop,
KErrNone,
iDtmfStringLex.Get() );
SVPDEBUG1("CSVPController::DtmfEventReceived START TO CURRENT");
// send start event to the current character in string
iSessionArray[ index ]->DtmfObserver().HandleDTMFEvent(
dtmfEvent,
KErrNone,
iDtmfStringLex.Peek() );
}
}
else
{
SVPDEBUG1( "CSVPController::DtmfEventReceived STOP TO PREVIOUS AND LAST" )
// send stop event to the previous character in string
iSessionArray[ index ]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfSequenceStop,
KErrNone,
iDtmfStringLex.Peek() );
SVPDEBUG1( "CSVPController::DtmfEventReceived COMPLETE" )
// send sequence stop event
iSessionArray[ index ]->DtmfObserver().HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfStringSendingCompleted,
KErrNone,
iDtmfStringLex.Peek() );
// sequence complete, clear flags
iDtmfStringSending = EFalse;
iFirstDtmfSent = EFalse;
delete iDtmfString;
iDtmfString = NULL;
}
}
// manual dtmf
else
{
// call back event to application
iSessionArray[ index ]->DtmfObserver().HandleDTMFEvent(
dtmfEvent,
KErrNone,
iDtmfTone );
}
}
else if ( iEmergencySession )
{
const MCCPDTMFObserver& dtmfObs = iEmergencySession->DtmfObserver();
SVPDEBUG2("CSVPController::DtmfEventReceived, %d = DtmfObserver()", &dtmfObs )
// match dtmf event
MCCPDTMFObserver::TCCPDtmfEvent dtmfEvent =
iSVPUtility->GetDtmfEvent( aEvent, iDtmfStringSending );
// dtmf string
if ( iDtmfStringSending && NULL != &dtmfObs )
{
// only start event received from mce
// logic below needed so that stop events can be sent
if ( MCCPDTMFObserver::ECCPDtmfSequenceStart == dtmfEvent )
{
if ( !iFirstDtmfSent )
{
SVPDEBUG1(
"CSVPController::DtmfEventReceived, emergency FIRST SEND")
// send start
iFirstDtmfSent = ETrue;
// call back event to application
dtmfObs.HandleDTMFEvent( dtmfEvent, KErrNone, iDtmfStringLex.Peek() );
}
else
{
SVPDEBUG1("CSVPController::DtmfEventReceived,\
emergency STOP TO PREVIOUS")
// send stop event to the previous character in string
dtmfObs.HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfSequenceStop,
KErrNone,
iDtmfStringLex.Get() );
SVPDEBUG1("CSVPController::DtmfEventReceived,\
emergency START TO CURRENT")
// send start event to the current character in string
dtmfObs.HandleDTMFEvent(
dtmfEvent,
KErrNone,
iDtmfStringLex.Peek() );
}
}
else
{
SVPDEBUG1("CSVPController::DtmfEventReceived,\
emergency STOP TO PREVIOUS AND LAST")
// send stop event to the previous character in string
dtmfObs.HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfSequenceStop,
KErrNone,
iDtmfStringLex.Peek() );
SVPDEBUG1("CSVPController::DtmfEventReceived,\
emergency COMPLETE")
// send sequence stop event
dtmfObs.HandleDTMFEvent(
MCCPDTMFObserver::ECCPDtmfStringSendingCompleted,
KErrNone,
iDtmfStringLex.Peek() );
// sequence complete, clear flags
iDtmfStringSending = EFalse;
iFirstDtmfSent = EFalse;
delete iDtmfString;
iDtmfString = NULL;
}
}
// manual dtmf
else if( NULL != &dtmfObs )
{
SVPDEBUG1("CSVPController::DtmfEventReceived,\
manual dtmf , call back event to application")
dtmfObs.HandleDTMFEvent( dtmfEvent, KErrNone, iDtmfTone );
}
else
{
SVPDEBUG1("CSVPController::DtmfEventReceived, DtmfObs not set")
}
}
SVPDEBUG1( "CSVPController::DtmfEventReceived Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::DtmfErrorOccured
// ---------------------------------------------------------------------------
//
void CSVPController::DtmfErrorOccured( CMceSession& aSession,
CMceAudioStream& /*aStream*/,CMceMediaSource& /*aSource*/,
TInt aError )
{
SVPDEBUG2( "CSVPController::DtmfErrorOccured In, aError: %d", aError )
// find what session received the event
const TInt index = FindSVPSession( aSession );
if ( KErrNotFound != index )
{
// match dtmf event, unknown set as default in error case, 'tis ok?
const MCCPDTMFObserver::TCCPDtmfEvent dtmfEvent =
MCCPDTMFObserver::ECCPDtmfUnknown;
// default tone char
TChar dtmfToneChar('0');
// call back error
iSessionArray[ index ]->
DtmfObserver().HandleDTMFEvent( dtmfEvent,
aError,
dtmfToneChar );
}
SVPDEBUG1( "CSVPController::DtmfErrorOccured Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::FinalizeSessionCreationL
// ---------------------------------------------------------------------------
//
void CSVPController::FinalizeSessionCreationL( CSVPSessionBase* aSession )
{
SVPDEBUG2( "CSVPController::FinalizeSessionCreationL In, aSession: 0x%x",
aSession )
__ASSERT_ALWAYS( aSession, User::Leave( KErrArgument ) );
if ( iCCPDtmfObserver )
{
aSession->SetDtmfObserver( *iCCPDtmfObserver );
}
iRtpObserver->AddSessionForObservingL( aSession );
iSessionArray.AppendL( aSession );
SVPDEBUG1( "CSVPController::FinalizeSessionCreationL Out" )
}
// ---------------------------------------------------------------------------
// CSVPController::ExecCbErrorOccurred
// ---------------------------------------------------------------------------
//
TInt CSVPController::ExecCbErrorOccurred( MCCPObserver::TCCPError aError )
{
SVPDEBUG2( "CSVPController::ExecCbErrorOccurred In, aError=%d", aError )
TInt status = KErrNotFound;
if ( iCCPMonitor )
{
status = KErrNone;
iCCPMonitor->ErrorOccurred( aError );
}
SVPDEBUG2( "CSVPController::ExecCbErrorOccurred Out return=%d", status )
return status;
}
// ---------------------------------------------------------------------------
// CSVPController::IncomingCall
// ---------------------------------------------------------------------------
//
TInt CSVPController::ExecCbIncomingCall( MCCPCall* aCall )
{
SVPDEBUG2( "CSVPController::ExecCbIncomingCall In, aCall= 0x%x", aCall )
TInt status = KErrNotFound;
if ( iCCPMonitor )
{
status = KErrNone;
iCCPMonitor->IncomingCall( aCall );
}
SVPDEBUG2( "CSVPController::ExecCbIncomingCall Out return=%d", status )
return status;
}
// ---------------------------------------------------------------------------
// CSVPController::ExecCbIncomingCall
// ---------------------------------------------------------------------------
//
TInt CSVPController::ExecCbIncomingCall( MCCPCall* aCall, MCCPCall& aTempCall )
{
SVPDEBUG2( "CSVPController::ExecCbIncomingCall In, aCall= 0x%x", aCall )
SVPDEBUG2( "CSVPController::ExecCbIncomingCall aTempCall= 0x%x", &aTempCall )
TInt status = KErrNotFound;
if ( iCCPMonitor )
{
status = KErrNone;
iCCPMonitor->IncomingCall( aCall, aTempCall );
}
SVPDEBUG2( "CSVPController::ExecCbIncomingCall Out return=%d", status )
return status;
}
// ---------------------------------------------------------------------------
// CSVPController::ExecCbCallCreated
// ---------------------------------------------------------------------------
//
TInt CSVPController::ExecCbCallCreated( MCCPCall* aNewTransferCall,
MCCPCall* aOriginator, TBool aAttended )
{
SVPDEBUG2( "CSVPController::ExecCbCallCreated In, aNewTransferCall= 0x%x", aNewTransferCall )
SVPDEBUG2( "CSVPController::ExecCbCallCreated aOriginator= 0x%x", aOriginator )
SVPDEBUG2( "CSVPController::ExecCbCallCreated aAttended= %d", aAttended )
TInt status = KErrNotFound;
if ( iCCPMonitor )
{
status = KErrNone;
iCCPMonitor->CallCreated( aNewTransferCall, aOriginator, aAttended );
}
SVPDEBUG2( "CSVPController::ExecCbCallCreated Out return=%d", status )
return status;
}
// ---------------------------------------------------------------------------
// CSVPController::ParseRecipientDtmfSuffixL
// ---------------------------------------------------------------------------
//
HBufC* CSVPController::ParseRecipientDtmfSuffixL( const TDesC& aRecipient ) const
{
__ASSERT_ALWAYS( &aRecipient, User::Leave( KErrArgument ) );
SVPDEBUG2( "CSVPController::ParseRecipientDtmfSuffixL In, aRecipient=%S", &aRecipient )
HBufC* result = aRecipient.AllocLC(); // CS:1
TInt recipientLength = result->Length();
if ( recipientLength )
{
if ( IsValidDtmfRecipientL( *result ) )
{
TInt loopCount = 0;
if ( KErrNotFound != KSVPDtmfTelNumRange().Locate( result->Des()[loopCount] ) )
{
loopCount++;
TBool doLoop = ETrue;
do
{
if ( loopCount < recipientLength )
{
if ( KErrNotFound !=
KSVPDtmfDelimiterRange().Locate( result->Des()[loopCount] ) )
{
TInt suffixLength = recipientLength - loopCount;
result->Des().Delete( loopCount, suffixLength );
doLoop = EFalse;
SVPDEBUG1(
"CSVPController::ParseRecipientDtmfSuffixL, DTMF suffix removed" )
}
else
{
loopCount++;
}
}
else
{
doLoop = EFalse;
}
} while ( doLoop );
}
}
}
SVPDEBUG2( "CSVPController::ParseRecipientDtmfSuffixL Out, result=%S", result )
CleanupStack::Pop( result ); // CS:0
return result;
}
// ---------------------------------------------------------------------------
// CSVPController::IsValidDtmfRecipientL
// ---------------------------------------------------------------------------
//
TBool CSVPController::IsValidDtmfRecipientL( const TDesC& aRecipient ) const
{
__ASSERT_ALWAYS( &aRecipient, User::Leave( KErrArgument ) );
SVPDEBUG1( "CSVPController::IsValidDtmfRecipientL In" )
TBool result = ETrue;
if ( aRecipient.Length() )
{
TBool loopDo = ETrue;
TInt loopCount = 0;
do
{
if ( loopCount < aRecipient.Length() )
{
if ( KErrNotFound == KSVPDtmfAllValidChars().Locate( aRecipient[loopCount] ) )
{
result = EFalse;
loopDo = EFalse;
}
else
{
loopCount++;
}
}
else
{
loopDo = EFalse;
}
} while ( loopDo );
}
else
{
SVPDEBUG1( "CSVPController::IsValidDtmfRecipientL, Invalid recipient length" )
result = EFalse;
}
SVPDEBUG2( "CSVPController::IsValidDtmfRecipientL Out, result=%d" , result )
return result;
}
// ---------------------------------------------------------------------------
// CSVPController::CheckCallEventToBeSent
// ---------------------------------------------------------------------------
//
void CSVPController::CheckCallEventToBeSent( CSVPSessionBase* aNewSVPSession,
CSVPSessionBase* aOldSVPSession ) const
{
SVPDEBUG1( "CSVPController::CheckCallEventToBeSent In" )
if ( aOldSVPSession->IsSecured() != aNewSVPSession->IsSecured() )
{
// Session secure status changed, need to send proper event
if ( aNewSVPSession->IsSecured() )
{
SVPDEBUG1( "CSVPController::CheckCallEventToBeSent, unsecure -> secure case" )
aNewSVPSession->SetCallEventToBeSent( MCCPCallObserver::ECCPSecureCall );
}
else
{
SVPDEBUG1( "CSVPController::CheckCallEventToBeSent, secure -> unsecure case" )
aNewSVPSession->SetCallEventToBeSent( MCCPCallObserver::ECCPNotSecureCall );
}
}
else
{
// remoteparty will be updated anyway after attended transfer
SVPDEBUG1( "CSVPController::CheckCallEventToBeSent, remoteparty will be updated after attended transfer" )
aNewSVPSession->SetCallEventToBeSent( MCCPCallObserver::ECCPNotifyRemotePartyInfoChange );
}
SVPDEBUG1( "CSVPController::CheckCallEventToBeSent Out" )
}
// ---------------------------------------------------------------------------
// From class MSIPObserver
// CSVPController::IncomingRequest
// ---------------------------------------------------------------------------
//
void CSVPController::IncomingRequest(
TUint32 /*aIapId*/, CSIPServerTransaction* /*aTransaction*/ )
{
SVPDEBUG1( "CSVPController::IncomingRequest" )
}
// ---------------------------------------------------------------------------
// From class MSIPObserver
// CSVPController::TimedOut
// ---------------------------------------------------------------------------
//
void CSVPController::TimedOut(
CSIPServerTransaction& /*aSIPServerTransaction*/ )
{
SVPDEBUG1( "CSVPController::TimedOut" )
}
// ---------------------------------------------------------------------------
// From class MSIPProfileRegistryObserver
// CSVPController::ProfileRegistryErrorOccurred
// ---------------------------------------------------------------------------
//
void CSVPController::ProfileRegistryErrorOccurred(
TUint32 /*aSIPProfileId*/, TInt /*aError*/ )
{
SVPDEBUG1( "CSVPController::ProfileRegistryErrorOccurred" )
}
// ---------------------------------------------------------------------------
// From class MSIPProfileRegistryObserver
// CSVPController::ProfileRegistryEventOccurred
// ---------------------------------------------------------------------------
//
void CSVPController::ProfileRegistryEventOccurred(
TUint32 /*aProfileId*/, TEvent /*aEvent*/ )
{
SVPDEBUG1( "CSVPController::ProfileRegistryEventOccurred" )
}