--- a/usbmgmt/usbmgr/host/fdf/production/server/src/deviceproxy.cpp Wed Jul 07 14:16:40 2010 +0800
+++ b/usbmgmt/usbmgr/host/fdf/production/server/src/deviceproxy.cpp Wed Jul 07 15:08:54 2010 +0800
@@ -1,5 +1,5 @@
/*
-* 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 "Eclipse Public License v1.0"
@@ -20,48 +20,54 @@
@internalComponent
*/
-#include "deviceproxy.h"
+
#include <usb/usblogger.h>
#include <usbhostdefs.h>
#include "utils.h"
#include "event.h"
-
-#ifdef __FLOG_ACTIVE
-_LIT8(KLogComponent, "fdf ");
+#include "deviceproxy.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "deviceproxyTraces.h"
#endif
#ifdef _DEBUG
-PANICCATEGORY("devproxy");
-#endif
-
-#ifdef __FLOG_ACTIVE
#define LOG Log()
+_LIT(KPanicCategory,"devproxy");
#else
#define LOG
#endif
+
+
CDeviceProxy* CDeviceProxy::NewL(RUsbHubDriver& aHubDriver, TUint aDeviceId)
{
- LOG_STATIC_FUNC_ENTRY
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_NEWL_ENTRY );
+
CDeviceProxy* self = new(ELeave) CDeviceProxy(aDeviceId);
CleanupStack::PushL(self);
self->ConstructL(aHubDriver);
CLEANUPSTACK_POP1(self);
+ OstTraceFunctionExit0( CDEVICEPROXY_NEWL_EXIT );
return self;
}
CDeviceProxy::CDeviceProxy(TUint aDeviceId)
: iId(aDeviceId)
{
- LOG_FUNC
+ OstTraceFunctionEntry0( CDEVICEPROXY_CDEVICEPROXY_CONS_ENTRY );
}
void CDeviceProxy::ConstructL(RUsbHubDriver& aHubDriver)
{
- LOG_FUNC
-
- LEAVEIFERRORL(iHandle.Open(aHubDriver, iId));
+ OstTraceFunctionEntry0( CDEVICEPROXY_CONSTRUCTL_ENTRY );
+
+ TInt err=iHandle.Open(aHubDriver, iId);
+ if (err<0)
+ {
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_CONSTRUCTL, "handle open with error %d", err );
+ User::Leave(err);
+ }
// Pre-allocate objects relating to this device for the event queue.
iAttachmentEvent = new(ELeave) TDeviceEvent;
@@ -79,12 +85,13 @@
ReadStringDescriptorsL();
LOG;
+ OstTraceFunctionExit0( CDEVICEPROXY_CONSTRUCTL_EXIT );
}
void CDeviceProxy::ReadStringDescriptorsL()
{
- LOG_FUNC
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_READSTRINGDESCRIPTORSL_ENTRY );
+
// wait 10 ms before reading any string descriptors
// to avoid IOP issues with some USB devices (e.g. PNY Attache)
User::After(10000);
@@ -101,8 +108,16 @@
// language IDs.
TBuf8<256> stringBuf;
TUsbStringDescriptor* stringDesc = NULL;
- ASSERT_DEBUG(iHandle.Handle());
- LEAVEIFERRORL(iHandle.GetStringDescriptor(stringDesc, stringBuf, 0));
+
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP1, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+
+ TInt err=iHandle.GetStringDescriptor(stringDesc, stringBuf, 0);
+ LEAVEIFERRORL(err, OstTrace1( TRACE_ERROR, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP6,
+ "iHandle.GetStringDescriptor error %d", err ););
CleanupStack::PushL(*stringDesc);
// Copy the language IDs into our array.
@@ -110,7 +125,8 @@
TInt16 langId = stringDesc->GetLangId(index);
while ( langId != KErrNotFound )
{
- LOGTEXT2(_L8("\tsupported language: 0x%04x"), langId);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_READSTRINGDESCRIPTORSL, "\tsupported language: 0x%04x", langId );
+
iLangIds.AppendL(langId); // stored as TUint
++index;
langId = stringDesc->GetLangId(index);
@@ -120,17 +136,38 @@
// Get the actual strings for each supported language.
TUsbDeviceDescriptor deviceDescriptor;
- ASSERT_DEBUG(iHandle.Handle());
- LEAVEIFERRORL(iHandle.GetDeviceDescriptor(deviceDescriptor));
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP2, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+
+ err=iHandle.GetDeviceDescriptor(deviceDescriptor);
+ LEAVEIFERRORL(err, OstTrace1( TRACE_ERROR, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP7,
+ "iHandle.GetDeviceDescriptor error %d", err ););
+
TUint8 manufacturerStringDescriptorIndex = deviceDescriptor.ManufacturerIndex();
TUint8 productStringDescriptorIndex = deviceDescriptor.ProductIndex();
TUint8 serialNumberStringDescriptorIndex = deviceDescriptor.SerialNumberIndex();
PopulateStringDescriptorsL(manufacturerStringDescriptorIndex, iManufacturerStrings);
PopulateStringDescriptorsL(productStringDescriptorIndex, iProductStrings);
PopulateStringDescriptorsL(serialNumberStringDescriptorIndex, iSerialNumberStrings);
- ASSERT_DEBUG(iManufacturerStrings.Count() == iLangIds.Count());
- ASSERT_DEBUG(iProductStrings.Count() == iLangIds.Count());
- ASSERT_DEBUG(iSerialNumberStrings.Count() == iLangIds.Count());
+ if(!(iManufacturerStrings.Count() == iLangIds.Count()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP3, "iLangIds error" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+ if(!(iProductStrings.Count() == iLangIds.Count()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP4, "iLangIds error" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+ if(!(iSerialNumberStrings.Count() == iLangIds.Count()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_READSTRINGDESCRIPTORSL_DUP5, "iLangIds error" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+ OstTraceFunctionExit0( CDEVICEPROXY_READSTRINGDESCRIPTORSL_EXIT );
}
// Populates the given array with the supported language variants of the given
@@ -139,8 +176,8 @@
// supported but serial number strings to *not* be.)
void CDeviceProxy::PopulateStringDescriptorsL(TUint8 aStringDescriptorIndex, RArray<TName>& aStringArray)
{
- LOG_FUNC
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_POPULATESTRINGDESCRIPTORSL_ENTRY );
+
const TUint langCount = iLangIds.Count();
for ( TUint ii = 0 ; ii < langCount ; ++ii )
{
@@ -152,17 +189,20 @@
string = KNullDesC();
}
else
- {
- LEAVEIFERRORL(err);
+ {
+ LEAVEIFERRORL(err, OstTrace1( TRACE_NORMAL, CDEVICEPROXY_POPULATESTRINGDESCRIPTORSL, "err=%d", err ););
}
- LEAVEIFERRORL(aStringArray.Append(string));
+ err=aStringArray.Append(string);
+ LEAVEIFERRORL(err, OstTrace0( TRACE_NORMAL, CDEVICEPROXY_POPULATESTRINGDESCRIPTORSL_DUP1, "aStringArray append error"););
}
+ OstTraceFunctionExit0( CDEVICEPROXY_POPULATESTRINGDESCRIPTORSL_EXIT );
}
CDeviceProxy::~CDeviceProxy()
{
- LOG_FUNC
+ OstTraceFunctionEntry0( CDEVICEPROXY_CDEVICEPROXY_DES_ENTRY );
+
LOG;
// In the design, the event objects should all have had ownership taken
@@ -182,76 +222,95 @@
iSerialNumberStrings.Reset();
iHandle.Close();
+ OstTraceFunctionExit0( CDEVICEPROXY_CDEVICEPROXY_DES_EXIT );
}
TInt CDeviceProxy::GetDeviceDescriptor(TUsbDeviceDescriptor& aDescriptor)
{
- LOG_FUNC
-
- ASSERT_DEBUG(iHandle.Handle());
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETDEVICEDESCRIPTOR_ENTRY );
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETDEVICEDESCRIPTOR_DUP1, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
TInt err = iHandle.GetDeviceDescriptor(aDescriptor);
- LOGTEXT2(_L8("\terr = %d"), err);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETDEVICEDESCRIPTOR, "\terr = %d", err );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETDEVICEDESCRIPTOR_EXIT );
return err;
}
TInt CDeviceProxy::GetConfigurationDescriptor(TUsbConfigurationDescriptor& aDescriptor) const
{
- LOG_FUNC
-
- ASSERT_DEBUG(iHandle.Handle());
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETCONFIGURATIONDESCRIPTOR_ENTRY );
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETCONFIGURATIONDESCRIPTOR, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
TInt err = const_cast<RUsbDevice&>(iHandle).GetConfigurationDescriptor(aDescriptor);
- LOGTEXT2(_L8("\terr = %d"), err);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETCONFIGURATIONDESCRIPTOR_DUP1, "\terr = %d", err );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETCONFIGURATIONDESCRIPTOR_EXIT );
return err;
}
TInt CDeviceProxy::GetTokenForInterface(TUint aIndex, TUint32& aToken) const
{
- LOG_FUNC
-
- ASSERT_DEBUG(iHandle.Handle());
- // We shouldn't need to worry about whether the device is suspended or
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETTOKENFORINTERFACE_ENTRY );
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETTOKENFORINTERFACE_DUP1, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+ // We shouldn't need to worry about whether the device is suspended or
// resumed before doing this. This function is only called if we find FDs
// for the device, in which case we wouldn't have suspended it in the
// first place.
TInt err = const_cast<RUsbDevice&>(iHandle).GetTokenForInterface(aIndex, aToken);
- LOGTEXT2(_L8("\terr = %d"), err);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETTOKENFORINTERFACE, "\terr = %d", err );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETTOKENFORINTERFACE_EXIT );
return err;
}
const RArray<TUint>& CDeviceProxy::GetSupportedLanguages() const
{
- LOG_FUNC
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETSUPPORTEDLANGUAGES_ENTRY );
+
return iLangIds;
}
void CDeviceProxy::GetManufacturerStringDescriptorL(TUint32 aLangId, TName& aString) const
{
- LOG_FUNC
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETMANUFACTURERSTRINGDESCRIPTORL_ENTRY );
+
GetStringDescriptorFromCacheL(aLangId, aString, iManufacturerStrings);
+ OstTraceFunctionExit0( CDEVICEPROXY_GETMANUFACTURERSTRINGDESCRIPTORL_EXIT );
}
void CDeviceProxy::GetProductStringDescriptorL(TUint32 aLangId, TName& aString) const
{
- LOG_FUNC
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETPRODUCTSTRINGDESCRIPTORL_ENTRY );
+
GetStringDescriptorFromCacheL(aLangId, aString, iProductStrings);
+ OstTraceFunctionExit0( CDEVICEPROXY_GETPRODUCTSTRINGDESCRIPTORL_EXIT );
}
void CDeviceProxy::GetSerialNumberStringDescriptorL(TUint32 aLangId, TName& aString) const
{
- LOG_FUNC
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETSERIALNUMBERSTRINGDESCRIPTORL_ENTRY );
+
GetStringDescriptorFromCacheL(aLangId, aString, iSerialNumberStrings);
+ OstTraceFunctionExit0( CDEVICEPROXY_GETSERIALNUMBERSTRINGDESCRIPTORL_EXIT );
}
void CDeviceProxy::GetOtgDescriptorL(TOtgDescriptor& aDescriptor) const
{
- LOG_FUNC
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETOTGDESCRIPTORL_ENTRY );
if (iOtgDescriptor)
{
@@ -259,8 +318,10 @@
}
else
{
- LEAVEL(KErrNotSupported);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETOTGDESCRIPTORL, "Error=%d", KErrNotSupported );
+ User::Leave(KErrNotSupported);
}
+ OstTraceFunctionExit0( CDEVICEPROXY_GETOTGDESCRIPTORL_EXIT );
}
void CDeviceProxy::SetOtgDescriptorL(const TUsbOTGDescriptor& aDescriptor)
@@ -279,31 +340,44 @@
// Used during instantiation to read supported strings.
void CDeviceProxy::GetStringDescriptorFromUsbdL(TUint32 aLangId, TName& aString, TUint8 aStringDescriptorIndex) const
{
- LOG_FUNC
- LOGTEXT3(_L8("\taLangId = 0x%04x, aStringDescriptorIndex = %d"), aLangId, aStringDescriptorIndex);
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL_ENTRY );
+
+ OstTraceExt2( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL, "\taLangId = 0x%d, aStringDescriptorIndex = %d", aLangId, aStringDescriptorIndex );
+
// If the string is not defined by the device, leave.
if ( aStringDescriptorIndex == 0 )
{
- LEAVEL(KErrNotFound);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL_DUP1, "err=%d", KErrNotFound );
+ User::Leave(KErrNotFound);
}
TBuf8<255> stringBuf;
TUsbStringDescriptor* stringDesc = NULL;
- ASSERT_DEBUG(iHandle.Handle());
- LEAVEIFERRORL(const_cast<RUsbDevice&>(iHandle).GetStringDescriptor(stringDesc, stringBuf, aStringDescriptorIndex, aLangId));
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL_DUP2, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+ TInt err=const_cast<RUsbDevice&>(iHandle).GetStringDescriptor(stringDesc, stringBuf, aStringDescriptorIndex, aLangId);
+ if(err<0)
+ {
+ OstTrace0( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL_DUP4, "GetStringDescriptor error" );
+ User::Leave(err);
+ }
stringDesc->StringData(aString);
stringDesc->DestroyTree();
delete stringDesc;
- LOGTEXT2(_L("\taString = \"%S\""), &aString);
+ OstTraceExt1( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL_DUP3, "\taString = \"%S\"", aString );
+ OstTraceFunctionExit0( CDEVICEPROXY_GETSTRINGDESCRIPTORFROMUSBDL_EXIT );
}
// Called indirectly by users of this class to query a string descriptor.
void CDeviceProxy::GetStringDescriptorFromCacheL(TUint32 aLangId, TName& aString, const RArray<TName>& aStringArray) const
{
- LOG_FUNC
- LOGTEXT2(_L8("\taLangId = 0x%04x"), aLangId);
-
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETSTRINGDESCRIPTORFROMCACHEL_ENTRY );
+
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMCACHEL_DUP1, "\taLangId = 0x%04x", aLangId );
+
// If the lang ID is not supported by the device, leave. At the same time
// find the index of the required string in the given string array.
const TUint langCount = iLangIds.Count();
@@ -317,21 +391,29 @@
}
if ( index == langCount )
{
- LEAVEL(KErrNotFound);
+ OstTrace0( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMCACHEL, "CDeviceProxy::GetStringDescriptorFromCacheL" );
+ User::Leave(KErrNotFound);
}
aString = aStringArray[index];
- LOGTEXT2(_L("\taString = \"%S\""), &aString);
+ OstTraceExt1( TRACE_NORMAL, CDEVICEPROXY_GETSTRINGDESCRIPTORFROMCACHEL_DUP2, "\taString = \"%S\"", aString );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETSTRINGDESCRIPTORFROMCACHEL_EXIT );
}
TInt CDeviceProxy::Suspend()
{
- LOG_FUNC
-
- ASSERT_DEBUG(iHandle.Handle());
+ OstTraceFunctionEntry0( CDEVICEPROXY_SUSPEND_ENTRY );
+ if(!(iHandle.Handle()))
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_SUSPEND_DUP1, "Empty handler" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
TInt ret = iHandle.Suspend();
- LOGTEXT2(_L8("\tret = %d"), ret);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_SUSPEND, "\tret = %d", ret );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_SUSPEND_EXIT );
return ret;
}
@@ -342,73 +424,100 @@
void CDeviceProxy::SetDriverLoadingEventData(TDriverLoadStatus aStatus, TInt aError)
{
- LOG_FUNC
- LOGTEXT3(_L8("\taStatus = %d, aError = %d"), aStatus, aError);
-
- ASSERT_DEBUG(iDriverLoadingEvent);
- iDriverLoadingEvent->iInfo.iDriverLoadStatus = aStatus;
+ OstTraceFunctionEntry0( CDEVICEPROXY_SETDRIVERLOADINGEVENTDATA_ENTRY );
+
+ OstTraceExt2( TRACE_NORMAL, CDEVICEPROXY_SETDRIVERLOADINGEVENTDATA, "\taStatus = %d, aError = %d", aStatus, aError );
+ if(!iDriverLoadingEvent)
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_SETDRIVERLOADINGEVENTDATA_DUP1, "Empty Driver Loading Event" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
+ iDriverLoadingEvent->iInfo.iDriverLoadStatus = aStatus;
iDriverLoadingEvent->iInfo.iError = aError;
LOG;
+ OstTraceFunctionExit0( CDEVICEPROXY_SETDRIVERLOADINGEVENTDATA_EXIT );
}
TDeviceEvent* CDeviceProxy::GetAttachmentEventObject()
{
- LOG_FUNC
- LOG;
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETATTACHMENTEVENTOBJECT_ENTRY );
+
+ LOG;
+ if(!iAttachmentEvent)
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETATTACHMENTEVENTOBJECT_DUP1, "Empty Attechment Event" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
- ASSERT_DEBUG(iAttachmentEvent);
TDeviceEvent* const obj = iAttachmentEvent;
iAttachmentEvent = NULL;
- LOGTEXT2(_L8("\tobj = 0x%08x"), obj);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETATTACHMENTEVENTOBJECT, "\tobj = 0x%08x", obj );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETATTACHMENTEVENTOBJECT_EXIT );
return obj;
}
TDeviceEvent* CDeviceProxy::GetDriverLoadingEventObject()
{
- LOG_FUNC
- LOG;
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETDRIVERLOADINGEVENTOBJECT_ENTRY );
+
+ LOG;
+ if(!iDriverLoadingEvent)
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETDRIVERLOADINGEVENTOBJECT, "Empty Driver Loading Event" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
- ASSERT_DEBUG(iDriverLoadingEvent);
TDeviceEvent* const obj = iDriverLoadingEvent;
iDriverLoadingEvent = NULL;
- LOGTEXT2(_L8("\tobj = 0x%08x"), obj);
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETDRIVERLOADINGEVENTOBJECT_DUP1, "\tobj = 0x%08x", obj );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETDRIVERLOADINGEVENTOBJECT_EXIT );
return obj;
}
TDeviceEvent* CDeviceProxy::GetDetachmentEventObject()
{
- LOG_FUNC
- LOG;
+ OstTraceFunctionEntry0( CDEVICEPROXY_GETDETACHMENTEVENTOBJECT_ENTRY );
+ LOG;
- ASSERT_DEBUG(iDetachmentEvent);
+ if(!iDetachmentEvent)
+ {
+ OstTrace0( TRACE_FATAL, CDEVICEPROXY_GETDETACHMENTEVENTOBJECT, "Empty Detachment Event" );
+ __ASSERT_DEBUG(EFalse,User::Panic(KPanicCategory, __LINE__));
+ }
TDeviceEvent* const obj = iDetachmentEvent;
iDetachmentEvent = NULL;
- LOGTEXT2(_L8("\tobj = 0x%08x"), obj);
+
+ OstTrace1( TRACE_NORMAL, CDEVICEPROXY_GETDETACHMENTEVENTOBJECT_DUP1, "\tobj = 0x%08x", obj );
+
+ OstTraceFunctionExit0( CDEVICEPROXY_GETDETACHMENTEVENTOBJECT_EXIT );
return obj;
}
-#ifdef __FLOG_ACTIVE
void CDeviceProxy::Log()
{
- LOG_FUNC
-
- LOGTEXT2(_L8("\tiId = %d"), iId);
- LOGTEXT2(_L8("\tiHandle.Handle() = %d"), iHandle.Handle());
- if ( iAttachmentEvent )
+ OstTraceFunctionEntry0( CDEVICEPROXY_LOG_ENTRY );
+
+ OstTrace1( TRACE_DUMP, CDEVICEPROXY_LOG, "\tiId = %d", iId );
+ OstTrace1( TRACE_DUMP, CDEVICEPROXY_LOG_DUP1, "\tiHandle.Handle() = %d", iHandle.Handle() );
+
+ if ( iAttachmentEvent )
{
- LOGTEXT(_L8("\tlogging iAttachmentEvent"));
- iAttachmentEvent->Log();
+ OstTrace0( TRACE_DUMP, CDEVICEPROXY_LOG_DUP2, "\tlogging iAttachmentEvent" );
+ iAttachmentEvent->Log();
}
if ( iDriverLoadingEvent )
{
- LOGTEXT(_L8("\tlogging iDriverLoadingEvent"));
+ OstTrace0( TRACE_DUMP, CDEVICEPROXY_LOG_DUP3, "\tlogging iDriverLoadingEvent" );
+
iDriverLoadingEvent->Log();
}
if ( iDetachmentEvent )
{
- LOGTEXT(_L8("\tlogging iDetachmentEvent"));
+ OstTrace0( TRACE_DUMP, CDEVICEPROXY_LOG_DUP4, "\tlogging iDetachmentEvent" );
iDetachmentEvent->Log();
}
const TUint langCount = iLangIds.Count();
@@ -421,24 +530,26 @@
// This has been done to protect in case there have been an incomplete construction etc..
// when logging the data
- LOGTEXT2(_L8("\tlangCount = %d"), langCount);
+ OstTrace1( TRACE_DUMP, CDEVICEPROXY_LOG_DUP5, "C\tlangCount = %d", langCount );
+
for ( TUint ii = 0 ; ii < langCount ; ++ii )
{
- LOGTEXT2(_L("\tlang ID 0x%04x:"), iLangIds[ii]);
+ OstTrace1( TRACE_FLOW, CDEVICEPROXY_LOG_DUP6, "\tlang ID 0x%04x:", iLangIds[ii] );
+
if(ii<manufacturerCount)
{
- LOGTEXT2(_L("\t\tmanufacturer string: \"%S\""), &iManufacturerStrings[ii]);
- }
+ OstTraceExt1( TRACE_FLOW, CDEVICEPROXY_LOG_DUP7, "\t\tmanufacturer string: \"%S\"", iManufacturerStrings[ii] );
+ }
if(ii<productCount)
{
- LOGTEXT2(_L("\t\tproduct string: \"%S\""), &iProductStrings[ii]);
- }
+ OstTraceExt1( TRACE_FLOW, CDEVICEPROXY_LOG_DUP8, "\t\tproduct string: \"%S\"", iProductStrings[ii]);
+ }
if(ii<serialNumberCount)
{
- LOGTEXT2(_L("\t\tserial number string: \"%S\""), &iSerialNumberStrings[ii]);
+ OstTraceExt1( TRACE_FLOW, CDEVICEPROXY_LOG_DUP9, "\t\tserial number string: \"%S\"", iSerialNumberStrings[ii]);
}
}
+ OstTraceFunctionExit0( CDEVICEPROXY_LOG_EXIT );
}
-#endif