diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/LogCli/src/LOGCLI.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/loggingservices/eventlogger/LogCli/src/LOGCLI.CPP Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,576 @@ +// 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 +#include // For CResourceFile +#include // For RResourceReader +#include + +// User includes +#include +#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