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

equal deleted inserted replaced

-:2c19c7cf5550
+:c20dd21d1eb4
 #include "cmtpstoragemgr.h"
 #include "mmtptransactionproxy.h"
 #include "rmtpframework.h"
 #include "cdummydp.h"
 #include "cmtpdatacodegenerator.h"
+#include "mtpdebug.h"
-// Class constants.
+#include "OstTraceDefinitions.h"
-__FLOG_STMT(_LIT8(KComponent,"DataProvider");)
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpdataproviderTraces.h"
+#endif
 const TInt KWaitForEnumeration = 1000000 * 3;
 #define KMTPDummyDataProvider             0x0000
 /**
 Destructor.
 */
 CMTPDataProvider::~CMTPDataProvider()
 {
-__FLOG_VA((_L8("~CMTPDataProvider - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_CMTPDATAPROVIDER_DES_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_CMTPDATAPROVIDER_DES,
+"data provider %d ", iId);
 Cancel();
 iSupported.ResetAndDestroy();
 delete iImplementation;
 iSingletons.Close();
 {
 delete iConfig;
 }
 	iTimer.Close();
-__FLOG_VA((_L8("~CMTPDataProvider - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_CMTPDATAPROVIDER_DES,
-__FLOG_CLOSE;
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_CMTPDATAPROVIDER_EXIT );
 }
 void CMTPDataProvider::ExecuteEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("ExecuteEventL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEEVENTL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_EXECUTEEVENTL,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 if (iTimerActive && aEvent.Uint16(TMTPTypeEvent::EEventCode) == EMTPEventCodeCancelTransaction)
 	    {
 	    Cancel();
 	    }
 // Pass this event notification directly to the plugin...
 // In reality we will only ever see one event canceltransaction.
 iImplementation->ProcessEventL(aEvent, aConnection);
-__FLOG_VA((_L8("ExecuteEventL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_EXECUTEEVENTL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEEVENTL_EXIT );
 }
 void CMTPDataProvider::ExecuteRequestL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("ExecuteRequestL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEREQUESTL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_EXECUTEREQUESTL,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 iCurrentRequest = &aRequest;
 iCurrentConnection = &iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId());
 // Schedule data provider to process this request.
 Schedule();
-__FLOG_VA((_L8("ExecuteRequestL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_EXECUTEREQUESTL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEREQUESTL_EXIT );
 }
 EXPORT_C void CMTPDataProvider::ExecuteProxyRequestL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection, MMTPTransactionProxy& aProxy)
 {
-__FLOG_VA((_L8("ExecuteProxyRequestL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL,
+"data provider %d ", iId);
 iProxy = &aProxy;
 iCurrentRequest    = &aRequest;
 iCurrentConnection = static_cast<CMTPConnection*>(&aConnection);
 Schedule();
-__FLOG_VA((_L8("ExecuteProxyRequestL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEPROXYREQUESTL_EXIT );
 }
 void CMTPDataProvider::ExecutePendingRequestL()
 {
-__FLOG_VA((_L8("SchedulePendingRequestL - Entry")));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_EXECUTEPENDINGREQUESTL_ENTRY );
 if (iCurrentRequest != NULL && !IsActive())
 {
 Schedule();
 }
-__FLOG_VA((_L8("SchedulePendingRequestL - Exit")));
+OstTraceFunctionExit0( CMTPDATAPROVIDER_EXECUTEPENDINGREQUESTL_EXIT );
 }
 void CMTPDataProvider::EnumerateObjectsL(TUint32 aStorageId)
 {
-__FLOG_VA((_L8("EnumerateObjectsL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_ENUMERATEOBJECTSL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ENUMERATEOBJECTSL,
+"data provider %d ", iId);
 iEnumerationState = ((iEnumerationState & ~EObjectsEnumerationState) | EObjectsEnumerating);
 TBool abnormaldown = EFalse;
 iSingletons.FrameworkConfig().GetValueL(CMTPFrameworkConfig::EAbnormalDown, abnormaldown);
 iImplementation->StartObjectEnumerationL(aStorageId, abnormaldown);
-__FLOG_VA((_L8("EnumerateObjectsL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ENUMERATEOBJECTSL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_ENUMERATEOBJECTSL_EXIT );
 }
 void CMTPDataProvider::EnumerateStoragesL()
 {
-__FLOG_VA((_L8("EnumerateStoragesL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_ENUMERATESTORAGESL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ENUMERATESTORAGESL,
+"data provider %d ", iId);
 iEnumerationState = ((iEnumerationState & ~EStoragesEnumerationState) | EStoragesEnumerating);
 iImplementation->StartStorageEnumerationL();
-__FLOG_VA((_L8("EnumerateStoragesL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ENUMERATESTORAGESL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_ENUMERATESTORAGESL_EXIT );
 }
 /**
 Provides the data provider's enumeration state.
 @return The data provider's enumeration state.
 /**
 Sets the
 */
 void CMTPDataProvider::SetDataProviderId(TUint aId)
 {
-__FLOG_VA((_L8("~CMTPDataProvider - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SETDATAPROVIDERID_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SETDATAPROVIDERID,
+"data provider %d ", iId);
 iId = aId;
-__FLOG_VA((_L8("~CMTPDataProvider - Entry, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SETDATAPROVIDERID,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_SETDATAPROVIDERID_EXIT );
 }
 /**
 Implements a linear order relation for @see CMTPDataProvider
 objects based on relative @see CMTPDataProvider::ImplementationUid.
 return (iSingletons.DpController().Mode());
 }
 void CMTPDataProvider::ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("ReceiveDataL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_RECEIVEDATAL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_RECEIVEDATAL,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 __ASSERT_DEBUG(!IsActive(), User::Invariant());
 if (iProxy)
 {
 CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));
 connection.ReceiveDataL(aData, aRequest, iStatus);
 SetActive();
 // Async call so wait for object to be activated...
 }
-__FLOG_VA((_L8("ReceiveDataL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_RECEIVEDATAL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_RECEIVEDATAL_EXIT );
 }
 void CMTPDataProvider::SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("SendDataL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDDATAL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDDATAL,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 __ASSERT_DEBUG(!IsActive(), User::Invariant());
 if (iProxy)
 {
 CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));
 connection.SendDataL(aData, aRequest, iStatus);
 SetActive();
 // Async call so wait for object to be activated...
 }
-__FLOG_VA((_L8("SendDataL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDDATAL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDDATAL_EXIT );
 }
 void CMTPDataProvider::SendEventL(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("SendEventL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));
 connection.SendEventL(aEvent);
-__FLOG_VA((_L8("SendEventL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_MMTPCONNECTION_EXIT );
 }
 void CMTPDataProvider::SendEventL(const TMTPTypeEvent& aEvent)
 {
-__FLOG_VA((_L8("SendEventL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT,
+"data provider %d ", iId);
 if (aEvent.Uint32(TMTPTypeEvent::EEventSessionID) != KMTPSessionAll)
 {
+OstTrace0( TRACE_ERROR, CMTPDATAPROVIDER_SENDEVENTL, "event session id not KMTPSessionALL!" );
 User::Leave(KErrArgument);
 }
 TUint numConnections(iSingletons.ConnectionMgr().ConnectionCount());
 for (TUint i(0); (i < numConnections); i++)
 {
 iSingletons.ConnectionMgr()[i].SendEventL(aEvent);
 }
-__FLOG_VA((_L8("SendEventL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDEVENTL_TMTPTYPEVENT_EXIT );
 }
 void CMTPDataProvider::SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("SendResponseL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDRESPONSEL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDRESPONSEL,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 __ASSERT_DEBUG(!IsActive(), User::Invariant());
 if (iProxy)
 {
 {
 CMTPConnection& connection(iSingletons.ConnectionMgr().ConnectionL(aConnection.ConnectionId()));
 connection.SendResponseL(aResponse, aRequest, iStatus);
 SetActive();
 }
-__FLOG_VA((_L8("SendResponseL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDRESPONSEL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDRESPONSEL_EXIT );
 }
 void CMTPDataProvider::TransactionCompleteL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("TransactionCompleteL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL,
+"data provider %d ", iId);
 __ASSERT_DEBUG(iImplementation, User::Invariant());
 if (iProxy)
 {
 // Pass to proxy plugin for processing
 // Clear pointers
 iProxy = NULL;
 iCurrentRequest = NULL;
 iCurrentConnection = NULL;
-__FLOG_VA((_L8("TransactionCompleteL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_TRANSACTIONCOMPLETEL_EXIT );
 }
 void CMTPDataProvider::RouteRequestRegisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("RouteRequestRegisterL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL,
+"data provider %d ", iId);
 iSingletons.Router().RouteRequestRegisterL(aRequest, aConnection, iId);
-__FLOG_VA((_L8("RouteRequestRegisterL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_ROUTEREQUESTREGISTERL_EXIT );
 }
 void CMTPDataProvider::RouteRequestUnregisterL(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection)
 {
-__FLOG_VA((_L8("RouteRequestUnregister - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL,
+"data provider %d ", iId);
 iSingletons.Router().RouteRequestUnregisterL(aRequest, aConnection);
-__FLOG_VA((_L8("RouteRequestUnregister - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL,
-}
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_ROUTEREQUESTUNREGISTERL_EXIT );
-#ifdef __FLOG_ACTIVE
+}
 void CMTPDataProvider::ObjectEnumerationCompleteL(TUint32 aStorageId)
-#else
+{
-void CMTPDataProvider::ObjectEnumerationCompleteL(TUint32 /*aStorageId*/)
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL_ENTRY );
-#endif // __FLOG_ACTIVE
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL,
-{
+"data provider %d ", iId);
-__FLOG_VA((_L8("ObjectEnumerationCompleteL - Entry, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL,
-__FLOG_VA((_L8("StorageId = 0x%08X "), aStorageId));
+"StorageId = 0x%08X ", aStorageId);
 iEnumerationState = ((iEnumerationState & ~EObjectsEnumerationState) | EObjectsEnumerated);
 iSingletons.DpController().EnumerationStateChangedL(*this);
-__FLOG_VA((_L8("ObjectEnumerationCompleteL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP2_CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_OBJECTENUMERATIONCOMPLETEL_EXIT );
 }
 void CMTPDataProvider::StorageEnumerationCompleteL()
 {
-__FLOG_VA((_L8("StorageEnumerationCompleteL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_STORAGEENUMERATIONCOMPLETEL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_STORAGEENUMERATIONCOMPLETEL,
+"data provider %d ", iId);
 iEnumerationState = ((iEnumerationState & ~EStoragesEnumerationState) | EStoragesEnumerated);
 iSingletons.DpController().EnumerationStateChangedL(*this);
-__FLOG_VA((_L8("StorageEnumerationCompleteL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_STORAGEENUMERATIONCOMPLETEL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_STORAGEENUMERATIONCOMPLETEL_EXIT );
 }
 const MMTPDataProviderConfig& CMTPDataProvider::DataProviderConfig() const
 	{
 	return *iConfig;
 return iSingletons.DataCodeGenerator();
 }
 void CMTPDataProvider::NotifyFrameworkL( TMTPNotificationToFramework aNotification, const TAny* aParams )
 {
-__FLOG(_L8("NotifyFrameworkL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_NOTIFYFRAMEWORKL_ENTRY );
 __ASSERT_DEBUG( aParams, User::Invariant());
 switch ( aNotification )
 {
 TUint deviceDpId = iSingletons.DpController().DeviceDpId();
 iSingletons.DpController().NotifyDataProvidersL( deviceDpId, EMTPObjectAdded, aParams );
 }
 break;
 default:
-__FLOG(_L8("Ignore other notification"));
+OstTrace0(TRACE_NORMAL, CMTPDATAPROVIDER_NOTIFYFRAMEWORKL, "Ignore other notification");
 break;
 }
-__FLOG(_L8("NotifyFrameworkL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDER_NOTIFYFRAMEWORKL_EXIT );
 }
 void CMTPDataProvider::RegisterPendingRequest(TUint aTimeOut)
 {
-__FLOG(_L8("RegisterPendingRequestL - Entry"));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_REGISTERPENDINGREQUEST_ENTRY );
 iSingletons.DpController().RegisterPendingRequestDP(iImplementationUid.iUid, aTimeOut);
-__FLOG(_L8("RegisterPendingRequestL - Exit"));
+OstTraceFunctionExit0( CMTPDATAPROVIDER_REGISTERPENDINGREQUEST_EXIT );
 }
 void CMTPDataProvider::DoCancel()
 {
-__FLOG_VA((_L8("DoCancel - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_DOCANCEL_ENTRY );
-__FLOG_VA((_L8("DoCancel - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_DOCANCEL,
+"data provider %d ", iId);
 if (iTimerActive)
 	    {
 	    iTimer.Cancel();
 	    iTimerActive = EFalse;
 else
 	    {
 	TRequestStatus* status = &iStatus;
 	    User::RequestComplete(status, KErrCancel);
 	    }
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_DOCANCEL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_DOCANCEL_EXIT );
 }
 void CMTPDataProvider::RunL()
 {
-__FLOG_VA((_L8("RunL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_RUNL_ENTRY );
-__MTP_HEAP_FLOG
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_RUNL,
+"data provider %d ", iId);
+#ifdef OST_TRACE_COMPILER_IN_USE
+__MTP_HEAP_OSTTRACE(OstTraceExt4(TRACE_NORMAL,DUP6_CMTPDATAPROVIDER_RUNL,"Heap: Size = %d, Allocated = %d, Available = %d, Largest block = %d", size, allocated, available, largest));
+#endif
 __ASSERT_DEBUG(iCurrentConnection, User::Invariant());
 iTimerActive = EFalse;
 if (iCurrentRequest != NULL)
 {
 iCurrentTransactionPhase = iCurrentConnection->TransactionPhaseL(iCurrentRequest->Uint32(TMTPTypeRequest::ERequestSessionID));
 }
 }
-__FLOG_VA((_L8("Current transaction phase = 0x%08X"), iCurrentTransactionPhase));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_RUNL, "Current transaction phase = 0x%08X", iCurrentTransactionPhase);
 TInt status(iStatus.Int());
 if ((status != KErrNone) &&
 	(status != KErrAbort) &&
 	(status != KErrCancel))
 }
 if (iErrorRecovery != KErrNone)
 {
-__FLOG(_L8("Error recovery in progress"));
+OstTrace0(TRACE_NORMAL, DUP2_CMTPDATAPROVIDER_RUNL, "Error recovery in progress");
 switch (iCurrentTransactionPhase)
 {
 case ERequestPhase:
 case EDataIToRPhase:
 case EDataRToIPhase:
 SendErrorResponseL(iErrorRecovery);
 break;
 case ECompletingPhase:
 TRAPD(err, iImplementation->ProcessRequestPhaseL(iCurrentTransactionPhase, *iCurrentRequest, *iCurrentConnection));
-__FLOG_VA((_L8("iImplementation->ProcessRequestPhaseL error %d"), err));
+OstTrace1(TRACE_NORMAL, DUP3_CMTPDATAPROVIDER_RUNL,
+"iImplementation->ProcessRequestPhaseL error %d", err);
 if (err != KErrNone)
 {
+OstTraceDef1(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, DUP8_CMTPDATAPROVIDER_RUNL,
+"iImplementation->ProcessRequestPhaseL error %d", err );
 TransactionCompleteL(*iCurrentRequest, *iCurrentConnection);
 }
 iErrorRecovery = KErrNone;
 break;
 }
 }
 		else if (iSingletons.DpController().EnumerateState() < CMTPDataProviderController::EEnumeratingPhaseOneDone)
 	{
-__FLOG(_L8("DP Enumeration is not complete"));
+OstTrace0(TRACE_NORMAL, DUP4_CMTPDATAPROVIDER_RUNL, "DP Enumeration is not complete");
 if (iCurrentRequest != NULL)
 {
 TUint16 opCode = iCurrentRequest->Uint16(TMTPTypeRequest::ERequestOperationCode);
 switch(opCode)
 }
 	}
 }
-__MTP_HEAP_FLOG
+#ifdef OST_TRACE_COMPILER_IN_USE
-__FLOG_VA((_L8("RunL - Exit, data provider %d "), iId));
+__MTP_HEAP_OSTTRACE(OstTraceExt4(TRACE_NORMAL,DUP7_CMTPSERVER_E32MAIN_HEAP,"Heap: Size = %d, Allocated = %d, Available = %d, Largest block = %d", size, allocated, available, largest));
+#endif
+OstTrace1(TRACE_NORMAL, DUP5_CMTPDATAPROVIDER_RUNL,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_RUNL_EXIT );
 }
 TInt CMTPDataProvider::RunError(TInt aError)
 	{
-__FLOG_VA((_L8("RunError - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_RUNERROR_ENTRY );
-__FLOG_VA((_L8("Error = %d"), aError));
+OstTraceDef1(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, CMTPDATAPROVIDER_RUNERROR,
+"data provider %d ", iId);
+OstTraceDef1(OST_TRACE_CATEGORY_PRODUCTION, TRACE_IMPORTANT, DUP1_CMTPDATAPROVIDER_RUNERROR, "Error = %d", aError);
 /*
 CMTPDataProvider or iImplementation error, save the error state and
 re-schedule.
 */
 iErrorRecovery = aError;
 Schedule();
-__FLOG_VA((_L8("RunError - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP2_CMTPDATAPROVIDER_RUNERROR,
+"data provider %d ", iId);
+	OstTraceFunctionExit0( CMTPDATAPROVIDER_RUNERROR_EXIT );
 	return KErrNone;
 	}
 /**
 Constructor.
 Second phase constructor.
 @leave One of the system wide error codes if a processing failure occurs.
 */
 void CMTPDataProvider::ConstructL()
 	{
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_CONSTRUCTL_ENTRY );
-__FLOG_VA((_L8("ConstructL - Entry, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_CONSTRUCTL,
+"data provider %d ", iId);
 iSingletons.OpenL();
 TUint tDPType = iConfig->UintValue(MMTPDataProviderConfig::EDataProviderType);
 const TUint KExcludeCategoryStart = EVendorExtensionSets;
 const TUint KExcludeCategoryEnd = EFormatExtensionSets;
 {
 CSupportedCodes* codes = CSupportedCodes::NewLC(static_cast<TMTPSupportCategory>(i), Plugin());
 if((i >= KExcludeCategoryStart) && (i <= KExcludeCategoryEnd) && (codes->Codes().Count() >0))
 	{
+OstTrace1( TRACE_ERROR, DUP3_CMTPDATAPROVIDER_CONSTRUCTL, "Dp MTP feature(%d) contained in exclude category!", i );
 	User::Leave(KErrNotSupported);
 	}
 iSupported.AppendL(codes);
 CleanupStack::Pop(codes);
 	{
 	CSupportedCodes* codes = CSupportedCodes::NewLC(static_cast<TMTPSupportCategory>(i), Plugin());
 	if((i >= KExcludeCategoryStart) && (i <= KExcludeCategoryEnd) && (codes->Codes().Count() >0))
 	{
+OstTrace1( TRACE_ERROR, DUP4_CMTPDATAPROVIDER_CONSTRUCTL, "Dp MTP feature(%d) contained in exclude category!", i );
 	User::Leave(KErrNotSupported);
 	}
 	iSupported.AppendL(codes);
 	CleanupStack::Pop(codes);
 	}
-	User::LeaveIfError(iTimer.CreateLocal());
+	LEAVEIFERROR(iTimer.CreateLocal(),
+	        OstTrace0( TRACE_ERROR, DUP5_CMTPDATAPROVIDER_CONSTRUCTL, "thread-relative timer create error!" ));
 		// Only assume ownership of passed objects on successful construction.
 		iConstructed = ETrue;
-		__FLOG_VA((_L8("Data provider %d iImplementationUid 0x08%X "), iId, iImplementationUid));
+		OstTraceExt2(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_CONSTRUCTL,
-	__FLOG_VA((_L8("ConstructL - Exit, data provider %d "), iId));
+		        "Data provider %d iImplementationUid 0x%X ", iId, iImplementationUid.iUid);
 	}
+OstTrace1(TRACE_NORMAL, DUP2_CMTPDATAPROVIDER_CONSTRUCTL,
+"data provider %d ", iId);
+	OstTraceFunctionExit0( CMTPDATAPROVIDER_CONSTRUCTL_EXIT );
 	}
 /**
 Schedules the next request phase or event.
 */
 void CMTPDataProvider::Schedule()
 {
-__FLOG_VA((_L8("Schedule - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SCHEDULE_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SCHEDULE,
+"data provider %d ", iId);
 iStatus = KRequestPending;
 TRequestStatus* status = &iStatus;
 SetActive();
 User::RequestComplete(status, KErrNone);
-__FLOG_VA((_L8("Schedule - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SCHEDULE,
+"data provider %d ", iId);
+OstTraceFunctionExit0( CMTPDATAPROVIDER_SCHEDULE_EXIT );
 }
 /**
 Formats and sends an MTP response dataset from the specified error code.
 @param aError The error code.
 @leave One of the system wide error codes, if a processing error occurs.
 */
 void CMTPDataProvider::SendErrorResponseL(TInt aError)
 	{
-__FLOG_VA((_L8("SendResponseL - Entry, data provider %d "), iId));
+OstTraceFunctionEntry0( CMTPDATAPROVIDER_SENDERRORRESPONSEL_ENTRY );
+OstTrace1(TRACE_NORMAL, CMTPDATAPROVIDER_SENDERRORRESPONSEL,
+"data provider %d ", iId);
 	__ASSERT_DEBUG(iCurrentRequest != NULL, User::Invariant());
 	TMTPResponseCode code;
 	switch (aError)
 	    {
 default:
 code = EMTPRespCodeGeneralError;
 break;
 	    }
-__FLOG_VA((_L8("Sending response code  0x%04X"), code));
+OstTrace1(TRACE_NORMAL, DUP2_CMTPDATAPROVIDER_SENDERRORRESPONSEL,
+"Sending response code  0x%04X", code);
 	iResponse.SetUint16(TMTPTypeResponse::EResponseCode, code);
 iResponse.SetUint32(TMTPTypeResponse::EResponseSessionID, iCurrentRequest->Uint32(TMTPTypeResponse::EResponseSessionID));
 	iResponse.SetUint32(TMTPTypeResponse::EResponseTransactionID, iCurrentRequest->Uint32(TMTPTypeResponse::EResponseTransactionID));
 	SendResponseL(iResponse, *iCurrentRequest, *iCurrentConnection);
-__FLOG_VA((_L8("SendResponseL - Exit, data provider %d "), iId));
+OstTrace1(TRACE_NORMAL, DUP1_CMTPDATAPROVIDER_SENDERRORRESPONSEL,
+"data provider %d ", iId);
+	OstTraceFunctionExit0( CMTPDATAPROVIDER_SENDERRORRESPONSEL_EXIT );
 	}
 CMTPDataProvider::CSupportedCodes* CMTPDataProvider::CSupportedCodes::NewLC(TMTPSupportCategory aCategory, MMTPDataProvider& aDp)
 {
 CSupportedCodes* self = new(ELeave) CSupportedCodes();

changeset 49	c20dd21d1eb4
parent 29	3ae5cb0b4c02
child 54	4dc88a4ac6f4