FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/src/cmtpconnectionmgr.cpp

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include "cmtpconnectionmgr.h"
 #include "cmtpconnection.h"
 #include "cmtptransportplugin.h"
 #include "mmtptransportconnection.h"
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpconnectionmgrTraces.h"
+#endif
 // Class constants.
-__FLOG_STMT(_LIT8(KComponent,"ConnectionMgr");)
 const TUint KMTPUsbTransportUid  = 0x102827B2;
 const TUint KMTPBTTransportUid  = 0x10286FCB;
 /**
 {
 StopTransport( iTransportUid, ETrue );
 iConnections.ResetAndDestroy();
 iSuspendedTransports.Close();
 delete iTransportTrigger;
-__FLOG_CLOSE;
 }
 /**
 Provides a reference to the connection with the specified connection identifier.
 @param aConnectionId The connection identifier.
 @leave KErrNotFound If a connection with the specified identifier does not
 exist.
 */
 EXPORT_C CMTPConnection& CMTPConnectionMgr::ConnectionL(TUint aConnectionId) const
 {
-__FLOG(_L8("ConnectionL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_CONNECTIONL_ENTRY );
 TInt idx(ConnectionFind(aConnectionId));
-__FLOG_VA((_L8("idx is %d "), idx));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_CONNECTIONL, "idx is %d", idx );
 __ASSERT_ALWAYS((idx != KErrNotFound), User::Invariant());
-__FLOG(_L8("ConnectionL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_CONNECTIONL_EXIT );
 return *iConnections[idx];
 }
 /**
 Provides a count of the number of currently open connections.
 return iTransportUid;
 }
 void CMTPConnectionMgr::ConnectionCloseComplete(const TUint& /*aConnUid*/)
 {
-__FLOG(_L8("ConnectionCloseComplete - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_CONNECTIONCLOSECOMPLETE_ENTRY );
 if (iTransportUid.iUid != KMTPUsbTransportUid )
 {
 ResumeSuspendedTransport();
 }
 else
 {
 iResumeCalled = ETrue;
 }
-__FLOG(_L8("ConnectionCloseComplete - exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_CONNECTIONCLOSECOMPLETE_EXIT );
 }
 EXPORT_C void CMTPConnectionMgr::StartTransportL(TUid aTransport)
 {
-__FLOG(_L8("StartTransportL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_ENTRY );
 //When USB plug out, BT will start Master mode to reconnect remote device. Else BT will start slave mode to listen connection.
 if(aTransport.iUid == KMTPBTTransportUid && iRemoteDevice.iDeviceAddr != 0 && aTransport != iTransportUid)
 {
-__FLOG(_L8("StartTransportL with parameter!"));
+OstTrace0( TRACE_NORMAL, CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT, "StartTransportL with parameter!" );
 TMTPBTRemoteDeviceBuf tmpdata(iRemoteDevice);
 StartTransportL( aTransport, &tmpdata );
 iRemoteDevice.iDeviceAddr = 0;
 iRemoteDevice.iDeviceServicePort = 0;
 }
 else
 {
-__FLOG(_L8("StartTransportL without parameter!"));
+OstTrace0( TRACE_NORMAL, DUP1_CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT, "StartTransportL without parameter!" );
 StartTransportL( aTransport, NULL );
 }
-__FLOG(_L8("StartTransportL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_EXIT );
 }
 /**
 Loads and starts up the MTP transport plug-in with the specified
 CMTPTransportPlugin interface implementation UID. Only one MTP transport
 @leave One of the system wide error codes, if a processing failure occurs.
 @see StopTransport
 */
 EXPORT_C void CMTPConnectionMgr::StartTransportL(TUid aTransport, const TAny* aParameter)
 {
-__FLOG(_L8("StartTransportL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER_ENTRY );
 if (iTransport)
 {
-__FLOG(_L8("The transport is not none."));
+OstTrace0( TRACE_NORMAL, CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER, "The transport is not none." );
 if (aTransport != iTransportUid)
 {
 // Multiple transports not currently supported.
-__FLOG(_L8("Multiple transports are not supported now!"));
+OstTrace0( TRACE_NORMAL, DUP1_CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER, "Multiple transports are not supported now!" );
 User::Leave(KErrNotSupported);
 }
 else
 {
-__FLOG_1(_L8("Relaunch the transport 0x%X"), iTransportUid.iUid);
+OstTrace1( TRACE_NORMAL, DUP2_CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER, "Relaunch the transport 0x%X",  iTransportUid.iUid);
 if(aTransport.iUid == KMTPBTTransportUid)
 {
 iTransport->Stop(*this);
 delete iTransport;
 iTransportCount--;
 iTransport = CMTPTransportPlugin::NewL(aTransport, aParameter);
 TRAPD(err, iTransport->StartL(*this));
 if (err != KErrNone)
 {
-__FLOG_VA( ( _L8("StartTransportL error, error code = %d"), err) );
+OstTraceDef1( OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, DUP3_CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER,
+"StartTransportL error, error code = %d",  err);
 delete iTransport;
 iTransport = NULL;
 User::Leave(err);
 }
 }
 }
 else
 {
-__FLOG(_L8("begin start transport."));
+OstTrace0( TRACE_NORMAL, DUP4_CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER, "begin start transport." );
 iTransport = CMTPTransportPlugin::NewL(aTransport, aParameter);
 TRAPD(err, iTransport->StartL(*this));
 if (err != KErrNone)
 {
-__FLOG_VA( ( _L8("StartTransportL error, error code = %d"), err) );
+OstTrace1( TRACE_NORMAL, DUP5_CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER, "StartTransportL error, error code = %d",  err);
 delete iTransport;
 iTransport = NULL;
 User::Leave(err);
 }
 iTransportUid = aTransport;
 {
 //Suspend BT transport to handle switching with Mass Storage
 SuspendTransportL( iTransportUid);
 }
 }
-	__FLOG(_L8("StartTransportL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_STARTTRANSPORTL_TUINT_TANYPOINTER_EXIT );
 }
 /**
 Queue the transport to start when there is no running transport
 @param aTransport, The CMTPTransportPlugin interface implementation UID.
 @param aParameter, reserved
 @leave One of the system wide error codes, if the operation fails.
 */
 EXPORT_C void CMTPConnectionMgr::QueueTransportL( TUid aTransport, const TAny* /*aParameter*/ )
 {
-__FLOG_VA( ( _L8("+QueueTransportL( 0x%08X )"), aTransport.iUid ) );
+OstTraceFunctionEntry0(CMTPCONNECTIONMGR_QUEUETRANSPORTL_ENTRY);
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_QUEUETRANSPORTL, "QueueTransportL( 0x%08X )", aTransport.iUid);
 __ASSERT_DEBUG( ( KErrNotFound == iSuspendedTransports.Find( aTransport ) ), User::Invariant() );
 iSuspendedTransports.InsertL( aTransport, 0 );
-__FLOG( _L8("-QueueTransportL") );
+OstTraceFunctionExit0(CMTPCONNECTIONMGR_QUEUETRANSPORTL_EXIT);
 }
 EXPORT_C void CMTPConnectionMgr::SetClientSId(TUid aSecureId)
 	{
 	iSecureId=aSecureId;
 @param aTransport The CMTPTransportPlugin interface implementation UID.
 @param aByBearer If ETrue, it means the transport plugin is stopped because the bearer is turned off or not activated.
 */
 EXPORT_C void CMTPConnectionMgr::StopTransport( TUid aTransport, TBool aByBearer )
 {
-	__FLOG(_L8("StopTransport - Entry"));
+	OstTraceFunctionEntry0( CMTPCONNECTIONMGR_STOPTRANSPORT_ENTRY );
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_STOPTRANSPORT, "aTransport is 0x%X", aTransport.iUid);
-__FLOG_1(_L8("aTransport is 0x%X"), aTransport.iUid);
-__FLOG_1(_L8("iTransportUid is 0x%X"), iTransportUid.iUid);
 TInt transportId = iTransportUid.iUid;
 if ( aByBearer )
 {
 UnsuspendTransport( aTransport );
 			iResumeCalled = EFalse;
 }
 }
-	__FLOG(_L8("StopTransport - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_STOPTRANSPORT_EXIT );
 }
 /**
 Shuts down and unloads all active MTP transport plug-ins.
 */
 iRemoteDevice.iDeviceServicePort = aPSMPort;
 }
 TBool CMTPConnectionMgr::ConnectionClosed(MMTPTransportConnection& aTransportConnection)
 {
-__FLOG(_L8("ConnectionClosed - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_CONNECTIONCLOSED_ENTRY );
 TInt idx(ConnectionFind(aTransportConnection.BoundProtocolLayer().ConnectionId()));
-__FLOG_VA((_L8("idx is %d "), idx));
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_CONNECTIONCLOSED, "idx is %d", idx );
 __ASSERT_DEBUG((idx != KErrNotFound), User::Invariant());
 CMTPConnection* connection(iConnections[idx]);
-__FLOG(_L8("ConnectionClosed - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_CONNECTIONCLOSED_EXIT);
 return connection->ConnectionSuspended();
 }
 void CMTPConnectionMgr::ConnectionOpenedL(MMTPTransportConnection& aTransportConnection)
 {
-__FLOG(_L8("ConnectionOpenedL - Entry"));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_CONNECTIONOPENEDL_ENTRY );
 TUint impUid = aTransportConnection.GetImplementationUid();
 TInt idx = ConnectionFind(impUid);
 CMTPConnection* connection = NULL;
 if (idx == KErrNotFound)
 {
 connection = iConnections[idx];
 }
 connection->ConnectionResumedL(aTransportConnection);
-__FLOG(_L8("ConnectionOpenedL - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_CONNECTIONOPENEDL_EXIT );
 }
 EXPORT_C TUid CMTPConnectionMgr::ClientSId()
 	{
 	return iSecureId;
 CMTPConnectionMgr::CMTPConnectionMgr() :
 iConnectionOrder(ConnectionOrderCompare),
 iShutdownConnectionIdx(KErrNotFound),
 	iTransportUid(KNullUid)
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
 iRemoteDevice.iDeviceAddr = 0;
 iRemoteDevice.iDeviceServicePort = 0;
 iResumeCalled = EFalse;
 }
 @return The connection table index of the required connection, or KErrNotFound
 if the connection identifier could not be found.
 */
 TInt CMTPConnectionMgr::ConnectionFind(TUint aConnectionId) const
 {
-__FLOG_VA((_L8("ConnectionFind - Entry with connectionId %d "), aConnectionId));
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_CONNECTIONFIND_ENTRY );
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_CONNECTIONFIND, "connectionId %d", aConnectionId);
 TInt ret(KErrNotFound);
 const TUint noConnections = iConnections.Count();
 for (TUint i(0); ((i < noConnections) && (ret == KErrNotFound)); i++)
 {
 {
 ret = i;
 break;
 }
 }
-__FLOG(_L8("ConnectionFind - Exit"));
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_CONNECTIONFIND_EXIT );
 return ret;
 }
 /**
 Determines the relative order of two CMTPConnection objects based on their
 @param aTransport, The implementation UID of the suspended transport plugin
 @leave One of the system wide error codes, if the operation fails.
 */
 void CMTPConnectionMgr::SuspendTransportL( TUid aTransport )
 {
-__FLOG_1( _L8("+SuspendTransportL( 0x%08X )"), aTransport );
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_SUSPENDTRANSPORTL_ENTRY );
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_SUSPENDTRANSPORTL, "SuspendTransportL( 0x%08X )", aTransport.iUid );
 if ( KErrNotFound == iSuspendedTransports.Find( aTransport ) )
 {
 iSuspendedTransports.AppendL( aTransport );
 }
-__FLOG( _L8("-SuspendTransportL") );
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_SUSPENDTRANSPORTL_EXIT );
 }
 /**
 Remove transport from the suspended transports list
 @param aTransport, The CMTPTransportPlugin interface implementation UID
 */
 void CMTPConnectionMgr::UnsuspendTransport( TUid aTransport )
 {
-__FLOG_1( _L8("+UnsuspendTransport( 0x%08X )"), aTransport.iUid );
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_UNSUSPENDTRANSPORT_ENTRY );
+OstTrace1( TRACE_NORMAL, CMTPCONNECTIONMGR_UNSUSPENDTRANSPORT, "Transport uid is 0x%08X;", aTransport.iUid );
 TInt idx = iSuspendedTransports.Find( aTransport );
 if ( KErrNotFound != idx )
 {
-__FLOG_1( _L8("Remove the number %d suspended transport"), idx );
+OstTrace1( TRACE_NORMAL, DUP1_CMTPCONNECTIONMGR_UNSUSPENDTRANSPORT, "Remove the number %d suspended transport", idx );
 iSuspendedTransports.Remove( idx );
 }
-__FLOG( _L8("-UnsuspendTransport") );
+OstTraceFunctionExit0( CMTPCONNECTIONMGR_UNSUSPENDTRANSPORT_EXIT );
 }
 /**
 Prepare to resume suspended transport
 */
 void CMTPConnectionMgr::ResumeSuspendedTransport()
 {
-__FLOG( _L8("+ResumeSuspendedTransport") );
+OstTraceFunctionEntry0( CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT_ENTRY );
 const TInt count = iSuspendedTransports.Count();
-__FLOG_1(_L8("The count number is %d"), count);
+OstTrace1(TRACE_NORMAL, CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT, "The count number is %d", count);
-__FLOG_1(_L8("The transportport id is 0x%X"), iTransportUid.iUid);
+OstTrace1(TRACE_NORMAL, DUP1_CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT, "The transportport id is 0x%X", iTransportUid.iUid);
 if ( ( count > 0 )
 // If the transport was just switched and suspended, it shouldn't be resumed.
 && (( iTransportUid != iSuspendedTransports[count-1] ) || iTransportUid.iUid == KMTPBTTransportUid))
 {
-__FLOG( _L8("Found suspended transport(s).") );
+OstTrace0(TRACE_NORMAL, DUP2_CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT, "Found suspended transport(s).");
 if ( !iTransportTrigger )
 {
 iTransportTrigger = new( ELeave ) CAsyncCallBack( CActive::EPriorityStandard );
 }
 if ( !iTransportTrigger->IsActive())
 {
-__FLOG( _L8("Set call back function!") );
+OstTrace0(TRACE_NORMAL, DUP3_CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT, "Set call back function!");
 TCallBack callback( CMTPConnectionMgr::DoResumeSuspendedTransport, this );
 iTransportTrigger->Set( callback );
 iTransportTrigger->CallBack();
 }
 else
 {
-__FLOG( _L8("Call back has been set!") );
+OstTrace0(TRACE_NORMAL, DUP4_CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT, "Call back has been set!");
 }
 }
-__FLOG( _L8("-ResumeSuspendedTransport") );
+OstTraceFunctionExit0( DUP1_CMTPCONNECTIONMGR_RESUMESUSPENDEDTRANSPORT_EXIT );
 }
 /**
 Resume suspended transport
 @param aSelf, The memory address of the CMTPConnectionMgr instance

changeset 49	c20dd21d1eb4
parent 35	c4c427c00f31
child 52	866b4af7ffbe