diff -r 000000000000 -r bde4ae8d615e os/persistentdata/loggingservices/eventlogger/LogWrap/src/LOGEVENT.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/persistentdata/loggingservices/eventlogger/LogWrap/src/LOGEVENT.CPP	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,319 @@
+// Copyright (c) 2002-2009 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"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <logwrap.h>
+#include <logwraplimits.h>
+#include "logcntdef.h"
+#include "s32strm.h"
+#include "LOGPANIC.H"
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+/**
+This is the current version number of the event data, after the introduction of the "dual SIM support". 
+New event properties in this version:
+ - TInt    iVersion;
+ - TSimId	iSimId;
+ 
+The data versioning was introduced together with the "dual SIM support" changes where a new data member was
+added to the CLogEvent class. 
+The idea is to keep InternalizeL()/ExternalizeL() functionality binary compatibly in case of the unlikely event
+CLogEvent data gets persisted to a file for example.
+
+The old format of the externalized event data is:
+ <id><type>.....<data length>[<optional: data>]
+ 
+The new format of the externalized event data is:
+ <id><type>.....<uint: data version><data length>[<optional: data>]<simId>
+ 
+In case if CLogEvent::InternalizeL() reads from a stream with old event data, then:
+1) The data vesrion is read first as an integer. 
+2) If the data version is negative then this is an event data with "dual SIM support",
+   because the version number of that is positive integer above the KMaxTInt constant
+   (interpreted as negative one if read as an integer from the stream)
+3) If the data version is positive then this is an event data without "dual SIM support".   
+ 
+@internalComponent 
+*/
+const TUint KLogEventDataVersion = 0x80000002U;
+
+#endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+EXPORT_C CLogEvent* CLogEvent::NewL()
+/** Creates a new log event detail object.
+
+@return Pointer to the new log event detail object. */
+	{
+	CLogEvent* self = new(ELeave)CLogEvent;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(); // self
+	return self;
+	}
+
+CLogEvent::CLogEvent() :
+	iId(KLogNullId), 
+	iEventType(KNullUid), 
+	iDurationType(KLogNullDurationType), 
+	iDuration(KLogNullDuration), 
+	iContact(KLogNullContactId), 
+	iLink(KLogNullLink), 
+	iFlags(KLogNullFlags)
+	{
+	}
+
+void CLogEvent::ConstructL()
+	{
+	iDescription = HBufC::NewL(KLogMaxDescriptionLength);
+	iRemoteParty = HBufC::NewL(KLogMaxRemotePartyLength);
+	iDirection = HBufC::NewL(KLogMaxDirectionLength);
+	iStatus = HBufC::NewL(KLogMaxStatusLength);
+	iSubject = HBufC::NewL(KLogMaxSubjectLength);
+	iNumber = HBufC::NewL(KLogMaxNumberLength);
+	}
+
+EXPORT_C CLogEvent::~CLogEvent()
+/** Frees all resources owned by the log event detail object. */
+	{
+	delete iDescription;
+	delete iRemoteParty;
+	delete iDirection;
+	delete iStatus;
+	delete iSubject;
+	delete iNumber;
+	delete iData;
+	}
+
+EXPORT_C void CLogEvent::SetDataL(const TDesC8& aData)
+/** Sets event specific data.
+
+The data can be used for any purpose. The data is copied into a heap descriptor 
+allocated by this function; the amount of data is only limited by the available 
+memory.
+
+@param aData The event specific data. */
+	{
+	if (iData)
+		{
+		if (iData->Des().MaxLength() < aData.Length())
+			iData = iData->ReAllocL(aData.Length());
+		}
+	else
+		{
+		if (aData.Length() > 0)
+			iData = HBufC8::NewL(aData.Length());
+		else
+			return;
+		}
+
+	iData->Des().Copy(aData);
+	}
+
+EXPORT_C void CLogEvent::SetDataL(RReadStream& aStream, TInt aLen)
+/** Sets event specific data from the specified stream.
+
+The data can be used for any purpose. The data is copied into a heap descriptor 
+allocated by this function; the amount of data is only limited by the available 
+memory.
+
+@param aStream The stream containing the event specific data.
+@param aLen The length of data to be read from the stream. */
+	{
+	HBufC8* buf = NULL;
+
+	if (aLen > 0)
+		{
+		buf = HBufC8::NewLC(aLen);
+		buf->Des().SetLength(aLen);
+
+		TPtr8 ptr(buf->Des());
+		aStream.ReadL(ptr, aLen);
+
+		CleanupStack::Pop(); // buf
+		}
+
+	delete iData;
+	iData = buf;
+	}
+
+EXPORT_C void CLogEvent::CopyL(const CLogEvent& aEvent)
+/** Makes a copy of the specified log event.
+
+@param aEvent The log event to be copied. */
+	{
+	// Set data first as this is the only function that can leave
+	// If this function fails nothing will be changed
+	SetDataL(aEvent.Data());
+
+	SetId(aEvent.Id());
+	SetEventType(aEvent.EventType());
+	SetTime(aEvent.Time());
+	SetDurationType(aEvent.DurationType());
+	SetDuration(aEvent.Duration());
+	SetContact(aEvent.Contact());
+	SetLink(aEvent.Link());
+	SetDescription(aEvent.Description());
+	SetRemoteParty(aEvent.RemoteParty());
+	SetDirection(aEvent.Direction());
+	SetStatus(aEvent.Status());
+	SetSubject(aEvent.Subject());
+	SetNumber(aEvent.Number());
+
+	ClearFlags(KLogFlagsMask);
+	SetFlags(aEvent.Flags());
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+	SetSimId(aEvent.SimId());
+#endif
+	}
+
+EXPORT_C void CLogEvent::InternalizeL(RReadStream& aStream)
+	{
+	iId = (TLogId) aStream.ReadInt32L();
+	iEventType.iUid = aStream.ReadInt32L();
+
+	TInt64 time; 
+	aStream >> time;
+	iTime = time;
+
+	iDurationType = (TLogDurationType) aStream.ReadInt8L();
+	iDuration = (TLogDuration) aStream.ReadUint32L();
+	iContact = (TLogContactItemId ) aStream.ReadInt32L();
+	iLink = (TLogLink) aStream.ReadUint32L();
+	iFlags = (TLogFlags) aStream.ReadUint8L();
+
+	InternalizeBufL(aStream, iDescription);
+	InternalizeBufL(aStream, iRemoteParty);
+	InternalizeBufL(aStream, iDirection);
+	InternalizeBufL(aStream, iStatus);
+	InternalizeBufL(aStream, iSubject);
+	InternalizeBufL(aStream, iNumber);
+
+	TInt dataLen = aStream.ReadInt32L();
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+	TUint dataVersion = 0;
+	if(dataLen < 0)
+		{
+		//This is CLogEvent data version with dual SIM support.
+		//The next property is the data length.
+		dataVersion = (TUint)dataLen;
+		dataLen = aStream.ReadInt32L();
+		}
+#endif
+	HBufC8* temp = NULL;
+	if(dataLen != 0)
+		{
+		temp = HBufC8::NewL(aStream, dataLen);
+		}
+	delete iData;
+	iData = temp;
+	
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+	if(dataVersion >= KLogEventDataVersion)
+		{
+		aStream >> iSimId;
+		}
+#endif
+	}
+
+void CLogEvent::InternalizeBufL(RReadStream& aStream, HBufC*& aDes)
+	{
+	TPtr ptr(aDes->Des());
+	HBufC* temp = HBufC::NewL(aStream, ptr.MaxLength());
+	ptr.Copy(*temp);
+	delete temp;
+	}
+
+EXPORT_C void CLogEvent::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream.WriteInt32L(iId);
+	aStream.WriteInt32L(iEventType.iUid);
+	aStream << iTime.Int64();
+	aStream.WriteInt8L(iDurationType);
+	aStream.WriteUint32L(iDuration);
+	aStream.WriteInt32L(iContact);
+	aStream.WriteUint32L(iLink);
+	aStream.WriteInt8L(iFlags);
+	aStream << *iDescription;
+	aStream << *iRemoteParty;
+	aStream << *iDirection;
+	aStream << *iStatus;
+	aStream << *iSubject; 
+	aStream << *iNumber;
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+	aStream.WriteUint32L(KLogEventDataVersion);
+#endif
+	
+	TInt dataLength = 0;
+	if(iData)
+		{
+		dataLength = iData->Length();
+		}
+	aStream.WriteInt32L(dataLength);
+	if	(iData && dataLength)
+		{
+		aStream << *iData;
+		}
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+	aStream << iSimId;
+#endif
+	}
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
+
+/**
+Sets the short Id of the SIM card being used.
+
+@param aSimId SIM card short Id;  
+*/
+EXPORT_C void CLogEvent::SetSimId(TSimId aSimId)
+	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is defined
+	iSimId = aSimId;
+	}
+
+/**
+Returns the short Id of the SIM card that was used.
+
+@return SIM card short Id;  
+*/
+EXPORT_C TSimId CLogEvent::SimId() const
+	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is defined
+	return iSimId;
+	}
+
+#else//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+
+#pragma BullseyeCoverage off
+
+/**
+Not supported.
+*/
+EXPORT_C void CLogEvent::SetSimId(TSimId)
+	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is not defined
+	__ASSERT_ALWAYS(0, ::Panic(ELogDualSimNotSupported));
+	}
+
+/**
+Not supported.
+*/
+EXPORT_C TSimId CLogEvent::SimId() const
+	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is not defined
+	__ASSERT_ALWAYS(0, ::Panic(ELogDualSimNotSupported));
+	return 0;
+	}
+
+#pragma BullseyeCoverage on
+
+#endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM