// 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:

 //

 // System includes

 #include <bautils.h>

 #include <barsc2.h> // For CResourceFile

 #include <barsread2.h> // For RResourceReader

 #include <logwrap.h>

 // User includes

 #include <logcli.h>

 #include "logservcli.h"

 #include "LogServShared.h"

 #include "logpackage.h"

 #include "logclipanic.h"

 #include "logclientop.h"

 #include "LogClientObserver.h"

 //**********************************

 // TLogConfig

 //**********************************

 /** Sets the:

 maximum age of events to zero

 maximum number of events to appear in the log to zero

 maximum number of events to appear in a recent event list to zero */

 EXPORT_C TLogConfig::TLogConfig()

 : iMaxLogSize(0), iMaxRecentLogSize(0), iMaxEventAge(0)

 	{

 	}

 void TLogConfig::InternalizeL(RReadStream& aStream)

 	{

 	aStream >> iMaxLogSize;

 	aStream >> iMaxRecentLogSize;

 	aStream >> iMaxEventAge;

 	}

 void TLogConfig::ExternalizeL(RWriteStream& aStream) const

 	{

 	aStream << iMaxLogSize;

 	aStream << iMaxRecentLogSize;

 	aStream << iMaxEventAge;

 	}

 //**********************************

 // CLogClient

 //**********************************

 EXPORT_C CLogClient* CLogClient::NewL(RFs& aFs, TInt aPriority/* = CActive::EPriorityStandard*/)

 	{

 	CLogClient* self = new(ELeave)CLogClient(aFs, aPriority);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(); // self

 	return self;

 	}

 void CLogClient::ConstructL()

 	{

 	// Load resources

 	LoadResourcesL(iFs);

 	iSession = new(ELeave)RLogSession;

 	User::LeaveIfError(iSession->Connect());

 	iPackage = CLogPackage::NewL();

 	iAddEvent = new(ELeave)CLogAddEventClientOp(*iSession, *iPackage, Priority());

 	iChangeEvent = new(ELeave)CLogChangeEventClientOp(*iSession, *iPackage, Priority());

 	iGetEvent = new(ELeave)CLogGetEventClientOp(*iSession, *iPackage, Priority());

 	iDeleteEvent = new(ELeave)CLogDeleteEventClientOp(*iSession, *iPackage, Priority());

 	iAddType = new(ELeave)CLogAddTypeClientOp(*iSession, *iPackage, Priority());

 	iChangeType = new(ELeave)CLogChangeTypeClientOp(*iSession, *iPackage, Priority());

 	iGetType = new(ELeave)CLogGetTypeClientOp(*iSession, *iPackage, Priority());

 	iDeleteType = new(ELeave)CLogDeleteTypeClientOp(*iSession, *iPackage, Priority());

 	iGetConfig = new(ELeave)CLogGetConfigClientOp(*iSession, *iPackage, Priority());

 	iChangeConfig = new(ELeave)CLogChangeConfigClientOp(*iSession, *iPackage, Priority());

 	iClearLog = new(ELeave)CLogClearLogClientOp(*iSession, *iPackage, Priority());

 	iClearRecent = new(ELeave)CLogClearRecentClientOp(*iSession, *iPackage, Priority());

 	}

 /** Frees all resources owned by the Log Engine object prior to its destruction. 

 In particular, any outstanding asynchronous request is cancelled, the database, 

 the database session and the resource file are all closed. */

 EXPORT_C CLogClient::~CLogClient()

 	{

 	Cancel();

 	delete iChangeObserver;

 	if (iSession && iSession->Handle())

 		{

 		// Complete change notification

 		NotifyChangeCancel();

 		iSession->Close();

 		}

 	delete iSession;

 	delete iPackage;

 	delete iAddEvent;

 	delete iChangeEvent;

 	delete iGetEvent;

 	delete iDeleteEvent;

 	delete iAddType;

 	delete iChangeType;

 	delete iGetType;

 	delete iDeleteType;

 	delete iGetConfig;

 	delete iChangeConfig;

 	delete iClearLog;

 	delete iClearRecent;

 	}

 CLogClient::CLogClient(RFs& aFs, TInt aPriority)

 : CLogBase(aPriority), iFs(aFs)

 	{

 	}

 /** Adds an event to the log database. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aEvent A log event detail object containing the attributes of the event 

 to be added. The Log Engine sets the unique event ID, the UTC time and the event 

 description, replacing any supplied values. The caller must ensure that this 

 object remains in existence and valid until the request is complete.

 @param aStatus The request status. On request completion,contains: KErrNone, 

 if the event has been successfully added to the log database; KErrNotFound, 

 if the event type is not registered with the Log Engine; KErrNotSupported, 

 if the logging of events of this type has been disabled; otherwise, one of 

 the other system wide error codes.

 @capability Note For built-in event types, the required capability level is defined in

 the event type's write access policy.

 @see CLogEventType::SetLoggingEnabled() */

 EXPORT_C void CLogClient::AddEvent(CLogEvent& aEvent, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iAddEvent->Start(aEvent, iStatus);

 	SetActive();

 	}

 /** Changes the details of an existing event. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 Note that it is not possible to change the event type using this function.

 @param aEvent The event detail object containing the attributes of the event 

 to be changed. Before calling the function, this object must contain the appropriate 

 unique event ID; if no unique event ID is set, the function raises a LogCli 

 13 panic. The caller must ensure that this object remains in existence and 

 valid until the request is complete.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes.

 @capability Note For built-in event types, the required capability level is defined in

 the event type's write access policy.

 @see TLogId */

 EXPORT_C void CLogClient::ChangeEvent(const CLogEvent& aEvent, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iChangeEvent->Start(aEvent, iStatus);

 	SetActive();

 	}

 /** Gets the details of the specified event. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aEvent A reference to a log event detail object. Before calling the 

 function, this object must contain the appropriate unique event ID; if no 

 unique event ID is set, the function raises a LogServ 50 panic. The caller 

 must ensure that this object remains in existence and valid until the request 

 is complete. On successful completion of the request, it contains the appropriate 

 log event detail.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes.

 @capability Note For built-in event types, the required capability level is defined in

 the event type's read access policy.

 @see TLogId */

 EXPORT_C void CLogClient::GetEvent(CLogEvent& aEvent, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iGetEvent->Start(aEvent, iStatus);

 	SetActive();

 	}

 /** Deletes the event with the specified unique event ID, from the main event log.

 @param aId The unique event ID of the event to be deleted. This must not be 

 the null unique event ID, KLogNullId, otherwise the function raises a LogCli 

 13 panic.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes. 

 @capability Note For built-in event types, the required capability level is defined in

 the event type's write access policy.

 */

 EXPORT_C void CLogClient::DeleteEvent(TLogId aId, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iDeleteEvent->Start(aId, iStatus);

 	SetActive();

 	}

 /** Registers a new event type. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aType The event type detail object containing the attributes of the 

 event type to be registered. The caller must ensure that this object remains 

 in existence and valid until the request is complete.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes.

 @capability WriteDeviceData

 @see TUid */

 EXPORT_C void CLogClient::AddEventType(const CLogEventType& aType, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iAddType->Start(aType, iStatus);

 	SetActive();

 	}

 /** Gets the details of an event type. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aType A reference to an event type detail object. Before calling the 

 function, this object must contain the UID identifying the event type; if 

 no UID is set, the function raises a LogCli 13 panic. The caller must ensure 

 that this object remains in existence and valid until the request is complete. 

 On successful completion of the request, it contains the appropriate event 

 type detail.

 @param aStatus The request status. On request completion, contains: KErrNone, 

 if successful; otherwise one of the other system wide error codes.

 @capability Note None required.

 @see TUid */

 EXPORT_C void CLogClient::GetEventType(CLogEventType& aType, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iGetType->Start(aType, iStatus);

 	SetActive();

 	}

 /** Changes the details of an existing event type. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aType The event type detail object containing the attributes of the 

 event type to be changed. Before calling the function, this object must contain 

 the UID identifying the event type; if no UID is set, the function raises 

 a LogCli 13 panic. The caller must ensure that this object remains in existence 

 and valid until the request is complete.

 @param aStatus The request status. On request completion, contains: KErrNone, 

 if successful; otherwise, one of the other system wide error codes.

 @capability WriteDeviceData

 @see TUid */

 EXPORT_C void CLogClient::ChangeEventType(const CLogEventType& aType, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iChangeType->Start(aType, iStatus);

 	SetActive();

 	}

 /** Removes an existing event type. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 Note that this function does not remove events from the event log, so it is 

 possible to have events in the log that are of an unknown type. This function 

 allows an event type associated with a component to be removed when that component 

 is uninstalled.

 @param aId The UID of the event type to be deleted.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes. 

 @capability WriteDeviceData

 */

 EXPORT_C void CLogClient::DeleteEventType(TUid aId, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iDeleteType->Start(aId, iStatus);

 	SetActive();

 	}

 /** Gets the Log Engine configuration. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aConfig A reference to a Log Engine configuration object. The caller 

 must ensure that this object remains in existence and valid until the request 

 is complete. On successful completion of the request, it contains the Log 

 Engine configuration data.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes. 

 @capability Note None required.

 */

 EXPORT_C void CLogClient::GetConfig(TLogConfig& aConfig, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iGetConfig->Start(aConfig, iStatus);

 	SetActive();

 	}

 /** Changes the Log Engine configuration. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aConfig The new configuration values for the Log Engine.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes. 

 @capability WriteDeviceData */

 EXPORT_C void CLogClient::ChangeConfig(const TLogConfig& aConfig, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iChangeConfig->Start(aConfig, iStatus);

 	SetActive();

 	}

 /** Clears all events from the main event log that occurred before the specified 

 date and time. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aDate The UTC date and time.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes. 

 @capability WriteDeviceData  */

 EXPORT_C void CLogClient::ClearLog(const TTime& aDate, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iClearLog->Start(aDate, iStatus);

 	SetActive();

 	}

 /** Clears the specified recent event list. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 @param aRecentList Identifies the recent event list to be cleared. The value 

 KlogNullRecentList indicates that all recent event lists are to be cleared.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful; otherwise, one of the other system wide error codes. 

 @capability WriteDeviceData  */

 EXPORT_C void CLogClient::ClearLog(TInt aRecentList, TRequestStatus& aStatus)

 	{

 	Queue(aStatus);

 	iClearRecent->Start((TLogRecentList)aRecentList, iStatus);

 	SetActive();

 	}

 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

 /** 

 Clears all events from the main event log that occurred before the specified 

 date and time and logged with the supplied SIM short Id. This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 Note: If KLogNullSimId is passed as value of aSimId parameter, then the method will produce the same result as the

            ClearLog() method without SimId parameter - all events occured before  the specified data will be deleted,

 	disregarding the SimId event property.

 @param aDate   The UTC date and time.

 @param aSimId  SIM card short Id.

 @param aStatus The request status. On request completion, contains:KErrNone, 

                if successful; otherwise, one of the other system wide error codes. 

 @capability WriteDeviceData  

 */

 EXPORT_C void CLogClient::ClearLog(const TTime& aDate, TSimId aSimId, TRequestStatus& aStatus)

 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is defined

 	Queue(aStatus);

 	iClearLog->Start(aDate, iStatus, aSimId);

 	SetActive();

 	}

 /** 

 Clears the specified recent event list from events with the specified SIM short Id. 

 This is an asynchronous request.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 Note: If KLogNullSimId is passed as value of aSimId parameter, then the method will produce the same result as the

            ClearLog() method without SimId parameter - all events from the specified event list will be cleared,

 	disregarding the SimId event property.

 @param aRecentList Identifies the recent event list to be cleared. The value 

                    KlogNullRecentList indicates that all recent event lists are to be cleared.

 @param aSimId      SIM card short Id.

 @param aStatus     The request status. On request completion, contains:KErrNone, 

                    if successful; otherwise, one of the other system wide error codes. 

 @capability WriteDeviceData  

 */

 EXPORT_C void CLogClient::ClearLog(TInt aRecentList, TSimId aSimId, TRequestStatus& aStatus)

 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is defined

 	Queue(aStatus);

 	iClearRecent->Start((TLogRecentList)aRecentList, iStatus, aSimId);

 	SetActive();

 	}

 #else //SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

 #pragma BullseyeCoverage off

 /**

 Not supported. 

 */

 EXPORT_C void CLogClient::ClearLog(const TTime&, TSimId, TRequestStatus&)

 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is not defined

 	__ASSERT_ALWAYS(0, ::Panic(ELogDualSimNotSupported));

 	}

 /**

 Not supported. 

 */

 EXPORT_C void CLogClient::ClearLog(TInt, TSimId, TRequestStatus&)

 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is not defined

 	__ASSERT_ALWAYS(0, ::Panic(ELogDualSimNotSupported));

 	}

 #pragma BullseyeCoverage on

 #endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

 /** Requests notification of changes to the Log Engine database. This is an asynchronous 

 request.

 The function requires the caller to specify a minimum time that must elapse 

 before this notification request can complete. The Log Engine buffers all 

 changes that occur during this time; the request, then completes after this 

 minimum time period has elapsed. If no changes occur within this time period, 

 then the request completes when the next change to the database occurs.

 There must be no asynchronous request outstanding when this function is called, 

 otherwise the function raises a LogCli 0 panic.

 Note that once a notification request has completed, this function must be 

 called again to get further change notifications.

 @param aDelay The minimum time, in microseconds, that elapses before the notification 

 request can complete.

 @param aStatus The request status. On request completion, contains:KErrNone, 

 if successful;KErrCancel, if an outstanding notification request is cancelled; 

 otherwise, one of the other system wide error codes. 

 @capability Note None required.

 */

 EXPORT_C void CLogClient::NotifyChange(TTimeIntervalMicroSeconds32 aDelay, TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	iSession->Send(ELogNotify, TIpcArgs(aDelay.Int()), aStatus);

 }

 /** Cancels any outstanding notification request for changes to Log Engine database.

 This function can be called even if there is no outstanding notification request. 

 @capability Note None required  */

 EXPORT_C void CLogClient::NotifyChangeCancel()

 	{

 	iSession->Send(ELogNotifyCancel, TIpcArgs());

 	}

 /**

 @capability Note None required

 */

 EXPORT_C void CLogClient::SetGlobalChangeObserverL(MLogClientChangeObserver* aObserver)

 	{

 	delete iChangeObserver;

 	iChangeObserver = NULL;

 	//

 	if	(aObserver)

 		{

 		iChangeObserver = CLogClientObserver::NewL(*this, *aObserver, Priority());

 		}

 	}

 /** Gets a standard string from the specified resource in logwrap.dll resource 

 file.

 The function can be used to populate some of the event fields in a CLogEvent 

 object before creating or changing an event.

 Note that TLogString is a modifiable buffer descriptor that is guaranteed 

 to be large enough to contain all standard strings used in the Log Engine; 

 pass an instance of this type to this function.

 @param aString A modifiable descriptor into which the string is copied.

 @param aId The resource id.

 @return KErrNone, if successful; otherwise, one of the other system wide error 

 codes.

 @capability Note None required.

 @see TLogString */

 EXPORT_C TInt CLogClient::GetString(TDes& aString, TInt aId) const

 	{

 	aString.Zero();

 	TRAPD(err, DoGetStringL(aString, aId));

 	return err;

 	}

 void CLogClient::DoGetStringL(TDes& aString, TInt aId) const

 	{

 	RResourceReader reader;

 #ifdef _DEBUG

 	const CResourceFile* rcFile = ResourceFile();

 	__ASSERT_DEBUG(rcFile != NULL, Panic(ELogNullRcFile));

 #endif

 	reader.OpenLC(ResourceFile(), aId);

 	aString.Copy(reader.ReadTPtrCL());

 	CleanupStack::PopAndDestroy();			// reader

 	}

 void CLogClient::DoCancel()

 	{

 	LOGTEXT("CLogClient::DoCancel()");

 	iAddEvent->Cancel();

 	iChangeEvent->Cancel();

 	iGetEvent->Cancel();

 	iDeleteEvent->Cancel();

 	iAddType->Cancel();

 	iChangeType->Cancel();

 	iGetType->Cancel();

 	iDeleteType->Cancel();

 	iGetConfig->Cancel(); 

 	iChangeConfig->Cancel();

 	iClearLog->Cancel();

 	iClearRecent->Cancel();

 	CLogBase::DoCancel();

 	LOGTEXT("CLogClient::DoCancel() - end");

 	}

 void CLogClient::DoRunL()

 	{

 	LOGTEXT2("CLogClient::DoRunL(%d)", iStatus.Int());

 	User::LeaveIfError(iStatus.Int());

 	LOGTEXT("CLogClient::DoRunL() - end");

 	}

 RLogSession& CLogClient::Session() const

 	{

 	return *iSession;

 	}

 #pragma BullseyeCoverage off

 EXPORT_C void CLogClient::CLogBase_Reserved1()

 	{

 	}

 #pragma BullseyeCoverage on