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 <gssisi.h>
 #include <infoisi.h>
 #include <net_modemisi.h>
 #include <uiccisi.h>
 #include <ss_wmisi.h>
-// #include <permisi.h> To be done in CPS
+// #include <permisi.h>
 #include <product_profile_definitions.h>
 #include <ctsy/serviceapi/mmgsmwcdmautils.h>
 #include <ctsy/pluginapi/cmmdatapackage.h>
 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>
 // -----------------------------------------------------------------------------
 //
 CMmCustomMessHandler::CMmCustomMessHandler()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CMmCustomMessHandler.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CMMCUSTOMMESSHANDLER, "CMmCustomMessHandler::CMmCustomMessHandler" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CMMCUSTOMMESSHANDLER_TD, "CMmCustomMessHandler::CMmCustomMessHandler" );
 iSimCBTopicToBeDeleted = KUnusedCbMsgId;
 // Set to true because it doesn't delete topic at start up
 iTopicInSimMemoryDelete = ETrue;
 }
 // -----------------------------------------------------------------------------
 //
 CMmCustomMessHandler::~CMmCustomMessHandler()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::~CMmCustomMessHandler.\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_CMMCUSTOMMESSHANDLER, "CMmCustomMessHandler::~CMmCustomMessHandler" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_CMMCUSTOMMESSHANDLER_TD, "CMmCustomMessHandler::~CMmCustomMessHandler" );
 if( iListOfCiphValues )
 {
 //close the array of ciphering values
 iListOfCiphValues->Close();
 CMmMessageRouter* aMessageRouter, //pointer to the message router
 CMmUiccMessHandler* aUiccMessHandler
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NewL.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NEWL, "CMmCustomMessHandler::NewL" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NEWL_TD, "CMmCustomMessHandler::NewL" );
 CMmCustomMessHandler* customMessHandler =
 new( ELeave ) CMmCustomMessHandler();
 CleanupStack::PushL( customMessHandler );
 customMessHandler,
 PN_MODEM_NETWORK );
 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
-// TO BE DONE WITH INFO_PP_DATA_READ_RESP
 aPhoNetReceiver->RegisterL(
 customMessHandler,
 PN_INFO,
 INFO_PP_READ_RESP );
 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 customMessHandler,
 PN_GSS,
 GSS_HSXPA_USER_SETTING_IND );
 // PMM
-/* To be done in CPS
+/*
 aPhoNetReceiver->RegisterL( customMessHandler,
 PN_PERMANENT_DATA,
 PERM_PM_RECORD_READ_RESP );
 aPhoNetReceiver->RegisterL( customMessHandler,
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::ConstructL()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ConstructL.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CONSTRUCTL, "CMmCustomMessHandler::ConstructL" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CONSTRUCTL_TD, "CMmCustomMessHandler::ConstructL" );
 // Initialize iListOfCiphValues
 iListOfCiphValues = new ( ELeave ) RArray<TCiphListEntry>( 1 );
 // Initialize refresh indication boolean
 {
 TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 TFLOGSTRING3("TSY: CMmCustomMessHandler::ReceiveMessageL, Resource: %d, Message: %d", resource, messageId);
-OstTraceExt2( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId );
+OstTraceExt2( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId );
 switch( resource )
 {
 case PN_MODEM_CALL:
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_MODEM_CALL, switch messageId - default");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_CALL, switch messageId - default" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_CALL, switch messageId - default" );
 break;
 }
 }
 break;
 }
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_GSS, switch messageId - default");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_GSS, switch messageId - default" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_GSS, switch messageId - default" );
 break;
 }
 }
 break; // end case PN_GSS
 }
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_MODEM_NETWORK, switch messageId - default");
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_MODEM_NETWORK, switch messageId - default" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_MODEM_NETWORK, switch messageId - default" );
 break;
 }
 }
 break;
 }
 // switch according to the message id
 // and call the appropriate messagehandler method
 switch( messageId )
 {
 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
-// TO BE DONE WITH INFO_PP_DATA_READ_RESP
 case INFO_PP_READ_RESP:
 {
 InfoPpReadResp( aIsiMessage );
 break;
 }
 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_INFO, switch messageId - default");
-OstTrace0( TRACE_NORMAL, DUP6_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_INFO, switch messageId - default" );
+OstTrace0( TRACE_NORMAL,  DUP6_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_INFO, switch messageId - default" );
 break;
 }
 }
 break;
 }
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_SS, switch messageId - default");
-OstTrace0( TRACE_NORMAL, DUP12_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_SS, switch messageId - default" );
+OstTrace0( TRACE_NORMAL,  DUP12_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_SS, switch messageId - default" );
 break;
 }
 }
 break;
 }
-/* To be done in CPS
+/*
 case PN_PERMANENT_DATA:
 {
 if ( KCustomTransId == aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) )
 {
 switch( messageId )
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL\
 - switch resource - case PN_PERMANENT_DATA, switch messageId - default.\n");
-OstTrace0( TRACE_NORMAL, DUP16_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_PERMANENT_DATA, switch messageId - default." );
+OstTrace0( TRACE_NORMAL,  DUP16_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_PERMANENT_DATA, switch messageId - default." );
 break;
 }
 }
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL\
 - switch resource - case PN_PERMANENT_DATA, transaction id is not KCustomTransId\n");
-OstTrace0( TRACE_NORMAL, DUP14_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_PERMANENT_DATA, transaction id is not KCustomTransId" );
+OstTrace0( TRACE_NORMAL,  DUP14_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_PERMANENT_DATA, transaction id is not KCustomTransId" );
 }
 break;
 }*/
 case PN_UICC:
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - default" );
-OstTrace0( TRACE_NORMAL, DUP13_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - default" );
+OstTrace0( TRACE_NORMAL,  DUP13_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL_TD, "CMmCustomMessHandler::ReceiveMessageL- switch resource - default" );
 break; // server not known
 }
 } // end of switch
 }
 TUint8 aCallId, //call id
 TUint8 aCause //cause value for releasing the call
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallReleaseReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLRELEASEREQ, "CMmCustomMessHandler::CallReleaseReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLRELEASEREQ_TD, "CMmCustomMessHandler::CallReleaseReq" );
 iReleaseCauseValueSent = aCause;
 //Append data for ISI message
 TBuf8< 2 + SIZE_CALL_MODEM_SB_CAUSE > messageBuf;
 (
 const TIsiReceiveC& aIsiMsg    //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallReleaseResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLRELEASERESP, "CMmCustomMessHandler::CallReleaseResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLRELEASERESP_TD, "CMmCustomMessHandler::CallReleaseResp" );
 //initialize the causeType and causeValue
 TUint8 causeType  = 0;
 TUint8 causeValue = 0;
 TInt ret = KErrNone;
 (
 const TIsiReceiveC& aIsiMsg    //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallMoAlertInd.");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLMOALERTIND, "CMmCustomMessHandler::CallMoAlertInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLMOALERTIND_TD, "CMmCustomMessHandler::CallMoAlertInd" );
 TBool playRemoteAlertToneLocally( EFalse );
 TUint sbStartOffSet( 0 );
 // Get call alerting info sub block
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallMoAlertInd,\
 - CALL_MODEM_SB_ALERTING_INFO sub block found.");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_CALLMOALERTIND, "CMmCustomMessHandler::CallMoAlertInd, CALL_MODEM_SB_ALERTING_INFO sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_CALLMOALERTIND_TD, "CMmCustomMessHandler::CallMoAlertInd, CALL_MODEM_SB_ALERTING_INFO sub block found" );
 // Get alerting info
 TUint8 callAlertingInfo( aIsiMsg.Get8bit(
 sbStartOffSet + CALL_MODEM_SB_ALERTING_INFO_OFFSET_ALERTINGINFO ) );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccReadCiReq( TInt aTrId )
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccReadCiReq, transaction ID: %d", aTrId );
-OstTrace1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADCIREQ, "CMmCustomMessHandler::UiccReadCiReq;aTrId=%d", aTrId );
+OstTrace1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADCIREQ_TD, "CMmCustomMessHandler::UiccReadCiReq;aTrId=%d", aTrId );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccReadTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = static_cast<TUiccTrId>( aTrId );
 TInt aStatus,
 TInt aTrId,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadCiResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADCIRESP, "CMmCustomMessHandler::UiccReadCiResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADCIRESP_TD, "CMmCustomMessHandler::UiccReadCiResp" );
 TInt ret( KErrNone );
 TBool cipherIndicatorStatus( EFalse );
 if( UICC_STATUS_OK == aStatus  )
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::NetCsWakeupReq( TUint8 aTransId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetCsWakeupReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETCSWAKEUPREQ, "CMmCustomMessHandler::NetCsWakeupReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETCSWAKEUPREQ_TD, "CMmCustomMessHandler::NetCsWakeupReq" );
 //Data buffer length is 2
 TBuf8<2> data;
 data.Append( aTransId );
 data.Append( NET_CS_WAKEUP_REQ );
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::NetCsWakeupResp()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetCsWakeupResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETCSWAKEUPRESP, "CMmCustomMessHandler::NetCsWakeupResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETCSWAKEUPRESP_TD, "CMmCustomMessHandler::NetCsWakeupResp" );
 //getting this message indicates that the wakeup was successful
 //complete NetWakeup method (no packed parameters)
 iMessageRouter->Complete( ECustomNetWakeupIPC, KErrNone );
 //
 void CMmCustomMessHandler::NetCipheringInd(
 const TIsiReceiveC &aIsiMsg )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetCipheringInd.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETCIPHERINGIND, "CMmCustomMessHandler::NetCipheringInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETCIPHERINGIND_TD, "CMmCustomMessHandler::NetCipheringInd" );
 //set chipering to False
 TBool cipher( EFalse );
 //get the ciphering status
 (
 const TIsiReceiveC& aIsiMsg
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetModemRegStatusInd");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND, "CMmCustomMessHandler::NetModemRegStatusInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmCustomMessHandler::NetModemRegStatusInd" );
 if ( 0 != aIsiMsg.Get8bit(
 ISI_HEADER_SIZE +
 NET_MODEM_REG_STATUS_IND_OFFSET_SUBBLOCKCOUNT ) )
 {
 }
 case NET_REG_STATUS_NOSERV_NOSIM:
 case NET_REG_STATUS_NOSERV_SIM_REJECTED_BY_NW:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetModemRegStatusInd, No SIM");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND, "CMmCustomMessHandler::NetModemRegStatusInd, No SIM" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmCustomMessHandler::NetModemRegStatusInd, No SIM" );
 // Complete NetworkConnectionFailure notification
 // (no packed parameters).
 // If puk code is required notification shouldn't
 // be completed.
 TBool pukCodeRequired( iSecurityMessHandler->GetPukCodeReq() );
 if( !pukCodeRequired )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetModemRegStatusInd - Complete network connection failure");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND, "CMmCustomMessHandler::NetModemRegStatusInd - Complete network connection failure" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmCustomMessHandler::NetModemRegStatusInd - Complete network connection failure" );
 iMessageRouter->Complete(
 ECustomNotifyNetworkConnectionFailureIPC,
 KErrNone );
 }
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetModemRegStatusInd, switch registrationStatus - default");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND, "CMmCustomMessHandler::NetModemRegStatusInd, switch registrationStatus - default" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSIND_TD, "CMmCustomMessHandler::NetModemRegStatusInd, switch registrationStatus - default" );
 break;
 }
 }
 // Inform of the status of NSPS.
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccReadDynamic2FlagsReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadDynamic2FlagsReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADDYNAMIC2FLAGSREQ, "CMmCustomMessHandler::UiccReadDynamic2FlagsReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADDYNAMIC2FLAGSREQ_TD, "CMmCustomMessHandler::UiccReadDynamic2FlagsReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccWriteTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdReadDynamic2Flags;
 params.dataOffset = 0;
 void CMmCustomMessHandler::UiccReadDynamic2FlagsResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadDynamic2FlagsResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADDYNAMIC2FLAGSRESP, "CMmCustomMessHandler::UiccReadDynamic2FlagsResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADDYNAMIC2FLAGSRESP_TD, "CMmCustomMessHandler::UiccReadDynamic2FlagsResp" );
 TInt ret( KErrNone );
 RMmCustomAPI::TGetAlsBlockStatus blockStatus
 ( RMmCustomAPI::EBlockStatusUnknown );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccWriteDynamic2FlagsReq( TUint8 aInfo )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccWriteDynamic2FlagsReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCWRITEDYNAMIC2FLAGSREQ, "CMmCustomMessHandler::UiccWriteDynamic2FlagsReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCWRITEDYNAMIC2FLAGSREQ_TD, "CMmCustomMessHandler::UiccWriteDynamic2FlagsReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccWriteTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdWriteDynamic2Flags;
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccWriteDynamic2FlagsResp( TInt aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccWriteDynamic2FlagsReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCWRITEDYNAMIC2FLAGSRESP, "CMmCustomMessHandler::UiccWriteDynamic2FlagsResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCWRITEDYNAMIC2FLAGSRESP_TD, "CMmCustomMessHandler::UiccWriteDynamic2FlagsResp" );
 TInt ret( KErrNone );
 if ( UICC_STATUS_OK != aStatus )
 {
 (
 const TIsiReceiveC& aIsiMsg    //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallTerminateInd.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLTERMINATEIND, "CMmCustomMessHandler::CallTerminateInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLTERMINATEIND_TD, "CMmCustomMessHandler::CallTerminateInd" );
 //unique call id (without possible generic id)
 TInt callId = static_cast<TInt>( aIsiMsg.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_TERMINATED_IND_OFFSET_CALLID ) & 0x07 );
 if ( 0 != ssDiagnostics )
 {
 ssDiagnostics |= 0x80; // binary 10000000
 TFLOGSTRING3("TSY:CMmCustomMessHandler::CallTerminatedInd: Diagnostic octet=%d received for call id=%d",
 ssDiagnostics, callId );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_CALLTERMINATEIND, "CMmCustomMessHandler::CallTerminateInd;Diagnostic octet==%hhu received for call id=%d", ssDiagnostics, callId );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_CALLTERMINATEIND_TD, "CMmCustomMessHandler::CallTerminateInd;Diagnostic octet==%hhu received for call id=%d", ssDiagnostics, callId );
 }
 }
 // set the diagnostics in call object (might be zero)
 // parameters for SOS layer: Call id and TUint8 with diagnostics
 (
 const TIsiReceiveC& aIsiMsg    //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallReleaseInd.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLRELEASEIND, "CMmCustomMessHandler::CallReleaseInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLRELEASEIND_TD, "CMmCustomMessHandler::CallReleaseInd" );
 //unique call id (without possible generic id)
 TInt callId = static_cast<TInt>( aIsiMsg.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_RELEASE_IND_OFFSET_CALLID ) & 0x07 );
 if ( 0 != ssDiagnostics )
 {
 ssDiagnostics |= 0x80; // binary 10000000
 TFLOGSTRING3("TSY:CMmCustomMessHandler::CallReleaseInd: Diagnostic octet=%d received for call id=%d",
 ssDiagnostics, callId );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_CALLRELEASEIND, "CMmCustomMessHandler::CallReleaseInd;Diagnostic octet==%hhu received for call id=%d", ssDiagnostics, callId );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_CALLRELEASEIND_TD, "CMmCustomMessHandler::CallReleaseInd;Diagnostic octet==%hhu received for call id=%d", ssDiagnostics, callId );
 }
 }
 // set the diagnostics in call object (might be zero)
 // parameters for SOS layer: Call id and TUint8 with diagnostics
 (
 TProductProfileRequestType aReqType // request type, used as
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::InfoPpReadReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_INFOPPREADREQ, "CMmCustomMessHandler::InfoPpReadReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_INFOPPREADREQ_TD, "CMmCustomMessHandler::InfoPpReadReq" );
 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
 //create the buffer for SB_PP subblock
 TBuf8<SIZE_INFO_SB_PP> sbPPSubBlockBuf( 0 );
 TIsiSubBlock sbPPSubBlock( sbPPSubBlockBuf, INFO_SB_PP, EIsiSubBlockTypeId8Len8 );
 }
 else if ( ECheckTwoDigitDialSupport == aReqType )
 {
 sbPPSubBlockBuf.Append( KinfoPpTwoDigitDial );
 }
 else
 {
 // not supported
 return KErrArgument;
 }
 //value of the product profile is 0x00, not need cause we are reading
 sbPPSubBlockBuf.Append( 0x00 );
 // Construct INFO_PP_READ_REQ message (1 data byte +
 // sub block count + INFO_SB_PP sub block)
 TBuf8< 2 + SIZE_INFO_SB_PP > infoPpReadReq;
 //set pp batch reading to read specific product profile, thus 0.
 infoPpReadReq.Append( INFO_PP_PROD_PROFILE_FEATURE );
 // add sub block
 infoPpReadReq.Append( 1 ); // number of sub blocks
 infoPpReadReq.Append( sbPPSubBlock.CompleteSubBlock() );
 //create the isi message
 //transaction id = request type
 TUint8 transId = static_cast<TUint8>( aReqType );
 return iPhoNetSender->Send( PN_INFO, transId, INFO_PP_READ_REQ, infoPpReadReq );
 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 return KErrNone;
 (
 const TIsiReceiveC& aIsiMessage    //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::InfoPpReadResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp" );
 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
 TInt errorValue( KErrGeneral );
 // Get Status
 TUint8 status = aIsiMessage.Get8bit( ISI_HEADER_SIZE + INFO_PP_READ_RESP_OFFSET_STATUS );
 //initialize two digit support with off
 RMmCustomAPI::TTwoDigitDialSupport twoDigitDialSupport(
 RMmCustomAPI::ETwoDigitDialSupportOff );
-TFLOGSTRING2("TSY: CMmCustomMessHandler::InfoPpReadResp - Status: %d",
+TFLOGSTRING2("TSY: CMmCustomMessHandler::InfoPpReadResp - Status: %d", status );
-status );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp;status=%hhu", status );
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp;status=%hhu", status );
 switch ( status )
 {
 case INFO_OK:
 {
+TUint sbInfoPpReadStartOffset(0);
-TUint sbInfoPpReadStartOffset( 0 );
 if ( KErrNone == aIsiMessage.FindSubBlockOffsetById( ISI_HEADER_SIZE + SIZE_INFO_PP_READ_RESP,
 INFO_SB_PP, EIsiSubBlockTypeId8Len8, sbInfoPpReadStartOffset ) )
 {
 TInt length = aIsiMessage.Get8bit( sbInfoPpReadStartOffset + INFO_SB_PP_OFFSET_STRLEN  );
 TFLOGSTRING2("TSY: CMmCustomMessHandler::InfoPpReadResp - Info length: %d",
 length );
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp - Info length=%d", length );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp - Info length=%d", length );
 if ( 1 == length )
 {
 //introduce the pPFeatures buffer to hold the feature value,
 //buffer size is 2
 TBuf8<KTwo> pPFeatures;
 pPFeatures.Copy( aIsiMessage.GetData( sbInfoPpReadStartOffset
 + INFO_SB_PP_OFFSET_PRODUCTPROFILE, KTwo ) );
 TFLOGSTRING2("TSY: CMmCustomMessHandler::InfoPpReadResp - Info data: %S",
 &pPFeatures );
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp;pPfeatures=%s", pPFeatures );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp;pPfeatures=%s", pPFeatures );
 //check that product profile is requested one
 if ( INFO_PP_ALS == pPFeatures [0] )
 {
 //Get the value of the Als feature
 if ( 0 != pPFeatures [1] )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::InfoPpReadResp - EAlsSupportOn");
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp - EAlsSupportOn" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp - EAlsSupportOn" );
 alsSupport = RMmCustomAPI::EAlsSupportOn;
 }
 //set the error value to KErrNone
 errorValue = KErrNone;
 }
 {
 //Get the value of the two digit dial feature
 if ( 0 != pPFeatures [1] )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::InfoPpReadResp - EAlsSupportOff");
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp - EAlsSupportOff" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp - EAlsSupportOff" );
 twoDigitDialSupport =
 RMmCustomAPI::ETwoDigitDialSupportOn;
 }
 //set the error value to KErrNone
 errorValue = KErrNone;
 }
 //No else
 }
 }
 break;
 }
 case INFO_FAIL:
 errorValue = KErrNotFound;
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::InfoPpReadResp, switch status - default.\n" );
-OstTrace0( TRACE_NORMAL, DUP6_CMMCUSTOMMESSHANDLER_INFOPPREADRESP, "CMmCustomMessHandler::InfoPpReadResp, switch status - default" );
+OstTrace0( TRACE_NORMAL,  DUP6_CMMCUSTOMMESSHANDLER_INFOPPREADRESP_TD, "CMmCustomMessHandler::InfoPpReadResp, switch status - default" );
 errorValue = KErrNotSupported;
 break;
 }
 }
 CMmDataPackage dataPackage;
 dataPackage.PackData( &twoDigitDialSupport );
 iMessageRouter->Complete( ECustomCheckTwoDigitDialSupportIPC,
 &dataPackage, errorValue );
 }
 //No else
 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 }
 // -----------------------------------------------------------------------------
 (
 TUint8 aTransId // Transaction Id
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmBlackListClearReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLGSMBLACKLISTCLEARREQ, "CMmCustomMessHandler::CallGsmBlackListClearReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLGSMBLACKLISTCLEARREQ_TD, "CMmCustomMessHandler::CallGsmBlackListClearReq" );
 // Construct CALL_MODEM_BLACKLIST_CLEAR_REQ message (1 data byte +
 // sub block count)
 TBuf8<2> blackListClearReq;
 (
 //         const TIsiReceiveC& aIsiMsg // Received isi messge
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmBlackListClearResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLGSMBLACKLISTCLEARRESP, "CMmCustomMessHandler::CallGsmBlackListClearResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLGSMBLACKLISTCLEARRESP_TD, "CMmCustomMessHandler::CallGsmBlackListClearResp" );
 // call server response
 //getting this message indicates that the clear blacklist was successful
 //complete SOS layer method
 iMessageRouter->Complete( ECustomClearCallBlackListIPC, KErrNone );
 (
 const TIsiReceiveC& aIsiMessage //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::SsServiceCompletedInd");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_SSSERVICECOMPLETEDIND, "CMmCustomMessHandler::SsServiceCompletedInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_SSSERVICECOMPLETEDIND_TD, "CMmCustomMessHandler::SsServiceCompletedInd" );
 if ( 0 < aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 SS_SERVICE_COMPLETED_IND_OFFSET_SUBBLOCKCOUNT ) )
 {
 TUint ssStatus( 0 );
 {
 ssStatus = KCustomApiSsGsmQuiescent;
 }
 TFLOGSTRING2("TSY: CMmCustomMessHandler::SsServiceCompletedInd: Complete SsRequestCompleteNotification ssStatus:%d",
 ssStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_SSSERVICECOMPLETEDIND, "CMmCustomMessHandler::SsServiceCompletedInd;Complete SsRequestCompleteNotification ssStatus=%u", ssStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_SSSERVICECOMPLETEDIND_TD, "CMmCustomMessHandler::SsServiceCompletedInd;Complete SsRequestCompleteNotification ssStatus=%u", ssStatus );
 CMmDataPackage dataPackage;
 // pack parameter: a TInt with SS status
 dataPackage.PackData( &ssStatus );
 iMessageRouter->Complete( ECustomNotifySsRequestCompleteIPC,
 additionalInfo.iAdditionalInfo.Copy( aIsiMessage.GetData(
 sbStartOffset + SS_GSM_ADDITIONAL_INFO_OFFSET_RETURNRESULT,
 length  ) );
 TFLOGSTRING("TSY: CMmCustomMessHandler::SsServiceCompletedInd: Complete SsAdditionalInfoNotification");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_SSSERVICECOMPLETEDIND, "CMmCustomMessHandler::SsServiceCompletedInd - Complete SsAdditionalInfoNotification" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_SSSERVICECOMPLETEDIND_TD, "CMmCustomMessHandler::SsServiceCompletedInd - Complete SsAdditionalInfoNotification" );
 // complete notification
 CMmDataPackage dataPackage;
 // pack parameter: pointer to RMmCustomAPI::TSsAdditionalInfo
 RMmCustomAPI::TSsAdditionalInfo* additionalInfoPtr =
 (
 const TIsiReceiveC& aIsiMessage //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::SsServiceFailedResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP, "CMmCustomMessHandler::SsServiceFailedResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP_TD, "CMmCustomMessHandler::SsServiceFailedResp" );
 TInt ssStatus( RMmCustomAPI::KSsStatusReturnError );
 CMmDataPackage dataPackage;
 additionalInfo.iAdditionalInfo.Append( 0x00 );
 break;
 }
 }
 TFLOGSTRING2("TSY: CMmCustomMessHandler::SsServiceFailedResp: Ss Status: %d", ssStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP, "CMmCustomMessHandler::SsServiceFailedResp;Ss Status=%d", ssStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP_TD, "CMmCustomMessHandler::SsServiceFailedResp;Ss Status=%d", ssStatus );
 // pack parameter: a TInt with SS status
 dataPackage.PackData( &ssStatus );
 // To complete outstanding SsRequestCompleteNotification
 iMessageRouter->Complete(
 ECustomNotifySsRequestCompleteIPC,
 &dataPackage,
 KErrNone );
 TFLOGSTRING2("TSY: CMmCustomMessHandler::SsServiceFailedResp: SB ID: 0x%x",subBlockId );
-OstTraceExt1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP, "CMmCustomMessHandler::SsServiceFailedResp;subBlockId=%hhx", subBlockId );
+OstTraceExt1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP_TD, "CMmCustomMessHandler::SsServiceFailedResp;subBlockId=%hhx", subBlockId );
 // pack parameter: pointer to RMmCustomAPI::TSsAdditionalInfo
 RMmCustomAPI::TSsAdditionalInfo* additionalInfoPtr = &additionalInfo;
 dataPackage.PackData( &additionalInfoPtr );
 // To complete outstanding SsAdditionalInfoNotification
 KErrNone );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::SsServiceFailedResp: No subblock's");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP, "CMmCustomMessHandler::SsServiceFailedResp - No subblock's" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_SSSERVICEFAILEDRESP_TD, "CMmCustomMessHandler::SsServiceFailedResp - No subblock's" );
 dataPackage.PackData( &ssStatus );
 // No subblocks, complete with default values
 iMessageRouter->Complete( ECustomNotifySsRequestCompleteIPC,
 RMmCustomAPI::TMobileTelNumber& aNumber,  // Telnumber
 RMmCustomAPI::TCheckMode aCheckMode     // Check mode
 )
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::CallEmergencyNbrCheckReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLEMERGENCYNBRCHECKREQ, "CMmCustomMessHandler::CallEmergencyNbrCheckReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLEMERGENCYNBRCHECKREQ_TD, "CMmCustomMessHandler::CallEmergencyNbrCheckReq" );
 //save the information to match it when the response is got
 iUsedEmergencyNbrCheckMode = aCheckMode;
 iEmergencyNumberLength = aNumber.Length();
 (
 const TIsiReceiveC& aIsiMsg        // Received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallEmergencyNbrCheckResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLEMERGENCYNBRCHECKRESP, "CMmCustomMessHandler::CallEmergencyNbrCheckResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLEMERGENCYNBRCHECKRESP_TD, "CMmCustomMessHandler::CallEmergencyNbrCheckResp" );
 // Get Status
 TUint8 status( aIsiMsg.Get8bit( ISI_HEADER_SIZE +
 CALL_MODEM_EMERG_NBR_CHECK_RESP_OFFSET_STATUS ));
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccOperatorReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccOperatorReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCOPERATORREQ, "CMmCustomMessHandler::UiccOperatorReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCOPERATORREQ_TD, "CMmCustomMessHandler::UiccOperatorReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccReadTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdReadOperatorNameCustom;
 // CMmCustomMessHandler::UiccOperatorResp
 // Complete operator name
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccOperatorResp(
-TInt aStatus,
+TUint8 aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccOperatorResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCOPERATORRESP, "CMmCustomMessHandler::UiccOperatorResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCOPERATORRESP_TD, "CMmCustomMessHandler::UiccOperatorResp" );
 TInt errorValue( KErrGeneral );
 // Network provider name
 TBuf<KNwProviderNameLength> name;
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 errorValue = KErrNone;
 name.Copy( aFileData );
 }
 (
 TUint8 aTransId             //transaction Id
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::SsGsmUssdSendReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_SSGSMUSSDSENDREQ, "CMmCustomMessHandler::SsGsmUssdSendReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_SSGSMUSSDSENDREQ_TD, "CMmCustomMessHandler::SsGsmUssdSendReq" );
 // create buffer for isi msg data
 TBuf8<2> data;
 data.Append( SS_GSM_USSD_END );
 //number of sub blocks
 (
 const TIsiReceiveC& aIsiMessage //received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::SsGsmUssdSendResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_SSGSMUSSDSENDRESP, "CMmCustomMessHandler::SsGsmUssdSendResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_SSGSMUSSDSENDRESP_TD, "CMmCustomMessHandler::SsGsmUssdSendResp" );
 TUint ussdType( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE +
 SS_GSM_USSD_SEND_RESP_OFFSET_USSDTYPE ) );
 const TCiphListEntry& aArg1, //first argument
 const TCiphListEntry& aArg2  //second argument
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Match.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_MATCH, "CMmCustomMessHandler::Match" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_MATCH_TD, "CMmCustomMessHandler::Match" );
 TBool ret ( EFalse );
 //we are interested only in the traId value
 if ( aArg1.iTraId == aArg2.iTraId )
 (
 const TUint8 aTransactionId
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetModemRegStatusGetReq." );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSGETREQ, "CMmCustomMessHandler::NetModemRegStatusGetReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSGETREQ_TD, "CMmCustomMessHandler::NetModemRegStatusGetReq" );
 // Data length buffer is 2.
 TBuf8<2> data;
 data.Append( aTransactionId );
 data.Append( NET_MODEM_REG_STATUS_GET_REQ );
 //
 void CMmCustomMessHandler::NetModemRegStatusGetResp(
 const TIsiReceiveC& aIsiMsg )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetModemRegStatusGetResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSGETRESP, "CMmCustomMessHandler::NetModemRegStatusGetResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETMODEMREGSTATUSGETRESP_TD, "CMmCustomMessHandler::NetModemRegStatusGetResp" );
 // Get the success code.
 TUint8 successCode( aIsiMsg.Get8bit(
 ISI_HEADER_SIZE +
 NET_MODEM_REG_STATUS_GET_RESP_OFFSET_SUCCESSCODE ) );
 (
 const TIsiReceiveC& aIsiMsg // received ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd" );
 TInt ret( KErrNone );
 // For packaging
 CMmDataPackage dataPackage;
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_SS_CODE sub block founded");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_CODE sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_CODE sub block found" );
 TUint16 ssCode( aIsiMsg.Get16bit(
 sbStartOffSet + CALL_MODEM_SB_SS_CODE_OFFSET_MMISSCODE ) );
 switch ( ssCode )
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 switch ssCode - default.");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, switch ssCode - default" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, switch ssCode - default" );
 break;
 }
 }
 }
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_SS_NOTIFY sub block founded");
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_NOTIFY sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_NOTIFY sub block found" );
 // Get the SsNotifyIndictor
 TUint8 ssNotify( aIsiMsg.Get8bit(
 sbStartOffSet + CALL_MODEM_SB_SS_NOTIFY_OFFSET_SSNOTIFICATION ) );
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_SS_NOTIFY_INDICATOR sub block founded");
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_NOTIFY_INDICATOR sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_NOTIFY_INDICATOR sub block found" );
 // Get the SsNotifyIndictor
 TUint8 ssNotifyIndicator( aIsiMsg.Get8bit( sbStartOffSet +
 CALL_MODEM_SB_SS_NOTIFY_INDICATOR_OFFSET_SSINDICATOR ) );
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_SS_HOLD_INDICATOR sub block founded");
-OstTrace0( TRACE_NORMAL, DUP6_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_HOLD_INDICATOR sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP6_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_HOLD_INDICATOR sub block found" );
 // Get the ectIndictor
 TUint8 holdIndicator( aIsiMsg.Get8bit( sbStartOffSet +
 CALL_MODEM_SB_SS_HOLD_INDICATOR_OFFSET_SSHOLDINDICATOR ) );
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_CUG_INFO sub block founded");
-OstTrace0( TRACE_NORMAL, DUP7_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_CUG_INFO sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP7_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_CUG_INFO sub block found" );
 // Get the CUG index
 ssInfo.iCugIndex = aIsiMsg.Get16bit(
 sbStartOffSet + CALL_MODEM_SB_CUG_INFO_OFFSET_CUGIND );
 }
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_SS_ECT_INDICATOR sub block founded");
-OstTrace0( TRACE_NORMAL, DUP8_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_ECT_INDICATOR sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP8_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_SS_ECT_INDICATOR sub block found" );
 // Get the ectIndictor
 TUint8 ectIndicator( aIsiMsg.Get8bit(
 sbStartOffSet + CALL_MODEM_SB_SS_ECT_INDICATOR_OFFSET_SSECTINDICATOR ) );
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_REMOTE_ADDRESS sub block founded");
-OstTrace0( TRACE_NORMAL, DUP9_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_REMOTE_ADDRESS sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP9_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_REMOTE_ADDRESS sub block found" );
 // Get the presentation
 TUint8 presentationIndicator( aIsiMsg.Get8bit(
 sbStartOffSet + CALL_MODEM_SB_REMOTE_ADDRESS_OFFSET_PRESENTATION ) );
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_REMOTE_ADDRESS sub block\
 - switch presentationIndicator - default.");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, switch presentationIndicator - default" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, switch presentationIndicator - default" );
 // The variable already has a default value
 break;
 }
 }
 EIsiSubBlockTypeId8Len8,
 sbStartOffSet ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CallGsmNotificationInd,\
 - CALL_MODEM_SB_ALERTING_INFO sub block founded");
-OstTrace0( TRACE_NORMAL, DUP10_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_ALERTING_INFO sub block found" );
+OstTrace0( TRACE_NORMAL,  DUP10_CMMCUSTOMMESSHANDLER_CALLGSMNOTIFICATIONIND_TD, "CMmCustomMessHandler::CallGsmNotificationInd, CALL_MODEM_SB_ALERTING_INFO sub block found" );
 TBool playRemoteAlertToneLocally( EFalse );
 // Get alerting info
 TUint8 callAlertingInfo( aIsiMsg.Get8bit(
 const TIsiReceiveC& aIsiMsg,  //Isi message
 RMmCustomAPI::TSsTypeAndMode& aSsTypeAndMode //ss type and mode
 ) const
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::HandleForwarding.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_HANDLEFORWARDING, "CMmCustomMessHandler::HandleForwarding" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_HANDLEFORWARDING_TD, "CMmCustomMessHandler::HandleForwarding" );
 //identify the kind of forwarding
 switch ( aSsCode )
 {
 case CALL_MODEM_SSC_ALL_FWDS:
 case CALL_MODEM_SSC_ALL_COND_FWD:
 aSsTypeAndMode.iSsType = RMmCustomAPI::ESsAllCondForwardings;
 break;
 default:
 TFLOGSTRING("TSY: CMmCustomMessHandler::HandleForwarding, switch aSsCode - default.\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_HANDLEFORWARDING, "CMmCustomMessHandler::HandleForwarding, switch aSsCode - default" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_HANDLEFORWARDING_TD, "CMmCustomMessHandler::HandleForwarding, switch aSsCode - default" );
 //this case is imposible, added due code convention
 break;
 }
 TUint sbStartOffSet( 0 );
 const TIsiReceiveC& aIsiMsg,  //ISI message
 RMmCustomAPI::TSsTypeAndMode& aSsTypeAndMode //Ss type and mode
 ) const
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::HandleBarring.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_HANDLEBARRING, "CMmCustomMessHandler::HandleBarring" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_HANDLEBARRING_TD, "CMmCustomMessHandler::HandleBarring" );
 //identify the kind of barring
 switch ( aSsCode )
 {
 case CALL_MODEM_SSC_OUTGOING_BARR_SERV:
 case CALL_MODEM_SSC_INCOMING_BARR_SERV:
 aSsTypeAndMode.iSsType = RMmCustomAPI::ESsIncomingBarrServ;
 break;
 default:
 TFLOGSTRING("TSY: CMmCustomMessHandler::HandleBarring, switch aSsCode - default.\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_HANDLEBARRING, "CMmCustomMessHandler::HandleBarring, switch aSsCode - default" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_HANDLEBARRING_TD, "CMmCustomMessHandler::HandleBarring, switch aSsCode - default" );
 //this case is imposible, added due code convention
 break;
 }
 TUint sbStartOffSet( 0 );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::NetSetReq( TUint8 aTransId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetSetReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETSETREQ, "CMmCustomMessHandler::NetSetReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETSETREQ_TD, "CMmCustomMessHandler::NetSetReq" );
 // Data for ISI message, buffer size is one
 TBuf8<2 + SIZE_NET_OPERATOR_INFO_COMMON> netSetReq;
 // Registered in another protocol is set to 0
 netSetReq.Append ( 0 );
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::NetSetResp( const TIsiReceiveC& aIsiMsg )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetSetResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETSETRESP, "CMmCustomMessHandler::NetSetResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETSETRESP_TD, "CMmCustomMessHandler::NetSetResp" );
 // Get the cause
 TUint8 cause( aIsiMsg.Get8bit(
 ISI_HEADER_SIZE +
 NET_SET_RESP_OFFSET_SUCCESSCODE ) );
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::NetRatResp( const TIsiReceiveC& aIsiMsg )
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::NetRatResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETRATRESP, "CMmCustomMessHandler::NetRatResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETRATRESP_TD, "CMmCustomMessHandler::NetRatResp" );
 // Get the success code
 TUint8 successCode( aIsiMsg.Get8bit(
 ISI_HEADER_SIZE + NET_RAT_RESP_OFFSET_SUCCESSCODE ) );
 TInt ret( KErrNone );
 TUint32 supportedNetworkModes( 0 );
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::NetRatResp successCode : %d", successCode);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_NETRATRESP, "CMmCustomMessHandler::NetRatResp;successCode=%hhu", successCode );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_NETRATRESP_TD, "CMmCustomMessHandler::NetRatResp;successCode=%hhu", successCode );
 // Check if we have sub blocks in the message
 if ( aIsiMsg.Get8bit( ISI_HEADER_SIZE + NET_RAT_RESP_OFFSET_SUBBLOCKCOUNT )
 != 0 && NET_CAUSE_OK == successCode )
 {
 CMmDataPackage dataPackage;
 dataPackage.PackData( &supportedNetworkModes );
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::NetRatResp - ret: %d", ret);
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_NETRATRESP, "CMmCustomMessHandler::NetRatResp;ret=%d", ret );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_NETRATRESP_TD, "CMmCustomMessHandler::NetRatResp;ret=%d", ret );
 // Completion ResetNetServer method (packed parameters)
 iMessageRouter->Complete(
 ECustomGetSystemNetworkModesIPC,
 &dataPackage,
 //
 void CMmCustomMessHandler::GssCsServiceResp (
 const TIsiReceiveC& aIsiMessage ) // Received isi message
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::GssCsServiceResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP_TD, "CMmCustomMessHandler::GssCsServiceResp" );
 TUint8 transactId ( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + GSS_CS_SERVICE_RESP_OFFSET_TRANSID ) );
 if ( KCustomTransId == transactId )
 // GSS_SELECTED_RAT_WRITE (0x0E)
 if ( GSS_SELECTED_RAT_WRITE == operation )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetSystemNetworkModeIPC");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetSystemNetworkModeIPC" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP_TD, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetSystemNetworkModeIPC" );
 //completion ResetGssServer method (no packed parameters)
 iMessageRouter->Complete( ECustomSetSystemNetworkModeIPC, KErrNone );
 }
 // GSS_SELECTED_RAT_READ (0x9C)
 else if ( GSS_SELECTED_RAT_READ == operation )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomGetCurrentSystemNetworkModesIPC");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomGetCurrentSystemNetworkModesIPC" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP_TD, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomGetCurrentSystemNetworkModesIPC" );
 TInt err( KErrNone );
 TUint32 ratMode ( RMmCustomAPI::KCapsNetworkModeDual );
 TUint subblockOffset( 0 );
 if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_GSS_CS_SERVICE_RESP,
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Unrecognized RAT");
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Unrecognized RAT" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP_TD, "CMmCustomMessHandler::GssCsServiceResp - Unrecognized RAT" );
 err = KErrGeneral;
 break;
 }
 }
 }
 #if ( NCP_COMMON_S60_VERSION_SUPPORT != S60_VERSION_32 )
 // GSS_SELECTED_BANDS_WRITE (0x9D)
 else if ( GSS_SELECTED_BANDS_WRITE == operation )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetBandSelectionIPC");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetBandSelectionIPC" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP_TD, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetBandSelectionIPC" );
 iMessageRouter->Complete( ECustomSetBandSelectionIPC, KErrNone );
 }
 // GSS_SELECTED_BANDS_READ (0x9E)
 else if ( GSS_SELECTED_BANDS_READ == operation )
 {
 //
 void CMmCustomMessHandler::GssCsServiceFailResp (
 const TIsiReceiveC& aIsiMessage ) // Received isi message
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::GssCsServiceFailResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP, "CMmCustomMessHandler::GssCsServiceFailResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP_TD, "CMmCustomMessHandler::GssCsServiceFailResp" );
 TUint8 transactId ( aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 GSS_CS_SERVICE_FAIL_RESP_OFFSET_TRANSID ) );
 TUint8 operation ( aIsiMessage.Get8bit( ISI_HEADER_SIZE +
 GSS_CS_SERVICE_FAIL_RESP_OFFSET_OPERATION ) );
 // GSS_SELECTED_RAT_WRITE (0x0E)
 if ( KCustomTransId == transactId && GSS_SELECTED_RAT_WRITE == operation )
 {
 //completion ResetGssServer method (no packed parameters)
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceFailResp - ECustomSetSystemNetworkModeIPC");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP, "CMmCustomMessHandler::GssCsServiceFailResp - ECustomSetSystemNetworkModeIPC" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP_TD, "CMmCustomMessHandler::GssCsServiceFailResp - ECustomSetSystemNetworkModeIPC" );
 iMessageRouter->Complete( ECustomSetSystemNetworkModeIPC, KErrGeneral );
 }
 // not suppoted for S60 ver 3.2
 #if ( NCP_COMMON_S60_VERSION_SUPPORT != S60_VERSION_32 )
 else if ( GSS_SELECTED_BANDS_WRITE == operation )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceFailResp - ECustomSetBandSelectionIPC");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP, "CMmCustomMessHandler::GssCsServiceFailResp - ECustomSetBandSelectionIPC" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP_TD, "CMmCustomMessHandler::GssCsServiceFailResp - ECustomSetBandSelectionIPC" );
 iMessageRouter->Complete( ECustomSetBandSelectionIPC, KErrGeneral );
 }
 else if ( GSS_SELECTED_BANDS_READ == operation )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceFailResp - ECustomGetBandSelectionIPC");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP, "CMmCustomMessHandler::GssCsServiceFailResp - ECustomGetBandSelectionIPC" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_GSSCSSERVICEFAILRESP_TD, "CMmCustomMessHandler::GssCsServiceFailResp - ECustomGetBandSelectionIPC" );
 iMessageRouter->Complete( ECustomGetBandSelectionIPC, KErrGeneral );
 }
 #endif // NCP_COMMON_S60_VERSION_SUPPORT
 }
 //
 TInt CMmCustomMessHandler::UiccReadFieldReq(
 RMmCustomAPI::TSimFileInfo& aSimFileInfo )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadFieldReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADFIELDREQ, "CMmCustomMessHandler::UiccReadFieldReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADFIELDREQ_TD, "CMmCustomMessHandler::UiccReadFieldReq" );
 // We have received only file path, file ID is two last bytes of path
 TInt length( aSimFileInfo.iPath.Length() );
 TBuf8<2> temp;
 if ( 2 <= length )
 // CMmCustomMessHandler::UiccReadFieldResp
 // Complete read file
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccReadFieldResp(
-TInt aStatus,
+TUint8 aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadFieldResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADFIELDRESP, "CMmCustomMessHandler::UiccReadFieldResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADFIELDRESP_TD, "CMmCustomMessHandler::UiccReadFieldResp" );
 TInt error( KErrNone );
-if ( aStatus != KErrNone )
+if ( aStatus != UICC_STATUS_OK )
 {
 error = KErrNotFound;
 }
 // Packed parameter for completion: pointer to TDesC8 with data
 TUint8 aTransId, // transaction Id
 TBool aUseCurrentRats // use current rats setting
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetRatReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETRATREQ, "CMmCustomMessHandler::NetRatReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETRATREQ_TD, "CMmCustomMessHandler::NetRatReq" );
 TFLOGSTRING3( "TSY: CCMmCustomMessHandler::NetRatReq - aTransId: %d, aUseCurrentRats: %d", aTransId, aUseCurrentRats );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_NETRATREQ, "CMmCustomMessHandler::NetRatReq;aTransId=%hhu;aUseCurrentRats=%hhu", aTransId, aUseCurrentRats );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_NETRATREQ_TD, "CMmCustomMessHandler::NetRatReq;aTransId=%hhu;aUseCurrentRats=%hhu", aTransId, aUseCurrentRats );
 // Create message data buffer for service type, buffer size is 1
 TBuf8<1> messageData;
 // Append service type
 if ( aUseCurrentRats )
 )
 {
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::GssCsServiceReq - aTransId: %d",
 aTransId );
-OstTraceExt1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GSSCSSERVICEREQ, "CMmCustomMessHandler::GssCsServiceReq;aTransId=%hhu", aTransId );
+OstTraceExt1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_GSSCSSERVICEREQ_TD, "CMmCustomMessHandler::GssCsServiceReq;aTransId=%hhu", aTransId );
 // create message data buffer for service type, buffer size is 6
 TBuf8< KGssCsBufferSize > messageData;
 // append service type, GSS_SELECTED_RAT_WRITE (0x0E)
 (
 TUint8 aTransId   //transaction Id
 )
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::GssCsServiceReq" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICEREQ, "CMmCustomMessHandler::GssCsServiceReq" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICEREQ_TD, "CMmCustomMessHandler::GssCsServiceReq" );
 TBuf8<KTwo> messageData;
 messageData.Append( GSS_SELECTED_RAT_READ );
 messageData.Append( 0 ); // number of subblocks
 TInt ret( KErrNone );
 TUint8 transId = KCustomTransId;
 TFLOGSTRING2("TSY: CMmCustomMessHandler::ExtFuncL -- aIpc -- (%d)", aIpc );
-OstTrace1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_EXTFUNCL, "CMmCustomMessHandler::ExtFuncL;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_EXTFUNCL_TD, "CMmCustomMessHandler::ExtFuncL;aIpc=%d", aIpc );
 switch ( aIpc )
 {
 case ECustomCancelUssdSessionIPC:
 {
 // call id means all calls. Taking absolute value of it gives
 // alerting call id.
 if ( 0 >= callId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ExtFuncL -- ECustomTerminateCallIPC -- (hold+active+alerting)");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_EXTFUNCL, "CMmCustomMessHandler::ExtFuncL - ECustomTerminateCallIPC - (hold+active+alerting)" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_EXTFUNCL_TD, "CMmCustomMessHandler::ExtFuncL - ECustomTerminateCallIPC - (hold+active+alerting)" );
 // alerting call (if any) is included as negated value..
 callIdISA = TUint8( CALL_MODEM_ID_HOLD | CALL_MODEM_ID_ACTIVE | ( -callId ));
 }
 else if ( 1 <= callId && 7 >= callId )
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::ExtFuncL -- ECustomTerminateCallIPC -- (%d)", TInt(callId) );
-OstTrace1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_EXTFUNCL, "CMmCustomMessHandler::ExtFuncL;callId=%d", callId );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_EXTFUNCL_TD, "CMmCustomMessHandler::ExtFuncL;callId=%d", callId );
 callIdISA = static_cast<TUint8>( callId );
 }
 else
 {
 // no call found
 default:
 {
 // this method should only be called for Custom Tsy cases
 TFLOGSTRING2("TSY: CMmCustomMessHandler::ExtFuncL - Unknown IPC: %d", aIpc);
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_EXTFUNCL, "CMmCustomMessHandler::ExtFuncL;aIpc=%d", aIpc );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_EXTFUNCL_TD, "CMmCustomMessHandler::ExtFuncL;aIpc=%d", aIpc );
 ret = KErrArgument;
 break;
 }
 }
 TInt aStatus,
 TUint8 /*aDetails*/,
 const TDesC8& aFileData )
 {
 TFLOGSTRING3("TSY: CMmCustomMessHandler::ProcessUiccMsg, transaction ID: %d, status: %d", aTraId, aStatus );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_PROCESSUICCMSG, "CMmCustomMessHandler::ProcessUiccMsg" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_PROCESSUICCMSG_TD, "CMmCustomMessHandler::ProcessUiccMsg" );
 TInt ret( KErrNone );
 switch( aTraId )
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmNetMessHandler::ProcessUiccMsg - unknown transaction ID" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_PROCESSUICCMSG, "CMmCustomMessHandler::ProcessUiccMsg - unknown transaction ID" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_PROCESSUICCMSG_TD, "CMmCustomMessHandler::ProcessUiccMsg - unknown transaction ID" );
 break;
 }
 }
 return ret;
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccReadViagHomeZoneParametersReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadViagHomeZoneParametersReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONEPARAMETERSREQ, "CMmCustomMessHandler::UiccReadViagHomeZoneParametersReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONEPARAMETERSREQ_TD, "CMmCustomMessHandler::UiccReadViagHomeZoneParametersReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccReadTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdReadViagHomeZoneParamsCustom;
 // CMmCustomMessHandler::UiccReadViagHomeZoneParametersResp
 // Complete home zone parameters
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccReadViagHomeZoneParametersResp(
-TInt aStatus,
+TUint8 aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadViagHomeZoneParametersResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONEPARAMETERSRESP, "CMmCustomMessHandler::UiccReadViagHomeZoneParametersResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONEPARAMETERSRESP_TD, "CMmCustomMessHandler::UiccReadViagHomeZoneParametersResp" );
 TInt error( KErrNone );
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 TUint8 length( 0 );
 TUint8 i( 0 );
 TUint8 j( 0 );
 TUint8 index( 2 );
 //
 TInt CMmCustomMessHandler::UiccReadViagHomeZoneCacheReq(
 const RMmCustomAPI::TViagCacheRecordId& aRecordId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadViagHomeZoneCacheReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONECACHEREQ, "CMmCustomMessHandler::UiccReadViagHomeZoneCacheReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONECACHEREQ_TD, "CMmCustomMessHandler::UiccReadViagHomeZoneCacheReq" );
 TUint8 cacheId( aRecordId.iCacheId );
 TUint8 recordId( aRecordId.iRecordId );
 TUint16 fileId( 0 );
 // CMmCustomMessHandler::UiccReadViagHomeZoneCacheResp
 // Complete home zone cache
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccReadViagHomeZoneCacheResp(
-TInt aStatus,
+TUint8 aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadViagHomeZoneCacheResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONECACHERESP, "CMmCustomMessHandler::UiccReadViagHomeZoneCacheResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADVIAGHOMEZONECACHERESP_TD, "CMmCustomMessHandler::UiccReadViagHomeZoneCacheResp" );
 TInt ret( KErrAccessDenied );
 RMmCustomAPI::TViagCacheRecordContent viagRecord;
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 viagRecord.iLac = ( aFileData[0] << 8 ) | aFileData[1];
 viagRecord.iCellId = ( aFileData[2] << 8 ) | aFileData[3];
 ret = KErrNone;
 }
 TInt CMmCustomMessHandler::UiccWriteViagHomeZoneCacheReq(
 const RMmCustomAPI::TViagCacheRecordId& aRecordId,
 const RMmCustomAPI::TViagCacheRecordContent& aViagRecordContent )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccWriteViagHomeZoneCacheReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONECACHEREQ, "CMmCustomMessHandler::UiccWriteViagHomeZoneCacheReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONECACHEREQ_TD, "CMmCustomMessHandler::UiccWriteViagHomeZoneCacheReq" );
 TUint8 cacheId( (TUint8)aRecordId.iCacheId );
 TUint8 recordId( (TUint8)aRecordId.iRecordId );
 TUint16 lac( (TUint16)aViagRecordContent.iLac );
 TUint16 cellId( (TUint16)aViagRecordContent.iCellId );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccWriteViagHomeZoneCacheResp
 // Complete home zone cache
 // -----------------------------------------------------------------------------
 //
-void CMmCustomMessHandler::UiccWriteViagHomeZoneCacheResp( TInt aStatus )
+void CMmCustomMessHandler::UiccWriteViagHomeZoneCacheResp( TUint8 aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccWriteViagHomeZoneCacheResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONECACHERESP, "CMmCustomMessHandler::UiccWriteViagHomeZoneCacheResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONECACHERESP_TD, "CMmCustomMessHandler::UiccWriteViagHomeZoneCacheResp" );
-if ( KErrNone == aStatus )
+if ( UICC_STATUS_OK == aStatus )
 {
 iMessageRouter->Complete( EWriteViagHomeZoneCacheIPC, KErrNone );
 }
 else
 {
 //
 TInt CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsReq(
 const RMmCustomAPI::TViagUHZIUESettings& aUhziuiSettings )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONEUHZIUESETTINGSREQ, "CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONEUHZIUESETTINGSREQ_TD, "CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsReq" );
 TUint8 settingsField( aUhziuiSettings.iSettings );
 TUint8 versionField( aUhziuiSettings.iVersion );
 // Set parameters for UICC_APPL_CMD_REQ message
 // CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsResp
 // Complete home zone settings
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsResp(
-TInt aStatus )
+TUint8 aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONEUHZIUESETTINGSRESP, "CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCWRITEVIAGHOMEZONEUHZIUESETTINGSRESP_TD, "CMmCustomMessHandler::UiccWriteViagHomeZoneUhziueSettingsResp" );
 TInt status( KErrAccessDenied );
-if ( KErrNone == aStatus  )
+if ( UICC_STATUS_OK == aStatus  )
 {
 status = KErrNone;
 }
 iMessageRouter->Complete( EWriteViagHomeZoneUHZIUESettingsIPC, status );
 }
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccReadCbMsgIdsReq( TUiccTrId aTrId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadCbMsgIdsReq" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADCBMSGIDSREQ, "CMmCustomMessHandler::UiccReadCbMsgIdsReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADCBMSGIDSREQ_TD, "CMmCustomMessHandler::UiccReadCbMsgIdsReq" );
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccReadTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = aTrId;
 // CMmCustomMessHandler::UiccReadCbMsgIdsResp
 // Complete CB message IDs
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccReadCbMsgIdsResp(
-TInt aStatus,
+TUint8 aStatus,
 TInt aTraId,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccReadCbMsgIdsResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCREADCBMSGIDSRESP, "CMmCustomMessHandler::UiccReadCbMsgIdsResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCREADCBMSGIDSRESP_TD, "CMmCustomMessHandler::UiccReadCbMsgIdsResp" );
-TInt numOfCbIds( 0 );
+TInt err( KErrNone );
-// File data in bytes
-TInt length( aFileData.Length() );
+TPtrC16 cbIdsBigEndian( reinterpret_cast<const TUint16*>( aFileData.Ptr() ),
-// Divide by two to get number of 16-bit CB ids
+aFileData.Length() / 2);
-numOfCbIds = length >> 1;
-// Buffer for 16 bits CB identifiers
-TBuf16<KSimNumberOfCbMsgIds> cbIds;
-TInt i( 0 );
-TInt j( 0 );
-// Loop all the bytes and append 16 bit id to buffer
-for ( ; i < length && j < numOfCbIds; i += 2, j++ )
-{
-TUint16 cbId ( ( aFileData[i] << 8 ) | ( aFileData[i+1] ) );
-cbIds.Append( cbId );
-}
 // Read request, complete CB topic list to CTSY
-if ( KErrNone == aStatus && ETrIdReadCbMsgIds == aTraId && numOfCbIds > 0 )
+if ( UICC_STATUS_OK == aStatus && ETrIdReadCbMsgIds == aTraId &&
-{
+cbIdsBigEndian.Length() > 0 )
-CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* simCbTopics = new ( ELeave )
+{
-CArrayFixFlat<RMmCustomAPI::TSimCbTopic> ( numOfCbIds );
+CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* simCbTopics( NULL );
+TRAP(err, simCbTopics = CollectCbTopicIdsL( cbIdsBigEndian ) );
-for ( i = 0; i < numOfCbIds; i++ )
+if ( KErrNone == err )
 {
-if ( KUnusedCbMsgId != cbIds[i] )
+CMmDataPackage dataPackage;
-{
+dataPackage.PackData( &simCbTopics );
-RMmCustomAPI::TSimCbTopic simCbTopic;
+iMessageRouter->Complete(
-// CB ID
+ECustomStartSimCbTopicBrowsingIPC,
-simCbTopic.iNumber = cbIds[i];
+&dataPackage,
-// Topic names are not stored on the SIM
+KErrNone );
-simCbTopic.iName.Zero();
+delete simCbTopics;
-// Add CB topic to array
+}
-simCbTopics->AppendL( simCbTopic );
-}
-}
-simCbTopics->Compress();
-// Complete to SOS layer with packed parameter:
-// pointer to array with CB topics
-CMmDataPackage dataPackage;
-dataPackage.PackData( &simCbTopics );
-iMessageRouter->Complete(
-ECustomStartSimCbTopicBrowsingIPC,
-&dataPackage,
-KErrNone );
 }
 // Delete request, update EF CBMI with new topic list
-else if ( KErrNone == aStatus && ETrIdUpdateCbMsgIdsPhase1 == aTraId &&
+else if ( UICC_STATUS_OK == aStatus && ETrIdUpdateCbMsgIdsPhase1 == aTraId
-numOfCbIds > 0 && iTopicInSimMemoryDelete )
+&& cbIdsBigEndian.Length() > 0 && iTopicInSimMemoryDelete )
 {
 // Set parameters for UICC_APPL_CMD_REQ message
 TUiccWriteTransparent params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdUpdateCbMsgIdsPhase2;
 // File id path
 params.filePath.Append( KMasterFileId >> 8 );
 params.filePath.Append( KMasterFileId );
 params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
-// File data to be updated.
+TUint16 topicToDeleteBigEndian =
-TBuf8<KSimNumberOfCbMsgIds*2> fileDataBuf;
+( iSimCBTopicToBeDeleted >> 8 ) | ( iSimCBTopicToBeDeleted << 8 );
-for ( i = 0; i < numOfCbIds; i++ )
+for ( TInt i = 0 ; i < cbIdsBigEndian.Length(); i++ )
 {
-if ( cbIds[ i ] != iSimCBTopicToBeDeleted )
+TUint16 appendData = cbIdsBigEndian[i] == topicToDeleteBigEndian ?
-{
+KUnusedCbMsgId : cbIdsBigEndian[i];
-fileDataBuf.Append( cbIds[ i ] >> 8 ); // MSB
+// already big-endian
-fileDataBuf.Append( cbIds[ i ] & 0x00FF ); // LSB
+params.fileData.Append( appendData );
-}
+params.fileData.Append( appendData >> 8 );
-else // This CB id is deleted-> set unused
-{
-fileDataBuf.Append( 0xFF );
-fileDataBuf.Append( 0xFF );
-}
 }
 iSimCBTopicToBeDeleted = KUnusedCbMsgId;
-params.fileData.Append( fileDataBuf );
 iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
-else // Complete error values
+else
+{
+err = KErrNotFound;
+}
+if ( KErrNone != err )
 {
 if ( ETrIdReadCbMsgIds == aTraId )
 {
 iMessageRouter->Complete(
 ECustomStartSimCbTopicBrowsingIPC,
-KErrNotFound );
+err );
 }
 else // Delete request
 {
 iMessageRouter->Complete(
 ECustomDeleteSimCbTopicIPC,
-KErrNotFound );
+err );
 }
-iTopicInSimMemoryDelete = ETrue;
+}
-}
+iTopicInSimMemoryDelete = ETrue;
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccDeleteCbMsgIdResp
 // Delete CB message ID
 // -----------------------------------------------------------------------------
 //
-void CMmCustomMessHandler::UiccDeleteCbMsgIdResp( TInt aStatus )
+void CMmCustomMessHandler::UiccDeleteCbMsgIdResp( TUint8 aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccDeleteCbMsgIdResp" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCDELETECBMSGIDRESP, "CMmCustomMessHandler::UiccDeleteCbMsgIdResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCDELETECBMSGIDRESP_TD, "CMmCustomMessHandler::UiccDeleteCbMsgIdResp" );
 TInt err( KErrNone );
-if ( KErrNone != aStatus )
+if ( UICC_STATUS_OK != aStatus )
 {
 err = KErrAccessDenied;
 }
 iMessageRouter->Complete( ECustomDeleteSimCbTopicIPC, err );
 TUint8 aTraId,                      // Transaction identification
 RMmCustomAPI::THSxPAStatus status   // HSxPA status
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::WriteHSxPAStatusReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_WRITEHSXPASTATUSREQ, "CMmCustomMessHandler::WriteHSxPAStatusReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_WRITEHSXPASTATUSREQ_TD, "CMmCustomMessHandler::WriteHSxPAStatusReq" );
 TBuf8<KHSxPAMaxMessageSize> data;
 TUint8 value(0);
 if ( RMmCustomAPI::EHSxPAEnabled == status )
 (
 const TIsiReceiveC& aIsiMessage    // an ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::WriteHSxPAStatusResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_WRITEHSXPASTATUSRESP, "CMmCustomMessHandler::WriteHSxPAStatusResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_WRITEHSXPASTATUSRESP_TD, "CMmCustomMessHandler::WriteHSxPAStatusResp" );
 TInt epocError( KErrWrite );
 TUint8 writeStatus = aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + GSS_HSXPA_USER_SETTING_WRITE_RESP_OFFSET_WRITESTATUS );
 }
 // GSS_FAIL == writeStatus and PP bit is disabled
 else if ( GSS_HSXPA_DISABLED_VIA_PP == reason )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::WriteHSxPAStatusResp. KErrNotSupported");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_WRITEHSXPASTATUSRESP, "CMmCustomMessHandler::WriteHSxPAStatusResp, KErrNotSupported" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_WRITEHSXPASTATUSRESP_TD, "CMmCustomMessHandler::WriteHSxPAStatusResp, KErrNotSupported" );
 epocError = KErrNotSupported;
 }
 iMessageRouter->Complete( ECustomWriteHSxPAStatusIPC, epocError );
 }
 (
 TUint8 aTraId              // Transaction identification
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReadHSxPAStatusReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_READHSXPASTATUSREQ, "CMmCustomMessHandler::ReadHSxPAStatusReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_READHSXPASTATUSREQ_TD, "CMmCustomMessHandler::ReadHSxPAStatusReq" );
 TBuf8<KHSxPAMaxMessageSize> data;
 data.Append( KCustomPadding ); //Filler
 data.Append( KCustomPadding ); //Filler
 (
 const TIsiReceiveC& aIsiMessage    // an ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReadHSxPAStatusResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_READHSXPASTATUSRESP, "CMmCustomMessHandler::ReadHSxPAStatusResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_READHSXPASTATUSRESP_TD, "CMmCustomMessHandler::ReadHSxPAStatusResp" );
 CMmDataPackage dataPackage;
 TUint8 state = aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + GSS_HSXPA_USER_SETTING_READ_RESP_OFFSET_HSXPAUSERSETTING );
 (
 const TIsiReceiveC& aIsiMessage    // an ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::HSxPASettingInd");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_HSXPASETTINGIND, "CMmCustomMessHandler::HSxPASettingInd" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_HSXPASETTINGIND_TD, "CMmCustomMessHandler::HSxPASettingInd" );
 CMmDataPackage dataPackage;
 RMmCustomAPI::THSxPAStatus hsxpaStatus;
 TUint8 currentState = aIsiMessage.Get8bit(
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::NetNeighbourCellsReq( const TUint8 aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetNeighbourCellsReq");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSREQ, "CMmCustomMessHandler::NetNeighbourCellsReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSREQ_TD, "CMmCustomMessHandler::NetNeighbourCellsReq" );
 // Add NET_NEIGHBOUR_CELL_INFO_TYPE
 // (data size is allways 1)
 TBuf8<1> data;
 data.Append( NET_ECID_INFORMATION );
 //
 void CMmCustomMessHandler::NetNeighbourCellsResp(
 const TIsiReceiveC& aIsiMessage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetNeighbourCellsResp");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP, "CMmCustomMessHandler::NetNeighbourCellsResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP_TD, "CMmCustomMessHandler::NetNeighbourCellsResp" );
-TECIDInfo tempECIDInfo;
+TBool triggerNotify( EFalse );
 TInt ret( KErrNone );
 // Get the success code.
 TUint8 successCode( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE +
 NET_NEIGHBOUR_CELLS_RESP_OFFSET_SUCCESSCODE ) );
 if ( NET_CAUSE_OK == successCode )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetNeighbourCellsResp - NET_CAUSE_OK");
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP, "CMmCustomMessHandler::NetNeighbourCellsResp, NET_CAUSE_OK" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP_TD, "CMmCustomMessHandler::NetNeighbourCellsResp, NET_CAUSE_OK" );
 TUint sbOffset( 0 );
 if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(
 ISI_HEADER_SIZE + SIZE_NET_NEIGHBOUR_CELLS_RESP,
 EIsiSubBlockTypeId8Len8,
 sbOffset ) )
 {
 // GSM cell info.
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetNeighbourCellsResp - NET_ECID_GERAN_INFO found");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP, "CMmCustomMessHandler::NetNeighbourCellsResp - NET_ECID_GERAN_INFO found" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP_TD, "CMmCustomMessHandler::NetNeighbourCellsResp - NET_ECID_GERAN_INFO found" );
 // Set mode
-tempECIDInfo.iCellInfo.iMode = RMmCustomAPI::TMmCellInfo::EGSM;
+if ( RMmCustomAPI::TMmCellInfo::EGSM != iECIDInfo.iCellInfo.iMode )
+{
+triggerNotify = ETrue;
+iECIDInfo.iCellInfo.iMode = RMmCustomAPI::TMmCellInfo::EGSM;
+}
 // Set Current MCC.
-tempECIDInfo.iMCC = aIsiMessage.Get16bit(
+TUint16 mcc( aIsiMessage.Get16bit(
-sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTMCC );
+sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTMCC ) );
+if ( mcc != iECIDInfo.iMCC )
+{
+triggerNotify = ETrue;
+iECIDInfo.iMCC = mcc;
+}
 // Set Current MNC.
-tempECIDInfo.iMNC = aIsiMessage.Get16bit(
+TUint16 mnc( aIsiMessage.Get16bit(
-sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTMNC );
+sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTMNC ) );
+if ( mnc != iECIDInfo.iMNC )
+{
+triggerNotify = ETrue;
+iECIDInfo.iMNC = mnc;
+}
 // Set Current LAC.
-tempECIDInfo.iLAC = aIsiMessage.Get16bit(
+TUint16 lac( aIsiMessage.Get16bit(
-sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTLAC );
+sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTLAC ) );
+if ( lac != iECIDInfo.iLAC )
+{
+triggerNotify = ETrue;
+iECIDInfo.iLAC = lac;
+}
 // Set Current Cell ID.
-tempECIDInfo.iCID = aIsiMessage.Get16bit(
+TUint16 cid( aIsiMessage.Get16bit(
-sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTCELLID );
+sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTCELLID ) );
+if ( cid != iECIDInfo.iCID )
+{
+triggerNotify = ETrue;
+iECIDInfo.iCID = cid;
+}
 // Set Current TA.
 TUint8 temp8bitUVal( aIsiMessage.Get8bit(
 sbOffset + NET_ECID_GERAN_INFO_OFFSET_CURRENTTA ) );
 if ( NET_ECID_TA_UNDEFINED != temp8bitUVal )
 {
-tempECIDInfo.iCellInfo.iGsmCellInfo.iTA = temp8bitUVal;
+iECIDInfo.iCellInfo.iGsmCellInfo.iTA = temp8bitUVal;
 }
 // No else.
 // Get Number of Neighbours included.
 TUint8 nmrCount( aIsiMessage.Get8bit(
 // Set NMR list.
 for ( TUint8 i = 0; i < nmrCount; i++ )
 {
 // Set Carrier number.
-tempECIDInfo.iCellInfo.iGsmCellInfo.iNmr[ i ].iARFCN =
+iECIDInfo.iCellInfo.iGsmCellInfo.iNmr[i].iARFCN =
 aIsiMessage.Get16bit(
 sbOffset + NET_ECID_GERAN_INFO_OFFSET_GSMNMRLIST +
 ( i * SIZE_NET_GSM_NMR_LIST_SEQ ) +
 NET_GSM_NMR_LIST_SEQ_OFFSET_ARFCN );
 // Set BSIC.
-tempECIDInfo.iCellInfo.iGsmCellInfo.iNmr[ i ].iBSIC =
+iECIDInfo.iCellInfo.iGsmCellInfo.iNmr[i].iBSIC =
 aIsiMessage.Get8bit(
 sbOffset + NET_ECID_GERAN_INFO_OFFSET_GSMNMRLIST +
 ( i * SIZE_NET_GSM_NMR_LIST_SEQ ) +
 NET_GSM_NMR_LIST_SEQ_OFFSET_BSIC );
 // Set RX level.
-tempECIDInfo.iCellInfo.iGsmCellInfo.iNmr[ i ].iRxLEV =
+iECIDInfo.iCellInfo.iGsmCellInfo.iNmr[i].iRxLEV =
 aIsiMessage.Get8bit(
 sbOffset + NET_ECID_GERAN_INFO_OFFSET_GSMNMRLIST +
 ( i * SIZE_NET_GSM_NMR_LIST_SEQ ) +
 NET_GSM_NMR_LIST_SEQ_OFFSET_RXLEVEL );
 }
 EIsiSubBlockTypeId8Len16,
 sbOffset ) )
 {
 // WCDMA cell info.
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetNeighbourCellsResp - NET_ECID_UTRAN_FDD_INFO found");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP, "CMmCustomMessHandler::NetNeighbourCellsResp - NET_ECID_UTRAN_FDD_INFO found" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP_TD, "CMmCustomMessHandler::NetNeighbourCellsResp - NET_ECID_UTRAN_FDD_INFO found" );
 // Set mode.
-tempECIDInfo.iCellInfo.iMode = RMmCustomAPI::TMmCellInfo::EWCDMA;
+if ( RMmCustomAPI::TMmCellInfo::EWCDMA != iECIDInfo.iCellInfo.iMode )
+{
+triggerNotify = ETrue;
+iECIDInfo.iCellInfo.iMode = RMmCustomAPI::TMmCellInfo::EWCDMA;
+}
 // Set UCID.
-tempECIDInfo.iCID = aIsiMessage.Get32bit(
+TUint32 cid( aIsiMessage.Get32bit(
-sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_UCID );
+sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_UCID ) );
+if ( cid != iECIDInfo.iCID )
+{
+triggerNotify = ETrue;
+iECIDInfo.iCID = cid;
+}
 // Set current MCC.
-tempECIDInfo.iMCC = aIsiMessage.Get16bit(
+TUint16 mcc( aIsiMessage.Get16bit(
-sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_CURRENTMCC );
+sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_CURRENTMCC ) );
+if ( mcc != iECIDInfo.iMCC )
+{
+triggerNotify = ETrue;
+iECIDInfo.iMCC = mcc;
+}
 // Set current MNC.
-tempECIDInfo.iMNC = aIsiMessage.Get16bit(
+TUint16 mnc( aIsiMessage.Get16bit(
-sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_CURRENTMNC );
+sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_CURRENTMNC ) );
+if ( mnc != iECIDInfo.iMNC )
-// Set current LAC (new value not received here).
+{
-tempECIDInfo.iLAC = iECIDInfo.iLAC;
+triggerNotify = ETrue;
+iECIDInfo.iMNC = mnc;
+}
+// New LAC not received here
 // Set primary scrambling code.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.iPrimaryScrambilingCode =
+iECIDInfo.iCellInfo.iWcdmaCellInfo.iPrimaryScrambilingCode =
 aIsiMessage.Get16bit(
 sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_PRISCRAMBLING );
 // Set Frequency Info.
 // Set frequency Info (Uplink UARFCN and UARFCN-Nt not available)
 // Downlink UARFCN.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.iFrequencyInfo.iFddDL =
+iECIDInfo.iCellInfo.iWcdmaCellInfo.iFrequencyInfo.iFddDL =
 aIsiMessage.Get16bit(
 sbOffset + NET_ECID_UTRAN_FDD_INFO_OFFSET_UARFCNDL );
 // Get number of neighbours included.
 TUint8 nmrCount( aIsiMessage.Get8bit(
 // Handle NMR lists.
 for ( TUint8 i( 0 ); i < nmrCount; i++ )
 {
 // Set Frequency Info: Downlink UARFCN.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iFrequencyInfo.iFddDL =
 aIsiMessage.Get16bit( nmrListOffset );
 // Uplink UARFCN and UARFCN-Nt not available, set to -1.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iFrequencyInfo.iFddUL = -1;
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iFrequencyInfo.iTddNt = -1;
 // Set UTRA Carrier RSSI.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iCarrierRSSI =
 aIsiMessage.Get8bit(
 nmrListOffset +
 NET_UTRAN_NEIGH_LIST_SEQ_OFFSET_UCRSSI );
 TUint32 temp32bitUVal(
 aIsiMessage.Get32bit( nmrListOffset ) );
 if ( NET_ECID_UCID_UNDEFINED != temp32bitUVal )
 {
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iCellMeasuredResult[f].iCID =
 temp32bitUVal;
 }
 // No else.
 // Set Primary CPICH.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iCellMeasuredResult[f].
 iFddInfo.iPrimaryCPICH = aIsiMessage.Get16bit(
 nmrListOffset +
 NET_UTRAN_CELL_LIST_SEQ_OFFSET_PCPICH );
 nmrListOffset +
 NET_UTRAN_CELL_LIST_SEQ_OFFSET_CPICHECNO ) );
 if ( NET_ECID_CPICH_ECNO_UNDEFINED != temp8bitUVal )
 {
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iCellMeasuredResult[f].
 iFddInfo.iCpichEcN0 = temp8bitUVal;
 }
 // No else.
 // Set CPICH RSCP.
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iCellMeasuredResult[f].
 iFddInfo.iCpichRscp = aIsiMessage.Get8bit(
 nmrListOffset +
 NET_UTRAN_CELL_LIST_SEQ_OFFSET_CPICHRSCP );
 nmrListOffset +
 NET_UTRAN_CELL_LIST_SEQ_OFFSET_PATHLOSS );
 if ( NET_ECID_PATHLOSS_UNDEFINED != temp8bitUVal )
 {
-tempECIDInfo.iCellInfo.iWcdmaCellInfo.
+iECIDInfo.iCellInfo.iWcdmaCellInfo.
 iNwkMeasureReport[i].iCellMeasuredResult[f].
 iFddInfo.iPathloss = temp8bitUVal;
 }
 // No else.
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::NetNeighbourCellsResp - No ECID data found");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP, "CMmCustomMessHandler::NetNeighbourCellsResp - No ECID data found" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP_TD, "CMmCustomMessHandler::NetNeighbourCellsResp - No ECID data found" );
 ret = KErrNotFound;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::NetNeighbourCellsResp - NET Server Error, Success Code: %d", successCode);
-OstTraceExt1( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP, "CMmCustomMessHandler::NetNeighbourCellsResp;NET Server Error, Success Code=%hhu", successCode );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_NETNEIGHBOURCELLSRESP_TD, "CMmCustomMessHandler::NetNeighbourCellsResp;NET Server Error, Success Code=%hhu", successCode );
 // Map cause to symbian error value.
 ret = CMmStaticUtility::CSCauseToEpocError(
 PN_MODEM_NETWORK,
 KTsyNetCauseCommon,
 {
 iECIDInfoRequested = EFalse;
 // Complete with packed parameter.
 CMmDataPackage dataPackage;
-dataPackage.PackData( &tempECIDInfo.iCellInfo );
+dataPackage.PackData( &iECIDInfo.iCellInfo );
 iMessageRouter->Complete(
 ECustomGetCellInfoIPC,
 &dataPackage,
 ret );
 }
 // No else.
 // If info received, save and complete change notification.
-if ( KErrNone == ret )
+if ( KErrNone == ret && triggerNotify )
 {
-if ( iECIDInfo.iCellInfo.iMode != tempECIDInfo.iCellInfo.iMode ||
+// Complete with packed parameter.
-iECIDInfo.iMCC != tempECIDInfo.iMCC ||
+CMmDataPackage dataPackage;
-iECIDInfo.iMNC != tempECIDInfo.iMNC ||
+dataPackage.PackData( &iECIDInfo.iCellInfo );
-iECIDInfo.iCID != tempECIDInfo.iCID ||
-iECIDInfo.iLAC != tempECIDInfo.iLAC )
+iMessageRouter->Complete(
-{
+ECustomNotifyCellInfoChangeIPC,
-// Complete with packed parameter.
+&dataPackage,
-CMmDataPackage dataPackage;
+KErrNone );
-dataPackage.PackData( &tempECIDInfo.iCellInfo );
-iMessageRouter->Complete(
-ECustomNotifyCellInfoChangeIPC,
-&dataPackage,
-KErrNone );
-}
-// No else.
-// Save ECID information.
-iECIDInfo = tempECIDInfo;
 }
 // No else.
 }
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::CheckECIDInfo(
 const TIsiReceiveC& aIsiMessage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CheckECIDInfo");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_CHECKECIDINFO, "CMmCustomMessHandler::CheckECIDInfo" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_CHECKECIDINFO_TD, "CMmCustomMessHandler::CheckECIDInfo" );
 TUint8 msgId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 if ( NET_MODEM_REG_STATUS_IND == msgId ||
 NET_MODEM_REG_STATUS_GET_RESP == msgId )
 {
 // Check if cell information needs to be updated.
 TBool isNetRetStatusInd( NET_MODEM_REG_STATUS_IND == msgId );
 TFLOGSTRING("TSY:CMmCustomMessHandler::CheckECIDInfo - Find NET_MODEM_CURRENT_CELL_INFO SubBlock");
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_CHECKECIDINFO, "CMmCustomMessHandler::CheckECIDInfo - Find NET_MODEM_CURRENT_CELL_INFO SubBlock" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_CHECKECIDINFO_TD, "CMmCustomMessHandler::CheckECIDInfo - Find NET_MODEM_CURRENT_CELL_INFO SubBlock" );
 // Get NET_MODEM_CURRENT_CELL_INFO sub block
 // (should be always used when exists (coming when in 3G/RRC
 // connected mode), otherwise NET_MODEM_GSM_REG_INFO is used).
 TUint sbStartOffSet( 0 );
 // Get NET_MODEM_GSM_REG_INFO sub block.
 if ( KErrNone != retValue )
 {
 TFLOGSTRING("TSY:CMmCustomMessHandler::CheckECIDInfo - Find NET_MODEM_GSM_REG_INFO SubBlock");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_CHECKECIDINFO, "CMmCustomMessHandler::CheckECIDInfo - Find NET_MODEM_GSM_REG_INFO SubBlock" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_CHECKECIDINFO_TD, "CMmCustomMessHandler::CheckECIDInfo - Find NET_MODEM_GSM_REG_INFO SubBlock" );
 sbStartOffSet = 0;
 if ( isNetRetStatusInd )
 {
 // If subblock found.
 if ( KErrNone == retValue )
 {
 TFLOGSTRING("TSY:CMmCustomMessHandler::CheckECIDInfo - SubBlock Found");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_CHECKECIDINFO, "CMmCustomMessHandler::CheckECIDInfo, SubBlock Found" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_CHECKECIDINFO_TD, "CMmCustomMessHandler::CheckECIDInfo, SubBlock Found" );
 TUint tempMCC( 0 ); // Mobile Country Code.
 TUint tempMNC( 0 ); // Mobile Network Code.
 TUint tempCID( 0 ); // Cell identity.
 TUint tempLAC( 0 ); // Location area code.
 (
 const TIsiReceiveC& aIsiMessage, TInt aError
 )
 {
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::HandleError - Error: %d", aError );
-OstTrace1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_HANDLEERROR, "CMmCustomMessHandler::HandleError;aError=%d", aError );
+OstTrace1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_HANDLEERROR_TD, "CMmCustomMessHandler::HandleError;aError=%d", aError );
 TInt resource( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_RESOURCEID ) );
 TInt messageId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) );
 TUint8 transId( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_TRANSID ) );
 TUint8 serviceType( aIsiMessage.Get8bit( ISI_HEADER_OFFSET_SUBMESSAGEID ) );
 switch( resource )
 {
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::HandleError, switch resource - default.\n" );
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_HANDLEERROR, "CMmCustomMessHandler::HandleError, switch resource - default" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_HANDLEERROR_TD, "CMmCustomMessHandler::HandleError, switch resource - default" );
 // Nothing to do here.
 break;
 }
 } // end switch ( resource )
 }
 TInt CMmCustomMessHandler::GssCsServiceSetBandReq( TUint8 aTransId, // transaction Id
 RMmCustomAPI::TNetworkModeCaps aNetworkModeCaps, // network mode caps
 RMmCustomAPI::TBandSelection aBandSelection ) // band selection
 {
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::GssCsServiceSetBandReq - aTransId: %d", aTransId );
-OstTraceExt1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GSSCSSERVICESETBANDREQ, "CMmCustomMessHandler::GssCsServiceSetBandReq;aTransId=%hhu", aTransId );
+OstTraceExt1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_GSSCSSERVICESETBANDREQ_TD, "CMmCustomMessHandler::GssCsServiceSetBandReq;aTransId=%hhu", aTransId );
 if ( RMmCustomAPI::KCapsNetworkModeUmts == aNetworkModeCaps ||
 RMmCustomAPI::KCapsNetworkModeDual == aNetworkModeCaps )
 {
 TFLOGSTRING3( "TSY: CMmCustomMessHandler::GssCsServiceSetBandReq - NWModeCaps: %d - Band: %d",
 aNetworkModeCaps, aBandSelection );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICESETBANDREQ, "CMmCustomMessHandler::GssCsServiceSetBandReq; - NWModeCaps=%d - Band=%d", aNetworkModeCaps, aBandSelection );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICESETBANDREQ_TD, "CMmCustomMessHandler::GssCsServiceSetBandReq; - NWModeCaps=%d - Band=%d", aNetworkModeCaps, aBandSelection );
 // create message data buffer
 TBuf8< 20 > messageData;
 messageData.Append( GSS_SELECTED_BANDS_WRITE ); // append service type
 messageData.Append( 1 ); // number of subblocks
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::GssCsServiceGetBandReq( TUint8 aTransId ) //transaction Id
 {
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::GssCsServiceGetBandReq - aTransId: %d", aTransId );
-OstTraceExt1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GSSCSSERVICEGETBANDREQ, "CMmCustomMessHandler::GssCsServiceGetBandReq;aTransId=%hhu", aTransId );
+OstTraceExt1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_GSSCSSERVICEGETBANDREQ_TD, "CMmCustomMessHandler::GssCsServiceGetBandReq;aTransId=%hhu", aTransId );
 // create message data buffer
 TBuf8< 4 > messageData;
 messageData.Append( GSS_SELECTED_BANDS_READ ); // append service type
 messageData.Append( 0 ); // No subblocks
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::CompleteGetBandSelection( const TIsiReceiveC& aIsiMessage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection" );
 RMmCustomAPI::TNetworkModeCaps nwModeCaps; // network mode caps
 RMmCustomAPI::TBandSelection bandSelection; // band selection
 bandSelection = RMmCustomAPI::ENetworkBandAny; // set "any" as a default
 GSS_CS_SERVICE_RESP_OFFSET_NBROFSUBBLOCKS + 1 );
 TUint8 firstSubblock ( aIsiMessage.Get8bit( sbOffset ) );
 TFLOGSTRING2("TSY: CMmCustomMessHandler::CompleteGetBandSelection - ECustomGetBandSelectionIPC. NrOfSubblocks:%d", nrOfSubblocks);
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection;nrOfSubblocks=%hhu", nrOfSubblocks );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection;nrOfSubblocks=%hhu", nrOfSubblocks );
 // In 2G only products only sub block GSS_SELECTED_GSM_BANDS_INFO is returned.
 if ( 1 == nrOfSubblocks && firstSubblock == GSS_SELECTED_GSM_BAND_INFO )
 {
 nwModeCaps = RMmCustomAPI::KCapsNetworkModeGsm;
 // first SB is GSS_SELECTED_GSM_BAND_INFO
 if ( GSS_SELECTED_GSM_BAND_INFO == firstSubblock )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - 1st SB = GSM BAND INFO");
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - 1st SB = GSM BAND INFO" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - 1st SB = GSM BAND INFO" );
 // calculate offsets
 gsmBandInfoOffset = sbOffset +
 GSS_SELECTED_GSM_BAND_INFO_OFFSET_SELECTEDGSMBANDS;
 }
 }
 else if ( GSS_SELECTED_UMTS_BAND_INFO == firstSubblock )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - 1st SB = UMTS BAND INFO");
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - 1st SB = UMTS BAND INFO" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - 1st SB = UMTS BAND INFO" );
 // calculate offsets
 umtsBandInfoOffset = sbOffset +
 GSS_SELECTED_UMTS_BAND_INFO_OFFSET_SELECTEDUMTSBANDS;
 //If phone is forced to GSM, value in GSS_SELECTED_UMTS_BAND_INFO shall be GSS_UMTS_NO_BANDS
 if ( GSS_UMTS_NO_BANDS == aIsiMessage.Get32bit( umtsBandInfoOffset ) ) // forced GSM
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - umtsBandInfo==GSS_UMTS_NO_BANDS => Forced GSM");
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - umtsBandInfo==GSS_UMTS_NO_BANDS => Forced GSM" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - umtsBandInfo==GSS_UMTS_NO_BANDS => Forced GSM" );
 nwModeCaps = RMmCustomAPI::KCapsNetworkModeGsm;
 }
 else
 {
 //If phone is forced to GSM, value in GSS_SELECTED_UMTS_BAND_INFO shall be GSS_UMTS_NO_BANDS.
 if ( 0 < gsmBandInfoOffset && GSS_GSM_NO_BANDS == aIsiMessage.Get8bit( gsmBandInfoOffset ) ) // forced UMTS
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - gsmBandInfo==GSS_GSM_NO_BANDS => Forced UMTS");
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - gsmBandInfo==GSS_GSM_NO_BANDS => Forced UMTS" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - gsmBandInfo==GSS_GSM_NO_BANDS => Forced UMTS" );
 nwModeCaps = RMmCustomAPI::KCapsNetworkModeUmts;
 }
 else // dual mode
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - Dual mode");
-OstTrace0( TRACE_NORMAL, DUP6_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - Dual mode" );
+OstTrace0( TRACE_NORMAL,  DUP6_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - Dual mode" );
 nwModeCaps = RMmCustomAPI::KCapsNetworkModeDual;
 }
 // Set network band
 if ( GSS_UMTS_BAND_V_MASK == aIsiMessage.Get32bit( umtsBandInfoOffset ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - UMTS850");
-OstTrace0( TRACE_NORMAL, DUP7_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - UMTS850" );
+OstTrace0( TRACE_NORMAL,  DUP7_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - UMTS850" );
 bandSelection = RMmCustomAPI::ENetworkBandUmts850;
 }
 else if( GSS_UMTS_BAND_I_MASK == aIsiMessage.Get32bit( umtsBandInfoOffset ) )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::CompleteGetBandSelection - UMTS2100");
-OstTrace0( TRACE_NORMAL, DUP8_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION, "CMmCustomMessHandler::CompleteGetBandSelection - UMTS2100" );
+OstTrace0( TRACE_NORMAL,  DUP8_CMMCUSTOMMESSHANDLER_COMPLETEGETBANDSELECTION_TD, "CMmCustomMessHandler::CompleteGetBandSelection - UMTS2100" );
 bandSelection = RMmCustomAPI::ENetworkBandUmts2100;
 }
 }
 }
 (
 const TUint8 //aTransId
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ReadLifeTimerFromPermanentMemory.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_READLIFETIMERFROMPERMANENTMEMORY, "CMmCustomMessHandler::ReadLifeTimerFromPermanentMemory" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_READLIFETIMERFROMPERMANENTMEMORY_TD, "CMmCustomMessHandler::ReadLifeTimerFromPermanentMemory" );
 // Group ID 2 + Index 2 + Filler 2 + Offset 4 + Data amount to be read 4 = 14
 TBuf8<14> data;
 // Append Group ID
 data.Append( static_cast<TUint8>( KCallLifeTimerDataAmount >> 24 ) );
 data.Append( static_cast<TUint8>( KCallLifeTimerDataAmount >> 16 ) );
 data.Append( static_cast<TUint8>( KCallLifeTimerDataAmount >> 8 ) );
 data.Append( static_cast<TUint8>( KCallLifeTimerDataAmount ) );
-/* To be done in CPS
+/*
 return iPhoNetSender->Send( PN_PERMANENT_DATA,
 aTransId,
 PERM_PM_RECORD_READ_REQ,
 data );*/
 return KErrNone;
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse
 // Breaks  PERM_PM_RECORD_READ_RESP message.
 // -----------------------------------------------------------------------------
 //
-/* To be done in CPS
+/*
 void CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse
 (
 const TIsiReceiveC& aIsiMessage    // an ISI message
 )
 {
 TFLOGSTRING("TSY: CCMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE_TD, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse" );
 TInt ret( KErrNone );
 TUint8 pmmStatus = aIsiMessage.Get8bit(
 ISI_HEADER_SIZE +
 if ( KCallLifeTimerDataAmount == dataSize )
 {
 iCallLifeTimer = aIsiMessage.Get32bit( sbStartOffSet +
 PERM_SB_PM_DATA_OFFSET_DATA );
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - iCallLifeTimer: %d", iCallLifeTimer );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse;iCallLifeTimer=%d", iCallLifeTimer );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE_TD, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse;iCallLifeTimer=%d", iCallLifeTimer );
 }
 else
 {
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - Incorrect data size: %d", dataSize );
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - Incorrect data size=%u", dataSize );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE_TD, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - Incorrect data size=%u", dataSize );
 TF_ASSERT( KCallLifeTimerDataAmount != dataSize );
 ret = KErrGeneral;
 }
 }
 }
 {
 if ( PMM_NOT_READY == pmmStatus )
 {
 // Send request again max 3 times
 TFLOGSTRING("TSY: CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - PMM not ready. Send request again\n" );
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - PMM not ready. Send request again" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE_TD, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - PMM not ready. Send request again" );
 iPMMReadRetryCounter++;
 if ( KMaxPMMReadRequests > iPMMReadRetryCounter )
 {
 ReadLifeTimerFromPermanentMemory ( KCustomTransId );
 }
 }
 else if ( PMM_RECORD_NOT_FOUND == pmmStatus )
 {
 // The first boot of the phone.
 TFLOGSTRING("TSY: CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - The first boot. Set iCallLifeTimer 0\n" );
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - The first boot. Set iCallLifeTimer 0" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE_TD, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - The first boot. Set iCallLifeTimer 0" );
 iCallLifeTimer = 0;
 }
 else
 {
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - PMM Status NOT OK: %d", pmmStatus );
-OstTraceExt1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - PMM Status NOT OK=%hhu", pmmStatus );
+OstTraceExt1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_LIFETIMERFROMPERMANENTMEMORYREADRESPONSE_TD, "CMmCustomMessHandler::LifeTimerFromPermanentMemoryReadResponse - PMM Status NOT OK=%hhu", pmmStatus );
 }
 }
 }*/
 // -----------------------------------------------------------------------------
 const TUint8 /*aTransId*/,
 TTimeIntervalSeconds aTime
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::WriteLifeTimerToPermanentMemory.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_WRITELIFETIMERTOPERMANENTMEMORY, "CMmCustomMessHandler::WriteLifeTimerToPermanentMemory" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_WRITELIFETIMERTOPERMANENTMEMORY_TD, "CMmCustomMessHandler::WriteLifeTimerToPermanentMemory" );
 // Group ID 2 + Index 2 + Filler 2 + Offset 4 + Data amount to be read 4 = 14
 TBuf8<14> data;
 // Append Group ID
 if ( KCallLifeTimerNotSet == iCallLifeTimer )
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::WriteLifeTimerToPermanentMemory - Call Life Timer is not set from PMM ret KErrNotReady\n" );
 TFLOGSTRING("TSY: CMmCustomMessHandler::WriteLifeTimerToPermanentMemory - PERM_PM_RECORD_WRITE_REQ is NOT send\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_WRITELIFETIMERTOPERMANENTMEMORY, "CMmCustomMessHandler::WriteLifeTimerToPermanentMemory - Call Life Timer is not set from PMM ret KErrNotReady" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_WRITELIFETIMERTOPERMANENTMEMORY_TD, "CMmCustomMessHandler::WriteLifeTimerToPermanentMemory - Call Life Timer is not set from PMM ret KErrNotReady" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_WRITELIFETIMERTOPERMANENTMEMORY, "CMmCustomMessHandler::WriteLifeTimerToPermanentMemory - PERM_PM_RECORD_WRITE_REQ is NOT send" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_WRITELIFETIMERTOPERMANENTMEMORY_TD, "CMmCustomMessHandler::WriteLifeTimerToPermanentMemory - PERM_PM_RECORD_WRITE_REQ is NOT send" );
 // Return request with KErrNotReady
 return ( KErrNotReady );
 }
 else
 data.Append( static_cast<TUint8>( iCallLifeTimer >> 24 ) );
 data.Append( static_cast<TUint8>( iCallLifeTimer >> 16 ) );
 data.Append( static_cast<TUint8>( iCallLifeTimer >> 8 ) );
 data.Append( static_cast<TUint8>( iCallLifeTimer ) );
-/* To be done in CPS
+/*
 return iPhoNetSender->Send( PN_PERMANENT_DATA,
 aTransId,
 PERM_PM_RECORD_WRITE_REQ,
 data );*/
 return KErrNone;
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse
 // Breaks  PERM_PM_RECORD_WRITE_RESP message.
 // -----------------------------------------------------------------------------
 //
-/* To be done in CPS
+/*
 void CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse
 (
 const TIsiReceiveC& aIsiMessage    // an ISI message
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_LIFETIMERTOPERMANENTMEMORYWRITERESPONSE, "CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_LIFETIMERTOPERMANENTMEMORYWRITERESPONSE_TD, "CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse" );
 TInt ret( KErrNone );
 TUint8 pmmStatus = aIsiMessage.Get8bit(
 ISI_HEADER_SIZE +
 PERM_PM_RECORD_WRITE_RESP_OFFSET_PMMSTATUS );
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse - pmmStatus: %d", pmmStatus );
-OstTraceExt1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_LIFETIMERTOPERMANENTMEMORYWRITERESPONSE, "CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse;pmmStatus=%hhu", pmmStatus );
+OstTraceExt1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_LIFETIMERTOPERMANENTMEMORYWRITERESPONSE_TD, "CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse;pmmStatus=%hhu", pmmStatus );
 if ( PMM_OK != pmmStatus )
 {
 ret = KErrNotReady;
 TF_ASSERT( PMM_OK != pmmStatus );
 TFLOGSTRING2( "TSY: CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse - Call Life Timer is not updated / error from PMM ret: %d", ret );
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_LIFETIMERTOPERMANENTMEMORYWRITERESPONSE, "CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse - Call Life Timer is not updated / error from PMM ret=%d", ret );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_LIFETIMERTOPERMANENTMEMORYWRITERESPONSE_TD, "CMmCustomMessHandler::LifeTimerToPermanentMemoryWriteResponse - Call Life Timer is not updated / error from PMM ret=%d", ret );
 }
 return iMessageRouter->Complete( EMmTsyUpdateLifeTimeIPC, ret );
 }*/
 TInt CMmCustomMessHandler::GetTotalLifeTimerValue
 (
 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::GetTotalLifeTimerValue.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE, "CMmCustomMessHandler::GetTotalLifeTimerValue" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE_TD, "CMmCustomMessHandler::GetTotalLifeTimerValue" );
 TInt ret( KErrNone );
 RMmCustomAPI::TLifeTimeData timeInfo;
 timeInfo.iHours = 0;
 if ( KCallLifeTimerNotSet == iCallLifeTimer )
 {
 ret = KErrNotReady;
 TFLOGSTRING( "TSY: CMmCustomMessHandler::GetTotalLifeTimerValue - PMM has not been able to be read ret: KErrNotReady\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE, "CMmCustomMessHandler::GetTotalLifeTimerValue - PMM has not been able to be read ret: KErrNotReady" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE_TD, "CMmCustomMessHandler::GetTotalLifeTimerValue - PMM has not been able to be read ret: KErrNotReady" );
 }
 else
 {
 //set the data into timeInfo class, one hour is 3600 seconds.
 timeInfo.iHours = iCallLifeTimer / KSecsInHour ;
 timeInfo.iCaps |=
 RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsLifeTime;
 TFLOGSTRING2( "TSY: TSY: CMmCustomMessHandler::GetTotalLifeTimerValue - iCallLifeTimer: %d", iCallLifeTimer );
 TFLOGSTRING2( "TSY: TSY: CMmCustomMessHandler::GetTotalLifeTimerValue - timeInfo.iHours: %d", timeInfo.iHours );
 TFLOGSTRING2( "TSY: TSY: CMmCustomMessHandler::GetTotalLifeTimerValue - timeInfo.iMinutes: %d", timeInfo.iMinutes );
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE, "CMmCustomMessHandler::GetTotalLifeTimerValue;iCallLifeTimer=%d", iCallLifeTimer );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE_TD, "CMmCustomMessHandler::GetTotalLifeTimerValue;iCallLifeTimer=%d", iCallLifeTimer );
-OstTrace1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE, "CMmCustomMessHandler::GetTotalLifeTimerValue;timeInfo.iHours=%u", timeInfo.iHours );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE_TD, "CMmCustomMessHandler::GetTotalLifeTimerValue;timeInfo.iHours=%u", timeInfo.iHours );
-OstTraceExt1( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE, "CMmCustomMessHandler::GetTotalLifeTimerValue;timeInfo.iMinutes=%hhu", timeInfo.iMinutes );
+OstTraceExt1( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_GETTOTALLIFETIMERVALUE_TD, "CMmCustomMessHandler::GetTotalLifeTimerValue;timeInfo.iMinutes=%hhu", timeInfo.iMinutes );
 }
 CMmDataPackage dataPackage;
 dataPackage.PackData( &timeInfo );
 iMessageRouter->Complete( ECustomGetLifeTimeIPC, &dataPackage, ret );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccSimPowerOffReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimPowerOffReq.\n");
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMPOWEROFFREQ, "CMmCustomMessHandler::UiccSimPowerOffReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMPOWEROFFREQ_TD, "CMmCustomMessHandler::UiccSimPowerOffReq" );
 iSapApduIfState = EUiccSapIfStatus1;
 // Set parameters for UICC_CONNECTION_REQ message
 TUiccParamsBase params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccSimPowerOffResp( TInt aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimPowerOffResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMPOWEROFFRESP, "CMmCustomMessHandler::UiccSimPowerOffResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMPOWEROFFRESP_TD, "CMmCustomMessHandler::UiccSimPowerOffResp" );
 TInt err ( KErrNone );
 if( aStatus == UICC_STATUS_OK )
 {
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccSimWarmResetReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimWarmResetReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMWARMRESETREQ, "CMmCustomMessHandler::UiccSimWarmResetReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMWARMRESETREQ_TD, "CMmCustomMessHandler::UiccSimWarmResetReq" );
 TUiccParamsApduReq params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdSimWarmReset;
 params.serviceType = UICC_APDU_CONTROL;
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccSimWarmResetResp( TInt aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimWarmResetResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMWARMRESETRESP, "CMmCustomMessHandler::UiccSimWarmResetResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMWARMRESETRESP_TD, "CMmCustomMessHandler::UiccSimWarmResetResp" );
 TInt err ( KErrNone );
 if( aStatus != UICC_STATUS_OK )
 {
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccSimGetAtrReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimGetAtrReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMGETATRREQ, "CMmCustomMessHandler::UiccSimGetAtrReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMGETATRREQ_TD, "CMmCustomMessHandler::UiccSimGetAtrReq" );
 TUiccParamsApduReq params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdSimGetATR;
 params.serviceType = UICC_APDU_ATR_GET;
 void CMmCustomMessHandler::UiccSimGetAtrResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimGetAtrResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMGETATRRESP, "CMmCustomMessHandler::UiccSimGetAtrResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMGETATRRESP_TD, "CMmCustomMessHandler::UiccSimGetAtrResp" );
 TInt err( KErrNone );
 const TDesC8* dataPtr = &aFileData;
 CMmDataPackage dataPackage;
 dataPackage.PackData( &dataPtr );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccSimPowerOnReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimPowerOnReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMPOWERONREQ, "CMmCustomMessHandler::UiccSimPowerOnReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMPOWERONREQ_TD, "CMmCustomMessHandler::UiccSimPowerOnReq" );
 //Set APDU interface state
 iSapApduIfState = EUiccSapIfStatus1;
 // Set parameters for UICC_CONNECTION_REQ message
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccSimPowerOnResp( TInt aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimPowerOnResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMPOWERONRESP, "CMmCustomMessHandler::UiccSimPowerOnResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMPOWERONRESP_TD, "CMmCustomMessHandler::UiccSimPowerOnResp" );
 TInt err( KErrNone );
 if( aStatus == UICC_STATUS_OK )
 {
 TInt CMmCustomMessHandler::UiccSendAPDUReq(
 const RMmCustomAPI::TApduParameters& aApduParameters,
 TInt aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSimSendAPDUReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMSENAPDUREQ, "CMmCustomMessHandler::UiccSendAPDUReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMSENAPDUREQ_TD, "CMmCustomMessHandler::UiccSendAPDUReq" );
 TUiccParamsApduReq params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ( TUiccTrId )aTraId;
 params.serviceType = UICC_APDU_SEND;
 TInt aStatus,
 const TDesC8& aFileData,
 TInt aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSendAPDUResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSIMSENAPDURESP, "CMmCustomMessHandler::UiccSendAPDUResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSIMSENAPDURESP_TD, "CMmCustomMessHandler::UiccSendAPDUResp" );
 TInt err( KErrNone );
 const TDesC8* dataPtr = &aFileData;
 CMmDataPackage dataPackage;
 dataPackage.PackData( &dataPtr );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccCardReaderStatusReq()
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCardReaderStatusReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCARDREADERSTATUSREQ, "CMmCustomMessHandler::UiccCardReaderStatusReq" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCARDREADERSTATUSREQ_TD, "CMmCustomMessHandler::UiccCardReaderStatusReq" );
 TUiccParamsApduReq params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.trId = ETrIdCardReaderStatus;
 params.serviceType = UICC_CARD_STATUS_GET;
 void CMmCustomMessHandler::UiccCardReaderStatusResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCardReaderStatusResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCARDREADERSTATUSRESP, "CMmCustomMessHandler::UiccCardReaderStatusResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCARDREADERSTATUSRESP_TD, "CMmCustomMessHandler::UiccCardReaderStatusResp" );
 TInt err ( KErrNone );
 CMmDataPackage dataPackage;
 TUint8 cardStatus( 0 );
 TBuf8<1> statusByte;
 // Get service type
 TUint8 serviceType( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + UICC_IND_OFFSET_SERVICETYPE ) );
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccCardInd, service type: %d", serviceType );
-OstTraceExt1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCIND, "CMmCustomMessHandler::UiccCardInd;serviceType=%hhu", serviceType );
+OstTraceExt1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCIND_TD, "CMmCustomMessHandler::UiccCardInd;serviceType=%hhu", serviceType );
 RMmCustomAPI::TSIMCardStatus returnStatus;
 returnStatus = RMmCustomAPI::SimCardUnknowError;
 switch ( serviceType )
 //
 TInt CMmCustomMessHandler::UiccSendAuthenticateApdu(
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu" );
 TInt ret( KErrNone );
 TBool apduSendNeeded( EFalse );
 // Let's construct AUTHENTICATE APDU based on authenticate type
 }
 else
 {
 // GBA not supported if card type is ICC or GBA not supported in EFust
 TFLOGSTRING3("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)\n", cardType, serviceStatus );
-OstTraceExt2( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: %x, ss: 0x%x)", cardType, serviceStatus );
+OstTraceExt2( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: %x, ss: 0x%x)", cardType, serviceStatus );
 ret = KErrGeneral;
 }
 break;
 }
 case RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapUpdate:
 }
 else
 {
 // GBA not supported if card type is ICC or GBA not supported in EFust
 TFLOGSTRING3("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)\n", cardType, serviceStatus );
-OstTraceExt2( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
+OstTraceExt2( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
 ret = KErrGeneral;
 }
 break;
 }
 case RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapNafDerivation:
 }
 else
 {
 // GBA not supported if card type is ICC or GBA not supported in EFust
 TFLOGSTRING3("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)\n", cardType, serviceStatus );
-OstTraceExt2( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
+OstTraceExt2( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: GBA not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
 ret = KErrGeneral;
 }
 break;
 }
 case RMmCustomAPI::TSimAuthenticationBase::EMgvMskUpdate:
 }
 else
 {
 // MBMS not supported if card type is ICC or MBMS not supported in EFust
 TFLOGSTRING3("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)\n", cardType, serviceStatus );
-OstTraceExt2( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
+OstTraceExt2( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
 ret = KErrGeneral;
 }
 break;
 }
 case RMmCustomAPI::TSimAuthenticationBase::EMgvMtkGeneration:
 }
 else
 {
 // MBMS not supported if card type is ICC or MBMS not supported in EFust
 TFLOGSTRING3("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)\n", cardType, serviceStatus );
-OstTraceExt2( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
+OstTraceExt2( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
 ret = KErrGeneral;
 }
 break;
 }
 case RMmCustomAPI::TSimAuthenticationBase::EMgvMskDeletion:
 }
 else
 {
 // MBMS not supported if card type is ICC or MBMS not supported in EFust
 TFLOGSTRING3("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)\n", cardType, serviceStatus );
-OstTraceExt2( TRACE_NORMAL, DUP6_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
+OstTraceExt2( TRACE_NORMAL,  DUP6_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: MBMS security not supported (card type: 0x%x, ss: 0x%x)", cardType, serviceStatus );
 ret = KErrGeneral;
 }
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: Unknown APDU\n" );
-OstTrace0( TRACE_NORMAL, DUP7_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu: Unknown APDU" );
+OstTrace0( TRACE_NORMAL,  DUP7_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApdu: Unknown APDU" );
 break;
 }
 }
 if( EFalse != apduSendNeeded )
 ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: APDU not sent\n" );
-OstTrace0( TRACE_NORMAL, DUP8_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApduu: APDU not sent" );
+OstTrace0( TRACE_NORMAL,  DUP8_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::UiccSendAuthenticateApduu: APDU not sent" );
 }
 return ret;
 }
 TUiccSendApdu& aParams,
 const TDesC8& aRand,
 TUiccTrId aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATERUNGSMALGORITHMAPDU, "CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATERUNGSMALGORITHMAPDU_TD, "CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu" );
 aParams.trId = aTraId;
 aParams.apdu.Append( KClaIcc );              // CLA
 aParams.apdu.Append( KEvenInstructionCode ); // INS
 aParams.apdu.Append( 0 ); // P1 is set to 0 in case of RUN GSM ALGORITH
 TInt aTraId,
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP_TD, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp" );
 TInt ret( KErrNone );
 TInt ipc( ETrIdRunGsmAlgorithmIms == aTraId ? EMobilePhoneIMSAuthenticate : ECustomGetSimAuthenticationDataIPC );
 RMmCustomAPI::TSimAuthenticationEapSim eapSim;
 RMmCustomAPI::TSimAuthenticationEapAka eapAka;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. APDU validation fails\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. APDU validation fails" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP_TD, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. APDU validation fails" );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else if( KCmdNotAllowedSecurityStatusNotSatisfied == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: Security conditions not satisfied\n" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: Security conditions not satisfied" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP_TD, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: Security conditions not satisfied" );
 ret = CMmStaticUtility::EpocErrorCode(
 KErrAccessDenied,
 KErrGsm0707SimPin1Required );
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. unknown result: 0x%X\n", result );
-OstTrace1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. unknown result: 0x%x", result );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP_TD, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. unknown result: 0x%x", result );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP_TD, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone != ret )
 {
 void CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEGSMSECURITYCONTEXTAPDU, "CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEGSMSECURITYCONTEXTAPDU_TD, "CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu" );
 RMmCustomAPI::TSimAuthenticationEapSim eapSim;
 aDataPackage.UnPackData( eapSim );
 params.trId = ETrIdEEapSimAuthenticate;
 TInt aTraId,
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGsmSecurityContextApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp" );
 TInt ret( KErrNone );
 RMmCustomAPI::TSimAuthenticationEapSim eapSim;
 if( UICC_STATUS_OK == aStatus )
 eapSim.iKC.Copy( aFileData.Mid( index , len ) );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGsmSecurityContextApduResp: APDU validation failed\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp: APDU validation failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp: APDU validation failed" );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGsmSecurityContextApduResp: unknown result\n" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp: unknown result" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp: unknown result" );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccGsmSecurityContextApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_UICCGSMSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::UiccGsmSecurityContextApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone != ret )
 {
 const TDesC8& aRand,
 const TDesC8& aAuth,
 TUiccTrId aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreate3GSecurityContextApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATE3GSECURITYCONTEXTAPDU, "CMmCustomMessHandler::UiccCreate3GSecurityContextApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATE3GSECURITYCONTEXTAPDU_TD, "CMmCustomMessHandler::UiccCreate3GSecurityContextApdu" );
 // len of data is sizeof RAND + sizeof AUTN + two length fields
 // (one for RAND len and one for AUTN len)
 TUint8 lc( aRand.Size() + aAuth.Size() + 2 );
 TInt aTraId,
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp" );
 TInt ret( KErrNone );
 TInt ipc( ETrIdEEapAkaAuthenticateIms == aTraId ? EMobilePhoneIMSAuthenticate : ECustomGetSimAuthenticationDataIPC );
 RMmCustomAPI::TSimAuthenticationEapAka eapAka;
 RMobilePhone::TImsAuthenticateDataV5 ims;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: APDU validation failed\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: APDU validation failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: APDU validation failed" );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else if( KAppAuthErrorIncorrectMac == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: incorrect MAC\n" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: incorrect MAC" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: incorrect MAC" );
 // no parameters in this case
 ret = KErrMMEtelMacVerificationFailed;
 }
 else if( KCmdNotAllowedSecurityStatusNotSatisfied == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: Security conditions not satisfied\n" );
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: Security conditions not satisfied" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: Security conditions not satisfied" );
 ret = CMmStaticUtility::EpocErrorCode(
 KErrAccessDenied,
 KErrGsm0707SimPin1Required );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: unknown result\n" );
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: unknown result" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: unknown result" );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: UICC status not ok: 0x%x", aStatus );
 ret = ETrIdEEapAkaAuthenticateIms == aTraId ? KErrGeneral : KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone == ret ||
 KErrMMEtelSqnVerificationFailed == ret ||
 void CMmCustomMessHandler::UiccCreateGBABootstrappingApdu(
 TUiccSendApdu& aParams,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateGBABootstrappingApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEGBABOOTSTRAPPINGAPDU, "CMmCustomMessHandler::UiccCreateGBABootstrappingApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEGBABOOTSTRAPPINGAPDU_TD, "CMmCustomMessHandler::UiccCreateGBABootstrappingApdu" );
 RMmCustomAPI::TSimAuthenticationGbaBootstrap gbaBootstrap;
 aDataPackage.UnPackData( gbaBootstrap );
 // len of data is GBA bootstrapping mode tag (1 byte) + sizeof RAND
 TInt aTraId,
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrappingApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::UiccGBABootstrappingApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP_TD, "CMmCustomMessHandler::UiccGBABootstrappingApduResp" );
 TInt ret( KErrNone );
 RMmCustomAPI::TSimAuthenticationGbaBootstrap gbaBootstrap;
 if( UICC_STATUS_OK == aStatus )
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrappingApduResp: APDU validation failed\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: APDU validation failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP_TD, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: APDU validation failed" );
 ret = KErrGeneral;
 }
 }
 else if( KAppAuthErrorIncorrectMac == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrappingApduResp: incorrect MAC\n" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: incorrect MAC" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP_TD, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: incorrect MAC" );
 // no parameters in this case
 ret = KErrMMEtelMacVerificationFailed;
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrappingApduResp: unknown result\n" );
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: unknown result" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP_TD, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: unknown result" );
 ret = KErrGeneral;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccGBABootstrappingApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP_TD, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone == ret ||
 KErrMMEtelSqnVerificationFailed == ret ||
 //
 void CMmCustomMessHandler::UiccGBABootstrapUpdate(
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapUpdate.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPUPDATE, "CMmCustomMessHandler::UiccGBABootstrapUpdate" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPUPDATE_TD, "CMmCustomMessHandler::UiccGBABootstrapUpdate" );
 // GBA bootstrap update is done by first reading of elementary file EFgba.
 // After that RAND is stored temporarily and B-Tid and keylifetime is written
 // to EFgba. After write operation, RAND is completed to the client.
 void CMmCustomMessHandler::UiccGBABootstrapReadResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapReadResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPREADRESP, "CMmCustomMessHandler::UiccGBABootstrapReadResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPREADRESP_TD, "CMmCustomMessHandler::UiccGBABootstrapReadResp" );
 iRandBuf.Zero();
 if( UICC_STATUS_OK == aStatus)
 {
 iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapReadResp. File too small for update\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPREADRESP, "CMmCustomMessHandler::UiccGBABootstrapReadResp. File too small for update" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPREADRESP_TD, "CMmCustomMessHandler::UiccGBABootstrapReadResp. File too small for update" );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 KErrArgument );
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccGBABootstrapReadResp. EFgba reading failed (0x%x)\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPREADRESP, "CMmCustomMessHandler::UiccGBABootstrapReadResp. EFgba reading failed (%x)", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPREADRESP_TD, "CMmCustomMessHandler::UiccGBABootstrapReadResp. EFgba reading failed (%x)", aStatus );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 KErrMMEtelAuthenticateFailed );
 }
 }
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccGBABootstrapUpdateResp( TInt aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapUpdateResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPUPDATERESP, "CMmCustomMessHandler::UiccGBABootstrapUpdateResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPUPDATERESP_TD, "CMmCustomMessHandler::UiccGBABootstrapUpdateResp" );
 TInt ret( KErrGeneral );
 RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate gbaBootstrapUpdate;
 if( UICC_STATUS_OK == aStatus )
 void CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu(
 TUiccSendApdu& aParams,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEGBABOOTSTRAPNAFDERIVATIONAPDU, "CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEGBABOOTSTRAPNAFDERIVATIONAPDU_TD, "CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu" );
 RMmCustomAPI::TSimAuthenticationGbaNafDerivation gbaBootstrapNafDerivation;
 aDataPackage.UnPackData( gbaBootstrapNafDerivation );
 // len of data is GBA NAF derivation mode tag (1 byte) + sizeof NAFId
 TInt aTraId,
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapNafDerivationApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP, "CMmCustomMessHandler::UiccGBANafDerivationApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP_TD, "CMmCustomMessHandler::UiccGBANafDerivationApduResp" );
 TInt ret( KErrNone );
 RMmCustomAPI::TSimAuthenticationGbaNafDerivation gbaNafDerivation;
 if( UICC_STATUS_OK == aStatus )
 gbaNafDerivation.iKsExtNaf.Copy( aFileData.Mid( index, len ) );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapNafDerivationApduResp: APDU validation failed\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP, "CMmCustomMessHandler::UiccGBANafDerivationApduResp: APDU validation failed" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP_TD, "CMmCustomMessHandler::UiccGBANafDerivationApduResp: APDU validation failed" );
 ret = KErrGeneral;
 }
 }
 else if( KCmdNotAllowedConditionsNotSatisfied == result )
 {
 ret = KErrNotSupported;
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapNafDerivationApduResp: unknown result\n" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP, "CMmCustomMessHandler::UiccGBANafDerivationApduResp: unknown result" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP_TD, "CMmCustomMessHandler::UiccGBANafDerivationApduResp: unknown result" );
 ret = KErrGeneral;
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccGBABootstrapNafDerivationApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP, "CMmCustomMessHandler::UiccGBANafDerivationApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_UICCGBANAFDERIVATIONAPDURESP_TD, "CMmCustomMessHandler::UiccGBANafDerivationApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone == ret )
 {
 void CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMSKUPDATEAPDU, "CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMSKUPDATEAPDU_TD, "CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu" );
 // Note. MBMS functionality is not tested in real hardware and in real environmen
 //  because of there is no users for this authentication type. So this is implemented
 // with the best knowledge at the moment and it can contain some bugs which
 // can be found when this is tested in real environment.
 void CMmCustomMessHandler::UiccMbmsMskUpdateApduResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMbmsMskUpdateApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMBMSMSKUPDATEAPDURESP, "CMmCustomMessHandler::UiccMbmsMskUpdateApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMBMSMSKUPDATEAPDURESP_TD, "CMmCustomMessHandler::UiccMbmsMskUpdateApduResp" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccMbmsMskUpdateApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCMBMSMSKUPDATEAPDURESP, "CMmCustomMessHandler::UiccMbmsMskUpdateApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCMBMSMSKUPDATEAPDURESP_TD, "CMmCustomMessHandler::UiccMbmsMskUpdateApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( completeNeeded )
 {
 void CMmCustomMessHandler::UiccMskUpdateHandleMbmsOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMskUpdate& aMskUpdate,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMskUpdateHandleMbmsOperationData.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMSKUPDATEHANDLEMBMSOPERATIONDATA, "CMmCustomMessHandler::UiccMskUpdateHandleMbmsOperationData" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMSKUPDATEHANDLEMBMSOPERATIONDATA_TD, "CMmCustomMessHandler::UiccMskUpdateHandleMbmsOperationData" );
 TUint8 index( 0 );
 TUint32 objLen( aMbmsData.Length() );
 if( KSuccessfullMbmsOperationTag == aMbmsData[index] &&
 void CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMskUpdate& aMskUpdate,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMSKUPDATEHANDLEOMABCASTOPERATIONDATA, "CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMSKUPDATEHANDLEOMABCASTOPERATIONDATA_TD, "CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData" );
 TBuf8<KMaxApduSize> omaBcastData;
 if( FindTlvObject( KOMABcastOperationResponseTag, aMbmsData, omaBcastData ) )
 {
 void CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMTKGENERATIONAPDU, "CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMTKGENERATIONAPDU_TD, "CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 void CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMBMSMTKGENERATIONAPDURESP, "CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMBMSMTKGENERATIONAPDURESP_TD, "CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCMBMSMTKGENERATIONAPDURESP, "CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCMBMSMTKGENERATIONAPDURESP_TD, "CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( completeNeeded )
 {
 void CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMtkGeneration& aMtkGen,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMTKGENHANDLEMBMSOPERATIONDATA, "CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMTKGENHANDLEMBMSOPERATIONDATA_TD, "CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData" );
 TUint8 index( 0 );
 TUint32 objLen( aMbmsData.Length() );
 if( KSuccessfullMbmsOperationTag == aMbmsData[index] &&
 void CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMtkGeneration& aMtkGen,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMTKGENHANDLEOMABCASTOPERATIONDATA, "CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMTKGENHANDLEOMABCASTOPERATIONDATA_TD, "CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData" );
 TBuf8<KMaxApduSize> omaBcastData;
 if( FindTlvObject( KOMABcastOperationResponseTag, aMbmsData, omaBcastData ) )
 {
 void CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMSKDELETIONAPDU, "CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMSKDELETIONAPDU_TD, "CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 void CMmCustomMessHandler::UiccMbmsMskDeletionApduResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMbmsMskDeletionApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMBMSMSKDELETIONAPDURESP, "CMmCustomMessHandler::UiccMbmsMskDeletionApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCMBMSMSKDELETIONAPDURESP_TD, "CMmCustomMessHandler::UiccMbmsMskDeletionApduResp" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 }
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccMbmsMskDeletionApduResp: UICC status not ok: 0x%x\n", aStatus );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICCMBMSMSKDELETIONAPDURESP, "CMmCustomMessHandler::UiccMbmsMskDeletionApduResp: UICC status not ok: 0x%x", aStatus );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_UICCMBMSMSKDELETIONAPDURESP_TD, "CMmCustomMessHandler::UiccMbmsMskDeletionApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( completeNeeded )
 {
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateFirstBlockOfAuthRespApdu( TUiccTrId aTrId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateFirstBlockOfAuthRespApdu.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEFIRSTBLOCKOFAUTHRESPAPDU, "CMmCustomMessHandler::UiccCreateFirstBlockOfAuthRespApdu" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCCREATEFIRSTBLOCKOFAUTHRESPAPDU_TD, "CMmCustomMessHandler::UiccCreateFirstBlockOfAuthRespApdu" );
 // Fill parameters to instance created from TUiccSendApdu
 // needed for APDU sending
 TUiccSendApdu params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult( TUint8 sw1, TUint8 sw2 )
 {
 TFLOGSTRING3("TSY: CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult. sw1: 0x%x sw2: 0x%x\n", sw1, sw2 );
-OstTraceExt2( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_MAPSW1SW2TOAUTHENTICATERESULT, "CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult. sw1: 0x%x sw2: 0x%x", sw1, sw2 );
+OstTraceExt2( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_MAPSW1SW2TOAUTHENTICATERESULT_TD, "CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult. sw1: 0x%x sw2: 0x%x", sw1, sw2 );
 TUint8 ret( KUnknownCommandEnding );
 switch( sw1 )
 {
 break;
 }
 default:
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateReceivedAuthenticateApdu: unknown APDU\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATERECEIVEDAUTHENTICATEAPDU, "CMmCustomMessHandler::ValidateReceivedAuthenticateApdu: unknown APDU" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_VALIDATERECEIVEDAUTHENTICATEAPDU_TD, "CMmCustomMessHandler::ValidateReceivedAuthenticateApdu: unknown APDU" );
 ret = KApduNok;
 break;
 }
 }
 return ret;
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::ValidateGsmSecurityContextApduResp( const TDesC8& aApdu )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateGsmSecurityContextApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATEGSMSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::ValidateGsmSecurityContextApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_VALIDATEGSMSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::ValidateGsmSecurityContextApduResp" );
 TUint8 ret( KApduNok );
 // apdu len is len of aApdu - 2 (because of
 // aApdu contains sw1 and sw2)
 TUint apduLen( aApdu.Length() - 2 );
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::Validate3GSecurityContextApduResp( const TDesC8& aApdu )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp" );
 TUint8 ret( KApduOk );
 // Let's calculate total APDU data len in aApdu. Length is
 // decremented by 2 because of aApdu contains also sw1 and sw2
 {
 // check the len of RES
 if( KMinLenOfRes > aApdu[index] || KMaxLenOfRes < aApdu[index] )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid RES\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid RES" );
+OstTrace0( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid RES" );
 ret = KApduNok;
 }
 else
 {
 // move pointer to field length of CK
 KLenOfCk != aApdu[index] )
 {
 if( KApduNok != ret )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid CK\n" );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid CK" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid CK" );
 ret = KApduNok;
 }
 }
 else
 {
 KLenOfIk != aApdu[index] )
 {
 if( KApduNok != ret )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid IK\n" );
-OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid IK" );
+OstTrace0( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid IK" );
 ret = KApduNok;
 }
 }
 else
 {
 // check the len of Kc
 if( KLenOfKc != aApdu[index] )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid Kc\n" );
-OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid Kc" );
+OstTrace0( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid Kc" );
 ret = KApduNok;
 }
 else
 {
 // move pointer to end of Kc
 // let's check that pointer doesn't go over
 // aApdu's limits.
 if( KApduOk == ret && index > apduLen - 1 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, APDU buffer overflow\n" );
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, APDU buffer overflow" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, APDU buffer overflow" );
 ret = KApduNok;
 }
 }
 else if(KSyncFailureTag == tag)
 {
 // check the len of AUTS
 if( KLenOfAuts != aApdu[index])
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid AUTS\n" );
-OstTrace0( TRACE_NORMAL, DUP6_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid AUTS" );
+OstTrace0( TRACE_NORMAL,  DUP6_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: invalid AUTS" );
 ret = KApduNok;
 }
 else
 {
 // move pointer to end of AUTS
 // let's check that pointer doesn't go over
 // aApdu's limits.
 if( KApduOk == ret && index > apduLen - 1 )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, APDU buffer overflow\n" );
-OstTrace0( TRACE_NORMAL, DUP7_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, APDU buffer overflow" );
+OstTrace0( TRACE_NORMAL,  DUP7_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, APDU buffer overflow" );
 ret = KApduNok;
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, unknown tag\n" );
-OstTrace0( TRACE_NORMAL, DUP8_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, unknown tag" );
+OstTrace0( TRACE_NORMAL,  DUP8_CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP_TD, "CMmCustomMessHandler::Validate3GSecurityContextApduResp: error, unknown tag" );
 ret = KApduNok;
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::ValidateGBABootstrappingApduResp( const TDesC8& aApdu )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateGBABootstrappingApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATEGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::ValidateGBABootstrappingApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_VALIDATEGBABOOTSTRAPPINGAPDURESP_TD, "CMmCustomMessHandler::ValidateGBABootstrappingApduResp" );
 TUint8 ret( KApduNok );
 // Let's calculate total APDU data len in aApdu. Length is
 // decremented by 2 because of aApdu contains also sw1 and sw2
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::ValidateGBANafDerivationApduResp( const TDesC8& aApdu )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateGBANafDerivationApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATEGBANAFDERIVATIONAPDURESP, "CMmCustomMessHandler::ValidateGBANafDerivationApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_VALIDATEGBANAFDERIVATIONAPDURESP_TD, "CMmCustomMessHandler::ValidateGBANafDerivationApduResp" );
 TUint8 ret = KApduNok;
 // Let's calculate total APDU data len in aApdu. Length is
 // decremented by 2 because of aApdu contains also sw1 and sw2
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::ValidateRunGsmAlgorithmApduResp( const TDesC8& aApdu )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateRunGsmAlgorithmApduResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATERUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::ValidateRunGsmAlgorithmApduResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_VALIDATERUNGSMALGORITHMAPDURESP_TD, "CMmCustomMessHandler::ValidateRunGsmAlgorithmApduResp" );
 TUint8 ret( KApduNok );
 if( aApdu.Length() == KRunGsmAlgorithmRespLen + 2 )
 {
 TUint8 aTlvTag,
 const TDesC8& aBerTlv,
 TDes8& aTlvObject )
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::FindTlvObject (tag: 0x%x)\n", aTlvTag );
-OstTrace1( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_FINDTLVOBJECT, "CMmCustomMessHandler::FindTlvObject (tag: 0x%x)", aTlvTag );
+OstTrace1( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_FINDTLVOBJECT_TD, "CMmCustomMessHandler::FindTlvObject (tag: 0x%x)", aTlvTag );
 TBool ret( EFalse );
 TUint32 index( 0 );
 TUint8 tag( 0 );
 TUint32 tlvLength( 0 );
 {
 if( tlvLength <= aTlvObject.MaxSize() )
 {
 // tlv object found
 TFLOGSTRING2("TSY: CMmCustomMessHandler::FindTlvObject: tag: 0x%x found\n", aTlvTag );
-OstTrace1( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT, "CMmCustomMessHandler::FindTlvObject: tag: 0x%x found", aTlvTag );
+OstTrace1( TRACE_NORMAL,  DUP1_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT_TD, "CMmCustomMessHandler::FindTlvObject: tag: 0x%x found", aTlvTag );
 aTlvObject.Copy( aBerTlv.Mid( index , tlvLength ) );
 ret = ETrue;
 }
 else
 {
 TFLOGSTRING3("TSY: CMmCustomMessHandler::FindTlvObject: length of aTlvObject is not enough, needed: %d max size: %d \n", tlvLength, aTlvObject.MaxSize() );
-OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT, "CMmCustomMessHandler::FindTlvObject: length of aTlvObject is not enough" );
+OstTrace0( TRACE_NORMAL,  DUP2_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT_TD, "CMmCustomMessHandler::FindTlvObject: length of aTlvObject is not enough" );
-OstTrace1( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT, "CMmCustomMessHandler::FindTlvObject: needed: %d", tlvLength );
+OstTrace1( TRACE_NORMAL,  DUP3_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT_TD, "CMmCustomMessHandler::FindTlvObject: needed: %d", tlvLength );
-OstTrace1( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT, "CMmCustomMessHandler::FindTlvObject: max size: %d", aTlvObject.MaxSize() );
+OstTrace1( TRACE_NORMAL,  DUP4_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT_TD, "CMmCustomMessHandler::FindTlvObject: max size: %d", aTlvObject.MaxSize() );
 }
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::FindTlvObject: buffer overflow \n" );
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT, "CMmCustomMessHandler::FindTlvObject: buffer overflow" );
+OstTrace0( TRACE_NORMAL,  DUP5_CMMCUSTOMMESSHANDLER_FINDTLVOBJECT_TD, "CMmCustomMessHandler::FindTlvObject: buffer overflow" );
 }
 break;
 }
 else
 {
 void CMmCustomMessHandler::DeriveCkFromKc(
 TDes8& aCk,
 const TDesC8& aKc )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::DeriveCkFromKc.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_DERIVECKFROMKC, "CMmCustomMessHandler::DeriveCkFromKc" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_DERIVECKFROMKC_TD, "CMmCustomMessHandler::DeriveCkFromKc" );
 /* This operation calculates the UMTS Ciphering Key (CK) from the GSM
 Ciphering Key (Kc). This is done by using the c4 algorithm defined in
 3GPP TS 33.102 v3.8.0 (Release 1999).
 void CMmCustomMessHandler::DeriveIkFromKc(
 TDes8& aIk,
 const TDesC8& aKc )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::DeriveIkFromKc.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_DERIVEIKFROMKC, "CMmCustomMessHandler::DeriveIkFromKc" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_DERIVEIKFROMKC_TD, "CMmCustomMessHandler::DeriveIkFromKc" );
 /* This operation derives the UMTS Integrity Key (IK) from the GSM
 Ciphering Key (Kc). This is done by using the c5 algorithm defined in
 3GPP TS 33.102 v3.8.0 (release 1999).
 //
 TInt CMmCustomMessHandler::UiccHandleImsAuthentication(
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccHandleImsAuthentication.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCHANDLEIMSAUTHENTICATION, "CMmCustomMessHandler::UiccHandleImsAuthentication" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCHANDLEIMSAUTHENTICATION_TD, "CMmCustomMessHandler::UiccHandleImsAuthentication" );
 TInt ret( KErrNone );
 // IMS authentication:
 // If card type is ICC, we just send the RUN GSM ALGORITHM to the ICC
 // If card type is UICC, we check is ISIM application activated:
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccHandleIsimActivationResp( TInt aStatus )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccHandleIsimActivationResp.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCHANDLEISIMACTIVATIONRESP, "CMmCustomMessHandler::UiccHandleIsimActivationResp" );
+OstTrace0( TRACE_NORMAL,  CMMCUSTOMMESSHANDLER_UICCHANDLEISIMACTIVATIONRESP_TD, "CMmCustomMessHandler::UiccHandleIsimActivationResp" );
 TUiccSendApdu params;
 params.messHandlerPtr = static_cast<MUiccOperationBase*>( this );
 params.serviceType = UICC_APPL_APDU_SEND;
 params.fileId = UICC_EF_ID_NOT_PRESENT;
 // to the USim application
 iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 }
+// -----------------------------------------------------------------------------
+// CMmCustomMessHandler::CollectCbTopicIdsL
+// Collects cellbroadcast topic IDs into array. Leaves if nothig found
+// -----------------------------------------------------------------------------
+//
+CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* CMmCustomMessHandler::CollectCbTopicIdsL(
+const TDesC16& aTopicIds ) const
+{
+TFLOGSTRING("TSY: CMmCustomMessHandler::CollectCbTopicIdsL");
+OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_COLLECTCBTOPICIDSL, "CMmCustomMessHandler::CollectCbTopicIdsL" );
+CArrayFixFlat<RMmCustomAPI::TSimCbTopic>* simCbTopics =
+new ( ELeave ) CArrayFixFlat<RMmCustomAPI::TSimCbTopic> (
+aTopicIds.Length() );
+CleanupStack::PushL( simCbTopics );
+for ( TInt i = 0; i < aTopicIds.Length(); i++ )
+{
+TUint16 cbId =
+( aTopicIds[i] >> 8 ) | ( aTopicIds[i] << 8 );
+if ( KUnusedCbMsgId != cbId )
+{
+RMmCustomAPI::TSimCbTopic simCbTopic;
+// CB ID
+simCbTopic.iNumber = cbId;
+// Topic names are not stored on the SIM
+simCbTopic.iName.Zero();
+// Add CB topic to array
+simCbTopics->AppendL( simCbTopic );
+}
+}
+simCbTopics->Compress();
+// handle this like error case
+__ASSERT_ALWAYS(
+0 < simCbTopics->Count(), User::Leave( KErrNotFound ) );
+CleanupStack::Pop( simCbTopics );
+return simCbTopics;
+}
 // ========================== OTHER EXPORTED FUNCTIONS =========================
 //None
 // End of File

changeset 9	8486d82aef45
parent 7	fa67e03b87df