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

equal deleted inserted replaced

-:6295dc2169f3
+:8486d82aef45
 /*
-* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include <ctsy/serviceapi/gsmerror.h>
 #include <net_modemisi.h>
 #include <infoisi.h>
 #include <tisi.h>
 #include <gpdsisi.h>
-//#include <permisi.h> To be done in CPS
+//#include <permisi.h>
 #include <uiccisi.h>
 #include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
 #include "cmmnetmesshandlerTraces.h"
 {
 if ( ( firstTime ) &&
 ( ( i + 1 ) == length ) ) // All bytes collected and traced.
 {
 firstTime = EFalse;
-OstTraceExt1( TRACE_NORMAL, DUP6__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message: [ %s]", trace_msg );
+OstTraceExt1( TRACE_NORMAL,  DUP6__TFLOG_PRINT_ISIMESSAGE_TD, "TSY:Queued NET message: [ %s]", trace_msg );
 trace_msg.SetLength( 0 );
 }
 else if ( firstTime ) // 1st line of the trace.
 {
 firstTime = EFalse;
-OstTraceExt1( TRACE_NORMAL, DUP7__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message: [ %s", trace_msg );
+OstTraceExt1( TRACE_NORMAL,  DUP7__TFLOG_PRINT_ISIMESSAGE_TD, "TSY:Queued NET message: [ %s", trace_msg );
 trace_msg.SetLength( 0 );
 }
 else if ( ( i + 1 ) == length ) // The last line.
 {
-OstTraceExt1( TRACE_NORMAL, DUP8__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message:   %s]", trace_msg );
+OstTraceExt1( TRACE_NORMAL,  DUP8__TFLOG_PRINT_ISIMESSAGE_TD, "TSY:Queued NET message:   %s]", trace_msg );
 trace_msg.SetLength( 0 );
 }
 else // just print bytes.
 {
-OstTraceExt1( TRACE_NORMAL, DUP9__TFLOG_PRINT_ISIMESSAGE, "TSY:Queued NET message:   %s", trace_msg );
+OstTraceExt1( TRACE_NORMAL,  DUP9__TFLOG_PRINT_ISIMESSAGE_TD, "TSY:Queued NET message:   %s", trace_msg );
 trace_msg.SetLength( 0 );
 }
 counter = 0;
 }
 counter++;
 )
 {
 TInt ret( KErrNone );
 TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset");
-OstTrace0( TRACE_NORMAL, _CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset" );
+OstTrace0( TRACE_NORMAL,  _CALCULATENETWORKINFORMATIONSBSTARTOFFSET_TD, "CalculateNetworkInformationSbStartOffset" );
 TUint8 messageId = aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID );
 if ( NET_MODEM_REG_STATUS_IND == messageId )
 {
 TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_IND");
-OstTrace0( TRACE_NORMAL, DUP1__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_IND" );
+OstTrace0( TRACE_NORMAL,  DUP1__CALCULATENETWORKINFORMATIONSBSTARTOFFSET_TD, "CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_IND" );
 aSbStartOffset = SIZE_NET_MODEM_REG_STATUS_IND;
 }
 else if ( NET_MODEM_REG_STATUS_GET_RESP == messageId )
 {
 TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_GET_RESP");
-OstTrace0( TRACE_NORMAL, DUP2__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_GET_RESP" );
+OstTrace0( TRACE_NORMAL,  DUP2__CALCULATENETWORKINFORMATIONSBSTARTOFFSET_TD, "CalculateNetworkInformationSbStartOffset; NET_REG_STATUS_GET_RESP" );
 aSbStartOffset = SIZE_NET_MODEM_REG_STATUS_GET_RESP;
 }
 else if ( NET_SET_RESP == messageId )
 {
 TFLOGSTRING("TSY: CalculateNetworkInformationSbStartOffset; NET_SET_RESP");
-OstTrace0( TRACE_NORMAL, DUP3__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset; NET_SET_RESP" );
+OstTrace0( TRACE_NORMAL,  DUP3__CALCULATENETWORKINFORMATIONSBSTARTOFFSET_TD, "CalculateNetworkInformationSbStartOffset; NET_SET_RESP" );
 aSbStartOffset = SIZE_NET_SET_RESP;
 }
 else
 {
 TFLOGSTRING2("TSY: CalculateNetworkInformationSbStartOffset;unknown messageId=%x", messageId);
-OstTrace1( TRACE_NORMAL, DUP4__CALCULATENETWORKINFORMATIONSBSTARTOFFSET, "CalculateNetworkInformationSbStartOffset;unknown messageId=%x", messageId );
+OstTrace1( TRACE_NORMAL,  DUP4__CALCULATENETWORKINFORMATIONSBSTARTOFFSET_TD, "CalculateNetworkInformationSbStartOffset;unknown messageId=%x", messageId );
 ret = KErrNotSupported;
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 CMmNetMessHandler::CMmNetMessHandler()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::CMmNetMessHandler() - Start");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_CMMNETMESSHANDLER, "CMmNetMessHandler::CMmNetMessHandler" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_CMMNETMESSHANDLER_TD, "CMmNetMessHandler::CMmNetMessHandler" );
 }
 // -----------------------------------------------------------------------------
 // CMmNetMessHandler::NewL
 // Two-phased constructor.
 CMmMessageRouter* aMessageRouter, // Pointer to the message router
 CMmUiccMessHandler* aUiccMessHandler
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NewL");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NEWL, "CMmNetMessHandler::NewL" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NEWL_TD, "CMmNetMessHandler::NewL" );
 CMmNetMessHandler* netMessHandler = new ( ELeave ) CMmNetMessHandler();
 CleanupStack::PushL( netMessHandler );
 PN_PERMANENT_DATA,
 PERM_PM_RECORD_WRITE_RESP );
 aPhoNetReceiver->RegisterL(
 netMessHandler,
 PN_PERMANENT_DATA,
-PERM_PM_RECORD_READ_RESP ); To be done in CPS */
+PERM_PM_RECORD_READ_RESP );  */
 CleanupStack::Pop( netMessHandler );
 return netMessHandler;
 }
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::ConstructL()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ConstructL()");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_CONSTRUCTL, "CMmNetMessHandler::ConstructL" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_CONSTRUCTL_TD, "CMmNetMessHandler::ConstructL" );
 iNetOperatorNameHandler = CMmNetOperatorNameHandler::NewL(
 this,
 iMmUiccMessHandler );
 // -----------------------------------------------------------------------------
 //
 CMmNetMessHandler::~CMmNetMessHandler()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::~CMmNetMessHandler() - End");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_CMMNETMESSHANDLER, "CMmNetMessHandler::~CMmNetMessHandler" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_CMMNETMESSHANDLER_TD, "CMmNetMessHandler::~CMmNetMessHandler" );
 delete iNetOperatorNameHandler;
 for ( TInt i = 0; i < iNetMessageQueue.Count(); i++ )
 {
 TInt aStatus,
 TUint8 /*aDetails*/,
 const TDesC8& aFileData )
 {
 TFLOGSTRING3("TSY: CMmNetMessHandler::ProcessUiccMsg, transaction ID: %d, status: %d", aTraId, aStatus );
-OstTraceExt2( TRACE_NORMAL, CMMNETMESSHANDLER_PROCESSUICCMSG, "CMmNetMessHandler::ProcessUiccMsg;aTraId=%d;aStatus=%d", aTraId, aStatus );
+OstTraceExt2( TRACE_NORMAL,  CMMNETMESSHANDLER_PROCESSUICCMSG_TD, "CMmNetMessHandler::ProcessUiccMsg;aTraId=%d;aStatus=%d", aTraId, aStatus );
 TInt ret( KErrNone );
 switch( aTraId )
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ProcessUiccMsg - unknown transaction ID" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_PROCESSUICCMSG, "CMmNetMessHandler::ProcessUiccMsg - - unknown transaction ID" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_PROCESSUICCMSG_TD, "CMmNetMessHandler::ProcessUiccMsg - - unknown transaction ID" );
 break;
 }
 }
 return ret;
 }
 TInt aIpc, // Ipc number
 const CMmDataPackage* aDataPackage // Packed data
 )
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::ExtFuncL - Ipc: %d", aIpc);
-OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_EXTFUNCL, "CMmNetMessHandler::ExtFuncL;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  CMMNETMESSHANDLER_EXTFUNCL_TD, "CMmNetMessHandler::ExtFuncL;aIpc=%d", aIpc );
 //*************************************************************//
 // NOTE:
 //
 // LICENSEE SPECIFIC MESSAGE HANDLER IMPLEMENTATION STARTS HERE
 break;
 }
 default:
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);
-OstTrace1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_EXTFUNCL, "CMmNetMessHandler::ExtFuncL;Unknown IPC=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_EXTFUNCL_TD, "CMmNetMessHandler::ExtFuncL;Unknown IPC=%d", aIpc );
 ret = KErrNotSupported;
 break;
 }
 }
 return ret;
 (
 const TIsiReceiveC& aIsiMessage  // ISI-message received
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ReceiveMessageL");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_RECEIVEMESSAGEL, "CMmNetMessHandler::ReceiveMessageL" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmNetMessHandler::ReceiveMessageL" );
 // Resource and message id
 TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 TFLOGSTRING3("TSY: CMmNetMessHandler::ReceiveMessageL - MessageId:%d. Resource: %d", messageId, resource);
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_RECEIVEMESSAGEL, "CMmNetMessHandler::ReceiveMessageL;messageId=%d;resource=%d", messageId, resource );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmNetMessHandler::ReceiveMessageL;messageId=%d;resource=%d", messageId, resource );
 // Transaction id.
 TUint8 transactId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );
 // NET functionality is implemented in NET server and SIM Server
 }
 default:
 {
 // No appropriate handler methods for ISI-message found.
 TFLOGSTRING("TSY: CMmNetMessHandler::ReceiveMessageL - no handler for the NETWORK message id");
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_RECEIVEMESSAGEL, "CMmNetMessHandler::ReceiveMessageL - no handler for the NETWORK message id" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmNetMessHandler::ReceiveMessageL - no handler for the NETWORK message id" );
 // Server not known
 break;
 }
 } // End switch ( messageId )
 break; // End case PN_MODEM_NETWORK
 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 default:
 {
 // No appropriate handler methods for ISI-message found.
 TFLOGSTRING("TSY: CMmNetMessHandler::ReceiveMessageL - no handler for the INFO message id");
-OstTrace0( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_RECEIVEMESSAGEL, "CMmNetMessHandler::ReceiveMessageL - no handler for the INFO message id" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmNetMessHandler::ReceiveMessageL - no handler for the INFO message id" );
 break;
 }
 }
 break;
 }
 }
 default:
 {
 // No appropriate handler methods for ISI-message found.
 TFLOGSTRING("TSY: CMmNetMessHandler::ReceiveMessageL - no handler for the PERMANENT_DATA message id");
-OstTrace0( TRACE_NORMAL, DUP5_CMMNETMESSHANDLER_RECEIVEMESSAGEL, "CMmNetMessHandler::ReceiveMessageL - no handler for the PERMANENT_DATA message id" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMNETMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmNetMessHandler::ReceiveMessageL - no handler for the PERMANENT_DATA message id" );
 break;
 }
 }
 break;
-} To be done in CPS */
+}  */
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ReceiveMessageL - Switch resource case default");
-OstTrace0( TRACE_NORMAL, DUP6_CMMNETMESSHANDLER_RECEIVEMESSAGEL, "CMmNetMessHandler::ReceiveMessageL - Switch resource case default" );
+OstTrace0( TRACE_NORMAL,  DUP6_CMMNETMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmNetMessHandler::ReceiveMessageL - Switch resource case default" );
 break; // Server not known
 }
 } // End switch ( resource )
 }
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemRegStatusInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETMODEMREGSTATUSIND, "CMmNetMessHandler::NetModemRegStatusInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmNetMessHandler::NetModemRegStatusInd" );
 // Assistant for packaging.
 CMmDataPackage dataPackage;
-RMobilePhone::TMobilePhoneNetworkInfoV5 networkInfo;
+RMobilePhone::TMobilePhoneNetworkInfoV5 iNetworkInfoHelper =
+RMobilePhone::TMobilePhoneNetworkInfoV5();
 RMobilePhone::TMobilePhoneLocationAreaV1 locationArea;
 // Buffer for Operator code, length is 3.
 TBuf8<KBCDLength> operatorCode;
 TBool campedInHplmn( EFalse );
 TUint sbStartOffSet( 0 );
 // Network mode received via NET_RAT_IND/NET_RAT_RESP.
-networkInfo.iMode = iNetworkMode;
+iNetworkInfoHelper.iMode = iNetworkMode;
 // look for subblock offset to get operator info from
 TInt returnValue( FindOperatorInfoSubBlock(
 aIsiMessage,
 sbStartOffSet ) );
 sbStartOffSet +
 NET_MODEM_CURRENT_CELL_INFO_OFFSET_CURRENTCELLID );
 // Area information is known.
 locationArea.iAreaKnown = ETrue;
 // Set status to current.
-networkInfo.iStatus = RMobilePhone::ENetworkStatusCurrent;
+iNetworkInfoHelper.iStatus = RMobilePhone::ENetworkStatusCurrent;
 // Band info is cdma specific.
-networkInfo.iBandInfo = RMobilePhone::EBandUnknown;
+iNetworkInfoHelper.iBandInfo = RMobilePhone::EBandUnknown;
 // Sid is cdma specific, set it to default value.
-networkInfo.iCdmaSID.Zero();
+iNetworkInfoHelper.iCdmaSID.Zero();
 // Analog SID is cdma specific, set it to default value.
-networkInfo.iAnalogSID.Zero();
+iNetworkInfoHelper.iAnalogSID.Zero();
 // Get the operator code. Size is 3 bytes.
 operatorCode = aIsiMessage.GetData(
 sbStartOffSet + NET_MODEM_CURRENT_CELL_INFO_OFFSET_OPERATORCODE,
 3 );
 // Map the operator and country code to symbian values
 MapOperatorAndCountryCode(
 operatorCode,
-networkInfo.iNetworkId,
+iNetworkInfoHelper.iNetworkId,
-networkInfo.iCountryCode );
+iNetworkInfoHelper.iCountryCode );
 // Access technology received via NET_RAT_IND/NET_RAT_RESP.
-networkInfo.iAccess = iNetworkAccess;
+iNetworkInfoHelper.iAccess = iNetworkAccess;
 // Network type.
 networkType = aIsiMessage.Get8bit(
 sbStartOffSet +
 NET_MODEM_CURRENT_CELL_INFO_OFFSET_NETWORKTYPE );
 sbStartOffSet +
 NET_MODEM_CURRENT_CELL_INFO_OFFSET_CAMPEDINHPLMN );
 // HSDPA availability indicator.
 // If TRUE then the cell supports HSDPA.
-networkInfo.iHsdpaAvailableIndicator = aIsiMessage.Get8bit(
+iNetworkInfoHelper.iHsdpaAvailableIndicator = aIsiMessage.Get8bit(
 sbStartOffSet +
 NET_MODEM_CURRENT_CELL_INFO_OFFSET_HSDPAAVAILABLEINCELL );
-TFLOGSTRING2("TSY: CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator = %d.", networkInfo.iHsdpaAvailableIndicator);
+TFLOGSTRING2("TSY: CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator = %d.", iNetworkInfoHelper.iHsdpaAvailableIndicator);
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_NETMODEMREGSTATUSIND, "CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator=%hhu", networkInfo.iHsdpaAvailableIndicator );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator=%hhu", iNetworkInfoHelper.iHsdpaAvailableIndicator );
 // This is done for SUB 403-7200: NokiaTSY: HSUPA Cell Indicator for S60 (S60 3.2.2 / S_CPR8.1).
 // This can be removed when actual implementation for HSUPA Cell Indicator is done.
 // CASW_HSXPA_INDICATOR_SUPPORTED flag.
 #if defined ( CASW_HSXPA_INDICATOR_SUPPORTED ) || defined ( INTERNAL_TESTING_CASW_HSXPA_INDICATOR_SUPPORT )
 sbStartOffSet +
 NET_MODEM_CURRENT_CELL_INFO_OFFSET_HSUPAAVAILABLEINCELL );
 if ( hsdpaAvailableIndicator || hsupaAvailableIndicator )
 {
-networkInfo.iHsdpaAvailableIndicator = ETrue;
+iNetworkInfoHelper.iHsdpaAvailableIndicator = ETrue;
-TFLOGSTRING2("TSY: CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator (HSDPA or HSUPA available) = %d.", networkInfo.iHsdpaAvailableIndicator);
+TFLOGSTRING2("TSY: CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator (HSDPA or HSUPA available) = %d.", iNetworkInfoHelper.iHsdpaAvailableIndicator);
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_NETMODEMREGSTATUSIND, "CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator (HSDPA or HSUPA available)=%hhu", networkInfo.iHsdpaAvailableIndicator );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmNetMessHandler::NetModemRegStatusInd, HSDPA Available Indicator (HSDPA or HSUPA available)=%hhu", iNetworkInfoHelper.iHsdpaAvailableIndicator );
 }
 #endif // defined ( CASW_HSXPA_INDICATOR_SUPPORTED ) || defined ( INTERNAL_TESTING_CASW_HSXPA_INDICATOR_SUPPORT )
 }
 sbStartOffSet = 0;
 // Map the selection mode to symbian values.
 MapNWAndRegStatus(
 registrationStatus,
 regStatus,
-networkInfo.iStatus );
+iNetworkInfoHelper.iStatus );
 // Get network selection mode. Will be handled after CAUSE EXTENSION
 // handling.
 TUint8 networkSelectionMode( aIsiMessage.Get8bit(
 sbStartOffSet +
 KTsyNetCauseGsm,
 successCode );
 }
 // Pack the data for sending to the manager.
-dataPackage.PackData( &regStatus, &networkInfo.iStatus );
+dataPackage.PackData( &regStatus, &iNetworkInfoHelper.iStatus );
 // Inform the manager that the network selection mode has changed.
 iMessageRouter->Complete(
 EMobilePhoneNotifyNetworkRegistrationStatusChange,
 &dataPackage,
 retValue );
 iNetOperatorNameHandler->GetOperatorName(
 campedInHplmn,
 networkType,
 operatorCode,
 locationArea,
-networkInfo );
+iNetworkInfoHelper );
 }
 else
 {
 if ( KCustomTransId == aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) )
 {
 // Phone is not registered to any network.
 // Complete EMobilePhoneNotifyCurrentNetworkChange without
 // operator names.
 CompleteMobilePhoneNotifyCurrentNetworkChange(
 locationArea,
-networkInfo );
+iNetworkInfoHelper );
 }
 }
 else
 {
 // No NET_MODEM_REG_INFO_COMMON subblock found,
 (
 TUint8 aTransactionId // Transaction id
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemRegStatusGetReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETMODEMREGSTATUSGETREQ, "CMmNetMessHandler::NetModemRegStatusGetReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETMODEMREGSTATUSGETREQ_TD, "CMmNetMessHandler::NetModemRegStatusGetReq" );
 // Data buffer length is 2
 TBuf8<2> data;
 data.Append( aTransactionId );
 data.Append( NET_MODEM_REG_STATUS_GET_REQ );
 (
 TUint8 aTransactionId // Transaction id
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemAvailableGetReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETMODEMAVAILABLEGETREQ, "CMmNetMessHandler::NetModemAvailableGetReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETMODEMAVAILABLEGETREQ_TD, "CMmNetMessHandler::NetModemAvailableGetReq" );
 // Append data for ISI message. Has room for mode, num of subBlocks
 // and NET_MODEM_GSM_BAND_INFO sb.
 TBuf8<2 + SIZE_NET_MODEM_GSM_BAND_INFO> netModemAvailableGetReq;
 netModemAvailableGetReq.Append( NET_MANUAL_SEARCH );
 (
 const TIsiReceiveC& aIsiMessage
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemAvailableGetRespL");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL, "CMmNetMessHandler::NetModemAvailableGetRespL" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL_TD, "CMmNetMessHandler::NetModemAvailableGetRespL" );
 // Check the success of the operation.
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_MODEM_AVAILABLE_GET_RESP_OFFSET_SUCCESSCODE ) );
 // Check if we have sub blocks in the message.
 if ( 0 < nbOfSubBlocks && NET_CAUSE_OK == successCode )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemAvailableGetRespL - Success case");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL, "CMmNetMessHandler::NetModemAvailableGetRespL - Success case" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL_TD, "CMmNetMessHandler::NetModemAvailableGetRespL - Success case" );
 // Handle NET_MODEM_AVAILABLE_GET_RESP ISI-message success case.
 iNetOperatorNameHandler->HandleManualSearchSuccessCaseL( aIsiMessage );
 }
 else
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemAvailableGetRespL - Error case");
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL, "CMmNetMessHandler::NetModemAvailableGetRespL - Error case" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL_TD, "CMmNetMessHandler::NetModemAvailableGetRespL - Error case" );
 TInt epocError( KErrGeneral );
 if ( !iSearchNetworkCancelIssued &&
 NET_CAUSE_REQUEST_INTERRUPTED == successCode )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemAvailableGetRespL - Error case - MT call during network search");
-OstTrace0( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL, "CMmNetMessHandler::NetModemAvailableGetRespL - Error case - MT call during network search" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL_TD, "CMmNetMessHandler::NetModemAvailableGetRespL - Error case - MT call during network search" );
 // In case of MT call during network search, NET server can
 // interrupt network search before client has chance to cancel
 // the search request. Thus in this case we need to convert the
 // error to more suitable like KErrAbort.
 epocError = CMmStaticUtility::EpocErrorCode(
 KErrGsmNetCauseCallActive );
 }
 else
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetModemAvailableGetRespL - Error case - Cancel or Other error");
-OstTrace0( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL, "CMmNetMessHandler::NetModemAvailableGetRespL - Error case - Cancel or Other error" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_NETMODEMAVAILABLEGETRESPL_TD, "CMmNetMessHandler::NetModemAvailableGetRespL - Error case - Cancel or Other error" );
 // If some other error or cancel is called, then complete
 // with mapped error code.
 epocError = CMmStaticUtility::CSCauseToEpocError(
 PN_MODEM_NETWORK,
 KTsyNetCauseCommon,
 (
 TUint8 aTransactionId // Transaction id
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetAvailableCancelReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETAVAILABLECANCELREQ, "CMmNetMessHandler::NetAvailableCancelReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETAVAILABLECANCELREQ_TD, "CMmNetMessHandler::NetAvailableCancelReq" );
 // Set the network search flag to ETrue.
 iSearchNetworkCancelIssued = ETrue;
 // Data buffer length is 2. Has room for transaction id and message id.
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetAvailableCancelResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETAVAILABLECANCELRESP, "CMmNetMessHandler::NetAvailableCancelResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETAVAILABLECANCELRESP_TD, "CMmNetMessHandler::NetAvailableCancelResp" );
 // Get success code
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_AVAILABLE_CANCEL_RESP_OFFSET_SUCCESSCODE ) );
 {
 // NW selection mode: Manual or reselection. Initialise variable.
 TUint8 networkSelectionMode( NET_SELECT_MODE_NO_SELECTION );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetSetReq -- Manual NW selection(T/F): %d", aIsManual);
-OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_NETSETREQ, "CMmNetMessHandler::NetSetReq;aIsManual=%d", aIsManual );
+OstTrace1( TRACE_NORMAL,  CMMNETMESSHANDLER_NETSETREQ_TD, "CMmNetMessHandler::NetSetReq;aIsManual=%d", aIsManual );
 TFLOGSTRING3("TSY: CMmNetMessHandler::NetSetReq -- MNC: %S MCC: %S", &aMnc, &aMcc);
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_NETSETREQ, "CMmNetMessHandler::NetSetReq;aMnc=%S;aMcc=%S", aMnc, aMcc );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_NETSETREQ_TD, "CMmNetMessHandler::NetSetReq;aMnc=%S;aMcc=%S", aMnc, aMcc );
 // If NW selection mode is changed from manual to automatic
 if ( NET_SELECT_MODE_MANUAL == iSelectionMethod
 && !aIsManual )
 {
 {
 networkSelectionMode = NET_SELECT_MODE_MANUAL;
 }
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetSetReq -- NW Selection Mode: %d", networkSelectionMode);
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_NETSETREQ, "CMmNetMessHandler::NetSetReq;networkSelectionMode=%hhu", networkSelectionMode );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_NETSETREQ_TD, "CMmNetMessHandler::NetSetReq;networkSelectionMode=%hhu", networkSelectionMode );
 // Append data for ISI message.
 // Has room for registered in another protocol, num of subBlocks,
 // net operator info common sb and net gsm operator info sb.
 TBuf8<2 + SIZE_NET_OPERATOR_INFO_COMMON + SIZE_NET_MODEM_GSM_OPERATOR_INFO>
 }
 if ( NET_SELECT_MODE_USER_RESELECTION != networkSelectionMode )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetSetReq -- Adding NET_MODEM_GSM_OPERATOR_INFO SubBlock");
-OstTrace0( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_NETSETREQ, "CMmNetMessHandler::NetSetReq, Adding NET_MODEM_GSM_OPERATOR_INFO SubBlock" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_NETSETREQ_TD, "CMmNetMessHandler::NetSetReq, Adding NET_MODEM_GSM_OPERATOR_INFO SubBlock" );
 // We add NET_MODEM_GSM_OPERATOR_INFO subblock to ISI.
 // The information about the Band is not send trough MM ETEL Api, thus
 // the value is set to unknown
 // Size is 3 bytes for operator code
 netSetReqData.Append( netModemGsmOperatorInfoSb.CompleteSubBlock() );
 }
 TFLOGSTRING("TSY: CMmNetMessHandler::NetSetReq -- Adding NET_OPERATOR_INFO_COMMON SubBlock");
-OstTrace0( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_NETSETREQ, "CMmNetMessHandler::NetSetReq, Adding NET_OPERATOR_INFO_COMMON SubBlock" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_NETSETREQ_TD, "CMmNetMessHandler::NetSetReq, Adding NET_OPERATOR_INFO_COMMON SubBlock" );
 // Data buffer for net operator info common sb.
 TBuf8<SIZE_NET_OPERATOR_INFO_COMMON> operatorInfoCommonBuf;
 TIsiSubBlock operatorInfoCommonSb( operatorInfoCommonBuf,
 NET_OPERATOR_INFO_COMMON,
 (
 TUint8 aTransactionId
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetSetCancelReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETSETCANCELREQ, "CMmNetMessHandler::NetSetCancelReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETSETCANCELREQ_TD, "CMmNetMessHandler::NetSetCancelReq" );
 // Set the network select flag to ETrue.
 // This flag is checked in NetSetCancelResp.
 iSelectNetworkCancelIssued = ETrue;
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetSetCancelResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETSETCANCELRESP, "CMmNetMessHandler::NetSetCancelResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETSETCANCELRESP_TD, "CMmNetMessHandler::NetSetCancelResp" );
 // Get success code
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_SET_CANCEL_RESP_OFFSET_SUCCESSCODE ) );
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRatInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETRATIND, "CMmNetMessHandler::NetRatInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRATIND_TD, "CMmNetMessHandler::NetRatInd" );
 // Call NetRatResp to do the common job
 NetRatResp( aIsiMessage );
 }
 (
 TUint8 /* aTransactionId */
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRatReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETRATREQ, "CMmNetMessHandler::NetRatReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRATREQ_TD, "CMmNetMessHandler::NetRatReq" );
 // Message data size is 1
 TBuf8<1> data;
 // we need to know the current RAT
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRatResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETRATRESP, "CMmNetMessHandler::NetRatResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRATRESP_TD, "CMmNetMessHandler::NetRatResp" );
 TUint sbStartOffSet( 0 );
 // NET_RAT_INFO sub block
 TInt retValue( aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_NET_RAT_RESP,
 case NET_GSM_RAT:
 {
 iNetworkMode = RMobilePhone::ENetworkModeGsm;
 iNetworkAccess = RMobilePhone::ENetworkAccessGsm;
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRatResp - network mode GSM");
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_NETRATRESP, "CMmNetMessHandler::NetRatResp - network mode GSM" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_NETRATRESP_TD, "CMmNetMessHandler::NetRatResp - network mode GSM" );
 break;
 }
 case NET_UMTS_RAT:
 {
 iNetworkMode = RMobilePhone::ENetworkModeWcdma;
 iNetworkAccess = RMobilePhone::ENetworkAccessUtran;
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRatResp - network mode UMTS");
-OstTrace0( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_NETRATRESP, "CMmNetMessHandler::NetRatResp - network mode UMTS" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_NETRATRESP_TD, "CMmNetMessHandler::NetRatResp - network mode UMTS" );
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRatResp. default network mode");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_NETRATRESP, "CMmNetMessHandler::NetRatResp, default network mode" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_NETRATRESP_TD, "CMmNetMessHandler::NetRatResp, default network mode" );
 iNetworkMode = RMobilePhone::ENetworkModeUnknown;
 iNetworkAccess = RMobilePhone::ENetworkAccessUnknown;
 break;
 }
 }
 // Network selection
 const RMobilePhone::TMobilePhoneNetworkSelectionV1& aNetworkSelection
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetNetworkSelectModeSetReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETNETWORKSELECTMODESETREQ, "CMmNetMessHandler::NetNetworkSelectModeSetReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETNETWORKSELECTMODESETREQ_TD, "CMmNetMessHandler::NetNetworkSelectModeSetReq" );
 TInt ret( KErrNone );
 // Check the selection Mode from the selection structure
 TUint8 networkSelectionMode( NET_SELECT_MODE_UNKNOWN );
 (
 const TIsiReceiveC& aIsiMessage
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetNetworkSelectModeSetResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETNETWORKSELECTMODESETRESP, "CMmNetMessHandler::NetNetworkSelectModeSetResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETNETWORKSELECTMODESETRESP_TD, "CMmNetMessHandler::NetNetworkSelectModeSetResp" );
 // Get success code
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE +
 NET_NETWORK_SELECT_MODE_SET_RESP_OFFSET_SUCCESSCODE ) );
 // -----------------------------------------------------------------------------
 //
 TInt CMmNetMessHandler::NetRssiGetReq() const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRssiGetReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETRSSIGETREQ, "CMmNetMessHandler::NetRssiGetReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRSSIGETREQ_TD, "CMmNetMessHandler::NetRssiGetReq" );
 // Data buffer length is 2 (message size minus transId, msgId)
 TBuf8< SIZE_NET_RSSI_GET_REQ - 2 > reqData;
 reqData.Append( NET_CS_GSM );            // CS type
 reqData.Append( NET_CURRENT_CELL_RSSI ); // measurement type
 {
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_RSSI_GET_RESP_OFFSET_SUCCESSCODE ) );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRssiGetResp, successcode=%d", successCode);
-OstTraceExt1( TRACE_NORMAL, CMMNETMESSHANDLER_NETRSSIGETRESP, "CMmNetMessHandler::NetRssiGetResp;successCode=%hhu", successCode );
+OstTraceExt1( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRSSIGETRESP_TD, "CMmNetMessHandler::NetRssiGetResp;successCode=%hhu", successCode );
 if ( NET_CAUSE_OK == successCode )
 {
 TUint sbOffset( 0 );
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRssiInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETRSSIIND, "CMmNetMessHandler::NetRssiInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRSSIIND_TD, "CMmNetMessHandler::NetRssiInd" );
 // Note: the unsigned value gathered from the ISI is percentages
 TUint8 bars( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_RSSI_IND_OFFSET_SIGNALSBAR ) );
 // Copy RSSI in dBm into 32 bit integer
 TInt32 rssiInDbm( aRSSIIsi );
 TFLOGSTRING3("TSY: CMmNetMessHandler::HandleRssi -- signalBars=%d rssiInDbm=%d", signalBars, aRSSIIsi);
-OstTraceExt2( TRACE_NORMAL, CMMNETMESSHANDLER_HANDLERSSI, "CMmNetMessHandler::HandleRssi;signalBars=%hhd;rssiInDbm=%hhu", signalBars, aRSSIIsi );
+OstTraceExt2( TRACE_NORMAL,  CMMNETMESSHANDLER_HANDLERSSI_TD, "CMmNetMessHandler::HandleRssi;signalBars=%hhd;rssiInDbm=%hhu", signalBars, aRSSIIsi );
 CMmDataPackage dataPackage;
 dataPackage.PackData( &signalBars, &rssiInDbm );
 iMessageRouter->Complete(
 (
 const TIsiReceiveC& aIsiMessage
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetTimeInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETTIMEIND, "CMmNetMessHandler::NetTimeInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETTIMEIND_TD, "CMmNetMessHandler::NetTimeInd" );
 TUint sbStartOffSet( 0 );
 TInt ret( aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_NET_TIME_IND,
 TInt totalYear; // Four digits year
 totalYear = KNitzYearOffset + year;
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetTimeInd year: %d", totalYear );
-OstTrace1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_NETTIMEIND, "CMmNetMessHandler::NetTimeInd;NetTimeInd year=%d", totalYear );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_NETTIMEIND_TD, "CMmNetMessHandler::NetTimeInd;NetTimeInd year=%d", totalYear );
 // NITZ information
 RMobilePhone::TMobilePhoneNITZ timeDate;
 // Default caps, will be updated below if not valid.
 timeDate.iNitzFieldsUsed = KMmTsyNITZCaps;
 RMobilePhone::TMobilePhoneRegistrationStatus& aRegStatus, // Registration status
 RMobilePhone::TMobilePhoneNetworkStatus& aNWStatus // Network status
 )
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::MapNWAndRegStatus. ISARegistrationStatus:%d", aISARegistrationStatus);
-OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_MAPNWANDREGSTATUS, "CMmNetMessHandler::MapNWAndRegStatus;aRegStatus=%d", aRegStatus );
+OstTrace1( TRACE_NORMAL,  CMMNETMESSHANDLER_MAPNWANDREGSTATUS_TD, "CMmNetMessHandler::MapNWAndRegStatus;aRegStatus=%d", aRegStatus );
 switch ( aISARegistrationStatus )
 {
 // Registered home
 case NET_REG_STATUS_HOME:
 }
 // Defaul case
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::MapNWAndRegStatus. default registration status");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_MAPNWANDREGSTATUS, "CMmNetMessHandler::MapNWAndRegStatus, default registration status" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_MAPNWANDREGSTATUS_TD, "CMmNetMessHandler::MapNWAndRegStatus, default registration status" );
 aNWStatus = RMobilePhone::ENetworkStatusUnknown;
 aRegStatus = RMobilePhone::ERegistrationUnknown;
 break;
 }
 }
 TUint8 aISASelectionMode, // Isa network selection mode
 RMobilePhone::TMobilePhoneNetworkSelectionV1& aSelectionMode // Network selection mode
 )
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::MapNWSelectionMode. ISA selectionmode:%d", aISASelectionMode);
-OstTraceExt1( TRACE_NORMAL, CMMNETMESSHANDLER_MAPNWSELECTIONMODE, "CMmNetMessHandler::MapNWSelectionMode;aISASelectionMode=%hhu", aISASelectionMode );
+OstTraceExt1( TRACE_NORMAL,  CMMNETMESSHANDLER_MAPNWSELECTIONMODE_TD, "CMmNetMessHandler::MapNWSelectionMode;aISASelectionMode=%hhu", aISASelectionMode );
 if ( NET_SELECT_MODE_AUTOMATIC == aISASelectionMode )
 {
 aSelectionMode.iMethod = RMobilePhone::ENetworkSelectionAutomatic;
 }
 TInt aMNCLength
 )
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::MapOperatorAndCountryCode - MNCLenght: %d",
 aMNCLength);
-OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_MAPOPERATORANDCOUNTRYCODE, "CMmNetMessHandler::MapOperatorAndCountryCode;aMNCLength=%d", aMNCLength );
+OstTrace1( TRACE_NORMAL,  CMMNETMESSHANDLER_MAPOPERATORANDCOUNTRYCODE_TD, "CMmNetMessHandler::MapOperatorAndCountryCode;aMNCLength=%d", aMNCLength );
 // Country code mapping
 TUint16 mcc1( 0 );
 TUint16 mcc2( 0 );
 TUint16 mcc3( 0 );
 TUint8 aISANetworkStatus, // Isa network status value
 RMobilePhone::TMobilePhoneNetworkStatus& aNWStatus // Network status
 )
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::MapNwStatus. ISANetworkStatus:%d", aISANetworkStatus);
-OstTraceExt1( TRACE_NORMAL, CMMNETMESSHANDLER_MAPNWSTATUS, "CMmNetMessHandler::MapNwStatus;aISANetworkStatus=%hhu", aISANetworkStatus );
+OstTraceExt1( TRACE_NORMAL,  CMMNETMESSHANDLER_MAPNWSTATUS_TD, "CMmNetMessHandler::MapNwStatus;aISANetworkStatus=%hhu", aISANetworkStatus );
 switch ( aISANetworkStatus )
 {
 case NET_OPER_STATUS_UNKNOWN:
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::MapNwStatus. mapped default network status");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_MAPNWSTATUS, "CMmNetMessHandler::MapNwStatus, mapped default network status" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_MAPNWSTATUS_TD, "CMmNetMessHandler::MapNwStatus, mapped default network status" );
 aNWStatus = RMobilePhone::ENetworkStatusUnknown;
 break;
 }
 }
 }
 TUint8 cipheringStatus( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + NET_CIPHERING_IND_OFFSET_CIPHERINGSTATUS ) );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetCipheringInd. CipheringStatus:%d", cipheringStatus);
-OstTraceExt1( TRACE_NORMAL, CMMNETMESSHANDLER_NETCIPHERINGIND, "CMmNetMessHandler::NetCipheringInd;cipheringStatus=%hhu", cipheringStatus );
+OstTraceExt1( TRACE_NORMAL,  CMMNETMESSHANDLER_NETCIPHERINGIND_TD, "CMmNetMessHandler::NetCipheringInd;cipheringStatus=%hhu", cipheringStatus );
 switch( cipheringStatus )
 {
 case NET_CIPHERING_INDICATOR_OFF:
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetCipheringInd. no ciphering status");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_NETCIPHERINGIND, "CMmNetMessHandler::NetCipheringInd, no ciphering status" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_NETCIPHERINGIND_TD, "CMmNetMessHandler::NetCipheringInd, no ciphering status" );
 break;
 }
 }
 CMmDataPackage package;
 (
 const TIsiReceiveC& aIsiMessage    // Received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRadioInfoInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd" );
 TBool oldCell_DCH = iCell_DCH;
 // Find NET_UTRAN_RADIO_INFO sub block
 TUint sbStartOffSet( 0 );
 TUint8 radioState( aIsiMessage.Get8bit(
 sbStartOffSet + NET_UTRAN_RADIO_INFO_OFFSET_RADIOSTATE ) );
 // iCell_DCH is true if and only if UTRAN radio state is Cell_DCH
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, UTRAN radio state=%d.", radioState);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;UTRAN radioState=%hhu", radioState );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;UTRAN radioState=%hhu", radioState );
 iCell_DCH = ( ( NET_UTRAN_RADIO_CELL_DCH == radioState ) ?
 ETrue : EFalse );
 }
 else
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::NetRadioInfoInd, no UTRAN radio state info.");
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd, no UTRAN radio state info" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd, no UTRAN radio state info" );
 iCell_DCH = EFalse;
 }
 // State changed?
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, iCell_DCH = %d.", iCell_DCH);
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, oldCell_DCH = %d.", oldCell_DCH);
-OstTrace1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;oldCell_DCH=%d", oldCell_DCH );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;oldCell_DCH=%d", oldCell_DCH );
 if ( iCell_DCH != oldCell_DCH )
 {
 if ( iCell_DCH )
 {
 location.iAreaKnown = EFalse;
 location.iLocationAreaCode = iLastLocInfo.iLocationAreaCode;
 location.iCellId = iLastLocInfo.iCellId;
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, location.iAreaKnown = %d.", location.iAreaKnown);
-OstTrace1( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;location.iAreaKnown=%d", location.iAreaKnown );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;location.iAreaKnown=%d", location.iAreaKnown );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, location.iLocationAreaCode = %d.", location.iLocationAreaCode);
-OstTrace1( TRACE_NORMAL, DUP5_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;location.iLocationAreaCode=%d", location.iLocationAreaCode );
+OstTrace1( TRACE_NORMAL,  DUP5_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;location.iLocationAreaCode=%d", location.iLocationAreaCode );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, location.iCellId = %d.", location.iCellId );
-OstTrace1( TRACE_NORMAL, DUP6_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;location.iCellId=%d", location.iCellId );
+OstTrace1( TRACE_NORMAL,  DUP6_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;location.iCellId=%d", location.iCellId );
 CMmDataPackage dataPackage;
 dataPackage.PackData( &iLastNWInfo, &location );
 iMessageRouter->Complete(
 KErrNone );
 }
 }
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, iLastLocInfo.iAreaKnown = %d.", iLastLocInfo.iAreaKnown);
-OstTrace1( TRACE_NORMAL, DUP7_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;iLastLocInfo.iAreaKnown=%d", iLastLocInfo.iAreaKnown );
+OstTrace1( TRACE_NORMAL,  DUP7_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;iLastLocInfo.iAreaKnown=%d", iLastLocInfo.iAreaKnown );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, iLastLocInfo.iLocationAreaCode = %d.", iLastLocInfo.iLocationAreaCode);
-OstTrace1( TRACE_NORMAL, DUP8_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;iLastLocInfo.iLocationAreaCode=%d", iLastLocInfo.iLocationAreaCode );
+OstTrace1( TRACE_NORMAL,  DUP8_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;iLastLocInfo.iLocationAreaCode=%d", iLastLocInfo.iLocationAreaCode );
 TFLOGSTRING2("TSY: CMmNetMessHandler::NetRadioInfoInd, iLastLocInfo.iCellId = %d.", iLastLocInfo.iCellId);
-OstTrace1( TRACE_NORMAL, DUP9_CMMNETMESSHANDLER_NETRADIOINFOIND, "CMmNetMessHandler::NetRadioInfoInd;iLastLocInfo.iCellId=%d", iLastLocInfo.iCellId );
+OstTrace1( TRACE_NORMAL,  DUP9_CMMNETMESSHANDLER_NETRADIOINFOIND_TD, "CMmNetMessHandler::NetRadioInfoInd;iLastLocInfo.iCellId=%d", iLastLocInfo.iCellId );
 }
 // -----------------------------------------------------------------------------
 // CMmNetMessHandler::UiccReadCiReq
 // Read ciphering information status from UICC
 // -----------------------------------------------------------------------------
 //
 TInt CMmNetMessHandler::UiccReadCiReq()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::UiccReadCiReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_UICCREADCIREQ, "CMmNetMessHandler::UiccReadCiReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_UICCREADCIREQ_TD, "CMmNetMessHandler::UiccReadCiReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccReadTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdReadCipheringIndicatorStatus;
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::UiccReadCiResp( TInt aStatus, const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::UiccReadCiResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_UICCREADCIRESP, "CMmNetMessHandler::UiccReadCiResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_UICCREADCIRESP_TD, "CMmNetMessHandler::UiccReadCiResp" );
 // Initialize ret value
 TInt ret( KErrNone );
 // Ciphering indicator information
 // -----------------------------------------------------------------------------
 //
 TInt CMmNetMessHandler::UiccCsReadReq()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::UiccCsReadReq");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_UICCCSREADREQ, "CMmNetMessHandler::UiccCsReadReq" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_UICCCSREADREQ_TD, "CMmNetMessHandler::UiccCsReadReq" );
 // At first we try to read EHPLMN, SIM file '6FD9'
 // When response is received and if EHPLMN is not supported
 // we need to read HPLMN from IMSI (EF '6F07')
 void CMmNetMessHandler::UiccCsReadEhpmlnResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::UiccCsReadEhpmlnResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_UICCCSREADEHPMLNRESP, "CMmNetMessHandler::UiccCsReadEhpmlnResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_UICCCSREADEHPMLNRESP_TD, "CMmNetMessHandler::UiccCsReadEhpmlnResp" );
 // If status was OK, EHPLMN was supported
-if ( KErrNone ==  aStatus )
+if ( UICC_STATUS_OK ==  aStatus )
 {
 iHplmn = aFileData;
 }
 else // EHPLMN was not supported, read HPLMN
 {
 void CMmNetMessHandler::UiccCsReadHpmlnResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::UiccCsReadHpmlnResp");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_UICCCSREADHPMLNRESP, "CMmNetMessHandler::UiccCsReadHpmlnResp" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_UICCCSREADHPMLNRESP_TD, "CMmNetMessHandler::UiccCsReadHpmlnResp" );
-if ( KErrNone ==  aStatus )
+if ( UICC_STATUS_OK ==  aStatus )
 {
 TUint8 tempByte( 0 );
 // Coding of HPMLN is defined in TS 24.008
 // First byte is MCC2|MCC1
 tempByte = ( ( aFileData[1] & 0x0F ) << 4 ) |
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::SetSimNetworkInfo()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::SetSimNetworkInfo");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_SETSIMNETWORKINFO, "CMmNetMessHandler::SetSimNetworkInfo" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_SETSIMNETWORKINFO_TD, "CMmNetMessHandler::SetSimNetworkInfo" );
 // iHomeInfo is declared in cmmnetmesshandler.h (class private parameter
 // to store the network information during the operator name is requested.
 // Remember to zero-fill the buffers before appending.
 CMmStaticUtility::GetIntFromDescriptor(
 mncNumber,
 iHomeInfo.iNetworkId );
 TFLOGSTRING2("TSY: CMmNetMessHandler::SetSimNetworkInfo - CountryCode: %S", &iHomeInfo.iCountryCode);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_SETSIMNETWORKINFO, "CMmNetMessHandler::SetSimNetworkInfo - CountryCode=%S", iHomeInfo.iCountryCode );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_SETSIMNETWORKINFO_TD, "CMmNetMessHandler::SetSimNetworkInfo - CountryCode=%S", iHomeInfo.iCountryCode );
 TFLOGSTRING2("TSY: CMmNetMessHandler::SetSimNetworkInfo - NetworkId: %S", &iHomeInfo.iNetworkId);
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_SETSIMNETWORKINFO, "CMmNetMessHandler::SetSimNetworkInfo - NetworkId=%S", iHomeInfo.iNetworkId );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_SETSIMNETWORKINFO_TD, "CMmNetMessHandler::SetSimNetworkInfo - NetworkId=%S", iHomeInfo.iNetworkId );
 // Buffer for Display tag.
 TBuf<KDisplayTagLength> alphaTag;
 // Get Hard coded name from operators.h.
 mccNumber,
 mncNumber,
 alphaTag );
 TFLOGSTRING2("TSY: CMmNetMessHandler::SetSimNetworkInfo - Name: %S", &alphaTag);
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_SETSIMNETWORKINFO, "CMmNetMessHandler::SetSimNetworkInfo - Name=%S", alphaTag );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_SETSIMNETWORKINFO_TD, "CMmNetMessHandler::SetSimNetworkInfo - Name=%S", alphaTag );
 // Copy hard coded name to iDisplayTag. Long and short names not handled
 // in this case and they will left empty.
 iHomeInfo.iDisplayTag.Copy( alphaTag );
 const TIsiReceiveC& /*aIsiMessage*/,    // Isi message
 TInt /*aError*/    // Error code
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::HandleError");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_HANDLEERROR, "CMmNetMessHandler::HandleError" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_HANDLEERROR_TD, "CMmNetMessHandler::HandleError" );
 }
 // -----------------------------------------------------------------------------
 // CMmNetMessHandler::GetImsPinVerifyStatus
 // Return status of SIM PIN verify
 // -----------------------------------------------------------------------------
 //
 TBool CMmNetMessHandler::GetImsPinVerifyStatus()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::GetImsPinVerifyStatus");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_GETIMSPINVERIFYSTATUS, "CMmNetMessHandler::GetImsPinVerifyStatus" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_GETIMSPINVERIFYSTATUS_TD, "CMmNetMessHandler::GetImsPinVerifyStatus" );
 return iImsPinVerifyRequired;
 }
 // -----------------------------------------------------------------------------
 (
 const TIsiReceiveC& aIsiMessage // Received ISI message
 )
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::GpdsRadioActivityInd, NetworkMode = %d.", iNetworkMode);
-OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_GPDSRADIOACTIVITYIND, "CMmNetMessHandler::GpdsRadioActivityInd;iNetworkMode=%d", iNetworkMode );
+OstTrace1( TRACE_NORMAL,  CMMNETMESSHANDLER_GPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::GpdsRadioActivityInd;iNetworkMode=%d", iNetworkMode );
 // Should be ignored in 3G (information not valid).
 if ( RMobilePhone::ENetworkModeGsm == iNetworkMode )
 {
 TUint8 radioActivityStatus( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + GPDS_RADIO_ACTIVITY_IND_OFFSET_STATUS ) );
 // iPacketTransfer is true if and only
 // if radio activity state is GPDS_RADIO_ON
 TFLOGSTRING2("TSY: CMmNetMessHandler::GpdsRadioActivityInd, radio activity state=%d.", radioActivityStatus);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_GPDSRADIOACTIVITYIND, "CMmNetMessHandler::GpdsRadioActivityInd;radio activity state=%hhu", radioActivityStatus );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_GPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::GpdsRadioActivityInd;radio activity state=%hhu", radioActivityStatus );
 TBool newPacketTransfer = ( ( GPDS_RADIO_ON == radioActivityStatus ) ?
 ETrue : EFalse );
 if ( GPDS_RADIO_OFF == radioActivityStatus )
 (
 const TIsiReceiveC& /*aIsiMessage*/
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::GpdsContextDeactivateInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_GPDSCONTEXTDEACTIVATEIND, "CMmNetMessHandler::GpdsContextDeactivateInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_GPDSCONTEXTDEACTIVATEIND_TD, "CMmNetMessHandler::GpdsContextDeactivateInd" );
 // GPDS_RADIO_ACTIVITY_IND / RADIO_OFF is not received when
 // last context is closed => iPacketTransfer remains to ETrue
 // => simulate GPDS_RADIO_OFF from GPDS_CONTEXT_DEACTIVATE_IND.
 //
 // When PDP context is deactivated, it is still on the list at this point.
 TBool aNewPacketTrancferStatus
 )
 {
 // State changed?
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, NEW transfer status = %d.", aNewPacketTrancferStatus);
-OstTrace1( TRACE_NORMAL, CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;NEW transfer status=%d", aNewPacketTrancferStatus );
+OstTrace1( TRACE_NORMAL,  CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;NEW transfer status=%d", aNewPacketTrancferStatus );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, OLD transfer status = %d.", iPacketTransfer);
-OstTrace1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;OLD transfer status=%d", iPacketTransfer );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;OLD transfer status=%d", iPacketTransfer );
 if ( iPacketTransfer != aNewPacketTrancferStatus )
 {
 // Save new state
 iPacketTransfer = aNewPacketTrancferStatus;
 location.iAreaKnown = EFalse;
 location.iLocationAreaCode = iLastLocInfo.iLocationAreaCode;
 location.iCellId = iLastLocInfo.iCellId;
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, location.iAreaKnown = %d.", location.iAreaKnown);
-OstTrace1( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;location.iAreaKnown=%d", location.iAreaKnown );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;location.iAreaKnown=%d", location.iAreaKnown );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, location.iLocationAreaCode = %d.", location.iLocationAreaCode);
-OstTrace1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;location.iLocationAreaCode=%d", location.iLocationAreaCode );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;location.iLocationAreaCode=%d", location.iLocationAreaCode );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, location.iCellId = %d.", location.iCellId);
-OstTrace1( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;location.iCellId=%d", location.iCellId );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;location.iCellId=%d", location.iCellId );
 CMmDataPackage dataPackage;
 dataPackage.PackData( &iLastNWInfo, &location );
 iMessageRouter->Complete(
 EMobilePhoneNotifyCurrentNetworkChange,
 }
 }
 // No else
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, iLastLocInfo.iAreaKnown = %d.", iLastLocInfo.iAreaKnown);
-OstTrace1( TRACE_NORMAL, DUP5_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;iLastLocInfo.iAreaKnown=%d", iLastLocInfo.iAreaKnown );
+OstTrace1( TRACE_NORMAL,  DUP5_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;iLastLocInfo.iAreaKnown=%d", iLastLocInfo.iAreaKnown );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, iLastLocInfo.iLocationAreaCode = %d.", iLastLocInfo.iLocationAreaCode);
-OstTrace1( TRACE_NORMAL, DUP6_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;iLastLocInfo.iLocationAreaCode=%d", iLastLocInfo.iLocationAreaCode );
+OstTrace1( TRACE_NORMAL,  DUP6_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;iLastLocInfo.iLocationAreaCode=%d", iLastLocInfo.iLocationAreaCode );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteGpdsRadioActivityInd, iLastLocInfo.iCellId = %d.", iLastLocInfo.iCellId);
-OstTrace1( TRACE_NORMAL, DUP7_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;iLastLocInfo.iCellId=%d", iLastLocInfo.iCellId );
+OstTrace1( TRACE_NORMAL,  DUP7_CMMNETMESSHANDLER_COMPLETEGPDSRADIOACTIVITYIND_TD, "CMmNetMessHandler::CompleteGpdsRadioActivityInd;iLastLocInfo.iCellId=%d", iLastLocInfo.iCellId );
 }
 // -----------------------------------------------------------------------------
 // CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork
 // This function completes EMobilePhoneGetHomeNetwork.
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK_TD, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork" );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork - Operator display tag: %S", &iHomeInfo.iDisplayTag);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork;Operator display tag=%S", iHomeInfo.iDisplayTag );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK_TD, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork;Operator display tag=%S", iHomeInfo.iDisplayTag );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork - Operator short name: %S", &iHomeInfo.iShortName);
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork;Operator short name=%S", iHomeInfo.iShortName );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK_TD, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork;Operator short name=%S", iHomeInfo.iShortName );
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork - Operator long name: %S", &iHomeInfo.iLongName);
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork;Operator long name=%S", iHomeInfo.iLongName );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_COMPLETEMOBILEPHONEGETHOMENETWORK_TD, "CMmNetMessHandler::CompleteMobilePhoneGetHomeNetwork;Operator long name=%S", iHomeInfo.iLongName );
 // Pack the data
 CMmDataPackage package;
 package.PackData( &iHomeInfo );
 ) const
 {
 TUint sbStartOffSet( 0 );
 TFLOGSTRING("TSY: CMmNetMessHandler::FindOperatorInfoSubBlock");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_FINDOPERATORINFOSUBBLOCK, "CMmNetMessHandler::FindOperatorInfoSubBlock" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_FINDOPERATORINFOSUBBLOCK_TD, "CMmNetMessHandler::FindOperatorInfoSubBlock" );
 TInt ret( CalculateNetworkInformationSbStartOffset(
 aIsiMessage, sbStartOffSet ) );
 if ( KErrNone == ret )
 NET_MODEM_CURRENT_CELL_INFO,
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet );
 if ( KErrNone != ret )
 { // look for NET_MODEM_GSM_REG_INFO subblock
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_FINDOPERATORINFOSUBBLOCK, "CMmNetMessHandler::FindOperatorInfoSubBlock - NET_MODEM_CURRENT_CELL_INFO NOT FOUND" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_FINDOPERATORINFOSUBBLOCK_TD, "CMmNetMessHandler::FindOperatorInfoSubBlock - NET_MODEM_CURRENT_CELL_INFO NOT FOUND" );
 TFLOGSTRING("TSY: CMmNetMessHandler::FindOperatorInfoSubBlock - NET_MODEM_CURRENT_CELL_INFO NOT FOUND");
 ret = aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + sbStartOffSet,
 NET_MODEM_GSM_REG_INFO,
 EIsiSubBlockTypeId8Len8,
 {
 aSbOffset = sbStartOffSet;
 }
 else
 {
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_FINDOPERATORINFOSUBBLOCK, "CMmNetMessHandler::FindOperatorInfoSubBlock - NOTHING FOUND!" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_FINDOPERATORINFOSUBBLOCK_TD, "CMmNetMessHandler::FindOperatorInfoSubBlock - NOTHING FOUND!" );
 TFLOGSTRING("TSY: CMmNetMessHandler::FindOperatorInfoSubBlock - NOTHING FOUND!");
 }
 }
 return ret;
 }
 TUint8& aRegistrationStatus,
 TUint& aSbStartOffset
 ) const
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ExtractNetworkRegistrationStatus");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS, "CMmNetMessHandler::ExtractNetworkRegistrationStatus" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS_TD, "CMmNetMessHandler::ExtractNetworkRegistrationStatus" );
 TUint sbStartOffSet( 0 );
 TInt ret( CalculateNetworkInformationSbStartOffset(
 aIsiMessage, sbStartOffSet ) );
 {
 aSbStartOffset = sbStartOffSet;
 aRegistrationStatus = aIsiMessage.Get8bit( sbStartOffSet +
 NET_MODEM_REG_INFO_COMMON_OFFSET_REGISTRATIONSTATUS );
 TFLOGSTRING2("TSY: CMmNetMessHandler::ExtractNetworkRegistrationStatus;registrationStatus=%d", aRegistrationStatus);
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS, "CMmNetMessHandler::ExtractNetworkRegistrationStatus;registrationStatus=%hhu", aRegistrationStatus );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS_TD, "CMmNetMessHandler::ExtractNetworkRegistrationStatus;registrationStatus=%hhu", aRegistrationStatus );
 // patch registration status if this is SIM-card
 if ( 0 < iHplmn.Length() )
 {
 if ( NET_REG_STATUS_ROAM == aRegistrationStatus &&
 aOperatorCode == KO2NetworkId &&
 iHplmn == KO2Hplmn
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ExtractNetworkRegistrationStatus; NET_REG_STATUS_ROAM --> NET_REG_STATUS_HOME");
-OstTrace0( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS, "CMmNetMessHandler::ExtractNetworkRegistrationStatus; NET_REG_STATUS_ROAM --> NET_REG_STATUS_HOME" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS_TD, "CMmNetMessHandler::ExtractNetworkRegistrationStatus; NET_REG_STATUS_ROAM --> NET_REG_STATUS_HOME" );
 aRegistrationStatus = NET_REG_STATUS_HOME;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ExtractNetworkRegistrationStatus; cant patch, HPLMN is empty");
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS, "CMmNetMessHandler::ExtractNetworkRegistrationStatus - cant patch, HPLMN is empty" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS_TD, "CMmNetMessHandler::ExtractNetworkRegistrationStatus - cant patch, HPLMN is empty" );
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ExtractNetworkRegistrationStatus; NET_MODEM_REG_INFO_COMMON not found");
-OstTrace0( TRACE_NORMAL, DUP5_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS, "CMmNetMessHandler::ExtractNetworkRegistrationStatus; NET_MODEM_REG_INFO_COMMON not found" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS_TD, "CMmNetMessHandler::ExtractNetworkRegistrationStatus; NET_MODEM_REG_INFO_COMMON not found" );
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 const RMobilePhone::TMobilePhoneLocationAreaV1& aLocationAreaData, // LAC info
 const RMobilePhone::TMobilePhoneNetworkInfoV5& aNetworkInfoData // Network info
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange" );
 // Assistant for packaging.
 CMmDataPackage dataPackage;
 // Take possible Cell_DCH or packet transfer state into account
 location.iCellId = iLastLocInfo.iCellId;
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iAreaKnown = %d", location.iAreaKnown);
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iLocationAreaCode = %d", location.iLocationAreaCode);
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iCellId = %d", location.iCellId);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iAreaKnown=%hhu", location.iAreaKnown );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iAreaKnown=%hhu", location.iAreaKnown );
-OstTrace1( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iLocationAreaCode=%u", location.iLocationAreaCode );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iLocationAreaCode=%u", location.iLocationAreaCode );
-OstTrace1( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iCellId=%u", location.iCellId );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - location.iCellId=%u", location.iCellId );
 dataPackage.PackData( &iLastNWInfo, &location );
 }
 else
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iAreaKnown = %d", iLastLocInfo.iAreaKnown);
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iLocationAreaCode = %d", iLastLocInfo.iLocationAreaCode);
 TFLOGSTRING2("TSY: CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iCellId = %d", iLastLocInfo.iCellId);
-OstTraceExt1( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iAreaKnown=%hhu", iLastLocInfo.iAreaKnown );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iAreaKnown=%hhu", iLastLocInfo.iAreaKnown );
-OstTrace1( TRACE_NORMAL, DUP5_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iLocationAreaCode=%u", iLastLocInfo.iLocationAreaCode );
+OstTrace1( TRACE_NORMAL,  DUP5_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iLocationAreaCode=%u", iLastLocInfo.iLocationAreaCode );
-OstTrace1( TRACE_NORMAL, DUP7_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iCellId=%u", iLastLocInfo.iCellId );
+OstTrace1( TRACE_NORMAL,  DUP7_CMMNETMESSHANDLER_COMPLETEMOBILEPHONENOTIFYCURRENTNETWORKCHANGE_TD, "CMmNetMessHandler::CompleteMobilePhoneNotifyCurrentNetworkChange - iLastLocInfo.iCellId=%u", iLastLocInfo.iCellId );
 // Pack the data for sending to the manager.
 dataPackage.PackData( &iLastNWInfo, &iLastLocInfo );
 }
 (
 const TIsiReceiveC& aIsiMessage
 )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::QueueNetModemRegStatusMessagesL");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_QUEUENETMODEMREGSTATUSMESSAGESL, "CMmNetMessHandler::QueueNetModemRegStatusMessagesL" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_QUEUENETMODEMREGSTATUSMESSAGESL_TD, "CMmNetMessHandler::QueueNetModemRegStatusMessagesL" );
 // Make a copy of received message. Allocate heap memory.
 // Can leave if out of mem.
 HBufC8* tempHBuf = HBufC8::NewL( aIsiMessage.GetBuffer().Length() );
 // Copy data.
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::StartHandlingNetModemRegStatusMessages()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages" );
 // Continue handling if there is messages in queue
 // and handling not already ongoing.
 if ( !iNetMessageHandlingOngoing
 && 0 < iNetMessageQueue.Count() )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - Start handling next queued message");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - Start handling next queued message" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - Start handling next queued message" );
 // Set flag ON as message handling start.
 iNetMessageHandlingOngoing = ETrue;
 // Copy message from array.
 // Check message id.
 if ( NET_MODEM_REG_STATUS_IND == messageId )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_IND");
-OstTrace0( TRACE_NORMAL, DUP2_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_IND" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_IND" );
 // destroy previous ind and store current NET_MODEM_REG_STATUS_IND
 // for later use
 delete iLastNetModemRegStatusInd;
 iLastNetModemRegStatusInd = tempHBuf;
 // Start handling NET_MODEM_REG_STATUS_IND message.
 NetModemRegStatusInd( isimessage );
 }
 else if ( NET_MODEM_REG_STATUS_GET_RESP == messageId )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_GET_RESP");
-OstTrace0( TRACE_NORMAL, DUP3_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_GET_RESP" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_GET_RESP" );
 // Get the success code.
 TUint8 successCode( isimessage.Get8bit(
 ISI_HEADER_SIZE +
 NET_MODEM_REG_STATUS_GET_RESP_OFFSET_SUCCESSCODE ) );
 PN_MODEM_NETWORK,
 KTsyNetCauseCommon,
 successCode ) );
 TFLOGSTRING2("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_GET_RESP - Error value: %d", error);
-OstTrace1( TRACE_NORMAL, DUP4_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_GET_RESP - Error value=%d", error );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_MODEM_REG_STATUS_GET_RESP - Error value=%d", error );
 // Initialize default return values to ECustomGetOperatorNameIPC
 // complete.
 RMmCustomAPI::TOperatorNameInfo operNameInfo;
 operNameInfo.iType = RMmCustomAPI::EOperatorNameFlexiblePlmn;
 }
 }
 else if ( NET_SET_RESP == messageId )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_SET_RESP");
-OstTrace0( TRACE_NORMAL, DUP5_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_SET_RESP" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_SET_RESP" );
 // Check if the NW selection was done ok.
 TUint8 successCode( isimessage.Get8bit(
 ISI_HEADER_SIZE + NET_SET_RESP_OFFSET_SUCCESSCODE ) );
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_SET_RESP - Error cause value: %d", successCode);
-OstTraceExt1( TRACE_NORMAL, DUP6_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_SET_RESP - Error cause value=%hhu", successCode );
+OstTraceExt1( TRACE_NORMAL,  DUP6_CMMNETMESSHANDLER_STARTHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::StartHandlingNetModemRegStatusMessages - NET_SET_RESP - Error cause value=%hhu", successCode );
 // SuccessCode is not ok, check also for GSM specific error code.
 TUint sbStartOffSet( 0 );
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::ContinueHandlingNetModemRegStatusMessages()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ContinueHandlingNetModemRegStatusMessages - Continue handling queued messages");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_CONTINUEHANDLINGNETMODEMREGSTATUSMESSAGES, "CMmNetMessHandler::ContinueHandlingNetModemRegStatusMessages - Continue handling queued messages" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_CONTINUEHANDLINGNETMODEMREGSTATUSMESSAGES_TD, "CMmNetMessHandler::ContinueHandlingNetModemRegStatusMessages - Continue handling queued messages" );
 // Message handling done.
 // Reset flag to OFF as message handling is finished.
 iNetMessageHandlingOngoing = EFalse;
 // -----------------------------------------------------------------------------
 //
 void CMmNetMessHandler::InitializeOnsAndOplReading()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::InitializeOnsAndOplReading");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_INITIALIZEONSANDOPLREADING, "CMmNetMessHandler::InitializeOnsAndOplReading" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_INITIALIZEONSANDOPLREADING_TD, "CMmNetMessHandler::InitializeOnsAndOplReading" );
 // Set iNetMessageHandlingOngoing flag to ETrue.
 iNetMessageHandlingOngoing = ETrue;
 // Start Operator Name String (ONS Name) reading.
 // ---------------------------------------------------------------------------
 //
 CMmMessageRouter* CMmNetMessHandler::GetMessageRouter()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::GetMessageRouter");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_GETMESSAGEROUTER, "CMmNetMessHandler::GetMessageRouter" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_GETMESSAGEROUTER_TD, "CMmNetMessHandler::GetMessageRouter" );
 return iMessageRouter;
 }
 // ---------------------------------------------------------------------------
 // CMmNetMessHandler::GetPhoNetSender
 // ---------------------------------------------------------------------------
 //
 CMmPhoNetSender* CMmNetMessHandler::GetPhoNetSender()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::GetPhoNetSender");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_GETPHONETSENDER, "CMmNetMessHandler::GetPhoNetSender" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_GETPHONETSENDER_TD, "CMmNetMessHandler::GetPhoNetSender" );
 return iPhoNetSender;
 }
 // -----------------------------------------------------------------------------
 // CMmNetMessHandler::ExtractNetworkRegistrationStatus
 TInt CMmNetMessHandler::ExtractNetworkRegistrationStatus(
 const TIsiReceiveC& aIsiMessage,
 TUint8& aRegistrationStatus
 ) const
 {
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS, "CMmNetMessHandler::ExtractNetworkRegistrationStatus" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_EXTRACTNETWORKREGISTRATIONSTATUS_TD, "CMmNetMessHandler::ExtractNetworkRegistrationStatus" );
 TFLOGSTRING("TSY: CMmNetMessHandler::ExtractNetworkRegistrationStatus");
 TUint sbStartOffSet( 0 );
 // find offset to subblock from which operator code can be read
 TInt returnValue( FindOperatorInfoSubBlock(
 // ---------------------------------------------------------------------------
 //
 CMmNetOperatorNameHandler* CMmNetMessHandler::GetNetOperatorNameHandler()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::GetNetOperatorNameHandler");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_GETNETOPERATORNAMEHANDLER, "CMmNetMessHandler::GetNetOperatorNameHandler" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_GETNETOPERATORNAMEHANDLER_TD, "CMmNetMessHandler::GetNetOperatorNameHandler" );
 return iNetOperatorNameHandler;
 }
 // ---------------------------------------------------------------------------
 // CMmNetMessHandler::HandleLastNetModemRegStatusInd
 // ---------------------------------------------------------------------------
 //
 void CMmNetMessHandler::HandleLastNetModemRegStatusInd()
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::HandleLastNetModemRegStatusInd");
-OstTrace0( TRACE_NORMAL, CMMNETMESSHANDLER_HANDLELASTNETMODEMREGSTATUSIND, "CMmNetMessHandler::HandleLastNetModemRegStatusInd" );
+OstTrace0( TRACE_NORMAL,  CMMNETMESSHANDLER_HANDLELASTNETMODEMREGSTATUSIND_TD, "CMmNetMessHandler::HandleLastNetModemRegStatusInd" );
 TBool handlingNeeded( ETrue );
 if( iNetMessageQueue.Count() )
 {
 // we need to check is there any NET_MODEM_REG_STATUS_IND or
 if( NET_MODEM_REG_STATUS_IND == messageId ||
 NET_MODEM_REG_STATUS_GET_RESP == messageId )
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::HandleLastNetModemRegStatusInd: Similar messages already in queue, no need to handle last received ind");
-OstTrace0( TRACE_NORMAL, DUP1_CMMNETMESSHANDLER_HANDLELASTNETMODEMREGSTATUSIND, "CMmNetMessHandler::HandleLastNetModemRegStatusInd:: Similar messages already in queue, no need to handle last received ind" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMNETMESSHANDLER_HANDLELASTNETMODEMREGSTATUSIND_TD, "CMmNetMessHandler::HandleLastNetModemRegStatusInd:: Similar messages already in queue, no need to handle last received ind" );
 handlingNeeded = EFalse;
 break;
 }
 }
 }
 //
 CDelayTimer* CDelayTimer::NewL(
 CMmNetMessHandler* aNetMessHandler )
 {
 TFLOGSTRING("TSY: CDelayTimer::NewL");
-OstTrace0( TRACE_NORMAL, CDELAYTIMER_NEWL, "CDelayTimer::NewL" );
+OstTrace0( TRACE_NORMAL,  CDELAYTIMER_NEWL_TD, "CDelayTimer::NewL" );
 CDelayTimer* self = new( ELeave ) CDelayTimer();
 CleanupStack::PushL( self );
 // -----------------------------------------------------------------------------
 //
 CDelayTimer::CDelayTimer() : CTimer( CActive::EPriorityStandard )
 {
 TFLOGSTRING("TSY: CDelayTimer::CDelayTimer");
-OstTrace0( TRACE_NORMAL, CDELAYTIMER_CDELAYTIMER, "CDelayTimer::CDelayTimer" );
+OstTrace0( TRACE_NORMAL,  CDELAYTIMER_CDELAYTIMER_TD, "CDelayTimer::CDelayTimer" );
 }
 // -----------------------------------------------------------------------------
 // CDelayTimer::ConstructL()
 // Symbian 2nd phase constructor can leave.
 // -----------------------------------------------------------------------------
 //
 void CDelayTimer::ConstructL()
 {
 TFLOGSTRING("TSY: CDelayTimer::ConstructL");
-OstTrace0( TRACE_NORMAL, CDELAYTIMER_CONSTRUCTL, "CDelayTimer::ConstructL" );
+OstTrace0( TRACE_NORMAL,  CDELAYTIMER_CONSTRUCTL_TD, "CDelayTimer::ConstructL" );
 iNewPacketTransferState = ETrue;
 CTimer::ConstructL();
 CActiveScheduler::Add( this );
 // -----------------------------------------------------------------------------
 //
 CDelayTimer::~CDelayTimer()
 {
 TFLOGSTRING("TSY: CDelayTimer::~CDelayTimer");
-OstTrace0( TRACE_NORMAL, DUP1_CDELAYTIMER_CDELAYTIMER, "CDelayTimer::~CDelayTimer" );
+OstTrace0( TRACE_NORMAL,  DUP1_CDELAYTIMER_CDELAYTIMER_TD, "CDelayTimer::~CDelayTimer" );
 Cancel();
 }
 // -----------------------------------------------------------------------------
 // CDelayTimer::StartDelayTimer()
 TBool aNewPacketTransferState, TInt aTimeOut )
 {
 if ( iNewPacketTransferState != aNewPacketTransferState )
 {
 TFLOGSTRING("TSY: CDelayTimer::StartDelayTimer, Restart.");
-OstTrace0( TRACE_NORMAL, CDELAYTIMER_STARTDELAYTIMER, "CDelayTimer::StartDelayTimer,Restart" );
+OstTrace0( TRACE_NORMAL,  CDELAYTIMER_STARTDELAYTIMER_TD, "CDelayTimer::StartDelayTimer,Restart" );
 Cancel();
 iNewPacketTransferState = aNewPacketTransferState;
 After( aTimeOut );
 }
 // No else
 // -----------------------------------------------------------------------------
 //
 void CDelayTimer::RunL()
 {
 TFLOGSTRING2("TSY: CDelayTimer::RunL, status = %d.", iStatus.Int());
-OstTrace1( TRACE_NORMAL, CDELAYTIMER_RUNL, "CDelayTimer::RunL;iStatus.Int=%d", iStatus.Int() );
+OstTrace1( TRACE_NORMAL,  CDELAYTIMER_RUNL_TD, "CDelayTimer::RunL;iStatus.Int=%d", iStatus.Int() );
 // Timer request has completed, so notify the timer's owner
 if ( iStatus == KErrNone )
 {
 iNetMessHandler->CompleteGpdsRadioActivityInd(
 // -----------------------------------------------------------------------------
 //
 void CDelayTimer::DoCancel()
 {
 TFLOGSTRING("TSY: CDelayTimer::DoCancel");
-OstTrace0( TRACE_NORMAL, CDELAYTIMER_DOCANCEL, "CDelayTimer::DoCancel" );
+OstTrace0( TRACE_NORMAL,  CDELAYTIMER_DOCANCEL_TD, "CDelayTimer::DoCancel" );
 CTimer::DoCancel();
 iNewPacketTransferState = ETrue;
 }

changeset 9	8486d82aef45
parent 8	6295dc2169f3