diff -r 7d48bed6ce0c -r 987c9837762f satengine/SatServer/Commands/SetUpCallCmd/src/CSetUpCallHandler.cpp
--- a/satengine/SatServer/Commands/SetUpCallCmd/src/CSetUpCallHandler.cpp	Tue Aug 31 15:45:17 2010 +0300
+++ b/satengine/SatServer/Commands/SetUpCallCmd/src/CSetUpCallHandler.cpp	Wed Sep 01 12:15:03 2010 +0100
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies). 
+* Copyright (c) 2002-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"
@@ -14,9 +14,13 @@
 * Description:  Handles SetUpCall command
 *
 */
-#include    <e32base.h>
-#include    <etelmm.h>
+
+
+#include    <aiwinternaldialdata.h>
+#include    <aiwdialdataext.h>
+
 #include    <exterror.h>
+#include    <ccpdefs.h>
 
 #include    "MSatApi.h"
 #include    "MSatUtils.h"
@@ -24,7 +28,6 @@
 #include    "MSatUiSession.h"
 #include    "SatSOpcodes.h"
 #include    "MSatSUiClientHandler.h"
-#include    "csetupcallrequesthandler.h"
 #include    "CSetUpCallHandler.h"
 #include    "TSatExtErrorUtils.h"
 #include    "SatLog.h"
@@ -41,21 +44,10 @@
 const TUint8 KWildChar( 0x77 );
 const TUint8 KExpansionChar( 0x2E );
 
-/** Maximum name length. */ 
-const TInt KSatMaximumNameLength = 50;
-
-/** Maximum phone number length same as  used by phone. */ 
-const TInt KSatMaximumPhoneNumberLength = 100;
-
-/** The subaddress length, see ITU-T I.330 and 3GPP TS 11.14. */ 
-const TInt KSatSubAddressLength = 21;
-
-/** The maximum bearer length. The bearer capabilities as 
-defined in GSM 04.08. */ 
-const TInt KSatBearerLength = 14;
-
-
 _LIT( KFixedSimEmergencyNumber, "112" );
+_LIT8( KContentType, "*" );
+// 3GPP TS 24.008
+const TInt KMaximumPhoneNumberLength( 80 );
 
 // ======== MEMBER FUNCTIONS ========
 
@@ -87,9 +79,18 @@
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::~CSetUpCallHandler calling" )
 
     Cancel();
-    
-    delete iRequestHandler;
-    iRequestHandler = NULL;
+
+    if ( iServiceHandler )
+        {
+        delete iServiceHandler;
+        iServiceHandler = NULL;
+        }
+
+    if ( iEmergencyCallApi )
+        {
+        delete iEmergencyCallApi;
+        iEmergencyCallApi = NULL;
+        }
 
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::~CSetUpCallHandler exiting" )
     }
@@ -144,15 +145,15 @@
     if ( iQueryRsp.iAccepted )
         {
         // User accepted the call, make the call
-        if( iRequestHandler )
+        TRAPD( error, DoSetupCallL() );
+
+        if ( KErrNone != error )
             {
-            DoSetupCall( *iRequestHandler );
-            }
-        else
-            {
-            CompleteSetupCall(
-                RSat::KMeUnableToProcessCmd,
-                RSat::KNoSpecificMeProblem );
+            LOG2( NORMAL, 
+            "SETUPCALL: CSetUpCallHandler::ClientResponse Dial failed: %i", 
+            error )
+
+            CompleteSetupCall( RSat::KCmdDataNotUnderstood );
             }
         }
     else
@@ -187,10 +188,6 @@
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::DoCancel calling" )
 
     iUtils->USatAPI().NotifySetUpCallCancel();
-    if( iRequestHandler )
-        {
-        iRequestHandler->Cancel();
-        }
 
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::DoCancel exiting" )
     }
@@ -394,13 +391,15 @@
         {
         LOG( SIMPLE, 
         "SETUPCALL: CSetUpCallHandler::HandleCommand iEmergencyCall true" )
-        if ( iRequestHandler )
+        TRAPD( err, CreateEmergencyCallL() );
+        if ( KErrNone != err )
             {
-            CreateEmergencyCall( *iRequestHandler );
-            }
-        else
-            {
+            LOG2( SIMPLE, 
+            "SETUPCALL: CSetUpCallHandler::HandleCommand DialEmergencyCallL \
+            failed: %d", err )
+
             iEmergencyCall = EFalse;
+
             // Set the terminal response info.
             CompleteSetupCall(
                 RSat::KMeUnableToProcessCmd,
@@ -521,49 +520,122 @@
     }
 
 // -----------------------------------------------------------------------------
-// CSetUpCallHandler::SetupCallRequestComplete
-// (other items were commented in a header).
+// From class MAiwNotifyCallback.
+// Called when dial request is completed.
 // -----------------------------------------------------------------------------
 //
-void CSetUpCallHandler::SetupCallRequestComplete( TInt aErrCode )
+TInt CSetUpCallHandler::HandleNotifyL(
+    const TInt aCmdId,
+    const TInt aEventId,
+    CAiwGenericParamList& aEventParamList,
+    const CAiwGenericParamList& /*aInParamList*/ )
     {
-    LOG( SIMPLE,
-    "SETUPCALL: CSetUpCallHandler::SetupCallRequestComplete calling" )
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::HandleNotifyL calling" )
+
+    if ( KAiwCmdCall == aCmdId )
+        {
+        LOG2( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::HandleNotifyL  event: %d", aEventId )
+        switch ( aEventId )
+            {
+            case KAiwEventError:
+            case KAiwEventCompleted:
+            case EGenericParamError: // This is due CCaUiPlugin behaviour.
+                                     // Also overlaps event KAiwEventStarted.
+                {
+                LOG( SIMPLE, 
+                "SETUPCALL: CSetUpCallHandler::HandleNotifyL SetupCall \
+                Completed" )
+
+                // Fetch completion status.
+                TInt index( 0 );
+                const TAiwGenericParam* param = aEventParamList.FindFirst(
+                    index, EGenericParamError );
+
+                if ( param )
+                    {
+                    LOG( SIMPLE, 
+                    "SETUPCALL: CSetUpCallHandler::HandleNotifyL param true" )
+                    
+                    // Converts error number to symbian-formatted before 
+                    // calling CompleteSetupCallWithStatus.
+                    TInt error = TccpErrorToSymbianError( 
+                        param->Value().AsTInt32() );
+                    CompleteSetupCallWithStatus( error );
+                    }
+                else
+                    {
+                    CompleteSetupCall( RSat::KSuccess );
+                    }
+                }
+                break;
 
-    LOG2( NORMAL,
-    "SETUPCALL: CSetUpCallHandler::SetupCallRequestComplete aErrCode %d",
-    aErrCode )
-    
-    if( !iEmergencyCall )
+            case KAiwEventCanceled:
+            case KAiwEventStopped:
+            case KAiwEventQueryExit:
+                {
+                LOG( SIMPLE, 
+                "SETUPCALL: CSetUpCallHandler::HandleNotifyL SetupCall \
+                cancelled" )
+
+                CompleteSetupCallWithStatus( KErrAbort );
+                }
+                break;
+
+            case KAiwEventOutParamCheck:
+            case KAiwEventInParamCheck:
+                {
+                LOG( SIMPLE, 
+                "SETUPCALL: CSetUpCallHandler::HandleNotifyL SetupCall param \
+                fail" )
+
+                CompleteSetupCall( RSat::KCmdDataNotUnderstood );
+                }
+                break;
+
+            default:
+                {
+                LOG( SIMPLE, 
+                "SETUPCALL: CSetUpCallHandler::HandleNotifyL Unknown event \
+                id" )
+                }
+                break;
+
+            }
+        }
+
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::HandleNotifyL exiting" )
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// From class MAiwNotifyCallback.
+// Called when dial request is completed.
+// -----------------------------------------------------------------------------
+//
+void CSetUpCallHandler::HandleEmergencyDialL( const TInt aStatus )
+    {
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::HandleEmergencyDialL calling" )
+
+    iEmergencyCall = EFalse;
+
+    if ( KErrNone == aStatus )
         {
-        CompleteSetupCallWithStatus( aErrCode );
+        // Set result
+        CompleteSetupCall( RSat::KSuccess );
         }
     else
         {
-        iEmergencyCall = EFalse;
+        CompleteSetupCall(
+            RSat::KNetworkUnableToProcessCmd,
+            RSat::KNoSpecificMeProblem );
 
-        if ( KErrNone == aErrCode )
-            {
-            // Set result
-            CompleteSetupCall( RSat::KSuccess );
-            }
-        else
-            {
-            // The emergency call implementation 
-            // before S60 SAT migration from AIW to EtelMM
-            // According current information, no requirement for this.
-            // We don't return extended network error.
-            CompleteSetupCall(
-                RSat::KNetworkUnableToProcessCmd,
-                RSat::KNoSpecificMeProblem );
+        LOG( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::HandleEmergencyDialL Network unable \
+        to process this" )
+        }
 
-            LOG( SIMPLE,
-            "SETUPCALL: CSetUpCallHandler::HandleEmergencyDialL Network unable \
-            to process this" )
-            }
-        }
-    LOG2( NORMAL,
-        "SETUPCALL: CSetUpCallHandler::SetupCallRequestComplete exiting %d", aErrCode )
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::HandleEmergencyDialL exiting" )
     }
 
 // -----------------------------------------------------------------------------
@@ -597,9 +669,6 @@
     {
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::ConstructL calling" )
 
-    
-    iRequestHandler = CSetupCallRequestHandler::NewL( iUtils->MultiModeApi(),
-            this ); 
     // Create request handler. This is same that LaunchBrowser uses, so this
     // is needed also in HandleCommand - function.
     iUtils->RegisterServiceRequestL(
@@ -610,6 +679,27 @@
     iUtils->RegisterL( this, MSatUtils::ECallControlExecuting );
     iUtils->RegisterL( this, MSatUtils::ECallControlDone );
 
+    // Create service handler for normal call setup.
+    iServiceHandler = CAiwServiceHandler::NewL();
+
+    // Create dynamic resource to attach service handler.
+    RCriteriaArray interest;
+    CAiwCriteriaItem* item = CAiwCriteriaItem::NewLC(
+        KAiwCmdCall,
+        KAiwCmdCall,
+        KContentType );
+
+    TUid serviceClassBase;
+    serviceClassBase.iUid = KAiwClassBase;
+    item->SetServiceClass( serviceClassBase );
+
+    interest.AppendL( item );
+
+    // Attach to call service.
+    iServiceHandler->AttachL( interest );
+
+    CleanupStack::PopAndDestroy( item );
+
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::ConstructL exiting" )
     }
 
@@ -617,60 +707,103 @@
 // Performs the request to dial
 // -----------------------------------------------------------------------------
 //
-void CSetUpCallHandler::DoSetupCall( CSetupCallRequestHandler& aHandler )
+void CSetUpCallHandler::DoSetupCallL()
     {
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::DoSetupCallL calling" )
-    
-    if( CheckSetupCallParam() )
-        {
+
+    RSat::TSetUpCallType callType( iSetUpCallData.iType );
 
-        RSat::TSetUpCallType callType( iSetUpCallData.iType );
-    
-        TDes& telNumber( iSetUpCallData.iAddress.iTelNumber );
-        CheckNumber( telNumber );
+    TDes& telNumber( iSetUpCallData.iAddress.iTelNumber );
+    CheckNumber( telNumber );
 
-        RMobileCall::TMobileCallParamsV7 dialParams;
-        RMobileCall::TMobileCallParamsV7Pckg package( dialParams );
-    
-        //Redail has been removed from MCL, no redail support.
-        dialParams.iAutoRedial = EFalse;
-        dialParams.iBearerMode = RMobileCall::EMulticallNewBearer;
-        dialParams.iCallParamOrigin = RMobileCall::EOriginatorSIM;
-        dialParams.iSubAddress = iSetUpCallData.iSubAddress;
-        dialParams.iBearerCap1 = iSetUpCallData.iCapabilityConfigParams;
-        
-        dialParams.iBCRepeatIndicator = RMobileCall::EBCAlternateMode;
-        
-        dialParams.iIconId.iQualifier = RMobileCall::ENoIconId;
-        
-        
-        dialParams.iAlphaId = iSetUpCallData.iAlphaIdCallSetUpPhase.iAlphaId;
-        LOG2( NORMAL, 
-            "SETUPCALL: CSetUpCallHandler::DoSetupCallL id:%S",
-            &dialParams.iAlphaId )
-        
-        LOG2( NORMAL, 
-            "SETUPCALL: CSetUpCallHandler::DoSetupCallL number:%S",
-            &iSetUpCallData.iAddress.iTelNumber )
-        
-        TBool terminateOtherCall( EFalse );
-        // check if we need to disconnect other calls
-        if ( ( RSat::EDisconnectOtherCalls == callType ) ||
-             ( RSat::EDisconnectOtherCallsWithRedial == callType ) )
-            {
-            LOG( SIMPLE, 
-            "SETUPCALL: CSetUpCallHandler::DoSetupCallL end other call" )
-            terminateOtherCall = ETrue ;
-            }
-        
-        aHandler.DialNumber( package, iSetUpCallData.iAddress.iTelNumber,
-                terminateOtherCall, iUtils->CreateAsyncToSyncHelper() );
+    // 80 is max length in SAT calls, AIW max length is 100
+    if ( telNumber.Length() > KMaximumPhoneNumberLength )
+        {
+        LOG( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::DoSetupCallL telNumber too long" )
+        User::Leave( KErrArgument );
+        }
+
+    TBuf< AIWDialDataExt::KMaximumNameLength > name;
+    if ( RSat::EAlphaIdProvided ==
+         iSetUpCallData.iAlphaIdCallSetUpPhase.iStatus )
+        {
+        LOG( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::DoSetupCallL EAlphaIdProvided" )
+        name = iSetUpCallData.iAlphaIdCallSetUpPhase.iAlphaId;
         }
     else
         {
-        CompleteSetupCallWithStatus( KErrArgument );
+        LOG( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::DoSetupCallL set AlphaId" )
+        name = iUtils->SatAppName();
+        }
+
+    // Make the phone call parameters.
+    CAiwInternalDialData* dialData = CAiwInternalDialData::NewLC();
+
+    dialData->SetCallType( CAiwDialData::EAIWVoice );
+    dialData->SetWindowGroup( AIWDialData::KAiwGoToIdle );
+    // coverity static analysis tool generates a false finding here 
+    // eliminating that 
+    // coverity[use_after_free]
+    dialData->SetPhoneNumberL( telNumber );
+    dialData->SetSATCall( ETrue );
+    dialData->SetShowNumber( EFalse );
+    // coverity static analysis tool generates a false finding here 
+    // eliminating that 
+    // coverity[use_after_free]
+    dialData->SetNameL( name );
+    dialData->SetAllowMatch( EFalse );
+    // Remove the redial mechanism from S60 5.x.
+    dialData->SetRedial( AIWDialDataExt::KAIWRedialOff );
+
+    // check if we need to disconnect other calls
+    if ( ( RSat::EDisconnectOtherCalls == callType ) ||
+         ( RSat::EDisconnectOtherCallsWithRedial == callType ) )
+        {
+        LOG( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::DoSetupCallL end other call" )
+        dialData->SetEndOtherCalls( ETrue );
         }
-    
+
+    if ( AIWInternalDialData::KAiwBearerLength >=
+         iSetUpCallData.iCapabilityConfigParams.Length() )
+        {
+        LOG( NORMAL, 
+        "SETUPCALL: CSetUpCallHandler::DoSetupCallL SetBearerL" )
+        // coverity static analysis tool generates a false finding here 
+        // eliminating that
+        // coverity[use_after_free]
+        dialData->SetBearerL( iSetUpCallData.iCapabilityConfigParams );
+        }
+
+    if ( AIWInternalDialData::KAiwSubAddressLength >=
+         iSetUpCallData.iSubAddress.Length() )
+        {
+        LOG( NORMAL, 
+        "SETUPCALL: CSetUpCallHandler::DoSetupCallL SetSubAddressL" )
+        // coverity static analysis tool generates a false finding here 
+        // eliminating that 
+        // coverity[use_after_free]
+        dialData->SetSubAddressL( iSetUpCallData.iSubAddress );
+        }
+
+    CAiwGenericParamList& paramList = iServiceHandler->InParamListL();
+    // coverity static analysis tool generates a false finding here 
+    // eliminating that
+    // coverity[use_after_free]
+    dialData->FillInParamListL( paramList );
+
+    iServiceHandler->ExecuteServiceCmdL(
+        KAiwCmdCall,
+        paramList,
+        iServiceHandler->OutParamListL(),
+        0,
+        this );
+
+    CleanupStack::PopAndDestroy( dialData );
+
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::DoSetupCallL exiting" )
     }
 
@@ -734,7 +867,6 @@
                 }
 
             case KErrGeneral:
-            case KErrArgument:
                 {
                 LOG( SIMPLE, 
                 "SETUPCALL: CSetUpCallHandler::CompleteSetupCallWithStatus Data \
@@ -813,8 +945,6 @@
         else if ( ( RSat::ESelfExplanatory == qualifier2 ) ||
                   ( RSat::ENotSelfExplanatory == qualifier2 ) )
             {
-            // Until 2009-10 the phone and NTSY not support the icon.
-            // to be updated after the updating of the phone and NTSY
             result = RSat::KSuccessRequestedIconNotDisplayed;
             LOG( SIMPLE, 
             "SETUPCALL: CSetUpCallHandler::CompleteSetupCallWithStatus Icon \
@@ -836,6 +966,7 @@
                 result = RSat::KSuccessRequestedIconNotDisplayed;
                 }
             }
+
         // Set result
         CompleteSetupCall( result );
         }
@@ -897,7 +1028,7 @@
 void CSetUpCallHandler::CheckNumber( TDes& aNumber ) const
     {
     LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CheckNumber calling" )
-    
+
     for ( TInt i = 0; i < aNumber.Length(); i++ )
         {
         // check values
@@ -936,7 +1067,6 @@
             aNumber[i] = KExpansionChar;
             }
         }
-    
     LOG2( SIMPLE, 
     "SETUPCALL: CSetUpCallHandler::CheckNumber length of aNumber: %d",
      aNumber.Length() )
@@ -944,54 +1074,297 @@
     }
 
 // -----------------------------------------------------------------------------
-// Create emergency call
+// Converts a TCCP error to the corresponding symbian error.
 // -----------------------------------------------------------------------------
 //
-void CSetUpCallHandler::CreateEmergencyCall( 
-        CSetupCallRequestHandler& aHandler )
+TInt CSetUpCallHandler::TccpErrorToSymbianError( const TInt aTccpError ) const
     {
-    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CreateEmergencyCall calling" )
-   
-    aHandler.DialEmergencyCall( iSetUpCallData.iAddress.iTelNumber );
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::TccpErrorToSymbianError \
+        calling" )
+    
+    // Error to be returned after mapped from aTccpError;
+    // Initialized with default value KErrAccessDenied.
+    TInt retValue( KErrAccessDenied );
     
-    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CreateEmergencyCall exiting" )    
+    // Convert TCCP Error to Symbian Error in the switch braces.
+    switch ( aTccpError )
+        {
+        case ECCPErrorNone:
+        case ECCPErrorNotFound:
+        case ECCPErrorGeneral:
+        case ECCPErrorCancel:
+        case ECCPErrorNoMemory:
+        case ECCPErrorNotSupported:
+        case ECCPErrorAlreadyInUse:
+        case ECCPErrorNotReady:
+            {
+            retValue = aTccpError;
+            break;
+            }
+            
+        case ECCPErrorCCCallRejected:
+            {
+            retValue = KErrGsmCCCallRejected;
+            break;
+            }
+            
+        case ECCPRequestFailure:
+            {
+            retValue = KErrGsmMMCongestion;
+            break;
+            }
+            
+        case ECCPErrorCCBearerCapabilityNotAuthorised:
+        case ECCPErrorBadRequest:
+            {
+            retValue = KErrGsmCCBearerCapabilityNotAuthorised;
+            break;
+            }
+            
+        case ECCPErrorAccessDenied:
+            {
+            retValue = KErrAccessDenied;
+            break;
+            }
+        
+         //The following are KErrGsmCallControlBase group.
+        case ECCPErrorNotReached:
+            {
+            retValue = KErrGsmCCUnassignedNumber;
+            break;
+            }
+            
+        case ECCPErrorBusy:
+            {
+            retValue = KErrGsmCCUserBusy;
+            break;
+            }
+            
+        case ECCPErrorMovedPermanently:
+            {
+            retValue = KErrGsmCCNumberChanged;
+            break;
+            }
+            
+        case ECCPErrorInvalidURI:
+            {
+            retValue = KErrGsmCCInvalidNumberFormat;
+            break;
+            }
+            
+        case ECCPErrorNetworkOutOfOrder:
+            {
+            retValue = KErrGsmCCNetworkOutOfOrder;
+            break;
+            }
+            
+        case ECCPErrorCCNoRouteToDestination:
+            {
+            retValue = KErrGsmCCNoRouteToDestination;
+            break;
+            }
+
+        case ECCPErrorCCDestinationOutOfOrder:
+            {
+            retValue = KErrGsmCCDestinationOutOfOrder;
+            break;
+            }
+            
+        case ECCPErrorCCResourceNotAvailable:
+            {
+            retValue = KErrGsmCCResourceNotAvailable;
+            break;
+            }
+            
+
+        case ECCPErrorCCInvalidTransitNetworkSelection:
+            {
+            retValue = KErrGsmCCInvalidTransitNetworkSelection;
+            break;
+            }
+            
+        case ECCPErrorCCIncompatibleDestination:
+            {
+            retValue = KErrGsmCCIncompatibleDestination;
+            break;
+            }
+            
+        case ECCPErrorCCIncompatibleMessageInCallState:
+            {
+            retValue = KErrGsmCCIncompatibleMessageInCallState;
+            break;
+            }
+
+        case ECCPErrorCCIncompatibleMessageInProtocolState:
+            {
+            retValue = KErrGsmCCIncompatibleMessageInProtocolState;
+            break;
+            }
+            
+        case ECCPErrorCCNormalCallClearing:
+            {
+            retValue = KErrGsmCCNormalCallClearing;
+            break;
+            }
+            
+        case ECCPErrorCCUserAlertingNoAnswer:
+            {
+            retValue = KErrGsmCCUserAlertingNoAnswer;
+            break;
+            }
+
+        case ECCPErrorCCUserNotResponding:
+            {
+            retValue = KErrGsmCCUserNotResponding;
+            break;
+            }
+
+        case ECCPErrorCCPreemption:
+            {
+            retValue = KErrGsmCCPreemption;
+            break;
+            }
+            
+        case ECCPErrorCCFacilityRejected:
+            {
+            retValue = KErrGsmCCFacilityRejected;
+            break;
+            }
+
+        case ECCPErrorCCResponseToStatusEnquiry:
+            {
+            retValue = KErrGsmCCResponseToStatusEnquiry;
+            break;
+            }
+            
+        case ECCPErrorCCInvalidMandatoryInformation:
+            {
+            retValue = KErrGsmCCInvalidMandatoryInformation;
+            break;
+            }
+            
+        case ECCPErrorCCNonExistentMessageType:
+            {
+            retValue = KErrGsmCCNonExistentMessageType;
+            break;
+            }
+
+        case ECCPErrorCCNonExistentInformationElement:
+            {
+            retValue = KErrGsmCCNonExistentInformationElement;
+            break;
+            }
+
+        case ECCPErrorCCNoChannelAvailable:
+            {
+            retValue = KErrGsmCCNoChannelAvailable;
+            break;
+            }
+
+        case ECCPErrorCCRequestedFacilityNotSubscribed:
+            {
+            retValue = KErrGsmCCRequestedFacilityNotSubscribed;
+            break;
+            }
+
+        case ECCPErrorCCIncomingCallsBarredInCug:
+            {
+            retValue = KErrGsmCCIncomingCallsBarredInCug;
+            break;
+            }
+            
+        case ECCPErrorUserNotInCug:
+            {
+            retValue = KErrGsmCCUserNotInCug;
+            break;
+            }
+            
+        case ECCPErrorCCRecoveryOnTimerExpiry:
+            {
+            retValue = KErrGsmCCRecoveryOnTimerExpiry;
+            break;
+            }
+
+        case ECCPErrorCCBearerCapabilityNotCurrentlyAvailable:
+            {
+            retValue = KErrGsmCCBearerCapabilityNotCurrentlyAvailable;
+            break;
+            }
+
+        case ECCPErrorCCServiceNotAvailable:
+            {
+            retValue = KErrGsmCCServiceNotAvailable;
+            break;
+            }
+
+        case ECCPErrorCCBearerServiceNotImplemented:
+            {
+            retValue = KErrGsmCCBearerServiceNotImplemented;
+            break;
+            }
+
+        case ECCPErrorCCOnlyRestrictedDigitalInformationBCAvailable:
+            {
+            retValue = KErrGsmCCOnlyRestrictedDigitalInformationBCAvailable;
+            break;
+            }
+            
+        case ECCPErrorCCServiceNotImplemented:
+            {
+            retValue = KErrGsmCCServiceNotImplemented;
+            break;
+            }
+            
+        case ECCPErrorCCUnspecifiedInterworkingError:
+            {
+            retValue = KErrGsmCCUnspecifiedInterworkingError;
+            break;
+            }
+            
+        case ECCPErrorSatControl:
+            {
+            retValue = KErrSatControl;
+            break;
+            }
+                
+        default:
+            {
+            retValue = KErrAccessDenied;
+            break;
+            }
+        }
+        
+    LOG2( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::TccpErrorToSymbianError TCCP error:%d",
+         aTccpError)
+    LOG2( SIMPLE, 
+        "SETUPCALL: CSetUpCallHandler::TccpErrorToSymbianError \
+        mapped Symbian Error:%d", retValue)
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::TccpErrorToSymbianError \
+        exiting" )
+    
+    return retValue;
     }
 
 // -----------------------------------------------------------------------------
-// check setup call param.
+// Create emergency call
 // -----------------------------------------------------------------------------
 //
-TBool CSetUpCallHandler::CheckSetupCallParam()
+void CSetUpCallHandler::CreateEmergencyCallL()
     {
-    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CheckSetupCallParam calling" )
-
-    TBool valid( ETrue );
-    if ( iSetUpCallData.iAddress.iTelNumber.Length()
-          > KSatMaximumPhoneNumberLength )
-        {
-        LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CheckSetupCallParam num" )
-        valid = EFalse;
-        }    
-    else if ( iSetUpCallData.iAlphaIdCallSetUpPhase.iAlphaId.Length()
-               > KSatMaximumNameLength )
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CreateEmergencyCallL calling" )
+    
+    if( !iEmergencyCallApi )
         {
-        LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CheckSetupCallParam name" )
-        valid = EFalse;
-        }    
-    else if ( iSetUpCallData.iSubAddress.Length() > KSatSubAddressLength )
-        {
-        LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CheckSetupCallParam sub" )
-        valid = EFalse;
-        }    
-    else if ( iSetUpCallData.iCapabilityConfigParams.Length()
-               > KSatBearerLength )
-        {
-        LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CheckSetupCallParam bear" )
-        valid = EFalse;
-        }    
-    LOG2( SIMPLE, 
-    "SETUPCALL: CSetUpCallHandler::CheckSetupCallParam exiting %d", valid )
+        // Create service handler for emergency call setup..
+        LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CreateEmergencyCallL\
+         create emergency call handler" )
+        iEmergencyCallApi = CPhCltEmergencyCall::NewL( this );
+        }
     
-    return valid;        
+    iEmergencyCallApi->DialEmergencyCallL( 
+        iSetUpCallData.iAddress.iTelNumber );
+    LOG( SIMPLE, "SETUPCALL: CSetUpCallHandler::CreateEmergencyCallL exiting" )    
     }
+
 // End Of File