1 /*

     2 * Copyright (c) 2006-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  SVP Emergency Sesssion class. Handles emergency 

    15 *                session methods.        

    16 *

    17 */

    18 

    19 

    20 #include <sip.h>

    21 #include <sipprofile.h>

    22 #include <sipprofileregistry.h>

    23 

    24 #include <mceaudiostream.h>

    25 #include <mcertpsource.h>

    26 #include <mcertpsink.h>

    27 #include <mcemicsource.h>

    28 #include <mcespeakersink.h>

    29 #include <mcetransactiondatacontainer.h>

    30 

    31 #include "crcseprofileentry.h"

    32 #include "crcseprofileregistry.h"

    33 

    34 #include "svpemergencysession.h"

    35 #include "svpuriparser.h"

    36 #include "svputility.h"

    37 #include "svpsipconsts.h"

    38 #include "svpconsts.h"

    39 #include "svppositioningprovider.h"

    40 #include "svpemergencyconnection.h"

    41 #include "svpholdcontroller.h"

    42 #include "svpaudioutility.h"

    43 #include "svpdtmfeventgenerator.h"

    44 

    45 // ---------------------------------------------------------------------------

    46 // CSVPEmergencySession::CSVPEmergencySession

    47 // ---------------------------------------------------------------------------

    48 //

    49 CSVPEmergencySession::CSVPEmergencySession( 

    50     CSVPUtility& aSVPUtility, 

    51     CMceManager& aMceManager, 

    52     TBool aIsLastProfile, 

    53     TBool aIsDummy )

    54     : iSVPUtility( aSVPUtility ), 

    55       iMceManager( aMceManager ), 

    56       iSessionExpires( KSVPDefaultSessionExpires ), 

    57       iIsLastProfile( aIsLastProfile ), 

    58       iIsDummy( aIsDummy ), 

    59       iIsDialed( EFalse ), 

    60       iIsLIRequestReady( ETrue )

    61     {

    62     }

    63 

    64 // ---------------------------------------------------------------------------

    65 // CSVPEmergencySession::ConstructL

    66 // ---------------------------------------------------------------------------

    67 //

    68 void CSVPEmergencySession::ConstructL( TUint32 aVoipProfileId, 

    69                                        const TDesC& aAddress, 

    70                                        const MCCPCallObserver& aObserver, 

    71                                        TBool aIsDummy )                                   

    72     {

    73     SVPDEBUG2("CSVPEmergencySession::ConstructL() IN, VoIP profile ID: %d", 

    74         aVoipProfileId)

    75 

    76     iEmergencyObserver = const_cast< MCCPCallObserver* >( &aObserver );

    77     iVoipProfileId = ( TInt )aVoipProfileId;

    78 

    79     // Start emergency timer, timeout 17 seconds

    80     StartTimerL( KSVPEmergencyTimeout, KSVPEmergencyExpired );

    81 

    82     if ( aIsDummy )

    83         {

    84         SVPDEBUG1("CSVPEmergencySession::ConstructL, dummy session")

    85         return;

    86         }

    87 

    88     // Initialize registries

    89     CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC(); // CS:1

    90     CSIP* sip = CSIP::NewLC( KSVPUid, *this ); // CS:2

    91     CSIPProfileRegistry* sipProfileRegistry = CSIPProfileRegistry::NewLC( 

    92         *sip, *this ); // CS:3

    93 

    94     // Find VoIP profile by its ID

    95     CRCSEProfileEntry* voipProfile = CRCSEProfileEntry::NewLC();  // CS:4

    96     reg->FindL( aVoipProfileId, *voipProfile );

    97 

    98     // Set Session Expires value

    99     iSessionExpires = ( TUint32 )voipProfile->iSIPSessionExpires;

   100     

   101     // There is only one (or zero) SIP profile per VoIP profile.

   102     // if profileId doesn't exist, report an error ( ECCPErrorGeneral ).

   103     if ( 0 == voipProfile->iIds.Count() )

   104         {

   105         SVPDEBUG1( "CSVPEmergencySession::ConstructL, no SIP profile, return" )

   106         CleanupStack::PopAndDestroy( 4, reg ); // CS:0

   107         ErrorOccurred( ECCPErrorGeneral );

   108         return;

   109         }

   110     CSIPProfile* sipProfile = sipProfileRegistry->ProfileL( 

   111         voipProfile->iIds[0].iProfileId );

   112     CleanupStack::PushL( sipProfile ); // CS:5

   113 

   114     // Get SIP profile ID

   115     User::LeaveIfError( 

   116         sipProfile->GetParameter( KSIPProfileId, iSipProfileId ) );

   117        

   118     // Get user AOR

   119     const TDesC8* userAor = NULL;

   120     User::LeaveIfError( sipProfile->GetParameter( KSIPUserAor, userAor ) );

   121     iUserAor = HBufC8::NewL( userAor->Length() );

   122     ( iUserAor->Des() ).Copy( *userAor );

   123     

   124     // Parse SIP URI

   125     HBufC8* recipient = HBufC8::NewLC( aAddress.Length() ); // CS:6

   126     ( recipient->Des() ).Copy( aAddress );

   127     CSVPUriParser* uriParser = CSVPUriParser::NewLC(); // CS:7

   128     iRecipientUri = uriParser->CompleteSipUriL( *recipient, *iUserAor, ETrue );

   129     CleanupStack::PopAndDestroy( 2, recipient ); // uriparser, recipient CS:5

   130 

   131     // Get registration status

   132     TBool registered( EFalse );

   133     sipProfile->GetParameter( KSIPProfileRegistered, registered );

   134 

   135     // Get SNAP ID

   136     TUint32 snapId( 0 );

   137     TInt errSnap = sipProfile->GetParameter( KSIPSnapId, snapId );

   138 

   139     // Define IAP ID

   140     if ( !registered && KErrNone == errSnap )

   141         {

   142         SVPDEBUG2("CSVPEmergencySession::ConstructL, snapId: %d", snapId)

   143         // Define IAP ID from SNAP ID, create WLAN connection

   144         iEmergencyConnection = CSVPEmergencyConnection::NewL( 

   145             CActive::EPriorityStandard, *this );

   146         iEmergencyConnection->ConnectWithSnapIdL( snapId );

   147         CleanupStack::PopAndDestroy( 5, reg );

   148         // reg, sip, sipProfileRegistry, voipProfile, sipProfile CS:0

   149         SVPDEBUG1("CSVPEmergencySession::ConstructL, return")

   150         return;

   151         }

   152     else

   153         {

   154         User::LeaveIfError( 

   155             sipProfile->GetParameter( KSIPAccessPointId, iIapId ) );

   156         }

   157 

   158     // Create MCE out session

   159     if ( registered )

   160         {

   161         SVPDEBUG1("CSVPEmergencySession::ConstructL, registered")

   162         iEmergencySession = CMceOutSession::NewL( 

   163             iMceManager, *sipProfile, *iRecipientUri );

   164         ConstructAudioStreamsL();

   165         }

   166     else

   167         {

   168         CreateUnregistedSessionL();

   169         }

   170     

   171     CleanupStack::PopAndDestroy( 5, reg ); 

   172     // CS:0 reg, sip, sipProfileRegistry, voipProfile, sipProfile

   173 

   174     // Request for position information

   175     RequestPosition( iIapId );

   176 

   177     SVPDEBUG1("CSVPEmergencySession::ConstructL() OUT")

   178     }

   179 

   180 // ---------------------------------------------------------------------------

   181 // CSVPEmergencySession::ConstructWithIapIdL

   182 // ---------------------------------------------------------------------------

   183 //

   184 void CSVPEmergencySession::ConstructWithIapIdL( 

   185     TUint32 aIapId, 

   186     const TDesC& aAddress, 

   187     const MCCPCallObserver& aObserver, 

   188     TBool aIsDummy )                                   

   189     {

   190     SVPDEBUG2("CSVPEmergencySession::ConstructWithIapIdL() In, IAP ID: %d", 

   191         aIapId)

   192 

   193     iEmergencyObserver = const_cast< MCCPCallObserver* >( &aObserver );

   194     iVoipProfileId = KErrNotFound;

   195     iIapId = aIapId;

   196     

   197     // Copy recipient address

   198     iAddress = HBufC8::NewL( aAddress.Length() );

   199     ( iAddress->Des() ).Copy( aAddress );

   200     

   201     // Start emergency timer, timeout 17 seconds

   202     StartTimerL( KSVPEmergencyTimeout, KSVPEmergencyExpired );

   203 

   204     if ( aIsDummy )

   205         {

   206         SVPDEBUG1("CSVPEmergencySession::ConstructWithIapIdL, dummy session")

   207         return;

   208         }

   209 

   210     // Request for SIP proxy address

   211     SVPDEBUG1("CSVPEmergencySession::ConstructWithIapIdL, SIP proxy address")

   212     iEmergencyConnection = CSVPEmergencyConnection::NewL( 

   213         CActive::EPriorityStandard, *this );

   214     iEmergencyConnection->ConnectL( iIapId );

   215     

   216     SVPDEBUG1("CSVPEmergencySession::ConstructWithIapIdL() Out")

   217     }

   218 

   219 // ---------------------------------------------------------------------------

   220 // CSVPEmergencySession::ContinueConstructWithIapIdL

   221 // ---------------------------------------------------------------------------

   222 //

   223 void CSVPEmergencySession::RequestSipProxyAddressL()

   224     {

   225     if ( NULL == iEmergencyConnection )

   226         {

   227         User::Leave( KErrGeneral );

   228         }

   229 

   230     iEmergencyConnection->RequestSipProxyAddressL( iIapId );

   231     }

   232 

   233 // ---------------------------------------------------------------------------

   234 // CSVPEmergencySession::ContinueConstructWithIapIdL

   235 // ---------------------------------------------------------------------------

   236 //

   237 void CSVPEmergencySession::ContinueConstructWithIapIdL( 

   238     const TDesC16& aSipProxyAddress )

   239     {

   240     SVPDEBUG2("CSVPEmergencySession::ContinueConstructWithIapIdL(),\

   241         SIP proxy address: %S", &aSipProxyAddress)

   242 

   243     if ( 0 == aSipProxyAddress.Length() )

   244         {

   245         User::Leave( KErrNotFound );

   246         }

   247 

   248     // Parse user AOR

   249     iUserAor = HBufC8::NewL(

   250         KSVPSipPrefix().Length() + 

   251         KSVPAnonymous().Length() + 

   252         KSVPAt().Length() + 

   253         aSipProxyAddress.Length() );

   254     TPtr8 userAorPtr = iUserAor->Des();

   255     userAorPtr.Copy( KSVPSipPrefix );

   256     userAorPtr.Append( KSVPAnonymous );

   257     userAorPtr.Append( KSVPAt );

   258     userAorPtr.Append( aSipProxyAddress );

   259 

   260     // Parse SIP URI

   261     SVPDEBUG1("CSVPEmergencySession::ContinueConstructWithIapIdL,\

   262         parse SIP URI")

   263     CSVPUriParser* uriParser = CSVPUriParser::NewLC(); // CS:1

   264     iRecipientUri = uriParser->CompleteSipUriL( *iAddress, *iUserAor, ETrue );

   265     CleanupStack::PopAndDestroy( uriParser ); // CS:0

   266 

   267     // Create MCE session

   268     CreateUnregistedSessionL();

   269 

   270     // Request for position information

   271     RequestPosition( iIapId );

   272     

   273     SVPDEBUG1("CSVPEmergencySession::ContinueConstructWithIapIdL() Out")

   274     }

   275 

   276 // ---------------------------------------------------------------------------

   277 // CSVPEmergencySession::NewL

   278 // ---------------------------------------------------------------------------

   279 //

   280 CSVPEmergencySession* CSVPEmergencySession::NewL(  

   281                                         CMceManager& aMceManager, 

   282                                         TUint32 aVoipProfileId, 

   283                                         const TDesC& aAddress, 

   284                                         const MCCPCallObserver& aObserver,

   285                                         CSVPUtility& aSVPUtility, 

   286                                         TBool aIsLastProfile, 

   287                                         TBool aIsDummy )

   288     {

   289     CSVPEmergencySession* self = new( ELeave ) CSVPEmergencySession( 

   290         aSVPUtility, aMceManager, aIsLastProfile, aIsDummy );

   291     CleanupStack::PushL( self );

   292     self->ConstructL( aVoipProfileId, aAddress, aObserver, aIsDummy );

   293     CleanupStack::Pop( self );

   294     return self;

   295     }

   296 

   297 // ---------------------------------------------------------------------------

   298 // CSVPEmergencySession::NewL

   299 // ---------------------------------------------------------------------------

   300 //

   301 CSVPEmergencySession* CSVPEmergencySession::NewL(  

   302                                         CMceManager& aMceManager, 

   303                                         const TDesC& aAddress, 

   304                                         const MCCPCallObserver& aObserver,

   305                                         CSVPUtility& aSVPUtility, 

   306                                         TUint32 aIapId, 

   307                                         TBool aIsLastProfile, 

   308                                         TBool aIsDummy )

   309     {

   310     CSVPEmergencySession* self = new( ELeave ) CSVPEmergencySession( 

   311         aSVPUtility, aMceManager, aIsLastProfile, aIsDummy );

   312     CleanupStack::PushL( self );

   313     self->ConstructWithIapIdL( aIapId, aAddress, aObserver, aIsDummy );

   314     CleanupStack::Pop( self );

   315     return self;

   316     }

   317 

   318 // ---------------------------------------------------------------------------

   319 // CSVPEmergencySession::~CSVPEmergencySession

   320 // ---------------------------------------------------------------------------

   321 //

   322 CSVPEmergencySession::~CSVPEmergencySession()

   323     {

   324     SVPDEBUG1("CSVPEmergencySession::~CSVPEmergencySession() In")

   325 

   326     StopTimers();  

   327     iTimers.Close();

   328 

   329     delete iEmergencySession;

   330     delete iFailedEmergencySession;

   331     

   332     delete iUserAor;

   333     delete iAddress;

   334     delete iRecipientUri;

   335     

   336     delete iPositionInformation;

   337     delete iPositioningProvider;

   338     

   339     delete iEmergencyConnection;

   340     

   341     delete iHoldController;

   342     

   343     delete iDTMFEventGenerator;

   344     

   345     delete iDtmfString;

   346 

   347     SVPDEBUG1("CSVPEmergencySession::~CSVPEmergencySession() Out")

   348     }

   349 

   350 // ---------------------------------------------------------------------------

   351 // CSVPEmergencySession::State

   352 // ---------------------------------------------------------------------------

   353 //

   354 MCCPCallObserver::TCCPCallState CSVPEmergencySession::State() const

   355     {

   356     SVPDEBUG1("CSVPEmergencySession::State()")

   357 

   358     // ccpState can be safely initialized with StatusIdle

   359     MCCPCallObserver::TCCPCallState ccpState = 

   360         MCCPCallObserver::ECCPStateIdle;

   361     

   362     switch ( iEmergencySession->State() )

   363         {

   364         case CMceSession::EIdle:

   365             SVPDEBUG1("CSVPEmergencySession::State, MCE EIdle")

   366             ccpState = MCCPCallObserver::ECCPStateIdle;

   367             break;

   368        

   369         case CMceSession::EProceeding:

   370             SVPDEBUG1("CSVPEmergencySession::State, MCE EProceeding")

   371             ccpState = MCCPCallObserver::ECCPStateConnecting;

   372             break;

   373             

   374         case CMceSession::EEstablished:

   375             SVPDEBUG1("CSVPEmergencySession::State, MCE EEstablished")

   376             ccpState = MCCPCallObserver::ECCPStateConnected;

   377             break;

   378             

   379         case CMceSession::ECancelling:

   380             SVPDEBUG1("CSVPEmergencySession::State, MCE ECancelling")

   381             ccpState = MCCPCallObserver::ECCPStateIdle;  

   382             break;

   383             

   384         case CMceSession::ETerminating:

   385             SVPDEBUG1("CSVPEmergencySession::State, MCE ETerminating")

   386             ccpState = MCCPCallObserver::ECCPStateDisconnecting;

   387             break;

   388             

   389         case CMceSession::ETerminated:

   390             SVPDEBUG1("CSVPEmergencySession::State, MCE ETerminated")

   391             if ( MCCPCallObserver::ECCPStateDisconnecting == iSessionState )

   392                 {

   393                 ccpState = MCCPCallObserver::ECCPStateDisconnecting;

   394                 }

   395             else

   396                 {

   397                 ccpState = MCCPCallObserver::ECCPStateIdle;     

   398                 }

   399             break;

   400             

   401         default:

   402             SVPDEBUG1("CSVPEmergencySession::State, DEFAULT")

   403             // This block should never be reached.

   404             break;

   405         }

   406 

   407     return ccpState;

   408     }

   409 

   410 // ---------------------------------------------------------------------------

   411 // Traps SessionStateChangedL

   412 // ---------------------------------------------------------------------------

   413 //

   414 void CSVPEmergencySession::SessionStateChanged( TInt aStatusCode )

   415     {

   416     TRAPD( err, SessionStateChangedL( aStatusCode ) )

   417     if ( err )

   418         {

   419         SVPDEBUG2("CSVPEmergencySession::SessionStateChanged, err: %d", err)

   420         }

   421     }

   422 

   423 // ---------------------------------------------------------------------------

   424 // Session connection state changed

   425 // ---------------------------------------------------------------------------

   426 //

   427 void CSVPEmergencySession::SessionConnectionStateChanged(

   428     CMceSession& aSession, TBool aActive )

   429     {

   430     SVPDEBUG2("CSVPEmergencySession::SessionConnectionStateChanged - %d", 

   431         aActive)

   432     

   433     if ( iEmergencySession == &aSession && aActive )

   434         {

   435         ProceedDial();

   436         }

   437     }

   438 

   439 // ---------------------------------------------------------------------------

   440 // Stream state changed

   441 // ---------------------------------------------------------------------------

   442 //

   443 void CSVPEmergencySession::StreamStateChanged( CMceMediaStream& aStream )

   444     {

   445     SVPDEBUG1("CSVPEmergencySession::StreamStateChanged()")

   446     

   447     if ( CMceMediaStream::EDisabled == aStream.State() &&

   448          CMceSession::EEstablished == aStream.Session()->State() )

   449         {

   450         // Remote end died

   451         iEmergencyObserver->CallStateChanged( 

   452             MCCPCallObserver::ECCPStateDisconnecting, NULL );

   453         TRAP_IGNORE( StartTimerL( 

   454             KSVPTerminatingTime, KSVPRemoteEndDiedExpired ) )

   455         }

   456     else if ( CMceMediaStream::EStreaming == aStream.State() )

   457         {

   458         SVPDEBUG1("CSVPEmergencySession::StreamStateChanged() - EStreaming")

   459         StopTimer( KSVPRemoteEndDiedExpired );

   460         }

   461     }

   462 

   463 // ---------------------------------------------------------------------------

   464 // Handle incoming request, i.e. hold

   465 // ---------------------------------------------------------------------------

   466 //

   467 void CSVPEmergencySession::IncomingRequestL( 

   468     CMceInSession* aUpdatedSession, TMceTransactionDataContainer aContainer )

   469     {

   470     SVPDEBUG1("CSVPEmergencySession::IncomingRequest() In")

   471 

   472     if ( !aUpdatedSession )

   473         {

   474         User::Leave( KErrArgument );

   475         }

   476 

   477     // Create hold controller

   478     if ( NULL == iHoldController )

   479         {

   480         iHoldController = CSVPHoldController::NewL( 

   481             *iEmergencySession,

   482             aContainer,

   483             this,

   484             ETrue );

   485         }

   486 

   487     iEmergencySession = aUpdatedSession;

   488 

   489     User::LeaveIfError( iHoldController->IncomingRequest( aUpdatedSession ) );

   490     }

   491 

   492 // ---------------------------------------------------------------------------

   493 // Returns ETrue, if hold controller exists

   494 // ---------------------------------------------------------------------------

   495 //

   496 TBool CSVPEmergencySession::HasHoldController() const

   497     {

   498     if ( iHoldController )

   499         {

   500         return ETrue;

   501         }

   502     else

   503         {

   504         return EFalse;

   505         }

   506     }

   507 

   508 // ---------------------------------------------------------------------------

   509 // Returns reference to hold controller

   510 // ---------------------------------------------------------------------------

   511 //    

   512 CSVPHoldController& CSVPEmergencySession::HoldController() const

   513     {

   514     return *iHoldController;

   515     }

   516 

   517 // ---------------------------------------------------------------------------

   518 // Handles hold session state changes

   519 // ---------------------------------------------------------------------------

   520 //

   521 void CSVPEmergencySession::HoldSessionStateChangedL( CMceSession& aSession )

   522     {

   523     SVPDEBUG1("CSVPEmergencySession::HoldSessionStateChangedL() In")

   524     

   525     if ( NULL == iHoldController )

   526         {

   527         User::Leave( KErrNotFound );

   528         }

   529 

   530     if ( iHoldController->HoldInProgress() )

   531         {

   532         SVPDEBUG1(

   533             "CSVPEmergencySession::HoldSessionStateChangedL, in progress")

   534         StopTimers();

   535         if ( iHoldController->ContinueHoldProcessing( aSession ) )

   536             {

   537             iEmergencyObserver->ErrorOccurred( ECCPLocalHoldFail, NULL );

   538             }

   539         }

   540 

   541     SVPDEBUG1("CSVPEmergencySession::HoldSessionStateChangedL() Out")

   542     }

   543 

   544 // ---------------------------------------------------------------------------

   545 // Returns DTMF observer

   546 // ---------------------------------------------------------------------------

   547 //

   548 const MCCPDTMFObserver& CSVPEmergencySession::DtmfObserver()

   549     {

   550     return *iDtmfObserver;

   551     }

   552 

   553 // ---------------------------------------------------------------------------

   554 // Sets DTMF observer

   555 // ---------------------------------------------------------------------------

   556 //

   557 void CSVPEmergencySession::SetDtmfObserver( 

   558     const MCCPDTMFObserver& aObserver )

   559     {

   560     SVPDEBUG1("CSVPEmergencySession::SetDtmfObserver()")

   561     

   562     iDtmfObserver = const_cast<MCCPDTMFObserver*>( &aObserver );

   563     }

   564 

   565 // ---------------------------------------------------------------------------

   566 // Starts DTMF tone

   567 // ---------------------------------------------------------------------------

   568 //

   569 TInt CSVPEmergencySession::StartDtmfTone( const TChar aTone )

   570     {

   571     SVPDEBUG1("CSVPEmergencySession::StartDtmfTone() In")

   572     

   573     TInt dtmfErr( KErrNone );

   574     if ( iSVPUtility.GetDTMFMode() )

   575         {

   576         const RPointerArray<CMceMediaStream>& streams = 

   577             iEmergencySession->Streams();

   578         TInt count = streams.Count();

   579         while ( count )

   580             {

   581             count--;

   582             CMceMediaStream& mediaStream = *streams[ count ];

   583             if ( SVPAudioUtility::DtmfActionCapableStream( mediaStream ) )

   584                 {

   585                 TRAP( dtmfErr, mediaStream.Source()->StartDtmfToneL( aTone ) )

   586                 }

   587             else

   588                 {

   589                 dtmfErr = KErrNotSupported;

   590                 }

   591             

   592             if ( KErrNone != dtmfErr )

   593                 {

   594                 SVPDEBUG2("CSVPEmergencySession::StartDtmfToneL dtmfErr: %d",

   595                     dtmfErr)

   596                 return dtmfErr;

   597                 }

   598             }

   599         }

   600     else

   601         {

   602         iDtmfTone = aTone;

   603         DtmfObserver().HandleDTMFEvent( MCCPDTMFObserver::ECCPDtmfManualStart, 

   604                                         KErrNone, 

   605                                         aTone );

   606         }

   607     SVPDEBUG1("CSVPEmergencySession::StartDtmfTone() Out")

   608     return dtmfErr;

   609     }

   610 

   611 // ---------------------------------------------------------------------------

   612 // Stops DTMF tone

   613 // ---------------------------------------------------------------------------

   614 //

   615 TInt CSVPEmergencySession::StopDtmfTone()

   616     {

   617     SVPDEBUG1("CSVPEmergencySession::StopDtmfTone() In")

   618     

   619     TInt dtmfErr( KErrNone );

   620     if ( iSVPUtility.GetDTMFMode() )

   621         {

   622         const RPointerArray<CMceMediaStream>& streams = 

   623             iEmergencySession->Streams();

   624         TInt count = streams.Count();

   625         while( count )

   626             {

   627             count--;

   628             CMceMediaStream& mediaStream = *streams[ count ];

   629             if ( SVPAudioUtility::DtmfActionCapableStream( mediaStream ) )

   630                 {

   631                 TRAP( dtmfErr, mediaStream.Source()->StopDtmfToneL() )

   632                 }

   633             // NOP with inband.

   634             

   635             if ( KErrNone != dtmfErr )

   636                 {

   637                 SVPDEBUG2("CSVPEmergencySession::StopDtmfTone dtmfErr: %d",

   638                     dtmfErr)

   639                 

   640                 return dtmfErr;

   641                 }

   642             }

   643         }

   644     else

   645         {

   646         DtmfObserver().HandleDTMFEvent( MCCPDTMFObserver::ECCPDtmfManualStop, 

   647                                         KErrNone, 

   648                                         iDtmfTone );

   649         }

   650     SVPDEBUG1("CSVPEmergencySession::StopDtmfTone() Out")

   651     return dtmfErr;

   652     }

   653 

   654 // ---------------------------------------------------------------------------

   655 // Sends DTMF tone string

   656 // ---------------------------------------------------------------------------

   657 //

   658 TInt CSVPEmergencySession::SendDtmfToneString( const TDesC& aString )

   659     {

   660     SVPDEBUG1("CSVPEmergencySession::SendDtmfToneString() In")

   661     

   662     TInt error( KErrNone );

   663 

   664     TChar dtmfPause('p');

   665     // MCE calls if outband DTMF.

   666     // Exception is character 'p' which is handled always locally

   667     if ( !iSVPUtility.GetDTMFMode() ||

   668         ( aString.Length() == 1 &&

   669           dtmfPause == aString[0] ) )   

   670         {

   671         delete iDtmfString;

   672         iDtmfString = NULL;

   673         TRAP( error, iDtmfString = HBufC::NewL( aString.Length() ) );

   674         if ( KErrNone != error )

   675             {

   676             return error;

   677             }

   678                        

   679         *iDtmfString = aString;

   680         iDtmfLex.Assign( *iDtmfString );

   681         

   682         SVPDEBUG1("CSVPEmergencySession::SendDtmfToneString, inband")

   683         if ( !iDTMFEventGenerator )

   684             {

   685             TRAP( error,

   686             iDTMFEventGenerator = CSVPDTMFEventGenerator::NewL( *this ) );

   687             }

   688         

   689         if ( KErrNone != error )

   690             {

   691             return error;    

   692             }

   693         

   694         // Dtmf pause interval is 2.5s

   695         TBool pauseChar = ( aString.Length() == 1 && 

   696                             dtmfPause == aString[0] ); 

   697         // start events

   698         iDTMFEventGenerator->StartDtmfEvents( aString.Length(), pauseChar );

   699         }

   700     else

   701         {

   702         SVPDEBUG1("CSVPEmergencySession::SendDtmfToneString, outband")

   703         

   704         const RPointerArray<CMceMediaStream>& streams = 

   705             iEmergencySession->Streams();

   706         TInt count = streams.Count();

   707         while( count && KErrNone == error )

   708             {

   709             count--;

   710             CMceMediaStream& mediaStream = *streams[ count ];

   711             if ( SVPAudioUtility::DtmfActionCapableStream( mediaStream ) )

   712                 {

   713                 TRAP( error, mediaStream.Source()->SendDtmfToneSequenceL( 

   714                     aString ) )

   715                 }

   716             else

   717                 {

   718                 error = KErrNotSupported;

   719                 }

   720             }

   721         }

   722 

   723     SVPDEBUG2("CSVPEmergencySession::SendDtmfToneString, error: %d", error)

   724     return error;

   725     }

   726 

   727 // ---------------------------------------------------------------------------

   728 // Cancels DTMF tone string sending

   729 // ---------------------------------------------------------------------------

   730 //

   731 TInt CSVPEmergencySession::CancelDtmfStringSending()

   732     {

   733     SVPDEBUG1("CSVPEmergencySession::CancelDtmfStringSending() In")

   734     

   735     TInt error( KErrNone );

   736     if ( !iSVPUtility.GetDTMFMode() ) 

   737         {

   738         error = KErrNotFound;

   739         if ( iDTMFEventGenerator )

   740             {

   741             iDTMFEventGenerator->StopEvents();

   742             error = KErrNone;

   743             }

   744         }

   745     else 

   746         {

   747         SVPDEBUG1("CSVPEmergencySession::CancelDtmfStringSending, outband")

   748         error = KErrNotSupported;

   749         }

   750 

   751     SVPDEBUG2("CSVPEmergencySession::CancelDtmfStringSending, error: %d", 

   752         error)

   753     return error;

   754     }

   755 

   756 // ---------------------------------------------------------------------------

   757 // CSVPEmergencySession::Dial

   758 // ---------------------------------------------------------------------------

   759 //

   760 TInt CSVPEmergencySession::Dial( const TDesC& /*aRecipient*/ )

   761     {

   762     SVPDEBUG1("CSVPEmergencySession::Dial()")

   763 

   764     if ( iIsDummy )

   765         {

   766         SVPDEBUG1("CSVPEmergencySession::Dial, dummy session")

   767         ErrorOccurred( ECCPErrorGeneral );

   768         return KErrNone;

   769         }

   770 

   771     iIsDialed = ETrue;

   772     ProceedDial();

   773 

   774     iEmergencyObserver->CallStateChanged( 

   775         MCCPCallObserver::ECCPStateDialling, NULL );

   776 

   777     return KErrNone;

   778     }

   779 

   780 // ---------------------------------------------------------------------------

   781 // CSVPEmergencySession::Cancel

   782 // ---------------------------------------------------------------------------

   783 //

   784 TInt CSVPEmergencySession::Cancel()

   785     {

   786     SVPDEBUG1("CSVPEmergencySession::Cancel()")

   787     

   788     TInt error( KErrNone );    

   789     if ( iEmergencySession )

   790         {

   791         TRAP( error, ( ( CMceOutSession* )iEmergencySession )->CancelL() )

   792         if ( error )

   793             {

   794             SVPDEBUG2("CSVPEmergencySession::Cancel, error: %d", error)

   795             iEmergencyObserver->CallStateChanged( 

   796                 MCCPCallObserver::ECCPStateIdle, NULL );

   797             }

   798         }

   799     else

   800         {

   801         iEmergencyObserver->CallStateChanged( 

   802             MCCPCallObserver::ECCPStateIdle, NULL );

   803         }

   804     

   805     return error;

   806     }

   807 

   808 // ---------------------------------------------------------------------------

   809 // CSVPEmergencySession::HangUp

   810 // ---------------------------------------------------------------------------

   811 //

   812 TInt CSVPEmergencySession::HangUp()

   813     {

   814     SVPDEBUG1("CSVPEmergencySession::HangUp()")

   815 

   816     if ( NULL == iEmergencySession )

   817         {

   818         iEmergencyObserver->CallStateChanged( 

   819             MCCPCallObserver::ECCPStateIdle, NULL );

   820         return KErrNone;

   821         }

   822     

   823     CMceSession::TState mceState = iEmergencySession->State();

   824     SVPDEBUG2("CSVPEmergencySession::HangUp, MCE state: %d", mceState)

   825     

   826     TInt err( KErrNone );

   827 

   828     if ( CMceSession::EEstablished == mceState || 

   829          CMceSession::EOffering == mceState )

   830         {

   831         if ( CMceSession::EEstablished == mceState )

   832             {

   833             TRAP( err, iEmergencySession->TerminateL() )

   834             }

   835         else // CMceSession::EOffering

   836             {

   837             err = Cancel();

   838             }

   839         

   840         if ( !err )

   841             {

   842             iEmergencyObserver->CallStateChanged( 

   843                 MCCPCallObserver::ECCPStateDisconnecting, NULL );

   844             TRAP_IGNORE( StartTimerL( 

   845                 KSVPMoHangupTerminatingTime, KSVPHangUpTimerExpired ) )

   846             }   

   847         }    

   848     else // Wrong MCE state

   849         {

   850         SVPDEBUG2("CSVPEmergencySession::HangUp, wrong state: %d ", mceState )

   851         StopTimers();

   852         iEmergencyObserver->CallStateChanged( 

   853             MCCPCallObserver::ECCPStateIdle, NULL );

   854         }

   855     

   856     return err;

   857     }

   858 

   859 // ---------------------------------------------------------------------------

   860 // CSVPEmergencySession::Answer

   861 // ---------------------------------------------------------------------------

   862 //

   863 TInt CSVPEmergencySession::Answer()

   864     {

   865     SVPDEBUG1("CSVPEmergencySession::Answer()")

   866     return KErrNotSupported;

   867     }

   868 

   869 // ---------------------------------------------------------------------------

   870 // CSVPEmergencySession::TimedOut

   871 // ---------------------------------------------------------------------------

   872 // 

   873 void CSVPEmergencySession::TimedOut( TInt aTimerId )

   874     {

   875     SVPDEBUG1("CSVPEmergencySession::TimedOut()")

   876     

   877      // Find the timer and delete it.

   878     for ( TInt t = 0; t < iTimers.Count(); )

   879         {

   880         if ( iTimers[t] ->Id() == aTimerId )

   881             {

   882             delete iTimers[t];

   883             iTimers.Remove( t );

   884             }

   885         else

   886             {

   887             t++;

   888             }

   889         }

   890 

   891     switch ( aTimerId )

   892         {

   893         case KSVPHangUpTimerExpired:

   894             SVPDEBUG1("CSVPEmergencySession::TimedOut, hangup")

   895             iEmergencyObserver->CallStateChanged( 

   896                 MCCPCallObserver::ECCPStateIdle, NULL );

   897             break;

   898 

   899         case KSVPTerminationTimerExpired:

   900             SVPDEBUG1("CSVPEmergencySession::TimedOut, termination")

   901             iSessionState = MCCPCallObserver::ECCPStateIdle;

   902             iEmergencyObserver->CallStateChanged( State(), NULL );

   903             break;

   904 

   905         case KSVPInviteTimerExpired:

   906             SVPDEBUG1("CSVPEmergencySession::TimedOut, invite")

   907             // Connection made but no answer, no point trying other profiles

   908             ErrorOccurred( ECCPEmergencyFailed );

   909             Cancel();

   910             iEmergencyObserver->CallStateChanged( 

   911                 MCCPCallObserver::ECCPStateDisconnecting, NULL );

   912             iEmergencyObserver->CallStateChanged( 

   913                 MCCPCallObserver::ECCPStateIdle, NULL );

   914             break;

   915         

   916         case KSVPEmergencyExpired:

   917             SVPDEBUG1("CSVPEmergencySession::TimedOut, emergency")

   918             ErrorOccurred( ECCPErrorTimedOut );

   919             break;

   920         

   921         case KSVPRemoteEndDiedExpired:

   922             SVPDEBUG1("CSVPEmergencySession::TimedOut, remote end died")

   923             iEmergencyObserver->CallStateChanged( 

   924                 MCCPCallObserver::ECCPStateIdle, NULL );

   925             break;

   926         

   927         default:

   928             SVPDEBUG1("CSVPEmergencySession::TimedOut, no timer found")

   929             break;

   930         }    

   931     }

   932 

   933 // ---------------------------------------------------------------------------

   934 // From class MSIPObserver

   935 // CSVPEmergencySession::IncomingRequest

   936 // ---------------------------------------------------------------------------

   937 // 

   938 void CSVPEmergencySession::IncomingRequest( 

   939     TUint32 /*aIapId*/, CSIPServerTransaction* /*aTransaction*/ )

   940     {

   941     }

   942 

   943 // ---------------------------------------------------------------------------

   944 // From class MSIPObserver

   945 // CSVPEmergencySession::TimedOut

   946 // ---------------------------------------------------------------------------

   947 //     

   948 void CSVPEmergencySession::TimedOut( 

   949     CSIPServerTransaction& /*aSIPServerTransaction*/ )

   950     {

   951     }

   952 

   953 // ---------------------------------------------------------------------------

   954 // From class MSIPProfileRegistryObserver

   955 // CSVPEmergencySession::ProfileRegistryErrorOccurred

   956 // ---------------------------------------------------------------------------

   957 //  

   958 void CSVPEmergencySession::ProfileRegistryErrorOccurred( 

   959     TUint32 /*aSIPProfileId*/, TInt /*aError*/ )

   960     {

   961     }

   962 

   963 // ---------------------------------------------------------------------------

   964 // From class MSIPProfileRegistryObserver

   965 // CSVPEmergencySession::ProfileRegistryEventOccurred

   966 // ---------------------------------------------------------------------------

   967 //  

   968 void CSVPEmergencySession::ProfileRegistryEventOccurred( 

   969     TUint32 /*aProfileId*/, TEvent /*aEvent*/ )

   970     {

   971     }

   972 

   973 // ---------------------------------------------------------------------------

   974 // From class MSVPPositioningProviderObserver.

   975 // Handles successful positioning requests

   976 // ---------------------------------------------------------------------------

   977 //

   978 void CSVPEmergencySession::PositioningRequestComplete( 

   979     const TDesC8& aPosition )

   980     {

   981     SVPDEBUG2("CSVPEmergencySession::PositioningRequestComplete() - \

   982      length: %d", aPosition.Length())

   983     

   984     iIsLIRequestReady = ETrue;

   985     

   986     delete iPositionInformation;

   987     iPositionInformation = NULL;

   988     TRAPD( err, iPositionInformation = HBufC8::NewL( aPosition.Length() ) )

   989     if ( !err )

   990         {

   991         ( iPositionInformation->Des() ).Copy( aPosition );

   992         }

   993 

   994     iPositioningProvider->CloseModule();

   995     ProceedDial();

   996     }

   997 

   998 // ---------------------------------------------------------------------------

   999 // From class MSVPPositioningProviderObserver.

  1000 // Handles failed positioning requests

  1001 // ---------------------------------------------------------------------------

  1002 //

  1003 #ifdef _DEBUG

  1004 void CSVPEmergencySession::PositioningErrorOccurred( TInt aError )

  1005 #else

  1006 void CSVPEmergencySession::PositioningErrorOccurred( TInt /*aError*/ )

  1007 #endif // _DEBUG

  1008     {

  1009     SVPDEBUG2("CSVPEmergencySession::PositioningErrorOccurred( %d )", aError)

  1010     

  1011     iIsLIRequestReady = ETrue;

  1012     iPositioningProvider->CloseModule();

  1013     ProceedDial();

  1014     }

  1015 

  1016 // ---------------------------------------------------------------------------

  1017 // From class MSVPEmergencyConnectionObserver.

  1018 // SNAP connection is established

  1019 // ---------------------------------------------------------------------------

  1020 //

  1021 void CSVPEmergencySession::SnapConnected()

  1022     {

  1023     SVPDEBUG1("CSVPEmergencySession::SnapConnected() In")

  1024     

  1025     if ( NULL == iEmergencyConnection )

  1026         {

  1027         SVPDEBUG1("CSVPEmergencySession::SnapConnected, no connection object")

  1028         ErrorOccurred( ECCPErrorGeneral );

  1029         return;

  1030         }

  1031     

  1032     TInt err = iEmergencyConnection->IapId( iIapId );

  1033     SVPDEBUG2("CSVPEmergencySession::ConnectionReady, IAP ID: %d", iIapId)

  1034     if ( err )

  1035         {

  1036         SVPDEBUG2("CSVPEmergencySession::SnapConnected, error: %d", err)

  1037         ErrorOccurred( ECCPErrorGeneral );

  1038         return;

  1039         }

  1040 

  1041     TRAP( err, CreateUnregistedSessionL() )

  1042     if ( err )

  1043         {

  1044         SVPDEBUG2("CSVPEmergencySession::SnapConnected, error: %d", err)

  1045         ErrorOccurred( ECCPErrorGeneral );

  1046         return;

  1047         }

  1048 

  1049     // Request for position information

  1050     RequestPosition( iIapId );    

  1051     

  1052     ProceedDial();

  1053         

  1054     SVPDEBUG1("CSVPEmergencySession::SnapConnected() Out")

  1055     }

  1056 

  1057 // ---------------------------------------------------------------------------

  1058 // From class MSVPEmergencyConnectionObserver.

  1059 // Connection is established

  1060 // ---------------------------------------------------------------------------

  1061 //    

  1062 void CSVPEmergencySession::Connected()

  1063     {

  1064     SVPDEBUG1("CSVPEmergencySession::Connected()")

  1065     

  1066     TRAPD( error, RequestSipProxyAddressL() )

  1067     if ( error )

  1068         {

  1069         SVPDEBUG2("CSVPEmergencySession::Connected, error: %d", error)

  1070         ErrorOccurred( ECCPErrorGeneral );

  1071         }

  1072     }

  1073 

  1074 // ---------------------------------------------------------------------------

  1075 // From class MSVPEmergencyConnectionObserver.

  1076 // SIP proxy address ready

  1077 // ---------------------------------------------------------------------------

  1078 //    

  1079 void CSVPEmergencySession::SipProxyAddressReady( const TDesC16& aAddress )

  1080     {

  1081     SVPDEBUG1("CSVPEmergencySession::SipProxyAddressReady()")

  1082     

  1083     TRAPD( error, ContinueConstructWithIapIdL( aAddress ) )

  1084     if ( error )

  1085         {

  1086         SVPDEBUG2("CSVPEmergencySession::SipProxyAddressReady, error: %d", 

  1087             error)

  1088         ErrorOccurred( ECCPErrorGeneral );

  1089         }

  1090     }

  1091 

  1092 // ---------------------------------------------------------------------------

  1093 // From class MSVPEmergencyConnectionObserver.

  1094 // Connection error has occurred

  1095 // ---------------------------------------------------------------------------

  1096 //

  1097 #ifdef _DEBUG

  1098 void CSVPEmergencySession::ConnectionError( TInt aError )

  1099 #else

  1100 void CSVPEmergencySession::ConnectionError( TInt /*aError*/ )

  1101 #endif // _DEBUG

  1102     {

  1103     SVPDEBUG2("CSVPEmergencySession::ConnectionError, error: %d", aError)

  1104     

  1105     ErrorOccurred( ECCPErrorGeneral );

  1106     }

  1107 

  1108 // ---------------------------------------------------------------------------

  1109 // From class MSVPHoldObserver.

  1110 // Local hold

  1111 // ---------------------------------------------------------------------------

  1112 //

  1113 void CSVPEmergencySession::SessionLocallyHeld()

  1114     {

  1115     SVPDEBUG1("CSVPEmergencySession::SessionLocallyHeld()")

  1116     iEmergencyObserver->CallStateChanged( MCCPCallObserver::ECCPStateHold, 

  1117                                           NULL );

  1118     }

  1119 

  1120 // ---------------------------------------------------------------------------

  1121 // From class MSVPHoldObserver.

  1122 // Local resume

  1123 // ---------------------------------------------------------------------------

  1124 //

  1125 void CSVPEmergencySession::SessionLocallyResumed()

  1126     {

  1127     SVPDEBUG1("CSVPEmergencySession::SessionLocallyResumed()")

  1128     iEmergencyObserver->CallStateChanged( 

  1129         MCCPCallObserver::ECCPStateConnected, NULL );

  1130     }

  1131 

  1132 // ---------------------------------------------------------------------------

  1133 // From class MSVPHoldObserver.

  1134 // Remote hold