FCL/sf/incubator/modemadaptation: comparison adaptationlayer/tsy/simatktsy

equal deleted inserted replaced

-:6295dc2169f3
+:8486d82aef45
 #include "satutil.h"            // sat utility class
 #include <tisi.h>               // isi message
 #include <net_modemisi.h>       // net server
 #include <gssisi.h>             // gss server
-#include <atkisi.h>             // atk server
 #include <uiccisi.h>            // uicc server
 #include <satcs.h>
 #include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
 #include "satnotificationsTraces.h"
 const TUint8 KLinkEstablishmentMask                 = 0x01;
 // Reconnection mode
 const TUint8 KReconnectionModeMask                  = 0x02;
+const TInt KECircularRepeatIndicator                = 0x01;
+const TInt KESequentalRepeatIndicator               = 0x03;
 // LOCAL FUNCTION PROTOTYPES
 // Declaration needed here for ARMV5 because method is used in Notifications
 // base, but method implementation is bit later.
 iSatMessHandler( aSatMessHandler ),
 iSatMessaging( aSatMessaging ),
 iTransId( KZero ),
 iReqHandle( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::CSatNotificationsBase" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE_TD, "CSatNotificationsBase::CSatNotificationsBase" );
 iCommandDetails.Zero();
 // Following results are accepted by all commands
 iAllowedResults = RSat::KSuccess + RSat::KPartialComprehension
 + RSat::KMissingInformation + RSat::KMeUnableToProcessCmd
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotificationsBase::~CSatNotificationsBase()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE, "CSatNotificationsBase::~CSatNotificationsBase" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFICATIONSBASE_CSATNOTIFICATIONSBASE_TD, "CSatNotificationsBase::~CSatNotificationsBase" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotificationsBase::CancelNotification
 TInt CSatNotificationsBase::CancelNotification
 (
 const TTsyReqHandle aReqHandle  // Request handle
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_CANCELNOTIFICATION, "CSatNotificationsBase::CancelNotification" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_CANCELNOTIFICATION_TD, "CSatNotificationsBase::CancelNotification" );
 TFLOGSTRING("TSY: CSatNotificationsBase::CancelNotification");
 // Check that the handle is valid
 if ( aReqHandle == iReqHandle )
 {
 TInt CSatNotificationsBase::TerminalResponse
 (
 TDes8* /* aRsp */   // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TERMINALRESPONSE, "CSatNotificationsBase::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_TERMINALRESPONSE_TD, "CSatNotificationsBase::TerminalResponse" );
 // Base class does not do anything
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TDes8& CSatNotificationsBase::GetCmdDetails()
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETCMDDETAILS, "CSatNotificationsBase::GetCmdDetails" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_GETCMDDETAILS_TD, "CSatNotificationsBase::GetCmdDetails" );
 return iCommandDetails;
 }
 // -----------------------------------------------------------------------------
 // CSatNotificationsBase::GetTransactionId
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TUint8 CSatNotificationsBase::GetTransactionId()
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_GETTRANSACTIONID, "CSatNotificationsBase::GetTransactionId" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_GETTRANSACTIONID_TD, "CSatNotificationsBase::GetTransactionId" );
 return iTransId;
 }
 // -----------------------------------------------------------------------------
 // CSatNotificationsBase::TsyReqHandle
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TTsyReqHandle CSatNotificationsBase::TsyReqHandle()
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFICATIONSBASE_TSYREQHANDLE, "CSatNotificationsBase::TsyReqHandle" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_TSYREQHANDLE_TD, "CSatNotificationsBase::TsyReqHandle" );
 return iReqHandle;
 }
 // -----------------------------------------------------------------------------
 // CSatNotificationsBase::CompleteRequest
 void CSatNotificationsBase::CompleteRequest
 (
 const TInt aError   // Possible error
 )
 {
-OstTraceExt2( TRACE_NORMAL, CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest, Handle: %d, Error: %d", (TInt)iReqHandle, aError );
+OstTraceExt2( TRACE_NORMAL,  CSATNOTIFICATIONSBASE_COMPLETEREQUEST_TD, "CSatNotificationsBase::CompleteRequest, Handle: %d, Error: %d", (TInt)iReqHandle, aError );
 TFLOGSTRING3("CSatNotificationsBase::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d",
 iReqHandle,
 aError);
 TTsyReqHandle tempReqHandle = iReqHandle;
 iReqHandle = NULL;
 iSatMessaging->ReqCompleted( tempReqHandle, aError );
 TFLOGSTRING("CSatNotificationsBase::CompleteRequest. Request is now completed");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFICATIONSBASE_COMPLETEREQUEST, "CSatNotificationsBase::CompleteRequest. Request is now completed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFICATIONSBASE_COMPLETEREQUEST_TD, "CSatNotificationsBase::CompleteRequest. Request is now completed" );
 }
 // -----------------------------------------------------------------------------
 // CSatNotificationsBase::TAllowedResults::TAllowedResults
 // C++ default constructor of the nested class.
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iDisplayTextV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::CSatNotifyDisplayText" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT_TD, "CSatNotifyDisplayText::CSatNotifyDisplayText" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
 + RSat::KNoResponseFromUser + RSat::KErrorRequiredValuesMissing;
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyDisplayText::~CSatNotifyDisplayText()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT, "CSatNotifyDisplayText::~CSatNotifyDisplayText" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYDISPLAYTEXT_CSATNOTIFYDISPLAYTEXT_TD, "CSatNotifyDisplayText::~CSatNotifyDisplayText" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyDisplayText::MessageReceived
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CSatNotifyDisplayText::MessageReceived( const TIsiReceiveC& aIsiMessage )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED_TD, "CSatNotifyDisplayText::MessageReceived" );
 TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived");
 // Completion return value
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
 // Test if pending request
 if ( !iReqHandle )
 {
 TFLOGSTRING("TSY: CSatNotifyDisplayText::MessageReceived - Request Off");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED, "CSatNotifyDisplayText::MessageReceived - Request Off" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYDISPLAYTEXT_MESSAGERECEIVED_TD, "CSatNotifyDisplayText::MessageReceived - Request Off" );
 // Request not on, returning response immediately
 iSatMessHandler->DisplayTextTerminalResp(
 iTransId,                       // Transaction id
 iCommandDetails,                // Command details tlv
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_NOTIFY, "CSatNotifyDisplayText::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYDISPLAYTEXT_NOTIFY_TD, "CSatNotifyDisplayText::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyDisplayText::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iDisplayTextV2Pckg = static_cast< RSat::TDisplayTextV2Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KDisplayText );
 TInt CSatNotifyDisplayText::TerminalResponse
 (
 TDes8* aRsp     // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYDISPLAYTEXT_TERMINALRESPONSE, "CSatNotifyDisplayText::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYDISPLAYTEXT_TERMINALRESPONSE_TD, "CSatNotifyDisplayText::TerminalResponse" );
 TFLOGSTRING("CSatNotifyDisplayText::TerminalResponse");
 // Completion return value
 TInt   ret( KErrNone );
 // Additional info
 TUint8 additionalInfo( 0 );
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iGetInkeyV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY, "CSatNotifyGetInkey::CSatNotifyGetInkey" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY_TD, "CSatNotifyGetInkey::CSatNotifyGetInkey" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
 + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyGetInkey::~CSatNotifyGetInkey()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY, "CSatNotifyGetInkey::~CSatNotifyGetInkey" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYGETINKEY_CSATNOTIFYGETINKEY_TD, "CSatNotifyGetInkey::~CSatNotifyGetInkey" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyGetInkey::MessageReceived
 void CSatNotifyGetInkey::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_MESSAGERECEIVED, "CSatNotifyGetInkey::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETINKEY_MESSAGERECEIVED_TD, "CSatNotifyGetInkey::MessageReceived" );
 TFLOGSTRING( "TSY: CSatNotifyGetInkey::MessageReceived" );
 // Completion return value
 TInt ret( KErrNone );
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYGETINKEY_NOTIFY, "CSatNotifyGetInkey::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYGETINKEY_NOTIFY_TD, "CSatNotifyGetInkey::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2( "TSY: CSatNotifyGetInkey::Notify. Handle: %d", aReqHandle );
 iReqHandle = aReqHandle;
 iGetInkeyV2Pckg = static_cast< RSat::TGetInkeyV2Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KGetInkey );
 TInt CSatNotifyGetInkey::TerminalResponse
 (
 TDes8* aRsp // Response packet from ETel
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINKEY_TERMINALRESPONSE, "CSatNotifyGetInkey::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETINKEY_TERMINALRESPONSE_TD, "CSatNotifyGetInkey::TerminalResponse" );
 TFLOGSTRING("TSY: CSatNotifyGetInkey::TerminalResponse" );
 TInt ret( KErrNone );
 RSat::TGetInkeyRspV2Pckg& aRspPckg =
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iGetInputV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT, "CSatNotifyGetInput::CSatNotifyGetInput" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT_TD, "CSatNotifyGetInput::CSatNotifyGetInput" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
 + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyGetInput::~CSatNotifyGetInput()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT, "CSatNotifyGetInput::~CSatNotifyGetInput" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYGETINPUT_CSATNOTIFYGETINPUT_TD, "CSatNotifyGetInput::~CSatNotifyGetInput" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyGetInput::MessageReceived
 void CSatNotifyGetInput::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_MESSAGERECEIVED, "CSatNotifyGetInput::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETINPUT_MESSAGERECEIVED_TD, "CSatNotifyGetInput::MessageReceived" );
 TFLOGSTRING("CSatNotifyGetInput::MessageReceived");
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 RSat::ESmsDefaultAlphabetUnpacked );// Data coding scheme
 ret = KErrCorrupt;
 }
 TFLOGSTRING2("TSY: GetInput, text: %S", &getInputV1.iText );
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYGETINPUT_MESSAGERECEIVED, "CSatNotifyGetInput::MessageReceived GetInput, text: %S", getInputV1.iText );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATNOTIFYGETINPUT_MESSAGERECEIVED_TD, "CSatNotifyGetInput::MessageReceived GetInput, text: %S", getInputV1.iText );
 // Response length expected
 CTlv responseLength;
 returnValue = berTlv.TlvByTagValue( &responseLength,
 KTlvResponseLengthTag );
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYGETINPUT_NOTIFY, "CSatNotifyGetInput::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYGETINPUT_NOTIFY_TD, "CSatNotifyGetInput::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyGetInput::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iGetInputV1Pckg = static_cast< RSat::TGetInputV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KGetInput );
 TInt CSatNotifyGetInput::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETINPUT_TERMINALRESPONSE, "CSatNotifyGetInput::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETINPUT_TERMINALRESPONSE_TD, "CSatNotifyGetInput::TerminalResponse" );
 TFLOGSTRING("CSatNotifyGetInput::TerminalResponse");
 TInt ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TGetInputRspV1Pckg* aRspPckg =
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iPlayToneV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE, "CSatNotifyPlayTone::CSatNotifyPlayTone" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE_TD, "CSatNotifyPlayTone::CSatNotifyPlayTone" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyPlayTone::~CSatNotifyPlayTone()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE, "CSatNotifyPlayTone::~CSatNotifyPlayTone" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYPLAYTONE_CSATNOTIFYPLAYTONE_TD, "CSatNotifyPlayTone::~CSatNotifyPlayTone" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyPlayTone::MessageReceived
 void CSatNotifyPlayTone::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_MESSAGERECEIVED, "CSatNotifyPlayTone::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPLAYTONE_MESSAGERECEIVED_TD, "CSatNotifyPlayTone::MessageReceived" );
 TFLOGSTRING("CSatNotifyPlayTone::MessageReceived");
 //get ber tlv
 CBerTlv berTlv;
 TInt returnValue( KErrNone );
 returnValue = berTlv.BerTlv( aIsiMessage );
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYPLAYTONE_NOTIFY, "CSatNotifyPlayTone::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYPLAYTONE_NOTIFY_TD, "CSatNotifyPlayTone::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyPlayTone::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iPlayToneV2Pckg = static_cast< RSat::TPlayToneV2Pckg* >( aDataPtr );
 TInt CSatNotifyPlayTone::TerminalResponse
 (
 TDes8* aRsp     // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPLAYTONE_TERMINALRESPONSE, "CSatNotifyPlayTone::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPLAYTONE_TERMINALRESPONSE_TD, "CSatNotifyPlayTone::TerminalResponse" );
 TFLOGSTRING("CSatNotifyPlayTone::TerminalResponse");
 TInt ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TPlayToneRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TPlayToneRspV1Pckg* >( aRsp );
 CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL, "CSatNotifyPollInterval::CSatNotifyPollInterval" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL_TD, "CSatNotifyPollInterval::CSatNotifyPollInterval" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyPollInterval::~CSatNotifyPollInterval()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL, "CSatNotifyPollInterval::~CSatNotifyPollInterval" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYPOLLINTERVAL_CSATNOTIFYPOLLINTERVAL_TD, "CSatNotifyPollInterval::~CSatNotifyPollInterval" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyPollInterval::MessageReceived
 void CSatNotifyPollInterval::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED_TD, "CSatNotifyPollInterval::MessageReceived" );
 TFLOGSTRING("CSatNotifyPollInterval::MessageReceived");
 //get ber tlv
 CBerTlv berTlv;
 TInt returnValue( KErrNone );
 berTlv.BerTlv( aIsiMessage );
 }
 default:
 {
 returnValue = KErrNotFound;
 TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived, Time unit did not match.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived, Time unit did not match." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED_TD, "CSatNotifyPollInterval::MessageReceived, Time unit did not match." );
 // Command data not understood
 iSatMessHandler->PollIntervalTerminalResp( iTransId, iCommandDetails,
 RSat::KCmdDataNotUnderstood, RSat::KNoSpecificMeProblem, 0);
 break;
 }
 else if ( KMaxPollInterval < anIntervalInSeconds )
 {
 if ( iSatMessHandler->OldPollInterval() )
 {
 TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived MaxPolInterval");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived MaxPolInterval" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED_TD, "CSatNotifyPollInterval::MessageReceived MaxPolInterval" );
 anIntervalInSeconds = KMaxPollInterval;
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyPollInterval::MessageReceived, DefaultPollInterval");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED, "CSatNotifyPollInterval::MessageReceived, DefaultPollInterval" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYPOLLINTERVAL_MESSAGERECEIVED_TD, "CSatNotifyPollInterval::MessageReceived, DefaultPollInterval" );
 // Use SIM server's default value (0)
 anIntervalInSeconds = KDefaultPollInterval;
 }
 }
 }
 (
 const TTsyReqHandle /*aReqHandle*/, // Request handle
 TDes8*              /*aDataPtr*/    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINTERVAL_NOTIFY, "CSatNotifyPollInterval::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPOLLINTERVAL_NOTIFY_TD, "CSatNotifyPollInterval::Notify" );
 // PollInterval is completely implemented by SimAtkTsy. Client
 // insn't notified about the command.
 }
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSetUpMenuV2Pckg( NULL ),
 iSatIsiMsg( NULL ),
 iItemsNextIndicatorRemoved( EFalse )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU, "CSatNotifySetUpMenu::CSatNotifySetUpMenu" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU_TD, "CSatNotifySetUpMenu::CSatNotifySetUpMenu" );
 TFLOGSTRING("CSatNotifySetUpMenu::CSatNotifySetUpMenu");
 iToolKitName.Zero();
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySetUpMenu::~CSatNotifySetUpMenu()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU, "CSatNotifySetUpMenu::~CSatNotifySetUpMenu" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPMENU_CSATNOTIFYSETUPMENU_TD, "CSatNotifySetUpMenu::~CSatNotifySetUpMenu" );
 TFLOGSTRING("CSatNotifySetUpMenu::~CSatNotifySetUpMenu");
 if ( iSatIsiMsg )
 {
 delete iSatIsiMsg;
 }
 void CSatNotifySetUpMenu::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived" );
 TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived");
 TInt ret( KErrNone );
 TInt returnValue( KErrNone );
 // get ber tlv
 CBerTlv berTlv;
 iSatIsiMsg = aIsiMessage.GetBuffer().Alloc();
 if ( iSatIsiMsg )
 {
 TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived, pcmd saved");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, pcmd saved" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived, pcmd saved" );
 }
 else
 {
 TFLOGSTRING("TSY:CSatNotifySetUpMenu::MessageReceived, \
 out of memory unable to buffer received cmd");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, out of memory unable to buffer received cmd" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived, out of memory unable to buffer received cmd" );
 iSatMessHandler->SetUpMenuTerminalResp( iTransId,
 iCommandDetails,
 RSat::KMeUnableToProcessCmd,
 NULL );
 ret = KErrCorrupt;
 }
 else
 {
 TUint16 alphaIdLength = alphaIdentifier.GetLength();
 TFLOGSTRING2("TSY: Alpha ID length:%d", alphaIdLength );
-OstTraceExt1( TRACE_NORMAL, DUP3_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived Alpha ID: %hu", alphaIdLength );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived Alpha ID: %hu", alphaIdLength );
 if ( alphaIdLength > RSat::KAlphaIdMaxSize )
 {
 // String too long
 ret = KErrCorrupt;
 }
 TSatUtility::SetAlphaId( temp , menu.iAlphaId.iAlphaId );
 // Set SAT toolikit name, send SAT SMS logging purpose
 iToolKitName.Copy( menu.iAlphaId.iAlphaId );
 TFLOGSTRING2("TSY: SetUpMenu iToolKitName:%S",
 &iToolKitName );
-OstTraceExt1( TRACE_NORMAL, DUP4_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived SetUpMenu iToolKitName: %S", iToolKitName );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived SetUpMenu iToolKitName: %S", iToolKitName );
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifySetUpMenu::MessageReceived,\
 Wrong length of alpha id.");
-OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, Wrong length of alpha id." );
+OstTrace0( TRACE_NORMAL,  DUP5_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived, Wrong length of alpha id." );
 }
 // Alpha Id status
 if ( menu.iAlphaId.iAlphaId.Length() )
 {
 menu.iAlphaId.iStatus = RSat::EAlphaIdProvided;
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifySetUpMenu::MessageReceived, \
 Wrong return value of icon identifier list.");
-OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, Wrong return value of icon identifier list." );
+OstTrace0( TRACE_NORMAL,  DUP6_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived, Wrong return value of icon identifier list." );
 }
 //Items Data
 TInt itemNbr( 0 );
 CTlv itemsData;
 // Filling up the menu items
 RSat::TItem newItem;
 // Suffle through all the menu items
 stringLength = 0;
 TFLOGSTRING2("TSY: item number:%d", i );
-OstTraceExt1( TRACE_NORMAL, DUP7_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived Item number: %hhd", i );
+OstTraceExt1( TRACE_NORMAL,  DUP7_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived Item number: %hhd", i );
 // Fill the newitem
 newItem.iItemId = itemsData.GetShortInfo( ETLV_IdentifierOfItem );
 stringLength = itemsData.GetLength();
 stringLength--;
 TPtrC8 itemData = itemsData.GetData( ETLV_TextStringOfItem );
 TSatUtility::ConvertSms7ToUnicode16( newItem.iItemString,
 itemData );
 }
 TFLOGSTRING2("TSY: SetUpMenu newItem.iItemString:%S",
 &newItem.iItemString );
-OstTraceExt1( TRACE_NORMAL, DUP8_CSATNOTIFYSETUPMENU_MESSAGERECEIVED, "CSatNotifySetUpMenu::MessageReceived, newItem.iItemString: %S", newItem.iItemString );
+OstTraceExt1( TRACE_NORMAL,  DUP8_CSATNOTIFYSETUPMENU_MESSAGERECEIVED_TD, "CSatNotifySetUpMenu::MessageReceived, newItem.iItemString: %S", newItem.iItemString );
 // Adding the new menuitem
 if( NULL != iconIdList.Size()  && ( i < iconIdList.Length() ) )
 {
 if( ( NULL != itemNextIndicator.Size() )
 && ( i < itemNextIndicator.Length() ) )
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSETUPMENU_NOTIFY, "CSatNotifySetUpMenu::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSETUPMENU_NOTIFY_TD, "CSatNotifySetUpMenu::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySetUpMenu::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 TInt ret( KErrNone );
 iReqHandle = aReqHandle;
 iSetUpMenuV2Pckg = static_cast< RSat::TSetUpMenuV2Pckg* >( aDataPtr );
 TInt CSatNotifySetUpMenu::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_TERMINALRESPONSE, "CSatNotifySetUpMenu::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPMENU_TERMINALRESPONSE_TD, "CSatNotifySetUpMenu::TerminalResponse" );
 TFLOGSTRING("CSatNotifySetUpMenu::TerminalResponse");
 TInt ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TSetUpMenuRspV1Pckg* aRspPckg =
 reinterpret_cast<RSat::TSetUpMenuRspV1Pckg*>( aRsp );
 }
 if( RSat::KSuccess == rspV1.iGeneralResult && iItemsNextIndicatorRemoved )
 {
 TFLOGSTRING("CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPMENU_TERMINALRESPONSE, "CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPMENU_TERMINALRESPONSE_TD, "CSatNotifySetUpMenu::TerminalResponseL, iItemsNextIndicatorRemoved" );
 rspV1.iGeneralResult = RSat::KPartialComprehension;
 }
 iItemsNextIndicatorRemoved = EFalse;
 // Creating the info message
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TDes16& CSatNotifySetUpMenu::SatApplicationName()
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPMENU_SATAPPLICATIONNAME, "CSatNotifySetUpMenu::SatApplicationName" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPMENU_SATAPPLICATIONNAME_TD, "CSatNotifySetUpMenu::SatApplicationName" );
 if ( 0x0 == iToolKitName.Length() )
 {
 // Default toolkit name
 iToolKitName.Copy( KSatToolkit );
 }
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSelectItemV2Pckg( NULL ),
 iItemNextIndicatorRemoved( EFalse )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM, "CSatNotifySelectItem::CSatNotifySelectItem" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM_TD, "CSatNotifySelectItem::CSatNotifySelectItem" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KBackwardModeRequestedByUser
 + RSat::KNoResponseFromUser + RSat::KHelpRequestedByUser
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySelectItem::~CSatNotifySelectItem()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM, "CSatNotifySelectItem::~CSatNotifySelectItem" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSELECTITEM_CSATNOTIFYSELECTITEM_TD, "CSatNotifySelectItem::~CSatNotifySelectItem" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySelectItem::MessageReceived
 void CSatNotifySelectItem::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSELECTITEM_MESSAGERECEIVED_TD, "CSatNotifySelectItem::MessageReceived" );
 TFLOGSTRING("CSatNotifySelectItem::MessageReceived");
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived, \
 Presentation type was not set.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Presentation type was not set" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSELECTITEM_MESSAGERECEIVED_TD, "CSatNotifySelectItem::MessageReceived, Presentation type was not set" );
 selectItemV2.iPresentationType = RSat::ENotSpecified;
 }
 // Selection preference
 if ( KSelectItemSelectUsingSoftKeyMask & cmdQualifier )
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived, \
 Return value not valid.");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Return value not valid." );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYSELECTITEM_MESSAGERECEIVED_TD, "CSatNotifySelectItem::MessageReceived, Return value not valid." );
 }
 CTlv item;
 // Get all items
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifySelectItem::MessageReceived,\
 Item with icon not valid.");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSELECTITEM_MESSAGERECEIVED, "CSatNotifySelectItem::MessageReceived, Item with icon not valid." );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYSELECTITEM_MESSAGERECEIVED_TD, "CSatNotifySelectItem::MessageReceived, Item with icon not valid." );
 }
 }
 else
 {
 if( ( NULL != itemNextIndicator.Size() )
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSELECTITEM_NOTIFY, "CSatNotifySelectItem::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSELECTITEM_NOTIFY_TD, "CSatNotifySelectItem::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySelectItem::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSelectItemV2Pckg = static_cast< RSat::TSelectItemV2Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSelectItem );
 TInt CSatNotifySelectItem::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSELECTITEM_TERMINALRESPONSE, "CSatNotifySelectItem::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSELECTITEM_TERMINALRESPONSE_TD, "CSatNotifySelectItem::TerminalResponse" );
 TFLOGSTRING("CSatNotifySelectItem::TerminalResponse");
 TInt   ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TSelectItemRspV1Pckg* aRspPckg =
 reinterpret_cast<RSat::TSelectItemRspV1Pckg*>( aRsp );
 }
 if( RSat::KSuccess == rspV1.iGeneralResult && iItemNextIndicatorRemoved )
 {
 TFLOGSTRING("CSatNotifySelectItem::TerminalResponseL, iItemNextIndicatorRemoved");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSELECTITEM_TERMINALRESPONSE, "CSatNotifySelectItem::TerminalResponse, iItemNextIndicatorRemoved" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSELECTITEM_TERMINALRESPONSE_TD, "CSatNotifySelectItem::TerminalResponse, iItemNextIndicatorRemoved" );
 rspV1.iGeneralResult = RSat::KPartialComprehension;
 }
 iItemNextIndicatorRemoved = EFalse;
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSendSmV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_CSATNOTIFYSENDSM, "CSatNotifySendSm::CSatNotifySendSm" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_CSATNOTIFYSENDSM_TD, "CSatNotifySendSm::CSatNotifySendSm" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KNetworkUnableToProcessCmd + RSat::KSmsRpError
 + RSat::KErrorRequiredValuesMissing
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySendSm::~CSatNotifySendSm()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_CSATNOTIFYSENDSM, "CSatNotifySendSm::~CSatNotifySendSm" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDSM_CSATNOTIFYSENDSM_TD, "CSatNotifySendSm::~CSatNotifySendSm" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySendSm::MessageReceived
 void CSatNotifySendSm::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_MESSAGERECEIVED, "CSatNotifySendSm::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_MESSAGERECEIVED_TD, "CSatNotifySendSm::MessageReceived" );
 TFLOGSTRING("CSatNotifySendSm::MessageReceived");
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 sendSmV1.iAddress.iTelNumber.Copy( tempScaNumber );
 TFLOGSTRING2("TSY:SendSm, SCA number: %S",
 &sendSmV1.iAddress.iTelNumber );
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_MESSAGERECEIVED, "CSatNotifySendSm::MessageReceived SCA number: %S", sendSmV1.iAddress.iTelNumber );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDSM_MESSAGERECEIVED_TD, "CSatNotifySendSm::MessageReceived SCA number: %S", sendSmV1.iAddress.iTelNumber );
 }
 else
 {
 // Address TLV found, TON/NPI present, but number epmpty.
 sendSmV1.iAddress.iTypeOfNumber = RSat::EUnknownNumber;
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDSM_NOTIFY, "CSatNotifySendSm::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSENDSM_NOTIFY_TD, "CSatNotifySendSm::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySendSm::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSendSmV1Pckg = static_cast< RSat::TSendSmV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSendShortMessage );
 TInt CSatNotifySendSm::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_TERMINALRESPONSE, "CSatNotifySendSm::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_TERMINALRESPONSE_TD, "CSatNotifySendSm::TerminalResponse" );
 TFLOGSTRING("CSatNotifySendSm::TerminalResponse");
 TInt ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TSendSmRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TSendSmRspV1Pckg* >( aRsp );
 TUint8 CSatNotifySendSm::GetTpUdlIndex
 (
 TPtrC8 aTpdu // Tpdu where to read TP-UDL or TP-CDL
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_GETTPUDLINDEX, "CSatNotifySendSm::GetTpUdlIndex" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_GETTPUDLINDEX_TD, "CSatNotifySendSm::GetTpUdlIndex" );
 TFLOGSTRING("CSatNotifySendSm::GetTpUdlIndex");
 // Position on TP-UDL/TP-CDL field in SMS TPDU
 TUint8 tpDlIndex( 0 );
 TUint8 CSatNotifySendSm::GetTpDcsIndex
 (
 TPtrC8 aTpdu // Tpdu
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_GETTPDCSINDEX, "CSatNotifySendSm::GetTpDcsIndex" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_GETTPDCSINDEX_TD, "CSatNotifySendSm::GetTpDcsIndex" );
 TFLOGSTRING("CSatNotifySendSm::GetTpDcsIndex");
 // Position of TP-DCS field in SMS TPDU
 // Add mandatory fields at first: TP-MTI, TP-MR, TP-DA(address length,
 // TON/NPI), TP-PID and TP-DCS.
 TInt CSatNotifySendSm::CheckTpdu
 (
 TPtrC8 aTpdu // TPDU
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_CHECKTPDU_TD, "CSatNotifySendSm::CheckTpdu" );
 TFLOGSTRING("CSatNotifySendSm::CheckTpdu");
 TInt ret( KErrNone );
 TUint8 tpUdlPos( 0 ); // UDL position
 TUint8 tpUdl( 0 ); // User data length
 TUint8 lengthOfTPDU( aTpdu.Length() ); // TPDU buffer length
 // At first check that TPDU length isn't under minimum
 if ( KMinSmsTpduLength > lengthOfTPDU )
 {
 TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid TPDU length");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid TPDU length" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDSM_CHECKTPDU_TD, "CSatNotifySendSm::CheckTpdu, error: invalid TPDU length" );
 ret = KErrCorrupt;
 }
 else
 {
 // Get index of UDL field
 tpUdl = aTpdu[tpUdlPos];
 }
 else
 {
 TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid UDL index");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid UDL index" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYSENDSM_CHECKTPDU_TD, "CSatNotifySendSm::CheckTpdu, error: invalid UDL index" );
 ret = KErrCorrupt;
 }
 }
 if ( KErrNone == ret )
 // Check the validity of user data length
 if ( KSmsMaxSize < tpUdl || maxSmsSize < tpUdByteCount )
 {
 // Message is over 160 bytes or invalid user data length
 TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid user data length");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYSENDSM_CHECKTPDU_TD, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" );
 ret = KErrCorrupt;
 }
 }
 else // 8-bit or 16-bit data
 {
 // Check the validity of user data length
 if ( maxSmsSize < tpUdl || tpUdByteCount < tpUdl )
 {
 // Message size is over the limit or invalid user data length
 TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: invalid user data length");
-OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" );
+OstTrace0( TRACE_NORMAL,  DUP4_CSATNOTIFYSENDSM_CHECKTPDU_TD, "CSatNotifySendSm::CheckTpdu, error: invalid user data length" );
 ret = KErrCorrupt;
 }
 }
 } // end of if ( KSATSmsMTISubmitOrSubmitReport == ( aTpdu[0] & KMask3 ) )
 else // SMS-COMMAND
 {
 if ( KSMSCommandMaxSize < tpUdl )
 {
 TFLOGSTRING("CSatNotifySendSm::CheckTpdu, error: user data length over maximum");
-OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYSENDSM_CHECKTPDU, "CSatNotifySendSm::CheckTpdu, error: user data length over maximum" );
+OstTrace0( TRACE_NORMAL,  DUP5_CSATNOTIFYSENDSM_CHECKTPDU_TD, "CSatNotifySendSm::CheckTpdu, error: user data length over maximum" );
 ret = KErrCorrupt;
 }
 }
 } // End of if ( KErrNone == ret )
 return ret;
 (
 TPtrC8 aTpdu, // Received Tpdu
 TTpdu& aSendSm // Where to store packed sms
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSM_PACKSMS, "CSatNotifySendSm::PackSms" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSM_PACKSMS_TD, "CSatNotifySendSm::PackSms" );
 TFLOGSTRING("CSatNotifySendSm::PackSms");
 TInt ret( KErrNone );
 // Checking the message type, SMS-SUBMIT can be packed:
 //
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSendDtmfV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF, "CSatNotifySendDtmf::CSatNotifySendDtmf" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF_TD, "CSatNotifySendDtmf::CSatNotifySendDtmf" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySendDtmf::~CSatNotifySendDtmf()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF, "CSatNotifySendDtmf::~CSatNotifySendDtmf" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDDTMF_CSATNOTIFYSENDDTMF_TD, "CSatNotifySendDtmf::~CSatNotifySendDtmf" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySendDtmf::MessageReceived
 void CSatNotifySendDtmf::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_MESSAGERECEIVED, "CSatNotifySendDtmf::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDDTMF_MESSAGERECEIVED_TD, "CSatNotifySendDtmf::MessageReceived" );
 TFLOGSTRING("CSatNotifySendDtmf::MessageReceived");
 // get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 // get command details tlv
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDDTMF_NOTIFY, "CSatNotifySendDtmf::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSENDDTMF_NOTIFY_TD, "CSatNotifySendDtmf::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySendDtmf::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSendDtmfV1Pckg = static_cast< RSat::TSendDtmfV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSendDtmf );
 TInt CSatNotifySendDtmf::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDTMF_TERMINALRESPONSE, "CSatNotifySendDtmf::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDDTMF_TERMINALRESPONSE_TD, "CSatNotifySendDtmf::TerminalResponse" );
 TFLOGSTRING("CSatNotifySendDtmf::TerminalResponse");
 TInt ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TSendDtmfRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TSendDtmfRspV1Pckg* >( aRsp );
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSendSsV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CSATNOTIFYSENDSS, "CSatNotifySendSs::CSatNotifySendSs" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSS_CSATNOTIFYSENDSS_TD, "CSatNotifySendSs::CSatNotifySendSs" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KModifiedByCallControl + RSat::KUssdTransactionTerminatedByUser
 + RSat::KNetworkUnableToProcessCmd
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySendSs::~CSatNotifySendSs()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSS_CSATNOTIFYSENDSS, "CSatNotifySendSs::~CSatNotifySendSs" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDSS_CSATNOTIFYSENDSS_TD, "CSatNotifySendSs::~CSatNotifySendSs" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySendSs::MessageReceived
 void CSatNotifySendSs::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_MESSAGERECEIVED, "CSatNotifySendSs::MessageReceived" );
+OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDSS_MESSAGERECEIVED_TD, "CSatNotifySendSs::MessageReceived" );
 TFLOGSTRING("CSatNotifySendSs::MessageReceived");
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 #if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
 // Notify NokiaTSY that next SS request is SAT originated
 if ( KErrNone == ret )
 {
 TFLOGSTRING("TSY: Inform NokiaTSY SS request being SAT originated, resource control needed");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDSS_MESSAGERECEIVED, "Inform NokiaTSY SS request being SAT originated, resource control needed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDSS_MESSAGERECEIVED_TD, "Inform NokiaTSY SS request being SAT originated, resource control needed" );
 TBool resourceControlSuppress( EFalse );
 CMmDataPackage dataPackage;
 dataPackage.PackData( &resourceControlSuppress );
-iSatMessaging->GetMessageRouter()->ExtFuncL(
+TRAP( ret, ret = iSatMessaging->GetMessageRouter()->ExtFuncL(
 ESatNotifySendSsPCmd,
-&dataPackage );
+&dataPackage ) );
+if ( KErrNone != ret )
+{
+TFLOGSTRING2("TSY: CSatNotifySendSs::MessageReceived: ExtFuncL for ESatNotifySendSsPCmd failed: %d", ret );
+OstTrace1( TRACE_NORMAL, DUP3_CSATNOTIFYSENDSS_MESSAGERECEIVED_TD, "CSatNotifySendSs::MessageReceived: ExtFuncL for ESatNotifySendSsPCmd failed: %d", ret );
+}
 }
 #endif
 }
 }
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDSS_NOTIFY, "CSatNotifySendSs::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSENDSS_NOTIFY_TD, "CSatNotifySendSs::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySendSs::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSendSsV1Pckg = static_cast< RSat::TSendSsV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSendSs );
 TInt CSatNotifySendSs::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_TERMINALRESPONSE, "CSatNotifySendSs::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSS_TERMINALRESPONSE_TD, "CSatNotifySendSs::TerminalResponse" );
 TFLOGSTRING("CSatNotifySendSs::TerminalResponse");
 TInt ret( KErrNone );
 // Buffer for additional information
 (
 TPtrC8 aSource,                 // original string
 RSat::TSsString& aSsString      // where to store modified string
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CHECKCALLFORWARDING, "CSatNotifySendSs::CheckCallForwarding" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSS_CHECKCALLFORWARDING_TD, "CSatNotifySendSs::CheckCallForwarding" );
 TFLOGSTRING("CSatNotifySendSs::CheckCallForwarding");
 _LIT8(KCFU,"*21*");    // Call forwarding unconditional (CFU)
 _LIT8(KCFB,"*67*");    // Call forwarding on Mobile Subscriber Busy(CFB)
 _LIT8(KCFNRy, "*61*"); // Call forwarding on No Reply (CFNRy)
 _LIT8(KCFNRc, "*62*"); // Call forwarding on Mobile Subscriber Not
 TInt CSatNotifySendSs::CheckSsStringValidity
 (
 TPtrC8 aSsString
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDSS_CHECKSSSTRINGVALIDITY, "CSatNotifySendSs::CheckSsStringValidity" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDSS_CHECKSSSTRINGVALIDITY_TD, "CSatNotifySendSs::CheckSsStringValidity" );
 TFLOGSTRING("CSatNotifySendSs::CheckSsStringValidity");
 TInt ret( KErrNone );
 if ( !aSsString.Length() )
 {
 // If length is zero
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSendUssdV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD, "CSatNotifySendUssd::CSatNotifySendUssd" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD_TD, "CSatNotifySendUssd::CSatNotifySendUssd" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KModifiedByCallControl + RSat::KUssdTransactionTerminatedByUser
 + RSat::KNetworkUnableToProcessCmd
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySendUssd::~CSatNotifySendUssd()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD, "CSatNotifySendUssd::~CSatNotifySendUssd" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDUSSD_CSATNOTIFYSENDUSSD_TD, "CSatNotifySendUssd::~CSatNotifySendUssd" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySendUssd::MessageReceived
 void CSatNotifySendUssd::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDUSSD_MESSAGERECEIVED_TD, "CSatNotifySendUssd::MessageReceived" );
 TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived");
 TInt ret( KErrNone );
 TInt returnValue( KErrNone );
 //get ber tlv
 CBerTlv berTlv;
 && RSat::KStringMaxSize<8*ussdStringLengthInBytes/7))
 {
 // The Ussd text string is too long.
 TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
 USSD String too long");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, USSD String too long" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDUSSD_MESSAGERECEIVED_TD, "CSatNotifySendUssd::MessageReceived, USSD String too long" );
 ret = KErrCorrupt;
 TUint8 noCause( 0 );
 TBuf<1>  emptyTextString;
 TUint8  paramNotSet( 0 );
 iSatMessHandler->SendUssdTerminalResp( iTransId,
 }
 default:
 {
 TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
 USSD DCS has a reserved value");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, USSD DCS has a reserved value" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYSENDUSSD_MESSAGERECEIVED_TD, "CSatNotifySendUssd::MessageReceived, USSD DCS has a reserved value" );
 // the DCS has a reserved value
 ret = KErrCorrupt;
 TUint8 noCause( 0 );
 TBuf<1>  emptyTextString;
 TUint8  paramNotSet( 0 );
 }
 else
 {
 TFLOGSTRING("TSY:CSatNotifySendUssd::MessageReceived, \
 Mandatory field missing");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYSENDUSSD_MESSAGERECEIVED, "CSatNotifySendUssd::MessageReceived, Mandatory field missing" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYSENDUSSD_MESSAGERECEIVED_TD, "CSatNotifySendUssd::MessageReceived, Mandatory field missing" );
 // Mandatory field missing
 ret = KErrCorrupt;
 TUint8 noCause( 0 );
 TBuf<1>  noTextString;
 TUint8  paramNotSet( 0 );
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDUSSD_NOTIFY, "CSatNotifySendUssd::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSENDUSSD_NOTIFY_TD, "CSatNotifySendUssd::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("TSY:CSatNotifySendUssd::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSendUssdV1Pckg = static_cast< RSat::TSendUssdV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSendUssd );
 TInt CSatNotifySendUssd::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDUSSD_TERMINALRESPONSE_TD, "CSatNotifySendUssd::TerminalResponse" );
 TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse");
 TInt ret( KErrNone );
 RSat::TSendUssdRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TSendUssdRspV1Pckg* >( aRsp );
 RSat::TSendUssdRspV1& rspV1 = ( *aRspPckg ) ();
 if ( 0 == rspV1.iAdditionalInfo.Length() )
 {
 // No info
 TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse, \
 AdditionalInfoType set, but no additional info available");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set, but no additional info available" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDUSSD_TERMINALRESPONSE_TD, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set, but no additional info available" );
 ret = KErrCorrupt;
 }
 else if ( RSat::KTextString == rspV1.iInfoType )
 {
 // Text string - additional info for a
 // performed successfully, SAT Server uses the
 // rspV1.iUssdString.iUssdString to return the USSD string
 // sent by the network.
 TFLOGSTRING("TSY:CSatNotifySendUssd::TerminalResponse, \
 AdditionalInfoType set to TextString.");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSENDUSSD_TERMINALRESPONSE, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set to TextString." );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYSENDUSSD_TERMINALRESPONSE_TD, "CSatNotifySendUssd::TerminalResponse, AdditionalInfoType set to TextString." );
 }
 else
 {
 // For the general result "USSD Return Error",
 // the ME shall provide additional information.
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSetUpCallV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL, "CSatNotifySetUpCall::CSatNotifySetUpCall" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL_TD, "CSatNotifySetUpCall::CSatNotifySetUpCall" );
 TFLOGSTRING( "TSY:CSatNotifySetUpCall::CSatNotifySetUpCall" );
 iCallConnectedEvent.Zero();
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySetUpCall::~CSatNotifySetUpCall()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL, "CSatNotifySetUpCall::~CSatNotifySetUpCall" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPCALL_CSATNOTIFYSETUPCALL_TD, "CSatNotifySetUpCall::~CSatNotifySetUpCall" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySetUpCall::MessageReceived
 void CSatNotifySetUpCall::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "CSatNotifySetUpCall::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPCALL_MESSAGERECEIVED_TD, "CSatNotifySetUpCall::MessageReceived" );
 TFLOGSTRING("CSatNotifySetUpCall::MessageReceived");
 TInt ret( KErrNone );
 TInt returnValue( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 TSatUtility::RemoveExpansionDigit( tempNumber );
 // Set actual number
 setUpCallV1.iAddress.iTelNumber.Copy( tempNumber );
 TFLOGSTRING2("TSY: SetUpCall, TelNumber: %S",
 &setUpCallV1.iAddress.iTelNumber );
-OstTraceExt1( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "CSatNotifySetUpCall::MessageReceived TelNumber: %S", setUpCallV1.iAddress.iTelNumber );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPCALL_MESSAGERECEIVED_TD, "CSatNotifySetUpCall::MessageReceived TelNumber: %S", setUpCallV1.iAddress.iTelNumber );
 }
 }
 else
 {
 // address is missing, returning response immediately
 {
 if ( subAddress.GetLength()
 || subAddress.GetComprehensionRequired() )
 {
 TFLOGSTRING("TSY: SetUpCall, SubAddress is not supported!" );
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYSETUPCALL_MESSAGERECEIVED, "SetUpCall, SubAddress is not supported!" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYSETUPCALL_MESSAGERECEIVED_TD, "SetUpCall, SubAddress is not supported!" );
 iSatMessHandler->SetUpCallTerminalResp( iTransId,
 iCommandDetails,
 RSat::KCmdBeyondMeCapabilities,
 KNoCause );
 ret = KErrCorrupt;
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_NOTIFY, "CSatNotifySetUpCall::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPCALL_NOTIFY_TD, "CSatNotifySetUpCall::Notify" );
 TFLOGSTRING("CSatNotifySetUpCall::Notify");
 iReqHandle = aReqHandle;
 iSetUpCallV1Pckg = static_cast< RSat::TSetUpCallV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSetUpCall );
 }
 TInt CSatNotifySetUpCall::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_TERMINALRESPONSE, "CSatNotifySetUpCall::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPCALL_TERMINALRESPONSE_TD, "CSatNotifySetUpCall::TerminalResponse" );
 TFLOGSTRING("CSatNotifySetUpCall::TerminalResponse");
 TInt    ret( KErrNone );
 TUint8  additionalInfo( 0 );
 RSat::TSetUpCallRspV2Pckg* aRspPckg =
 reinterpret_cast< RSat::TSetUpCallRspV2Pckg* >( aRsp );
 void CSatNotifySetUpCall::StoreCallConnectedEvent
 (
 const TDesC8& aEnvelope // envelope received from CSatEventDownload
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPCALL_STORECALLCONNECTEDEVENT, "CSatNotifySetUpCall::StoreCallConnectedEvent" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPCALL_STORECALLCONNECTEDEVENT_TD, "CSatNotifySetUpCall::StoreCallConnectedEvent" );
 // store it to the buffer
 iCallConnectedEvent = aEnvelope;
 }
 iRefreshV2Pckg( NULL ),
 iRefreshRequiredV2Pckg( NULL ),
 iReqHandleRefreshRequired( NULL ),
 iInternalCache( KZero )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CSATNOTIFYREFRESH, "CSatNotifyRefresh::CSatNotifyRefresh" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_CSATNOTIFYREFRESH_TD, "CSatNotifyRefresh::CSatNotifyRefresh" );
 iFileList.Zero();
 iAid.Zero();
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyRefresh::~CSatNotifyRefresh()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_CSATNOTIFYREFRESH, "CSatNotifyRefresh::~CSatNotifyRefresh" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYREFRESH_CSATNOTIFYREFRESH_TD, "CSatNotifyRefresh::~CSatNotifyRefresh" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyRefresh::MessageReceived
 void CSatNotifyRefresh::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::MessageReceived");
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 // Get command details tlv
 iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
 if ( !iReqHandle || !iReqHandleRefreshRequired )
 {
 TFLOGSTRING3("TSY: CSatNotifyRefresh::MessageReceived, iReqHandle:%d,\
 iReqHandleRefreshRequired:%d ", iReqHandle, iReqHandleRefreshRequired );
-OstTraceExt2( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived iReqHandle: %u, iReqHandleRefreshRequired: %u", iReqHandle, iReqHandleRefreshRequired );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived iReqHandle: %u, iReqHandleRefreshRequired: %u", iReqHandle, iReqHandleRefreshRequired );
 // Some of the request were not on, returning response immediately
 iSatMessHandler->RefreshTerminalResp(
 iTransId,                       // Transaction id
 iCommandDetails,                // Command details tlv
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyRefresh::MessageReceived, \
 Return value of file list TLV not valid.");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Return value of file list TLV not valid." );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Return value of file list TLV not valid." );
 }
 if ( KErrNone == ret )
 {
 // Set refresh mode
 switch ( iCommandDetails[KCommandQualifier] )
 {
 case KSimInitFullFileChangeNotification:
 {
 TFLOGSTRING("TSY: SAT, Refresh mode: Sim init and \
 full file change notification");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and full file change notification" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and full file change notification" );
 refreshV2.iType = RSat::ESimInitFullFileChangeNotification;
 iInternalCache = KCacheEFSST + KCacheEFCBMID;
 break;
 }
 case KFileChangeNotification:
 TFLOGSTRING("TSY: SAT, refresh mode: File Change \
 Notification");
 TFLOGSTRING2("TSY: Number of files: %d",
 refreshV2.iFileList.Length() );
-OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: File Change Notification" );
+OstTrace0( TRACE_NORMAL,  DUP4_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: File Change Notification" );
-OstTrace1( TRACE_NORMAL, DUP5_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() );
+OstTrace1( TRACE_NORMAL,  DUP5_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() );
 refreshV2.iType = RSat::EFileChangeNotification;
 if ( KErrNotFound !=
 refreshV2.iFileList.Locate( RSat::KImsiEf )
 && !fileListTlv.GetComprehensionRequired() )
 TFLOGSTRING("TSY: SAT, Refresh mode: Sim init and \
 file change notification");
 TFLOGSTRING2("TSY: Number of files: %d",
 refreshV2.iFileList.Length() );
-OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and file change notification" );
+OstTrace0( TRACE_NORMAL,  DUP6_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init and file change notification" );
-OstTrace1( TRACE_NORMAL, DUP7_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() );
+OstTrace1( TRACE_NORMAL,  DUP7_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Number of files: %d", refreshV2.iFileList.Length() );
 refreshV2.iType = RSat::ESimInitFileChangeNotification;
 break;
 }
 case KSimInit:
 {
 TFLOGSTRING("TSY: SAT, Refresh mode: Sim init ");
-OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init" );
+OstTrace0( TRACE_NORMAL,  DUP8_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: Sim init" );
 refreshV2.iType = RSat::ESimInit;
 iInternalCache = KCacheEFSST + KCacheEFCBMID;
 break;
 }
 case KSimReset:
 {
 refreshV2.iType = RSat::ESimReset;
 TFLOGSTRING("TSY: SAT, Refresh mode: Reset");
-OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: Reset" );
+OstTrace0( TRACE_NORMAL,  DUP9_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: Reset" );
 iInternalCache = KCacheEFSST + KCacheEFCBMID;
 break;
 }
 case KUSIMApplicationReset:
 {
 TFLOGSTRING("TSY: SAT, Refresh mode: USIM Application Reset");
-OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: USIM Application Reset" );
+OstTrace0( TRACE_NORMAL,  DUP10_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: USIM Application Reset" );
 refreshV2.iType = RSat::EUsimApplicationReset;
 iInternalCache = KCacheEFSST + KCacheEFCBMID;
 break;
 }
 case K3GSessionReset:
 {
 TFLOGSTRING("TSY: SAT, Refresh mode: 3G Session Reset");
-OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYREFRESH_MESSAGERECEIVED, "CSatNotifyRefresh::MessageReceived, Refresh mode: 3G Session Reset" );
+OstTrace0( TRACE_NORMAL,  DUP11_CSATNOTIFYREFRESH_MESSAGERECEIVED_TD, "CSatNotifyRefresh::MessageReceived, Refresh mode: 3G Session Reset" );
 refreshV2.iType = RSat::E3GSessionReset;
 break;
 }
 default:
 // This migth be an error case
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_NOTIFY, "CSatNotifyRefresh::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_NOTIFY_TD, "CSatNotifyRefresh::Notify" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::Notify");
 iReqHandle = aReqHandle;
 iRefreshV2Pckg = static_cast< RSat::TRefreshV2Pckg* >( aDataPtr );
 if ( iReqHandleRefreshRequired )
 {
 (
 const TTsyReqHandle aReqHandle,  // Request handle
 TDes8*              aDataPtr     // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_NOTIFYREFRESHREQUIRED, "CSatNotifyRefresh::NotifyRefreshRequired" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_NOTIFYREFRESHREQUIRED_TD, "CSatNotifyRefresh::NotifyRefreshRequired" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::NotifyRefreshRequired");
 iReqHandleRefreshRequired = aReqHandle;
 iRefreshRequiredV2Pckg = static_cast< RSat::TRefreshV2Pckg* >( aDataPtr );
 if ( iReqHandle )
 {
 TInt CSatNotifyRefresh::CancelRefreshRequiredNotification
 (
 const TTsyReqHandle aReqHandle  // Request handle
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CANCELREFRESHREQUIREDNOTIFICATION, "CSatNotifyRefresh::CancelRefreshRequiredNotification" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_CANCELREFRESHREQUIREDNOTIFICATION_TD, "CSatNotifyRefresh::CancelRefreshRequiredNotification" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::CancelRefreshRequiredNotification");
 // Check that the handle is valid
 if ( aReqHandle == iReqHandleRefreshRequired )
 {
 iSatMessaging->ReqCompleted( aReqHandle, KErrCancel );
 TInt CSatNotifyRefresh::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_TERMINALRESPONSE_TD, "CSatNotifyRefresh::TerminalResponse" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse");
 RSat::TRefreshRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TRefreshRspV1Pckg* >( aRsp );
 RSat::TRefreshRspV1& rspV1 = ( *aRspPckg ) ();
 TUint8 additionalInfo( 0x00 );
 // Empty TR is sent to Simson, if refresh type was Reset or IMSI was
 // changed during the SIM Init refresh. Empty TR is not sent to SIM,
 if ( KSimReset == iCommandDetails[KCommandQualifier] )
 {
 TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYREFRESH_TERMINALRESPONSE_TD, "CSatNotifyRefresh::TerminalResponse, Reset performed, send an empty TR" );
 TBuf8<1> emptyDescriptor( KNullDesC8 );
 iSatMessHandler->UiccCatReqTerminalResponse(
 emptyDescriptor, emptyDescriptor, iTransId );
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" );
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYREFRESH_TERMINALRESPONSE, "CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYREFRESH_TERMINALRESPONSE_TD, "CSatNotifyRefresh::TerminalResponse, S60 has done the Refresh" );
 // Send terminal response
 iSatMessHandler->RefreshTerminalResp(
 iTransId,                        // Transaction id
 iCommandDetails,                 // Command number
 TUint8 ( rspV1.iGeneralResult ), // Result
 TInt CSatNotifyRefresh::RefreshAllowed
 (
 TDesC8* aDataPtr
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_REFRESHALLOWED, "CSatNotifyRefresh::RefreshAllowed" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_REFRESHALLOWED_TD, "CSatNotifyRefresh::RefreshAllowed" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::RefreshAllowed ");
 RSat::TRefreshRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TRefreshRspV1Pckg* >( aDataPtr );
 RSat::TRefreshRspV1& rspV1 = ( *aRspPckg ) ();
 if ( ( RSat::KSuccess == rspV1.iGeneralResult )
 else
 {
 // Refresh not allowed by the client
 TFLOGSTRING("TSY: CSatNotifyRefresh::RefreshAllowed, refresh was not \
 allowed by the client");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_REFRESHALLOWED, "CSatNotifyRefresh::RefreshAllowed, refresh was not allowed by the client" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYREFRESH_REFRESHALLOWED_TD, "CSatNotifyRefresh::RefreshAllowed, refresh was not allowed by the client" );
 TUint8 additionalInfo( 0x00 );
 if ( RSat::KNoAdditionalInfo != rspV1.iInfoType )
 {
 additionalInfo = TUint8( rspV1.iAdditionalInfo[0] );
 }
 TUint8 CSatNotifyRefresh::Map3GppRefreshToUiccValues
 (
 const TUint8 a3GppRefresh // 3GPP refresh level
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_MAP3GPPREFRESHTOUICCVALUES, "CSatNotifyRefresh::Map3GppRefreshToUiccValues" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_MAP3GPPREFRESHTOUICCVALUES_TD, "CSatNotifyRefresh::Map3GppRefreshToUiccValues" );
 TFLOGSTRING("TSY: CSatNotifyRefresh::Map3GppRefreshToUiccValues ");
 TUint8 serviceType( a3GppRefresh );
 switch ( serviceType )
 {
 void CSatNotifyRefresh::CompleteRequest
 (
 const TInt aError
 )
 {
-OstTraceExt2( TRACE_NORMAL, CSATNOTIFYREFRESH_COMPLETEREQUEST, "CSatNotifyRefresh::CompleteRequest Handle: %d, Error: %d", (TInt)iReqHandle, aError );
+OstTraceExt2( TRACE_NORMAL,  CSATNOTIFYREFRESH_COMPLETEREQUEST_TD, "CSatNotifyRefresh::CompleteRequest Handle: %d, Error: %d", (TInt)iReqHandle, aError );
 TFLOGSTRING3("CSatNotifyRefresh::CompleteRequest. \n\t\t\t Handle:%d\n\t\t\t Error:%d",
 iReqHandle,
 aError);
 TTsyReqHandle tempReqHandle = iReqHandle;
 iReqHandle = NULL;
 iSatMessaging->ReqCompleted( tempReqHandle, aError );
 TFLOGSTRING("CSatNotifyRefresh::CompleteRequest. Request is now completed");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYREFRESH_COMPLETEREQUEST, "CSatNotifyRefresh::CompleteRequest Request is now completed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYREFRESH_COMPLETEREQUEST_TD, "CSatNotifyRefresh::CompleteRequest Request is now completed" );
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyRefresh::CachedFiles
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TUint16 CSatNotifyRefresh::CachedFiles() const
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYREFRESH_CACHEDFILES, "CSatNotifyRefresh::CachedFiles" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYREFRESH_CACHEDFILES_TD, "CSatNotifyRefresh::CachedFiles" );
 return iInternalCache;
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySimSessionEnd::CSatNotifySimSessionEnd
 CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND, "CSatNotifySimSessionEnd::CSatNotifySimSessionEnd" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND_TD, "CSatNotifySimSessionEnd::CSatNotifySimSessionEnd" );
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND, "CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSIMSESSIONEND_CSATNOTIFYSIMSESSIONEND_TD, "CSatNotifySimSessionEnd::~CSatNotifySimSessionEnd" );
 // None
 }
 // -----------------------------------------------------------------------------
 void CSatNotifySimSessionEnd::MessageReceived
 (
 const TIsiReceiveC& /*aIsiMessage*/ // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_MESSAGERECEIVED, "CSatNotifySimSessionEnd::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSIMSESSIONEND_MESSAGERECEIVED_TD, "CSatNotifySimSessionEnd::MessageReceived" );
 TFLOGSTRING("CSatNotifySimSessionEnd::MessageReceived");
 if ( iReqHandle ) // If request on
 {
 CompleteRequest( KErrNone );
 }
 (
 const TTsyReqHandle aReqHandle,     // Request handle
 TDes8*           /* aDataPtr */     // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSIMSESSIONEND_NOTIFY, "CSatNotifySimSessionEnd::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSIMSESSIONEND_NOTIFY_TD, "CSatNotifySimSessionEnd::Notify" );
 TFLOGSTRING("CSatNotifySimSessionEnd::Notify");
 iReqHandle = aReqHandle;
 }
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSetUpIdleModeTextV1Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT, "CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT_TD, "CSatNotifySetUpIdleModeText::CSatNotifySetUpIdleModeText" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT, "CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPIDLEMODETEXT_CSATNOTIFYSETUPIDLEMODETEXT_TD, "CSatNotifySetUpIdleModeText::~CSatNotifySetUpIdleModeText" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySetUpIdleModeText::MessageReceived
 void CSatNotifySetUpIdleModeText::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED, "CSatNotifySetUpIdleModeText::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED_TD, "CSatNotifySetUpIdleModeText::MessageReceived" );
 TFLOGSTRING("CSatNotifySetUpIdleModeText::MessageReceived");
 TInt ret( KErrNone );
 TInt returnValue( KErrNone );
 //get ber tlv
 CBerTlv berTlv;
 }
 else
 {
 TFLOGSTRING("CSatNotifySetUpIdleModeText::MessageReceived \
 No TLV text string found");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED, "CSatNotifySetUpIdleModeText::MessageReceived No TLV text string found" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPIDLEMODETEXT_MESSAGERECEIVED_TD, "CSatNotifySetUpIdleModeText::MessageReceived No TLV text string found" );
 iSatMessHandler->SetUpIdleModeTextTerminalResp(
 iTransId,
 iCommandDetails,
 RSat::KCmdDataNotUnderstood,
 KNoCause );
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_NOTIFY, "CSatNotifySetUpIdleModeText::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPIDLEMODETEXT_NOTIFY_TD, "CSatNotifySetUpIdleModeText::Notify" );
 TFLOGSTRING("CSatNotifySetUpIdleModeText::Notify");
 iReqHandle = aReqHandle;
 iSetUpIdleModeTextV1Pckg =
 static_cast< RSat::TSetUpIdleModeTextV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSetUpIdleModeText );
 TInt CSatNotifySetUpIdleModeText::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPIDLEMODETEXT_TERMINALRESPONSE, "CSatNotifySetUpIdleModeText::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPIDLEMODETEXT_TERMINALRESPONSE_TD, "CSatNotifySetUpIdleModeText::TerminalResponse" );
 TFLOGSTRING("CSatNotifySetUpIdleModeText::TerminalResponse");
 TInt   ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TSetUpIdleModeTextRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TSetUpIdleModeTextRspV1Pckg* >( aRsp );
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iCallControlPckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST, "CSatNotifyCallControlRequest::CSatNotifyCallControlRequest" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST_TD, "CSatNotifyCallControlRequest::CSatNotifyCallControlRequest" );
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST, "CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYCALLCONTROLREQUEST_CSATNOTIFYCALLCONTROLREQUEST_TD, "CSatNotifyCallControlRequest::~CSatNotifyCallControlRequest" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyCallControlRequest::MessageReceived
 void CSatNotifyCallControlRequest::MessageReceived
 (
 const TIsiReceiveC& /*aIsiMessage*/ // ISI  message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_MESSAGERECEIVED, "CSatNotifyCallControlRequest::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCALLCONTROLREQUEST_MESSAGERECEIVED_TD, "CSatNotifyCallControlRequest::MessageReceived" );
 // In S60 phones, the call control request is received via an ISI
 // message coming from the ATK Guardian / Call server. That's why the body
 // of this method is empty, see the class CSatCC. The Etel Sat API is used
 // to pass to S60 Sat Server the alpha identifier provided by the SIM,
 // if any. The SIM can provide such an alpha id to tell the user that the
 (
 TDesC& aAlphaId,
 RSat::TControlResult aResult
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION_TD, "CSatNotifyCallControlRequest::CompleteNotification" );
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotification");
 //check that someone has requested this notifications
 if ( iReqHandle )
 {
 // Temporary storage for Alpha Id
 (
 const TDesC& aAlphaId,
 const RSat::TControlResult aResult
 )
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION_TD, "CSatNotifyCallControlRequest::CompleteNotification" );
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotification");
 // Check that someone has requested this notifications
 if ( iReqHandle )
 {
 // Create the call control structure
 (
 const TUint8 aCcResult,
 TPtrC8 aEnvelopeResponse
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL" );
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL");
 #if ( NCP_COMMON_S60_VERSION_SUPPORT >= S60_VERSION_50 )
 // Check that someone has requested this notifications
 if ( iReqHandle )
 {
 }
 default:
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL\
 Not a valid call control result");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Not a valid call control result" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Not a valid call control result" );
 break;
 }
 }
 TInt ret( KErrNotFound );
 // Initialize ton and npi
 if ( KErrNone == response.TlvByTagValue( &ssString, KTlvSsStringTag ) )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 Modified to SS");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to SS" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to SS" );
 // This SS related
 RSat::TSsString tempSs;
 // Call utility function that maps received TON and NPI
 // to RSat values
 TSatUtility::GetTonAndNpi(
 tempString );
 tempSs.iSsString.Append( tempString );
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 SetSendSsDetails");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendSsDetails" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendSsDetails" );
 // Set SS string to struct
 callControl.SetSendSsDetails( tempSs );
-if ( ATK_CHANGED == aCcResult )
+if ( KChanged == aCcResult )
 {
 // Notify NokiaTSY that next SS request is SAT originated, because this is changed action made by SAT server
 TFLOGSTRING("TSY: Inform NokiaTSY SS request being Call Control originated, no further call control actions needed");
-OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "Inform NokiaTSY SS request being Call Control originated, no further call control actions needed" );
+OstTrace0( TRACE_NORMAL,  DUP4_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "Inform NokiaTSY SS request being Call Control originated, no further call control actions needed" );
 TBool resourceControlSuppress( ETrue );
 CMmDataPackage dataPackage;
 dataPackage.PackData( &resourceControlSuppress );
 else if ( KErrNone ==
 response.TlvByTagValue( &ussdTlv, KTlvUssdStringTag ) )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 Modified to USSD");
-OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to USSD" );
+OstTrace0( TRACE_NORMAL,  DUP5_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to USSD" );
 // This is USSD related
 RSat::TUssdString tempUssd;
 // Get the data coding scheme from the ISI msg
 // and set the corresponding ETel Sat data field.
 tempUssd.iDcs = ussdTlv.GetShortInfo( ETLV_DataCodingScheme );
 // Client wants USSD data as received from SIM
 tempUssd.iUssdString.Copy(
 ussdTlv.GetData( ETLV_UssdString ) );
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 SetSendUssdDetails");
-OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendUssdDetails" );
+OstTrace0( TRACE_NORMAL,  DUP6_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL SetSendUssdDetails" );
 callControl.SetSendUssdDetails( tempUssd );
 }
 else
 {
 // USSD string is too long
 }
 else
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 Modified to Call");
-OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to Call" );
+OstTrace0( TRACE_NORMAL,  DUP7_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Modified to Call" );
 // This must be call related response
 CTlv addressTlv;
 RSat::TCallSetUpParams tempCallParams;
 ret = response.TlvByTagValue( &addressTlv, KTlvAddressTag );
 if ( KErrNone == ret && addressTlv.GetLength() )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 Address found");
-OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Address found" );
+OstTrace0( TRACE_NORMAL,  DUP8_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Address found" );
 // Call utility function that maps received TON and NPI to
 // RSat values
 TSatUtility::GetTonAndNpi(
 addressTlv.GetShortInfo( ETLV_TonAndNpi ), &ton, &npi );
 if ( KErrNone == ret )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 bcc1 found");
-OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL bcc1 found" );
+OstTrace0( TRACE_NORMAL,  DUP9_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL bcc1 found" );
 // BC length is the first byte in BC data
 tempCallParams.iCcp1.Copy(
 bcc1.GetData( ETLV_CapabilityConfigurationParameters ) );
 }
 ret = response.TlvByTagValue( &subAddress, KTlvSubaddressTag );
 if ( KErrNone == ret )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 subaddress found");
-OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL subaddress found" );
+OstTrace0( TRACE_NORMAL,  DUP10_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL subaddress found" );
 tempCallParams.iSubAddress.Copy(
 subAddress.GetData( ETLV_SubAddress ) );
 }
 // Capability configuration parameters 2
 // --> BC repeat indicator is mandatory, only if BCC2 present
 if ( KErrNone == ret )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 bcc2 found");
-OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL bcc2 found" );
+OstTrace0( TRACE_NORMAL,  DUP11_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL bcc2 found" );
 CTlv bcRepeat;
 ret = response.TlvByTagValue(
 &bcRepeat,
 KTlvBcRepeatIndicatorTag );
 if ( KErrNone == ret )
 {
 // If bcc2 present, BC repeat indicator is mandatory
-if ( ATK_CIRCULAR_REPEAT_INDICATOR ==
+if ( KECircularRepeatIndicator ==
 bcRepeat.GetShortInfo( ETLV_BcRepeatIndicatorValues ) )
 {
 callControl.SetBCRepeatIndicator(
 RSat::EBCAlternateMode );
 }
-else if ( ATK_SEQUENTIAL_REPEAT_INDICATOR ==
+else if ( KESequentalRepeatIndicator ==
 bcRepeat.GetShortInfo( ETLV_BcRepeatIndicatorValues ) )
 {
 callControl.SetBCRepeatIndicator(
 RSat::EBCFallbackMode );
 }
 }
 }
 // set call parameters
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 SetCallSetUpDetails");
-OstTrace0( TRACE_NORMAL, DUP12_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetCallSetUpDetails" );
+OstTrace0( TRACE_NORMAL,  DUP12_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL SetCallSetUpDetails" );
 callControl.SetCallSetUpDetails( tempCallParams );
-if ( ATK_CHANGED == aCcResult )
+if ( KChanged == aCcResult )
 {
 // Notify NokiaTSY that next dial request is SAT originated, because this is changed action made by SAT server
 TFLOGSTRING("TSY: CSatNotifyCallControlRequest::CompleteNotificationL: Notify NTSY next dial request is SAT-originated");
-OstTrace0( TRACE_NORMAL, DUP16_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL: Notify NTSY next dial request is SAT-originated" );
+OstTrace0( TRACE_NORMAL,  DUP16_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL: Notify NTSY next dial request is SAT-originated" );
 TBool resourceControlSuppress( ETrue );
 CMmDataPackage dataPackage;
 dataPackage.PackData( &resourceControlSuppress );
 iSatMessaging->GetMessageRouter()->ExtFuncL(
 ESatNotifySetUpCallPCmd,
 // if alpha id string exist
 if ( KErrNone == ret )
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 Alpha id found");
-OstTrace0( TRACE_NORMAL, DUP13_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha id found" );
+OstTrace0( TRACE_NORMAL,  DUP13_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha id found" );
 if ( alphaIdentifier.GetLength() )
 {
 // 8-bit string to 16-bit string
 sourceString.Set(
 alphaIdentifier.GetData( ETLV_AlphaIdentifier ) );
 // Alpha id not present
 else
 {
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 Alpha ID not present");
-OstTrace0( TRACE_NORMAL, DUP14_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha ID not present" );
+OstTrace0( TRACE_NORMAL,  DUP14_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL Alpha ID not present" );
 tempAlphaId.iStatus = RSat::EAlphaIdNotPresent;
 tempValidity = RSat::ENoAlphaId;
 }
 // Set alpha id values
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 SetAlphaId");
-OstTrace0( TRACE_NORMAL, DUP15_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL, "CSatNotifyCallControlRequest::CompleteNotificationL SetAlphaId" );
+OstTrace0( TRACE_NORMAL,  DUP15_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATIONL_TD, "CSatNotifyCallControlRequest::CompleteNotificationL SetAlphaId" );
 callControl.SetAlphaId( tempValidity, tempAlphaId );
 TFLOGSTRING("CSatNotifyCallControlRequest::CompleteNotificationL \
 SetCallParamOrigin");
-OstTrace0( TRACE_NORMAL, DUP18_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyCallControlRequest::CompleteNotification SetCallParamOrigin" );
+OstTrace0( TRACE_NORMAL,  DUP18_CSATNOTIFYCALLCONTROLREQUEST_COMPLETENOTIFICATION_TD, "CSatNotifyCallControlRequest::CompleteNotification SetCallParamOrigin" );
 CompleteRequest( KErrNone );
 }
 #endif
 }
 (
 const TTsyReqHandle aReqHandle,
 TDes8* aDataPtr
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCALLCONTROLREQUEST_NOTIFY, "CSatNotifyCallControlRequest::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCALLCONTROLREQUEST_NOTIFY_TD, "CSatNotifyCallControlRequest::Notify" );
 TFLOGSTRING("CSatNotifyCallControlRequest::Notify");
 iReqHandle = aReqHandle;
 iCallControlPckg = static_cast<RSat::TCallControlV5Pckg*>( aDataPtr );
 }
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iLaunchBrowserV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER, "CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER_TD, "CSatNotifyLaunchBrowser::CSatNotifyLaunchBrowser" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser
 + RSat::KLaunchBrowserError;
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER, "CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYLAUNCHBROWSER_CSATNOTIFYLAUNCHBROWSER_TD, "CSatNotifyLaunchBrowser::~CSatNotifyLaunchBrowser" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyLaunchBrowser::MessageReceived
 void CSatNotifyLaunchBrowser::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_MESSAGERECEIVED, "CSatNotifyLaunchBrowser::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLAUNCHBROWSER_MESSAGERECEIVED_TD, "CSatNotifyLaunchBrowser::MessageReceived" );
 TFLOGSTRING("CSatNotifyLaunchBrowser::MessageReceived");
 //get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 //get command details tlv
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_NOTIFY, "CSatNotifyLaunchBrowser::Notify Handle :%u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYLAUNCHBROWSER_NOTIFY_TD, "CSatNotifyLaunchBrowser::Notify Handle :%u", aReqHandle );
 TFLOGSTRING2("CSatNotifyLaunchBrowser::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iLaunchBrowserV2Pckg = static_cast< RSat::TLaunchBrowserV2Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KLaunchBrowser );
 TInt CSatNotifyLaunchBrowser::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLAUNCHBROWSER_TERMINALRESPONSE, "CSatNotifyLaunchBrowser::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLAUNCHBROWSER_TERMINALRESPONSE_TD, "CSatNotifyLaunchBrowser::TerminalResponse" );
 TFLOGSTRING("CSatNotifyLaunchBrowser::TerminalResponse");
 TInt   ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TLaunchBrowserRspV2Pckg* aRspPckg =
 reinterpret_cast< RSat::TLaunchBrowserRspV2Pckg* >( aRsp );
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSetUpEventListV1Pckg( NULL ),
 iCmdQualifier( KZero ),
 iEvents( KZero )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST, "CSatNotifySetUpEventList::CSatNotifySetUpEventList" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST_TD, "CSatNotifySetUpEventList::CSatNotifySetUpEventList" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySetUpEventList::~CSatNotifySetUpEventList()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST, "CSatNotifySetUpEventList::~CSatNotifySetUpEventList" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPEVENTLIST_CSATNOTIFYSETUPEVENTLIST_TD, "CSatNotifySetUpEventList::~CSatNotifySetUpEventList" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySetUpEventList::MessageReceived
 void CSatNotifySetUpEventList::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED, "CSatNotifySetUpEventList::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED_TD, "CSatNotifySetUpEventList::MessageReceived" );
 TFLOGSTRING("CSatNotifySetUpEventList::MessageReceived");
 TInt ret( KErrNone );
 TUint8 generalResult( RSat::KSuccess );
 //get ber tlv
 CBerTlv berTlv;
 else
 {
 TFLOGSTRING("TSY: \
 CSatNotifySetUpEventList::MessageReceived, \
 Event not recognized or not supported.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED, "CSatNotifySetUpEventList::MessageReceived, Event not recognized or not supported." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSETUPEVENTLIST_MESSAGERECEIVED_TD, "CSatNotifySetUpEventList::MessageReceived, Event not recognized or not supported." );
 }
 }
 }
 }
 else
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_NOTIFY, "CSatNotifySetUpEventList::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSETUPEVENTLIST_NOTIFY_TD, "CSatNotifySetUpEventList::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySetUpEventList::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSetUpEventListV1Pckg = static_cast< RSat::TSetUpEventListV1Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KSetUpEventList );
 TInt CSatNotifySetUpEventList::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSETUPEVENTLIST_TERMINALRESPONSE, "CSatNotifySetUpEventList::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSETUPEVENTLIST_TERMINALRESPONSE_TD, "CSatNotifySetUpEventList::TerminalResponse" );
 TFLOGSTRING("CSatNotifySetUpEventList::TerminalResponse");
 TInt   ret( KErrNone );
 TUint8 additionalInfo( 0 );
 RSat::TSetUpEventListRspV1Pckg* aRspPckg =
 reinterpret_cast< RSat::TSetUpEventListRspV1Pckg* >( aRsp );
 CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF, "CSatNotifyPollingOff::CSatNotifyPollingOff" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF_TD, "CSatNotifyPollingOff::CSatNotifyPollingOff" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyPollingOff::~CSatNotifyPollingOff()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF, "CSatNotifyPollingOff::~CSatNotifyPollingOff" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYPOLLINGOFF_CSATNOTIFYPOLLINGOFF_TD, "CSatNotifyPollingOff::~CSatNotifyPollingOff" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyPollingOff::MessageReceived
 void CSatNotifyPollingOff::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_MESSAGERECEIVED, "CSatNotifyPollingOff::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPOLLINGOFF_MESSAGERECEIVED_TD, "CSatNotifyPollingOff::MessageReceived" );
 TFLOGSTRING("CSatNotifyPollingOff::MessageReceived");
 //get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 //get command details tlv
 (
 const TTsyReqHandle /*aReqHandle*/, // Request handle
 TDes8*              /*aDataPtr*/    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYPOLLINGOFF_NOTIFY, "CSatNotifyPollingOff::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYPOLLINGOFF_NOTIFY_TD, "CSatNotifyPollingOff::Notify" );
 // PollingOff is completely implemented by SimAtkTsy. Client
 // insn't notified about the command.
 }
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iLocalInfoV3Pckg( NULL ),
 iLocalInfoIsOngoing( EFalse ),
 iLocalInfoAccTechOngoing( EFalse )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO, "CSatNotifyLocalInfo::CSatNotifyLocalInfo" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO_TD, "CSatNotifyLocalInfo::CSatNotifyLocalInfo" );
 TFLOGSTRING("CSatNotifyLocalInfo::CSatNotifyLocalInfo");
 // Initialize response structure
 iLocalInfoRspV3 = RSat::TLocalInfoRspV3();
 // Following results are also allowed for this command:
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyLocalInfo::~CSatNotifyLocalInfo()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO, "CSatNotifyLocalInfo::~CSatNotifyLocalInfo" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYLOCALINFO_CSATNOTIFYLOCALINFO_TD, "CSatNotifyLocalInfo::~CSatNotifyLocalInfo" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyLocalInfo::MessageReceived
 void CSatNotifyLocalInfo::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived" );
 TFLOGSTRING("CSatNotifyLocalInfo::MessageReceived");
 // Clear additional info
 iLocalInfoRspV3.iAdditionalInfo.Zero();
 // Get ber tlv
 CBerTlv berTlv;
 switch ( iCommandDetails[KCommandQualifier] )
 {
 case RSat::KProvideLocalInfo:
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: LOCAL INFO");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived Request: LOCAL INFO" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::Messagereceived Request: LOCAL INFO" );
 iLocalInfoIsOngoing = ETrue;
 // Send a net cell info request to the net server.
 // Use same transaction id what comes with proactive
 // command and compare that when response is received
 break;
 }
 case RSat::KProvideLocalInfoImei:
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: IMEI");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived Request: IMEI" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::Messagereceived Request: IMEI" );
 // Check if IMEI is received
 if ( iSatMessHandler->ImeiAvailable() )
 {
 // IMEI is received from info server
 iLocalInfoRspV3.iGeneralResult = RSat::KSuccess;
 break;
 }
 case RSat::KProvideLocalInfoIMEISV:
 {
 TFLOGSTRING("TSY: CSatNotifyLocalInfo::MessageReceived Request: IMEISV");
-OstTrace0( TRACE_NORMAL, DUP14_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: IMEISV" );
+OstTrace0( TRACE_NORMAL,  DUP14_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived Request: IMEISV" );
 // Check if IMEISV is received
 if ( iSatMessHandler->ImeiSvAvailable() )
 {
 // IMEISV is received from info server
 iLocalInfoRspV3.iGeneralResult = RSat::KSuccess;
 // ME has to be connected to GERAN if UTRAN NMR's are requested
 if ( KNetworkModeUtran ==
 iSatMessHandler->CurrentAccessTechnology() )
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: UTRAN NMR");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived UTRAN NMR" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::Messagereceived UTRAN NMR" );
 switch( utranMeasurement.GetShortInfo(
 ETLV_UtranMeasurementQualifier ) )
 {
 case KIntraFrequencyMeasurements:
 {
 iLocalInfoIsOngoing = ETrue;
 TFLOGSTRING("CSatNotifyLocalInfo::INTRA_FREQ_NMR");
-OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::Messagereceived INTRA_FREQ_NMR" );
+OstTrace0( TRACE_NORMAL,  DUP4_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::Messagereceived INTRA_FREQ_NMR" );
 iSatMessHandler->NetNeighbourCellsReq(
 iSatMessaging->GetTransactionId(),
 NET_SIM_INTRA_FREQ_NMR );
 break;
 }
 case KInterFrequencyMeasurements:
 {
 iLocalInfoIsOngoing = ETrue;
 TFLOGSTRING("CSatNotifyLocalInfo::INTER_FREQ_NMR");
-OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived INTER_FREQ_NMR" );
+OstTrace0( TRACE_NORMAL,  DUP5_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived INTER_FREQ_NMR" );
 iSatMessHandler->NetNeighbourCellsReq(
 iSatMessaging->GetTransactionId(),
 NET_SIM_INTER_FREQ_NMR );
 break;
 }
 case KInterRatMeasurements:
 {
 iLocalInfoIsOngoing = ETrue;
 TFLOGSTRING("CSatNotifyLocalInfo::INTER_RAT_NMR");
-OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived INTER_RAT_NMR" );
+OstTrace0( TRACE_NORMAL,  DUP6_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived INTER_RAT_NMR" );
 iSatMessHandler->NetNeighbourCellsReq(
 iSatMessaging->GetTransactionId(),
 NET_SIM_INTER_RAT_NMR );
 break;
 }
 }
 }
 else
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: NMR");
-OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: NMR" );
+OstTrace0( TRACE_NORMAL,  DUP7_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived Request: NMR" );
 iLocalInfoIsOngoing = ETrue;
 // Request NET_SIM_NMR
 iSatMessHandler->NetNeighbourCellsReq(
 iSatMessaging->GetTransactionId(),
 NET_SIM_NMR );
 break;
 }
 case RSat::KProvideLocalInfoDateTimeTimeZone:
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: DATE/TIME/TIMEZONE");
-OstTrace0( TRACE_NORMAL, DUP8_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: DATE/TIME/TIMEZONE" );
+OstTrace0( TRACE_NORMAL,  DUP8_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived Request: DATE/TIME/TIMEZONE" );
 TTime time;
 TLocale locale;
 TDateTime dateTime;
 // Get Universal time
 time.UniversalTime();
 break;
 }
 case RSat::KProvideLocalInfoLanguage:
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: Language");
-OstTrace0( TRACE_NORMAL, DUP9_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: Language" );
+OstTrace0( TRACE_NORMAL,  DUP9_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived Request: Language" );
 if( !iReqHandle )
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: No reqHandle");
-OstTrace0( TRACE_NORMAL, DUP10_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived No reqHandle" );
+OstTrace0( TRACE_NORMAL,  DUP10_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived No reqHandle" );
 iLocalInfoRspV3.iGeneralResult = RSat::KMeUnableToProcessCmd;
 iLocalInfoRspV3.iAdditionalInfo.Append( RSat::KNoSpecificMeProblem );
 TerminalResponse();
 }
 else
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: reqHandle");
-OstTrace0( TRACE_NORMAL, DUP11_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived reqHandle" );
+OstTrace0( TRACE_NORMAL,  DUP11_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived reqHandle" );
 // Fill the send sm structure
 RSat::TLocalInfoV3& localInfoV3 = ( *iLocalInfoV3Pckg )();
 // Get command details tlv
 CTlv deviceIdentities;
 berTlv.TlvByTagValue( &deviceIdentities, KTlvDeviceIdentityTag );
 break;
 }
 case RSat::KProvideLocalInfoTimingAdv:
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: TimingAdvance");
-OstTrace0( TRACE_NORMAL, DUP12_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: TimingAdvance" );
+OstTrace0( TRACE_NORMAL,  DUP12_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived Request: TimingAdvance" );
 iLocalInfoIsOngoing = ETrue;
 //request GSS_CS_SERVICE_REQ
 iSatMessHandler->GssCsServiceReq(
 iSatMessaging->GetTransactionId(),
 GSS_ATK_TIMING_ADVANCE_GET );
 break;
 }
 case RSat::KProvideLocalInfoAccTech:
 {
 TFLOGSTRING("CSatNotifyLocalInfo:: request: Access Technology");
-OstTrace0( TRACE_NORMAL, DUP13_CSATNOTIFYLOCALINFO_MESSAGERECEIVED, "CSatNotifyLocalInfo::MessageReceived Request: Access Technology" );
+OstTrace0( TRACE_NORMAL,  DUP13_CSATNOTIFYLOCALINFO_MESSAGERECEIVED_TD, "CSatNotifyLocalInfo::MessageReceived Request: Access Technology" );
 iLocalInfoIsOngoing = ETrue;
 iLocalInfoAccTechOngoing = ETrue;
 // Use same transaction id what comes with proactive
 // command and compare that when response is received
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYLOCALINFO_NOTIFY, "CSatNotifyLocalInfo::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYLOCALINFO_NOTIFY_TD, "CSatNotifyLocalInfo::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyLocalInfo::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iLocalInfoV3Pckg = static_cast< RSat::TLocalInfoV3Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KProvideLocalInformation );
 TInt CSatNotifyLocalInfo::TerminalResponse
 (
 TDes8* aRsp     // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_TERMINALRESPONSE, "CSatNotifyLocalInfo::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLOCALINFO_TERMINALRESPONSE_TD, "CSatNotifyLocalInfo::TerminalResponse" );
 TFLOGSTRING("CSatNotifyLocalInfo::TerminalResponse");
 TInt ret( KErrNone );
 if ( aRsp )
 {
 RSat::TLocalInfoRspV3Pckg* aRspPckg =
 TBool CSatNotifyLocalInfo::LocalInfoStatus
 (
 TBool aClearStatus
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_LOCALINFOSTATUS, "CSatNotifyLocalInfo::LocalInfoStatus" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLOCALINFO_LOCALINFOSTATUS_TD, "CSatNotifyLocalInfo::LocalInfoStatus" );
 TFLOGSTRING("CSatNotifyLocalInfo::LocalInfoStatus");
 if ( aClearStatus )
 {
 iLocalInfoIsOngoing = EFalse;
 TBool CSatNotifyLocalInfo::LocalInfoAccTechStatus
 (
 TBool aClearStatus
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLOCALINFO_LOCALINFOACCTECHSTATUS, "CSatNotifyLocalInfo::LocalInfoAccTechStatus" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLOCALINFO_LOCALINFOACCTECHSTATUS_TD, "CSatNotifyLocalInfo::LocalInfoAccTechStatus" );
 TFLOGSTRING("CSatNotifyLocalInfo::LocalInfoAccTechStatus");
 if ( aClearStatus )
 {
 iLocalInfoAccTechOngoing = EFalse;
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iCmdQualifier( KZero )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT, "CSatNotifyTimerMgmt::CSatNotifyTimerMgmt" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT_TD, "CSatNotifyTimerMgmt::CSatNotifyTimerMgmt" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KContradictionWithTimerState
 + RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT, "CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYTIMERMGMT_CSATNOTIFYTIMERMGMT_TD, "CSatNotifyTimerMgmt::~CSatNotifyTimerMgmt" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyTimerMgmt::MessageReceived
 void CSatNotifyTimerMgmt::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_MESSAGERECEIVED, "CSatNotifyTimerMgmt::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYTIMERMGMT_MESSAGERECEIVED_TD, "CSatNotifyTimerMgmt::MessageReceived" );
 TFLOGSTRING("CSatNotifyTimerMgmt::MessageReceived");
 TInt ret( KErrNone );
 TInt returnValue( KErrNone );
 TUint8 generalResult ( RSat::KSuccess );
 //get ber tlv
 (
 const TTsyReqHandle /*aReqHandle*/, // Request handle
 TDes8*              /*aDataPtr*/    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_NOTIFY, "CSatNotifyTimerMgmt::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYTIMERMGMT_NOTIFY_TD, "CSatNotifyTimerMgmt::Notify" );
 // TimerManagement is completely implemented by SimAtkTsy. Client
 // insn't notified about the command.
 }
 // -----------------------------------------------------------------------------
 TUint32 CSatNotifyTimerMgmt::ConvertToSeconds
 (
 TPtrC8 time
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYTIMERMGMT_CONVERTTOSECONDS, "CSatNotifyTimerMgmt::ConvertToSeconds" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYTIMERMGMT_CONVERTTOSECONDS_TD, "CSatNotifyTimerMgmt::ConvertToSeconds" );
 TFLOGSTRING("CSatNotifyTimerMgmt::ConvertToSeconds");
 TUint32 timeValue( 0 );
 // value of a timer, expressed using
 // the format hour, minute, second
 // Semi-octec presentation used (23.040)
 CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_CSATNOTIFYMORETIME, "CSatNotifyMoreTime::CSatNotifyMoreTime" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMORETIME_CSATNOTIFYMORETIME_TD, "CSatNotifyMoreTime::CSatNotifyMoreTime" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyMoreTime::~CSatNotifyMoreTime()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYMORETIME_CSATNOTIFYMORETIME, "CSatNotifyMoreTime::~CSatNotifyMoreTime" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYMORETIME_CSATNOTIFYMORETIME_TD, "CSatNotifyMoreTime::~CSatNotifyMoreTime" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyMoreTime::MessageReceived
 void CSatNotifyMoreTime::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_MESSAGERECEIVED, "CSatNotifyMoreTime::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMORETIME_MESSAGERECEIVED_TD, "CSatNotifyMoreTime::MessageReceived" );
 TFLOGSTRING("CSatNotifyMoreTime::MessageReceived");
 //get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 //get command details tlv
 (
 const TTsyReqHandle /*aReqHandle*/, // Request handle
 TDes8*              /*aDataPtr*/    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMORETIME_NOTIFY, "CSatNotifyMoreTime::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMORETIME_NOTIFY_TD, "CSatNotifyMoreTime::Notify" );
 // MoreTime is completely implemented by SimAtkTsy. Client
 // insn't notified about the command.
 }
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iLanguageNotificationV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION, "CSatNotifyLanguageNotification::CSatNotifyLanguageNotification" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION_TD, "CSatNotifyLanguageNotification::CSatNotifyLanguageNotification" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION, "CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYLANGUAGENOTIFICATION_CSATNOTIFYLANGUAGENOTIFICATION_TD, "CSatNotifyLanguageNotification::~CSatNotifyLanguageNotification" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyLanguageNotification::MessageReceived
 void CSatNotifyLanguageNotification::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED, "CSatNotifyLanguageNotification::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED_TD, "CSatNotifyLanguageNotification::MessageReceived" );
 TFLOGSTRING("TSY: CSatNotifyLanguageNotification::MessageReceived");
 TInt ret( KErrNone );
 TInt returnValue( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 else
 {
 TFLOGSTRING("TSY: \
 CSatNotifyLanguageNotification::MessageReceived, \
 Command qualifier did not match.");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED, "CSatNotifyLanguageNotification::MessageReceived, Command qualifier did not match." );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYLANGUAGENOTIFICATION_MESSAGERECEIVED_TD, "CSatNotifyLanguageNotification::MessageReceived, Command qualifier did not match." );
 }
 CTlv language;
 returnValue = berTlv.TlvByTagValue( &language,
 KTlvLanguageTag );
 // If the Language tag is found
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_NOTIFY, "CSatNotifyLanguageNotification::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLANGUAGENOTIFICATION_NOTIFY_TD, "CSatNotifyLanguageNotification::Notify" );
 TFLOGSTRING("CSatNotifyLanguageNotification::Notify");
 iReqHandle = aReqHandle;
 iLanguageNotificationV2Pckg =
 static_cast< RSat::TLanguageNotificationV2Pckg* >( aDataPtr );
 iSatMessaging->SatReady( KLanguageNotification );
 TInt CSatNotifyLanguageNotification::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYLANGUAGENOTIFICATION_TERMINALRESPONSE, "CSatNotifyLanguageNotification::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYLANGUAGENOTIFICATION_TERMINALRESPONSE_TD, "CSatNotifyLanguageNotification::TerminalResponse" );
 TFLOGSTRING("CSatNotifyLanguageNotification::TerminalResponse");
 TUint8 additionalInfo( 0 );
 RSat::TLanguageNotificationRspV2Pckg* aRspPckg =
 reinterpret_cast< RSat::TLanguageNotificationRspV2Pckg* >( aRsp );
 RSat::TLanguageNotificationRspV2& rspV1 = ( *aRspPckg ) ();
 iOpenBaseChannelV2Pckg( NULL ),
 iOpenCsChannelV2Pckg( NULL ),
 iOpenGprsChannelV4Pckg( NULL ),
 iOpenLocalLinksChannelV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL, "CSatNotifyOpenChannel::CSatNotifyOpenChannel" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL_TD, "CSatNotifyOpenChannel::CSatNotifyOpenChannel" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPerformedWithModifications+ RSat::KPSessionTerminatedByUser
 + RSat::KNetworkUnableToProcessCmd + RSat::KPCmdNotAcceptedByUser
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyOpenChannel::~CSatNotifyOpenChannel()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL, "CSatNotifyOpenChannel::~CSatNotifyOpenChannel" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYOPENCHANNEL_CSATNOTIFYOPENCHANNEL_TD, "CSatNotifyOpenChannel::~CSatNotifyOpenChannel" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyOpenChannel::MessageReceived
 void CSatNotifyOpenChannel::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage // ISI message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived" );
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived");
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 iCommandDetails.Copy( commandDetails.Data() );
 iTransId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID );
 if ( !iReqHandle )
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Request Off");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Request Off" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - Request Off" );
 // Request not on, returning response immediately
 TBuf8<1> noBearer( 0 );
 TBuf8<1> noAdditionalInfo( 0 );
 TUint16 noBufferSize( 0 );
 iSatMessHandler->OpenChannelTerminalResp(
 switch ( openChannelV2.iBearer.iType )
 {
 case RSat::EGPRSBearer:
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - GPRS Bearer");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - GPRS Bearer" );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - GPRS Bearer" );
 // Fill in TOpenGprsChannelV4
 RSat::TOpenGprsChannelV4& openGprsChannelV4
 = ( *iOpenGprsChannelV4Pckg )();
 openGprsChannelV4
 = static_cast<RSat::TOpenGprsChannelV4&>( openChannelV2 );
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived -\
 Local Adress - not present");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Local Adress - not present" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - Local Adress - not present" );
 openGprsChannelV4.iLocalAddress.iType =
 RSat::EAddressNotPresent;
 }
 // Handling GPRS bearer specific data
 break;
 }
 case RSat::EDefaultBearer:
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Default Bearer");
-OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Default Bearer" );
+OstTrace0( TRACE_NORMAL,  DUP4_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - Default Bearer" );
 // Fill in TOpenChannelBaseV2
 openChannelV2.iPCmdType = RSat::EAnyBearer;
 break;
 }
 case RSat::ECSDBearer:
 case RSat::EIrDaBearer:
 case RSat::ERS232Bearer:
 case RSat::EUSBBearer:
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Bearer not supported");
-OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" );
+OstTrace0( TRACE_NORMAL,  DUP5_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" );
 // Bearer not supported
 TBuf8<1> noAdditionalInfo( 0 );
 iSatMessHandler->OpenChannelTerminalResp(
 iTransId,
 iCommandDetails,
 }
 default:
 {
 // Bearer not supported (RFU)
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Bearer not supported");
-OstTrace0( TRACE_NORMAL, DUP6_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" );
+OstTrace0( TRACE_NORMAL,  DUP6_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - Bearer not supported" );
 // Required values missing
 TBuf8<1> noBearer( 0 );
 TBuf8<1> noAdditionalInfo( 0 );
 TUint16 noBufferSize( 0 );
 iSatMessHandler->OpenChannelTerminalResp(
 } // End of switch according to bearer type
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::MessageReceived - Required values missing");
-OstTrace0( TRACE_NORMAL, DUP7_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED, "CSatNotifyOpenChannel::MessageReceived - Required values missing" );
+OstTrace0( TRACE_NORMAL,  DUP7_CSATNOTIFYOPENCHANNEL_MESSAGERECEIVED_TD, "CSatNotifyOpenChannel::MessageReceived - Required values missing" );
 // Required values missing
 TBuf8<1> noBearer( 0 );
 TBuf8<1> noAdditionalInfo( 0 );
 TUint16 noBufferSize( 0 );
 iSatMessHandler->OpenChannelTerminalResp(
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_NOTIFY, "CSatNotifyOpenChannel::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_NOTIFY_TD, "CSatNotifyOpenChannel::Notify" );
 TFLOGSTRING("CSatNotifyOpenChannel::Notify");
 iReqHandle = aReqHandle;
 iOpenBaseChannelV2Pckg =
 static_cast< RSat::TOpenChannelBaseV2Pckg* >( aDataPtr );
 iOpenCsChannelV2Pckg =
 TInt CSatNotifyOpenChannel::TerminalResponse
 (
 TDes8* aRsp // Response
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_TERMINALRESPONSE, "CSatNotifyOpenChannel::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_TERMINALRESPONSE_TD, "CSatNotifyOpenChannel::TerminalResponse" );
 TFLOGSTRING("CSatNotifyOpenChannel::TerminalResponse");
 TInt   ret( KErrNone );
 TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
 additionalInfo.Zero();
 RSat::TOpenChannelRspV2Pckg* aRspPckg =
 (
 CTlv& aBearerDescriptionTlv,
 RSat::TBearer& aBearer
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_GETBEARERTYPEANDPARAMS, "CSatNotifyOpenChannel::GetBearerTypeAndParams" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_GETBEARERTYPEANDPARAMS_TD, "CSatNotifyOpenChannel::GetBearerTypeAndParams" );
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::GetBearerTypeAndParams");
 TUint8 bearerType( aBearerDescriptionTlv.GetShortInfo( ETLV_BearerType ) );
 // Switch for setting bearer type values
 switch( bearerType )
 CBerTlv& aBerTlv,
 RSat::TSimMeInterface& aSimMeInterface,
 RSat::TOtherAddress& aDestinationAddress
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS_TD, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress" );
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress");
 // SIM/ME Interface transport level ( Optional )
 CTlv simMeInterfaceTlv;
 if ( KErrNone == aBerTlv.TlvByTagValue( &simMeInterfaceTlv,
 KTlvSimMeTransportLevelTag ) )
 {
 TFLOGSTRING("CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
 SIM/ME Interface");
-OstTrace0( TRACE_NORMAL, DUP5_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - SIM/ME Interface" );
+OstTrace0( TRACE_NORMAL,  DUP5_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS_TD, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - SIM/ME Interface" );
 aSimMeInterface.iPrtNumber = simMeInterfaceTlv.GetLongInfo(
 ETLV_PortNumber );
 TUint8 protocol( simMeInterfaceTlv.GetShortInfo(
 ETLV_TransportProtocolType ) );
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
 SIM/ME Interface - Not present");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -SIM/ME Interface - Not present" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS_TD, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -SIM/ME Interface - Not present" );
 aSimMeInterface.iTransportProto = RSat::EProtocolNotPresent;
 }
 // Data destination address
 // The Data Destination Address is the end point destination
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress,\
 Transport protocol did not match.");
-OstTrace0( TRACE_NORMAL, DUP2_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress, Transport protocol did not match." );
+OstTrace0( TRACE_NORMAL,  DUP2_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS_TD, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress, Transport protocol did not match." );
 }
 // Other Address - Set Destination Address
 if( dataDestAddressTlv )
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
 Destination Address");
-OstTrace0( TRACE_NORMAL, DUP3_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address" );
+OstTrace0( TRACE_NORMAL,  DUP3_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS_TD, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address" );
 TUint8 typeOfAddress( dataDestAddressTlv->GetShortInfo(
 ETLV_TypeOfAddress ) );
 switch( typeOfAddress )
 {
 case KIPV4: // IPv4
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress -\
 Destination Address - Not present");
-OstTrace0( TRACE_NORMAL, DUP4_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address - Not present" );
+OstTrace0( TRACE_NORMAL,  DUP4_CSATNOTIFYOPENCHANNEL_SIMMEINTERFACEANDDATADESTINATIONADDRESS_TD, "CSatNotifyOpenChannel::SimMeInterfaceAndDataDestinationAddress - Destination Address - Not present" );
 aDestinationAddress.iType = RSat::EAddressNotPresent;
 } // End of Other Address - Set Destination Address
 return retValueLocalAdd;
 }
 (
 CBerTlv& aBerTlv,
 RSat::TOtherAddress& aLocalAddress
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_LOCALADDRESS, "CSatNotifyOpenChannel::LocalAddress" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_LOCALADDRESS_TD, "CSatNotifyOpenChannel::LocalAddress" );
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::LocalAddress");
 // Other Address - Set Local Address ( Optional )
 CTlv localAddressTlv;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::LocalAddress - not present");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_LOCALADDRESS, "CSatNotifyOpenChannel::LocalAddress - not present" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYOPENCHANNEL_LOCALADDRESS_TD, "CSatNotifyOpenChannel::LocalAddress - not present" );
 aLocalAddress.iType = RSat::EAddressNotPresent;
 } // End of If Other local address present
 }
 }
 (
 CBerTlv& aBerTlv,
 RSat::TOpenGprsChannelV4& aOpenGprsChannelV4
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC, "CSatNotifyOpenChannel::GprsBearerSpecific" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC_TD, "CSatNotifyOpenChannel::GprsBearerSpecific" );
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::GprsBearerSpecific");
 // Network Access Point Name ( Optional )
 CTlv nanTlv;
 // If Network Access Point Name present
 if ( KErrNone == aBerTlv.TlvByTagValue( &nanTlv,
 KTlvNetworkAccessNameTag ) )
 {
 TFLOGSTRING("TSY: CSatNotifyOpenChannel::GprsBearerSpecific -\
 Access Point name");
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC, "CSatNotifyOpenChannel::GprsBearerSpecific - Access Point name" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYOPENCHANNEL_GPRSBEARERSPECIFIC_TD, "CSatNotifyOpenChannel::GprsBearerSpecific - Access Point name" );
 aOpenGprsChannelV4.iAccessName =
 nanTlv.GetData( ETLV_NetworkAccessName );
 }
 // Text string - User Login ( Optional )
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iGetChannelStatusRspV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS, "CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS_TD, "CSatNotifyGetChannelStatus::CSatNotifyGetChannelStatus" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KPSessionTerminatedByUser
 + RSat::KErrorRequiredValuesMissing;
 }
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS, "CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYGETCHANNELSTATUS_CSATNOTIFYGETCHANNELSTATUS_TD, "CSatNotifyGetChannelStatus::~CSatNotifyGetChannelStatus" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyGetChannelStatus::MessageReceived
 void CSatNotifyGetChannelStatus::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage    // Received isi-message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_MESSAGERECEIVED, "CSatNotifyGetChannelStatus::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETCHANNELSTATUS_MESSAGERECEIVED_TD, "CSatNotifyGetChannelStatus::MessageReceived" );
 TFLOGSTRING("CSatNotifyGetChannelStatus::MessageReceived");
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 // Get command details tlv
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_NOTIFY, "CSatNotifyGetChannelStatus::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYGETCHANNELSTATUS_NOTIFY_TD, "CSatNotifyGetChannelStatus::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyGetChannelStatus::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iGetChannelStatusRspV2Pckg =
 static_cast< RSat::TGetChannelStatusV2Pckg* >( aDataPtr );
 TInt CSatNotifyGetChannelStatus::TerminalResponse
 (
 TDes8* aRsp     // Response package
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYGETCHANNELSTATUS_TERMINALRESPONSE, "CSatNotifyGetChannelStatus::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYGETCHANNELSTATUS_TERMINALRESPONSE_TD, "CSatNotifyGetChannelStatus::TerminalResponse" );
 TFLOGSTRING("CSatNotifyGetChannelStatus::TerminalResponse");
 TInt   ret( KErrNone );
 TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
 additionalInfo.Zero();
 RSat::TGetChannelStatusRspV2Pckg* aRspPckg =
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iCloseChannelRspV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL, "CSatNotifyCloseChannel::CSatNotifyCloseChannel" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL_TD, "CSatNotifyCloseChannel::CSatNotifyCloseChannel" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing
 + RSat::KBearerIndepProtocolError;
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyCloseChannel::~CSatNotifyCloseChannel()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL, "CSatNotifyCloseChannel::~CSatNotifyCloseChannel" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYCLOSECHANNEL_CSATNOTIFYCLOSECHANNEL_TD, "CSatNotifyCloseChannel::~CSatNotifyCloseChannel" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyCloseChannel::MessageReceived
 void CSatNotifyCloseChannel::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage    // Received isi-message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_MESSAGERECEIVED, "CSatNotifyCloseChannel::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCLOSECHANNEL_MESSAGERECEIVED_TD, "CSatNotifyCloseChannel::MessageReceived" );
 TFLOGSTRING("CSatNotifyCloseChannel::MessageReceived");
 // Get ber tlv
 CBerTlv berTlv;
 berTlv.BerTlv( aIsiMessage );
 // Get command details tlv
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_NOTIFY, "CSatNotifyCloseChannel::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYCLOSECHANNEL_NOTIFY_TD, "CSatNotifyCloseChannel::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyCloseChannel::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iCloseChannelRspV2Pckg =
 static_cast< RSat::TCloseChannelV2Pckg* >( aDataPtr );
 TInt CSatNotifyCloseChannel::TerminalResponse
 (
 TDes8* aRsp     // Response package
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYCLOSECHANNEL_TERMINALRESPONSE, "CSatNotifyCloseChannel::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYCLOSECHANNEL_TERMINALRESPONSE_TD, "CSatNotifyCloseChannel::TerminalResponse" );
 TFLOGSTRING("CSatNotifyCloseChannel::TerminalResponse");
 TInt   ret( KErrNone );
 TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
 additionalInfo.Zero();
 RSat::TCloseChannelRspV2Pckg* aRspPckg =
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iSendDataRspV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA, "CSatNotifySendData::CSatNotifySendData" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA_TD, "CSatNotifySendData::CSatNotifySendData" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KNetworkUnableToProcessCmd
 + RSat::KErrorRequiredValuesMissing + RSat::KBearerIndepProtocolError;
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifySendData::~CSatNotifySendData()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA, "CSatNotifySendData::~CSatNotifySendData" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYSENDDATA_CSATNOTIFYSENDDATA_TD, "CSatNotifySendData::~CSatNotifySendData" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifySendData::MessageReceived
 void CSatNotifySendData::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage    // Received isi-message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_MESSAGERECEIVED, "CSatNotifySendData::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDDATA_MESSAGERECEIVED_TD, "CSatNotifySendData::MessageReceived" );
 TFLOGSTRING("CSatNotifySendData::MessageReceived");
 // return value for completion of the request
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYSENDDATA_NOTIFY, "CSatNotifySendData::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYSENDDATA_NOTIFY_TD, "CSatNotifySendData::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifySendData::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iSendDataRspV2Pckg =
 static_cast< RSat::TSendDataV2Pckg* >( aDataPtr );
 TInt CSatNotifySendData::TerminalResponse
 (
 TDes8* aRsp     // Response package
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYSENDDATA_TERMINALRESPONSE, "CSatNotifySendData::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYSENDDATA_TERMINALRESPONSE_TD, "CSatNotifySendData::TerminalResponse" );
 TFLOGSTRING("CSatNotifySendData::TerminalResponse");
 TInt   ret( KErrNone );
 TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
 additionalInfo.Zero();
 RSat::TSendDataRspV2Pckg* aRspPckg =
 )
 :
 CSatNotificationsBase( aSatMessHandler, aSatMessaging ),
 iReceiveDataRspV2Pckg( NULL )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA, "CSatNotifyReceiveData::CSatNotifyReceiveData" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA_TD, "CSatNotifyReceiveData::CSatNotifyReceiveData" );
 // Following results are also allowed for this command:
 // (in addition to result declared in base class constructor)
 iAllowedResults += RSat::KSuccessRequestedIconNotDisplayed
 + RSat::KPSessionTerminatedByUser + RSat::KErrorRequiredValuesMissing
 + RSat::KBearerIndepProtocolError;
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyReceiveData::~CSatNotifyReceiveData()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA, "CSatNotifyReceiveData::~CSatNotifyReceiveData" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYRECEIVEDATA_CSATNOTIFYRECEIVEDATA_TD, "CSatNotifyReceiveData::~CSatNotifyReceiveData" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyReceiveData::MessageReceived
 void CSatNotifyReceiveData::MessageReceived
 (
 const TIsiReceiveC& aIsiMessage    // Received isi-message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_MESSAGERECEIVED, "CSatNotifyReceiveData::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYRECEIVEDATA_MESSAGERECEIVED_TD, "CSatNotifyReceiveData::MessageReceived" );
 TFLOGSTRING("CSatNotifyReceiveData::MessageReceived");
 // return value for completion of the request
 TInt ret( KErrNone );
 // Get ber tlv
 CBerTlv berTlv;
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace1( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_NOTIFY, "CSatNotifyReceiveData::Notify Handle: %u", aReqHandle );
+OstTrace1( TRACE_NORMAL,  CSATNOTIFYRECEIVEDATA_NOTIFY_TD, "CSatNotifyReceiveData::Notify Handle: %u", aReqHandle );
 TFLOGSTRING2("CSatNotifyReceiveData::Notify. \n\t\t\t Handle:%d\n\t\t\t",
 aReqHandle );
 iReqHandle = aReqHandle;
 iReceiveDataRspV2Pckg =
 static_cast< RSat::TReceiveDataV2Pckg* >( aDataPtr );
 TInt CSatNotifyReceiveData::TerminalResponse
 (
 TDes8* aRsp     // Response package
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYRECEIVEDATA_TERMINALRESPONSE, "CSatNotifyReceiveData::TerminalResponse" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYRECEIVEDATA_TERMINALRESPONSE_TD, "CSatNotifyReceiveData::TerminalResponse" );
 TFLOGSTRING("CSatNotifyReceiveData::TerminalResponse");
 TInt   ret( KErrNone );
 TBuf8<RSat::KAdditionalInfoMaxSize> additionalInfo;
 additionalInfo.Zero();
 RSat::TReceiveDataRspV2Pckg* aRspPckg =
 (
 CSatMessHandler*    aSatMessHandler, //Pointer to the message handler
 CTsySatMessaging*   aSatMessaging    //Pointer to satmessaging class
 ) : CSatNotificationsBase( aSatMessHandler, aSatMessaging )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST, "CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST_TD, "CSatNotifyMoSmControlRequest::CSatNotifyMoSmControlRequest" );
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest
 // Destructor
 // -----------------------------------------------------------------------------
 //
 CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest()
 {
-OstTrace0( TRACE_NORMAL, DUP1_CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST, "CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest" );
+OstTrace0( TRACE_NORMAL,  DUP1_CSATNOTIFYMOSMCONTROLREQUEST_CSATNOTIFYMOSMCONTROLREQUEST_TD, "CSatNotifyMoSmControlRequest::~CSatNotifyMoSmControlRequest" );
 // None
 }
 // -----------------------------------------------------------------------------
 // CSatNotifyMoSmControlRequest::MessageReceived
 void CSatNotifyMoSmControlRequest::MessageReceived
 (
 const TIsiReceiveC& /*aIsiMessage*/    // ISI  message
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_MESSAGERECEIVED, "CSatNotifyMoSmControlRequest::MessageReceived" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMOSMCONTROLREQUEST_MESSAGERECEIVED_TD, "CSatNotifyMoSmControlRequest::MessageReceived" );
 // In S60 phones, the MoSm control request is received via an ISI
 // message coming from the SMS server. That's why the body
 // of this method is empty, see the class CSatMoSmCtrl. The Etel Sat API is used
 // to pass to S60 Sat Server the alpha identifier provided by the SIM,
 // if any. The SIM can provide such an alpha id to tell the user that the
 (
 TDesC& aAlphaId,                // Alpha Id
 RSat::TControlResult aResult    // Call Control result
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_COMPLETENOTIFICATION, "CSatNotifyMoSmControlRequest::CompleteNotification" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMOSMCONTROLREQUEST_COMPLETENOTIFICATION_TD, "CSatNotifyMoSmControlRequest::CompleteNotification" );
 TFLOGSTRING("CSatNotifyMoSmControlRequest::CompleteNotification");
 //check that a client has requested this notifications
 if ( iReqHandle )
 {
 // Fill the call control structure
 (
 const TTsyReqHandle aReqHandle, // Request handle
 TDes8*              aDataPtr    // Pointer to data
 )
 {
-OstTrace0( TRACE_NORMAL, CSATNOTIFYMOSMCONTROLREQUEST_NOTIFY, "CSatNotifyMoSmControlRequest::Notify" );
+OstTrace0( TRACE_NORMAL,  CSATNOTIFYMOSMCONTROLREQUEST_NOTIFY_TD, "CSatNotifyMoSmControlRequest::Notify" );
 TFLOGSTRING("CSatNotifyMoSmControlRequest::Notify");
 iReqHandle = aReqHandle;
 iMoSmControlV1Pckg = static_cast< RSat::TMoSmControlV1Pckg* >( aDataPtr );
 }

changeset 9	8486d82aef45
parent 8	6295dc2169f3