FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/dataproviders/devdp/src/cmtpdevicedatastore.cpp

equal deleted inserted replaced

-:a5deb6b96675
+:63cf70d3ecd8
 #include "cmtpdevicedatastore.h"
 #include "cmtpframeworkconfig.h"
 #include "mmtpenumerationcallback.h"
 #include "mtpdevdppanic.h"
 #include "mtpdevicedpconst.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmtpdevicedatastoreTraces.h"
+#endif
 // Class constants.
-__FLOG_STMT(_LIT8(KComponent,"DeviceDataStore");)
 _LIT( KFileName, "z:\\private\\102827a2\\mtpdevice.ico");
 // Device property datastore constants.
 /**
 Destructor.
 */
 CMTPDeviceDataStore::~CMTPDeviceDataStore()
 {
-__FLOG(_L8("~CMTPDeviceDataStore - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_CMTPDEVICEDATASTORE_DES_ENTRY );
 Cancel();
 delete iDeviceFriendlyNameDefault;
 delete iSyncPartnerNameDefault;
 delete iDeviceFriendlyName;
 delete iSynchronisationPartner;
 delete iDateTime;
 iDeviceVersion.Close();
 iSerialNumber.Close();
 iSingletons.Close();
 iMTPExtensions.Close();
-__FLOG(_L8("~CMTPDeviceDataStore - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_CMTPDEVICEDATASTORE_DES_EXIT );
-__FLOG_CLOSE;
 }
 /**
 Check to see if a request such as BatteryLevel is currently
 pending for processing. If so it's not advisable to make another
 	return IsActive();
 	}
 void CMTPDeviceDataStore::BatteryLevelL(TRequestStatus& aStatus, TUint& aBatteryLevel)
 {
-__FLOG(_L8("BatteryLevel - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_BATTERYLEVELL_ENTRY );
 	if (RequestPending())
 		{
 		// We are already reading battery level
 		// leave so we don't set ourselves active twice
+OstTrace0( TRACE_ERROR, CMTPDEVICEDATASTORE_BATTERYLEVELL, "already reading battery level, no need to set active twice" );
 		User::Leave(KErrInUse);
 		}
 iPendingStatus = &aStatus;
 	SetRequestPending(*iPendingStatus);
 else
 {
 aBatteryLevel = KMTPDefaultBatteryLevel;
 	SetRequestComplete(*iPendingStatus, KErrNone);
 }
-__FLOG(_L8("BatteryLevel - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_BATTERYLEVELL_EXIT );
 }
 /**
 Provides the MTP device friendly name.
 @return The MTP device friendly name.
 */
 const TDesC& CMTPDeviceDataStore::DeviceFriendlyName() const
 {
-__FLOG(_L8("DeviceFriendlyName - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_DEVICEFRIENDLYNAME_ENTRY );
-__FLOG(_L8("DeviceFriendlyName - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_DEVICEFRIENDLYNAME_EXIT );
 return iDeviceFriendlyName->StringChars();
 }
 /**
 Provides the default MTP device friendly name.
 @return The default MTP device friendly name.
 */
 const TDesC& CMTPDeviceDataStore::DeviceFriendlyNameDefault() const
 {
-__FLOG(_L8("DeviceFriendlyNameDefault - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_DEVICEFRIENDLYNAMEDEFAULT_ENTRY );
-__FLOG(_L8("DeviceFriendlyNameDefault - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_DEVICEFRIENDLYNAMEDEFAULT_EXIT );
 return *iDeviceFriendlyNameDefault;
 }
 /**
 Provides the device firmware version identifier
 @return The device firmware version identifier .
 */
 const TDesC& CMTPDeviceDataStore::DeviceVersion() const
 {
-__FLOG(_L8("DeviceVersion - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_DEVICEVERSION_ENTRY );
-__FLOG(_L8("DeviceVersion - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_DEVICEVERSION_EXIT );
 return iDeviceVersion;
 }
 /**
 Provides the device manufacturer name.
 @return The device manufacturer name.
 */
 const TDesC& CMTPDeviceDataStore::Manufacturer() const
 {
-__FLOG(_L8("Manufacturer - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_MANUFACTURER_ENTRY );
 __ASSERT_DEBUG(Enumerated(), Panic(EMTPDevDpInvalidState));
-__FLOG(_L8("Manufacturer - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_MANUFACTURER_EXIT );
 return iPhoneIdV1.iManufacturer;
 }
 /**
 Provides the device model identifier.
 @return The device model identifier.
 */
 const TDesC& CMTPDeviceDataStore::Model() const
 {
-__FLOG(_L8("Model - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_MODEL_ENTRY );
 __ASSERT_DEBUG(Enumerated(), Panic(EMTPDevDpInvalidState));
-__FLOG(_L8("Model - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_MODEL_EXIT );
 return iPhoneIdV1.iModel;
 }
 /**
 Provides the MTP Vendor Extension string.
 @return The MTP Vendor Extension string.
 */
 const TDesC& CMTPDeviceDataStore::MTPExtensions() const
 {
-__FLOG(_L8("MTPExtensions - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_MTPEXTENSIONS_ENTRY );
-__FLOG(_L8("MTPExtensions - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_MTPEXTENSIONS_EXIT );
 return iMTPExtensions;
 }
 /**
 Provides the device serial number.
 @return The device serial number.
 */
 const TDesC& CMTPDeviceDataStore::SerialNumber() const
 {
-__FLOG(_L8("SerialNumber - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SERIALNUMBER_ENTRY );
 __ASSERT_DEBUG(Enumerated(), Panic(EMTPDevDpInvalidState));
-__FLOG(_L8("SerialNumber - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SERIALNUMBER_EXIT );
 return iPhoneIdV1.iSerialNumber;
 }
 /**
 Provides the MTP synchronisation partner name.
 @return The MTP synchronisation partner name.
 */
 const TDesC& CMTPDeviceDataStore::SynchronisationPartner() const
 {
-__FLOG(_L8("SynchronisationPartner - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SYNCHRONISATIONPARTNER_ENTRY );
-__FLOG(_L8("SynchronisationPartner - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SYNCHRONISATIONPARTNER_EXIT );
 return iSynchronisationPartner->StringChars();
 }
 /**
 Provides the default MTP synchronisation partner name.
 @return The default MTP synchronisation partner name.
 */
 const TDesC& CMTPDeviceDataStore::SynchronisationPartnerDefault() const
 {
-__FLOG(_L8("SynchronisationPartnerDefault - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SYNCHRONISATIONPARTNERDEFAULT_ENTRY );
-__FLOG(_L8("SynchronisationPartnerDefault - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SYNCHRONISATIONPARTNERDEFAULT_EXIT );
 return *iSyncPartnerNameDefault;
 }
 /**
 Sets the MTP device friendly name.
 @param aName The new MTP device friendly name.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::SetDeviceFriendlyNameL(const TDesC& aName)
 {
-__FLOG(_L8("SetDeviceFriendlyNameL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETDEVICEFRIENDLYNAMEL_ENTRY );
 iDeviceFriendlyName->SetL(aName);
 StoreL();
-__FLOG(_L8("SetDeviceFriendlyNameL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETDEVICEFRIENDLYNAMEL_EXIT );
 }
 /**
 Sets the synchronisation partner name.
 @param aName The new MTP synchronisation partner name.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::SetSynchronisationPartnerL(const TDesC& aName)
 {
-__FLOG(_L8("SetSynchronisationPartnerL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETSYNCHRONISATIONPARTNERL_ENTRY );
 iSynchronisationPartner->SetL(aName);
 StoreL();
-__FLOG(_L8("SetSynchronisationPartnerL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETSYNCHRONISATIONPARTNERL_EXIT );
 }
 /**
 Initiates the MTP device data provider's device information data store
 enumeration sequence. The sequence is concluded when ObjectEnumerationCompleteL
 @param aCallback Callback to be called when enumeration completes.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::StartEnumerationL(TUint32 aStorageId, MMTPEnumerationCallback& aCallback)
 {
-__FLOG(_L8("StartEnumerationL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_STARTENUMERATIONL_ENTRY );
 if (State() != EUndefined)
 {
 aCallback.NotifyEnumerationCompleteL(aStorageId, KErrNone);
 }
 else
 {
 iStorageId = aStorageId;
 iCallback = &aCallback;
 Schedule(EEnumeratingDevicePropertyStore);
 }
-__FLOG(_L8("StartEnumerationL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_STARTENUMERATIONL_EXIT );
 }
 void CMTPDeviceDataStore::DoCancel()
 {
-__FLOG(_L8("DoCancel - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_DOCANCEL_ENTRY );
 if (iTelephony)
 {
 switch (State())
 {
 case EEnumeratingPhoneId:
 default:
 // Nothing to do.
 break;
 }
 }
-__FLOG(_L8("DoCancel - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_DOCANCEL_EXIT );
 }
 /**
 Handles leaves occurring in RunL.
 @param aError leave error code
 @return KErrNone
 */
 TInt CMTPDeviceDataStore::RunError(TInt aError)
 {
-__FLOG(_L8("RunError - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_RUNERROR_ENTRY );
-__FLOG_VA((_L8("Error = %d, State = %d"), aError, State()));
+OstTraceExt2(TRACE_NORMAL, CMTPDEVICEDATASTORE_RUNERROR,
+"Error = %d, State = %d", aError, (TInt)State());
 	aError = aError;	// suppress compiler warning
 switch (State())
 {
 case EEnumeratingDevicePropertyStore:
 default:
 __DEBUG_ONLY(Panic(EMTPDevDpInvalidState));
 break;
 }
-__FLOG(_L8("RunError - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_RUNERROR_EXIT );
 return KErrNone;
 }
 void CMTPDeviceDataStore::RunL()
 {
-__FLOG(_L8("RunL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_RUNL_ENTRY );
 switch (State())
 {
 case EEnumeratingDevicePropertyStore:
 RestoreL();
 Schedule(EEnumeratingDeviceVersion);
 case EUndefined:
 default:
 __DEBUG_ONLY(Panic(EMTPDevDpInvalidState));
 break;
 }
-__FLOG(_L8("RunL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_RUNL_EXIT );
 }
 /**
 Constructor.
 @param aConnectionMgr The MTP connection manager interface.
 	iBatteryInfoV1Pckg(iBatteryInfoV1),
 	iPhoneIdV1Pckg(iPhoneIdV1),
 	iIsConnectMac(EFalse),
 	iHasPendingRequest(EFalse)
 {
+OstTraceFunctionEntry0( DUP1_CMTPDEVICEDATASTORE_CMTPDEVICEDATASTORE_ENTRY );
 CActiveScheduler::Add(this);
+OstTraceFunctionExit0( DUP1_CMTPDEVICEDATASTORE_CMTPDEVICEDATASTORE_EXIT );
 }
 /**
 Second phase constructor.
 */
 void CMTPDeviceDataStore::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL - Entry"));
 iSingletons.OpenL();
 /*
 Set the default values.
 iDateTime = CMTPTypeString::NewL(dateTimeString);
 //11 Device Icon property, Load the icon into Auint Atrray
 LoadDeviceIconL();
-__FLOG(_L8("ConstructL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_CONSTRUCTL_EXIT );
 }
 /**
 Indicates if the device information data store is in the EEnumerated state.
 @return ETrue if the device data store state is enumerated, otherwiese EFalse.
 */
 TBool CMTPDeviceDataStore::Enumerated() const
 {
-__FLOG(_L8("Enumerated - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_ENUMERATED_ENTRY );
 TInt32 state(State());
-__FLOG(_L8("Enumerated - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_ENUMERATED_EXIT );
 return (state & EEnumerated);
 }
 /**
 Externalizes device properties to the device property store.
 @param aWriteStream the stream to externalize the device properties
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::ExternalizeL(RWriteStream& aWriteStream) const
 {
-__FLOG(_L8("ExternalizeL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_EXTERNALIZEL_ENTRY );
 aWriteStream.WriteInt32L(KMTPDevicePropertyStoreVersion);
 aWriteStream << DeviceFriendlyName();
 aWriteStream << SynchronisationPartner();
-__FLOG(_L8("ExternalizeL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_EXTERNALIZEL_EXIT );
 }
 /**
 Internalises device properties from the device property store.
 @param aReadStream The device property store input data stream.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::InternalizeL(RReadStream& aReadStream)
 {
-__FLOG(_L8("InternalizeL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_INTERNALIZEL_ENTRY );
 RBuf buf;
 buf.CleanupClosePushL();
 /*
 Read the device property store version. This is present for future
 buf.CreateL(aReadStream, KMTPMaxStringCharactersLength);
 iSynchronisationPartner->SetL(buf);
 buf.Close();
 CleanupStack::Pop();  //buf
-__FLOG(_L8("InternalizeL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_INTERNALIZEL_EXIT );
 }
 /**
 Provides the full pathname of the device property store.
 @return The full pathname of the device property store.
 */
 const TDesC& CMTPDeviceDataStore::PropertyStoreName()
 {
-__FLOG(_L8("PropertyStoreName - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_PROPERTYSTORENAME_ENTRY );
 if (iPropertyStoreName.Length() == 0)
 {
 iSingletons.Fs().PrivatePath(iPropertyStoreName);
 iPropertyStoreName.Insert(0, KMTPDevicePropertyStoreDrive);
 iPropertyStoreName.Append(KMTPNoBackupFolder);
 iPropertyStoreName.Append(KMTPDevicePropertyStoreFileName);
 }
-__FLOG(_L8("PropertyStoreName - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_PROPERTYSTORENAME_EXIT );
 return iPropertyStoreName;
 }
 /**
 Query all dps for the MTP Vendor extensions set.
 @return ETrue if finished querying all the dps, otherwise EFalse.
 */
 void CMTPDeviceDataStore::AppendMTPExtensionSetsL(TBool& aCompleted)
 {
-__FLOG(_L8("AppendMTPExtensionSetsL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_APPENDMTPEXTENSIONSETSL_ENTRY );
 	CMTPDataProviderController& dps(iSingletons.DpController());
 	const TInt count = Min<TInt>(iCurrentDpIndex + KExtensionSetIterationRunLength, dps.Count());
 	aCompleted = EFalse;
 	CDesCArraySeg* extensions = new (ELeave) CDesCArraySeg(KExtensionSetGranularity);
 	CleanupStack::PushL(extensions);
 		for (TInt i = 0; i < n; i++)
 			{
 			len += (*extensions)[i].Length() + KMTPVendorExtensionSetDelimiter().Length();
 			if (len > KMTPMaxStringCharactersLength)
 				{
-				__FLOG(_L8("MTP Extensions set exceeded the maximum MTP String length"));
+				OstTrace0(TRACE_WARNING, CMTPDEVICEDATASTORE_APPENDMTPEXTENSIONSETSL,
+				        "MTP Extensions set exceeded the maximum MTP String length");
 				// End querying dps when the extension set exceeds the maximum mtp string length.
 				aCompleted = ETrue;
 				break;
 				}
 			else
 	if(!aCompleted && iCurrentDpIndex >= dps.Count())
 		{
 		aCompleted = ETrue;
 		}
-	__FLOG(_L8("AppendMTPExtensionSetsL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_APPENDMTPEXTENSIONSETSL_EXIT );
 }
 /**
 Loads device properties from the device property store.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::RestoreL()
 {
-__FLOG(_L8("RestoreL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_RESTOREL_ENTRY );
 RFs& fs(iSingletons.Fs());
 if(BaflUtils::FileExists(fs, PropertyStoreName()))
 {
 CFileStore* store(CDirectFileStore::OpenLC(fs, PropertyStoreName(), EFileRead));
 RStoreReadStream instream;
 instream.OpenLC(*store, store->Root());
 InternalizeL(instream);
 CleanupStack::PopAndDestroy(2, store); // instream, store
 }
-__FLOG(_L8("RestoreL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_RESTOREL_EXIT );
 }
 /**
 Schedules the device information data store to transition to the specified state.
 @param aState The new data stream state.
 */
 void CMTPDeviceDataStore::Schedule(TInt32 aState)
 {
-__FLOG(_L8("Schedule - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SCHEDULE_ENTRY );
 SetState(aState);
 SetRequestPending(iStatus);
 SetActive();
 SetRequestComplete(iStatus,KErrNone);
-__FLOG(_L8("Schedule - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SCHEDULE_EXIT );
 }
 /**
 Completes the supplied asynchronous request completion status.
 */
 void CMTPDeviceDataStore::SetRequestComplete(TRequestStatus& aRequest, TUint aErr)
 {
-__FLOG(_L8("CompleteRequest - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETREQUESTCOMPLETE_ENTRY );
 TRequestStatus* status(&aRequest);
 User::RequestComplete(status, aErr);
-__FLOG(_L8("CompleteRequest - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETREQUESTCOMPLETE_EXIT );
 }
 /**
 Initialises the supplied asynchronous request completion status.
 */
 void CMTPDeviceDataStore::SetRequestPending(TRequestStatus& aRequest)
 {
-__FLOG(_L8("SetRequestPending - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETREQUESTPENDING_ENTRY );
 aRequest = KRequestPending;
-__FLOG(_L8("SetRequestPending - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETREQUESTPENDING_EXIT );
 }
 /**
 Sets the device information data store state variable.
 @param aState The new data stream state.
 */
 void CMTPDeviceDataStore::SetState(TInt32 aState)
 {
-__FLOG(_L8("SetState - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETSTATE_ENTRY );
 iState = ((EEnumerated & iState) | aState);
-__FLOG_VA((_L8("State set to 0x%08X"), iState));
+OstTrace1(TRACE_NORMAL, CMTPDEVICEDATASTORE_SETSTATE,
-__FLOG(_L8("SetState - Exit"));
+"State set to 0x%08X", iState);
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETSTATE_EXIT );
 }
 /**
 Provides the device information data store state variable value.
 @return The device information data store state variable value.
 */
 TInt32 CMTPDeviceDataStore::State() const
 {
-__FLOG(_L8("State - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_STATE_ENTRY );
-__FLOG_VA((_L8("State = 0x%08X"), iState));
+OstTrace1(TRACE_NORMAL, CMTPDEVICEDATASTORE_STATE,
-__FLOG(_L8("State - Exit"));
+"State = 0x%08X", iState);
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_STATE_EXIT );
 return iState;
 }
 /**
 Stores device properties in the device property store.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 void CMTPDeviceDataStore::StoreL()
 {
-__FLOG(_L8("StoreL - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_STOREL_ENTRY );
 CFileStore* store(CDirectFileStore::ReplaceLC(iSingletons.Fs(), PropertyStoreName(), EFileWrite));
 store->SetTypeL(KDirectFileStoreLayoutUid);
 RStoreWriteStream outstream;
 TStreamId id = outstream.CreateLC(*store);
 ExternalizeL(outstream);
 outstream.CommitL();
 CleanupStack::PopAndDestroy(&outstream);
 store->SetRootL(id);
 store->CommitL();
 CleanupStack::PopAndDestroy(store);
-__FLOG(_L8("StoreL - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_STOREL_EXIT );
 }
 /**
 Formats the specified serial number as a valid MTP Serial Number string. The
 MTP specification recommends that the serial number always be represented as
 exactly 32 characters, with leading zeros as required.
 */
 void CMTPDeviceDataStore::StoreFormattedSerialNumber(const TDesC& aSerialNo)
 {
-__FLOG(_L8("FormatSerialNumber - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_STOREFORMATTEDSERIALNUMBER_ENTRY );
 TBuf<KMTPSerialNumberLength> formatted;
 if (aSerialNo.Length() < KMTPSerialNumberLength)
 {
 formatted = aSerialNo;
 }
 }
 // Store the formatted serial number.
 iPhoneIdV1.iSerialNumber = formatted;
-__FLOG(_L8("FormatSerialNumber - Exit"));
+OstTraceFunctionExit0( CMTPDEVICEDATASTORE_STOREFORMATTEDSERIALNUMBER_EXIT );
 }
 /**
 * Get method for Session initiator version info(0xD406).
 *
 * @return TDesC& : session initiator version info
 */
 const TDesC& CMTPDeviceDataStore::SessionInitiatorVersionInfo() const
 	{
-	__FLOG(_L8("SessionInitiatorVersionInfo - Entry:Exit"));
+	OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SESSIONINITIATORVERSIONINFO_ENTRY );
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SESSIONINITIATORVERSIONINFO_EXIT );
 	return iSessionInitiatorVersionInfo->StringChars();
 	}
 /**
 * Get method for Session initiator version info Default value.
 *
 * @return TDesC& : session initiator version info default.
 */
 const TDesC& CMTPDeviceDataStore::SessionInitiatorVersionInfoDefault() const
 	{
-	__FLOG(_L8("SessionInitiatorVersionInfoDefault - Entry:Exit"));
+	OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SESSIONINITIATORVERSIONINFODEFAULT_ENTRY );
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SESSIONINITIATORVERSIONINFODEFAULT_EXIT );
 	return KDefaultSessionInitiatorVersionInfo;
 	}
 /**
 * Set method for Session initiator version info(0xD406).
 *
 * @Param TDesC& : session initiator version info from the initiator
 */
 void CMTPDeviceDataStore::SetSessionInitiatorVersionInfoL(const TDesC& aVerInfo)
 	{
-	 __FLOG(_L8("SetDeviceFriendlyNameL - Entry"));
+	 OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETSESSIONINITIATORVERSIONINFOL_ENTRY );
 	 iSessionInitiatorVersionInfo->SetL(aVerInfo);
 	 StoreL();
-	 __FLOG(_L8("SetDeviceFriendlyNameL - Exit"));
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETSESSIONINITIATORVERSIONINFOL_EXIT );
 	}
 /**
 * Get method for PerceivedDeviceTypeDefault(0x00000000	Generic).
 *
 * @return TUint32: return value for PerceivedDeviceTypeDefault
 */
 TUint32 CMTPDeviceDataStore::PerceivedDeviceTypeDefault() const
 	{
-	__FLOG(_L8("SessionInitiatorVersionInfoDefault - Entry:Exit"));
+	OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_PERCEIVEDDEVICETYPEDEFAULT_ENTRY );
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_PERCEIVEDDEVICETYPEDEFAULT_EXIT );
 	return DefaultPerceivedDeviceType;
 	}
 /**
 * Get method for PerceivedDeviceType(0x00000003 Mobile Handset).
 * 0x00000006	Audio Recorder.
 * @return TUint32: return value for PerceivedDeviceType.
 */
 TUint32 CMTPDeviceDataStore::PerceivedDeviceType() const
 	{
-	__FLOG(_L8("SessionInitiatorVersionInfo - Entry:Exit"));
+	OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_PERCEIVEDDEVICETYPE_ENTRY );
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_PERCEIVEDDEVICETYPE_Exit );
 	return iPerceivedDeviceType.Value();
 	}
 /**
 * Get method for Date time.
 * @return TDesC: const date time string YYYYMMDDThhmmss.s
 **/
 const TDesC& CMTPDeviceDataStore::DateTimeL()
 	{
-	__FLOG(_L8("DateTime - Entry:Exit"));
+	OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_DATETIMEL_ENTRY );
 	TBuf<30> dateTimeString;
 	DateTimeToStringL(dateTimeString);
 	iDateTime->SetL(dateTimeString);
-	__FLOG(_L8("DateTime -Exit"));
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_DATETIMEL_EXIT );
 	return iDateTime->StringChars();
 	}
 /**
 * This method to set the date time on MTP device
 *@Param aDateTime : Date time string.
 * Some modification need to be done on this method(minor change).
 **/
 TInt CMTPDeviceDataStore::SetDateTimeL(const TDesC& aDateTime )
 {
-__FLOG(_L8("SetDateTime - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_SETDATETIMEL_ENTRY );
 TBuf<30> dateTime;
 TInt offset = User::UTCOffset().Int();
 	//get actul time to set, offset  + ,- or UTC and offset from UTC in seconds.
 TInt errorCode = ValidateString(aDateTime, dateTime, offset);
 if(KErrNone == errorCode)
 	   	{
 //if date time is YYYYMMDDTHHMMSS.S or append with 'Z' then
 		  TTimeIntervalSeconds utcOffset(offset);
 	  // Subtract seconds ahead, to get to UTC timezone
 	  tt -= utcOffset;
-	  __FLOG(_L8("Setting UTC time"));
+	  OstTrace0( TRACE_NORMAL, DUP1_CMTPDEVICEDATASTORE_SETDATETIMEL,
+	          "Setting UTC time" );
 	  errorCode = User::SetUTCTime(tt);
-__FLOG_STMT(TBuf<30> readable;)
+#ifdef OST_TRACE_COMPILER_IN_USE
-	  __FLOG_STMT(tt.FormatL(readable, _L("%F%Y%M%DT%H%T%SZ"));)
+	  TBuf<30> readable;
-	  __FLOG_1(_L("Time now: %S"), &readable);
+	  tt.FormatL(readable, _L("%F%Y%M%DT%H%T%SZ"));
+#endif
+OstTraceExt1( TRACE_NORMAL, DUP2_CMTPDEVICEDATASTORE_SETDATETIMEL,
+"Time now: %S", readable);
 }
 }
-__FLOG_1(_L8("SetDateTime - Exit %d"), errorCode);
+OstTrace1(TRACE_NORMAL, CMTPDEVICEDATASTORE_SETDATETIMEL, "Exit %d", errorCode);
-	return errorCode;
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_SETDATETIMEL_EXIT );
+		return errorCode;
 }
 /**
 *This method will create a string that is compatible for MTP datet time .
 * yet but that can be done easly. one more function can be implemented
 * for appending 0s
 **/
 void CMTPDeviceDataStore::DateTimeToStringL(TDes& aDateTime)
 {
-__FLOG(_L8("DateTimeToString - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_DATETIMETOSTRINGL_ENTRY );
 //get home time and convert it to string
 TTime tt;
 tt.UniversalTime();
 _LIT(KFormat,"%F%Y%M%DT%H%T%SZ");
 tt.FormatL(aDateTime, KFormat);
-__FLOG(_L8("DateTimeToString - Exit"));
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_DATETIMETOSTRINGL_EXIT );
 	}
 /**
 *This method will convert MTP date time format ("YYYYMMDDThhmmss.s")to
 *TTime time format YYYYMMDD:hhmmss.ssssss. Right now microsecond part is
 * not implemented.
 **/
 void CMTPDeviceDataStore::StringToDateTimeL(TDes& aDateTime )
 	{
-__FLOG(_L8("StringToDateTime - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_STRINGTODATETIMEL_ENTRY );
 	TBuf<30> newTime;
 	_LIT(KDlemMTP,"T");
 	_LIT(KDlemTTime,":");
 	TInt pos = aDateTime.Find(KDlemMTP)	;
 	if((KErrNotFound != pos) && (KPosDelemT == pos))
 		newTime.Append(aDateTime.Mid(pos + 1));
 		aDateTime.Copy(newTime);
 		}
 	else
 		{
+OstTraceExt1( TRACE_ERROR, DUP1_CMTPDEVICEDATASTORE_STRINGTODATETIMEL,
+"wrong argument, can't convert string %S to datetime", aDateTime);
 User::Leave( KErrArgument );
 		}
-__FLOG_1(_L("Processed DateTime: %S"), &aDateTime);
+OstTraceExt1(TRACE_NORMAL, CMTPDEVICEDATASTORE_STRINGTODATETIMEL,
-	__FLOG(_L8("StringToDateTime - Exit"));
+"Processed DateTime: %S", aDateTime);
+	OstTraceFunctionExit0( CMTPDEVICEDATASTORE_STRINGTODATETIMEL_EXIT );
 	}
 /**
 *This method to validate the incoming date time string
 *Any incoming string from intiator supposed to be either  YYYYMMDDThhmmss.s
 *2.based on the carector and its position.
 *char allowded are 'Z', 'T', '.','+' and '-'
 */
 TInt CMTPDeviceDataStore::ValidateString(const TDesC& aDateTimeStr, TDes& aDateTime, TInt &aOffsetVal)
 	{
-__FLOG(_L8("ValidateString - Entry"));
+OstTraceFunctionEntry0( CMTPDEVICEDATASTORE_VALIDATESTRING_ENTRY );
-__FLOG_1(_L("Supplied date: %S"), &aDateTimeStr);
+OstTraceExt1(TRACE_NORMAL, CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Supplied date: %S", aDateTimeStr);
 	_LIT(KDlemMTP,"T");
 	TInt errCode = KErrNone;
 	TInt pos = aDateTimeStr.Find(KDlemMTP);
 TInt nullCharPos = aDateTimeStr.Locate('\0');
 	if ( KErrNotFound != nullCharPos )
 	//1.validation is done based on minimum length of the string and pos
 	if((KErrNotFound ==  pos )	|| (aDateTimeStr.Length() > KMaxDateTimeLength) ||
 	    (aDateTimeStr.Length() < KMinDateTimeLength) || pos != KPosDelemT)
 		{
-__FLOG_2(_L8("Invalid. pos: %d, len: %d"), pos, aDateTimeStr.Length());
+OstTraceExt2(TRACE_NORMAL, DUP1_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Invalid. pos: %d, len: %d", pos, aDateTimeStr.Length());
 		errCode = KErrGeneral;
 		}
 	else
 		{
 		//validation based on the carector and its position.
 				{
 				case 'T':
 				case 't':
 				if(i != pos)
 					{
-__FLOG_1(_L8("Invalid. 'T' encountered at offset %d"), i);
+OstTrace1(TRACE_NORMAL, DUP2_CMTPDEVICEDATASTORE_VALIDATESTRING,
-					//error char at rong position
+"Invalid. 'T' encountered at offset %d", i);
+//error char at rong position
 					errCode = KErrGeneral;
 					}//else fine
 				break;
 				case 'Z':
 				case 'z':
 					aOffsetVal = 0;
 aDateTime.Copy(aDateTimeStr.Mid(0, i));
 					//error char at wrong position
 					if(i <KMinDateTimeLength)
 						{
-__FLOG_1(_L8("Invalid. 'Z' encountered at offset %d"), i);
+OstTrace1(TRACE_NORMAL, DUP3_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Invalid. 'Z' encountered at offset %d", i);
 						//error char at wrong position
 						errCode = KErrGeneral;
 						}//else fine
 					break;
 				case '+':
 				case '-':
 					if(i < KMinDateTimeLength)
 						{
 						//error char at wrong position
 						errCode = KErrGeneral;
-__FLOG_1(_L8("Invalid. '+/-' encountered at offset %d"), i);
+OstTrace1(TRACE_NORMAL, DUP4_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Invalid. '+/-' encountered at offset %d", i);
 						break;
 						}
 					else
 						{
 						const TInt KHoursDigits = 2;
 TLex minuteOffsetLex(aDateTimeStr.Mid(i+KHoursDigits+1, KMinutesDigits));
 minuteOffsetLex.Val(minuteOffset);
 						if ((hourOffset > 23) || (minuteOffset > 59))
 {
 errCode = KErrGeneral;
-__FLOG_2(_L8("Invalid. Hour(%d) or Minute(%d) offset out of range."), hourOffset, minuteOffset);
+OstTraceExt2(TRACE_NORMAL, DUP5_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Invalid. Hour(%d) or Minute(%d) offset out of range.", hourOffset, minuteOffset);
 break;
 }
 aOffsetVal = (hourOffset * KSecondsPerHour) + (minuteOffset * KSecondsPerMinute);
 if ('-' == aDateTimeStr[i])
 							{
 					                aOffsetVal = -aOffsetVal;
 							}
-__FLOG_1(_L8("Info: Timezone offset %d seconds"), aOffsetVal);
+OstTrace1(TRACE_NORMAL, DUP6_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Info: Timezone offset %d seconds", aOffsetVal);
 						}
 					break;
 				case '.':
 				case '\0':
 				if(i < KMinDateTimeLength)
 					{
 					//error char at wrong position
 					errCode = KErrGeneral;
-__FLOG_1(_L8("Invalid. '.' or NULL at offset %d"), i);
+OstTrace1(TRACE_NORMAL, DUP7_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Invalid. '.' or NULL at offset %d", i);
 					}
 				break;
 				default :
 				//wrong char
 				errCode = KErrGeneral;
-__FLOG_2(_L8("Invalid. Character %04x at offset %d"), aDateTimeStr[i], i);
+OstTraceExt2(TRACE_NORMAL, DUP8_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"Invalid. Character %04x at offset %d", aDateTimeStr[i], i);
 				break;
 				}
 		}
 		if(KErrNone != errCode)
 			{
-		        __FLOG_2(_L("Processed date: %S, TimeZone: %ds ahead"), &aDateTimeStr, aOffsetVal);
+OstTraceExt2(TRACE_NORMAL, DUP9_CMTPDEVICEDATASTORE_VALIDATESTRING,
-__FLOG_1(_L8("ValidateString - Exit %d"), errCode);
+"Processed date: %S, TimeZone: %ds ahead", aDateTimeStr, aOffsetVal);
+OstTrace1(TRACE_NORMAL, DUP10_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"ValidateString - Exit %d", errCode);
+			OstTraceFunctionExit0( CMTPDEVICEDATASTORE_VALIDATESTRING_EXIT );
 			return errCode;
 			}
 		}
 	}
-	__FLOG_2(_L("Processed date: %S, TimeZone: %ds ahead"), &aDateTimeStr, aOffsetVal);
+OstTraceExt2(TRACE_NORMAL, DUP11_CMTPDEVICEDATASTORE_VALIDATESTRING,
-__FLOG_1(_L8("ValidateString - Exit %d"), errCode);
+"Processed date: %S, TimeZone: %ds ahead", aDateTimeStr, aOffsetVal);
+OstTrace1(TRACE_NORMAL, DUP12_CMTPDEVICEDATASTORE_VALIDATESTRING,
+"ValidateString - Exit %d", errCode);
+	OstTraceFunctionExit0( DUP1_CMTPDEVICEDATASTORE_VALIDATESTRING_EXIT );
 	return errCode;
 	}
 /**
 *This method is to load/Store the deviceIcon to the  CMTPTypeArray iDeviceIcon

changeset 47	63cf70d3ecd8
parent 33	883e91c086aa