1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 // System includes

    17 #include <bautils.h>

    18 #include <barsc2.h> // For CResourceFile

    19 #include <barsread2.h> // For RResourceReader

    20 #include <logwrap.h>

    21 

    22 // User includes

    23 #include <logcli.h>

    24 #include "logservcli.h"

    25 #include "LogServShared.h"

    26 #include "logpackage.h"

    27 #include "logclipanic.h"

    28 #include "logclientop.h"

    29 #include "LogClientObserver.h"

    30 

    31 //**********************************

    32 // TLogConfig

    33 //**********************************

    34 

    35 /** Sets the:

    36 

    37 maximum age of events to zero

    38 

    39 maximum number of events to appear in the log to zero

    40 

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

    42 EXPORT_C TLogConfig::TLogConfig()

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

    44 	{

    45 	}

    46 

    47 void TLogConfig::InternalizeL(RReadStream& aStream)

    48 	{

    49 	aStream >> iMaxLogSize;

    50 	aStream >> iMaxRecentLogSize;

    51 	aStream >> iMaxEventAge;

    52 	}

    53 

    54 void TLogConfig::ExternalizeL(RWriteStream& aStream) const

    55 	{

    56 	aStream << iMaxLogSize;

    57 	aStream << iMaxRecentLogSize;

    58 	aStream << iMaxEventAge;

    59 	}

    60 

    61 //**********************************

    62 // CLogClient

    63 //**********************************

    64 

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

    66 	{

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

    68 	CleanupStack::PushL(self);

    69 	self->ConstructL();

    70 	CleanupStack::Pop(); // self

    71 	return self;

    72 	}

    73 

    74 void CLogClient::ConstructL()

    75 	{

    76 	// Load resources

    77 	LoadResourcesL(iFs);

    78 

    79 	iSession = new(ELeave)RLogSession;

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

    81 	iPackage = CLogPackage::NewL();

    82 

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

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

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

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

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

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

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

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

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

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

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

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

    95 	}

    96 

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

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

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

   100 EXPORT_C CLogClient::~CLogClient()

   101 	{

   102 	Cancel();

   103 

   104 	delete iChangeObserver;

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

   106 		{

   107 		// Complete change notification

   108 		NotifyChangeCancel();

   109 		iSession->Close();

   110 		}

   111 

   112 	delete iSession;

   113 	delete iPackage;

   114 	delete iAddEvent;

   115 	delete iChangeEvent;

   116 	delete iGetEvent;

   117 	delete iDeleteEvent;

   118 	delete iAddType;

   119 	delete iChangeType;

   120 	delete iGetType;

   121 	delete iDeleteType;

   122 	delete iGetConfig;

   123 	delete iChangeConfig;

   124 	delete iClearLog;

   125 	delete iClearRecent;

   126 	}

   127 

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

   129 : CLogBase(aPriority), iFs(aFs)

   130 	{

   131 	}

   132 

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

   134 

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

   136 otherwise the function raises a LogCli 0 panic.

   137 

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

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

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

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

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

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

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

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

   146 the other system wide error codes.

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

   148 the event type's write access policy.

   149 @see CLogEventType::SetLoggingEnabled() */

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

   151 	{

   152 	Queue(aStatus);

   153 	iAddEvent->Start(aEvent, iStatus);

   154 	SetActive();

   155 	}

   156 

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

   158 

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

   160 otherwise the function raises a LogCli 0 panic.

   161 

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

   163 

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

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

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

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

   168 valid until the request is complete.

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

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

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

   172 the event type's write access policy.

   173 @see TLogId */

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

   175 	{

   176 	Queue(aStatus);

   177 	iChangeEvent->Start(aEvent, iStatus);

   178 	SetActive();

   179 	}

   180 

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

   182 

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

   184 otherwise the function raises a LogCli 0 panic.

   185 

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

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

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

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

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

   191 log event detail.

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

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

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

   195 the event type's read access policy.

   196 @see TLogId */

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

   198 	{

   199 	Queue(aStatus);

   200 	iGetEvent->Start(aEvent, iStatus);

   201 	SetActive();

   202 	}

   203 

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

   205 

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

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

   208 13 panic.

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

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

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

   212 the event type's write access policy.

   213 */

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

   215 	{

   216 	Queue(aStatus);

   217 	iDeleteEvent->Start(aId, iStatus);

   218 	SetActive();

   219 	}

   220 

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

   222 

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

   224 otherwise the function raises a LogCli 0 panic.

   225 

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

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

   228 in existence and valid until the request is complete.

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

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

   231 @capability WriteDeviceData

   232 @see TUid */

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

   234 	{

   235 	Queue(aStatus);

   236 	iAddType->Start(aType, iStatus);

   237 	SetActive();

   238 	}

   239 

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

   241 

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

   243 otherwise the function raises a LogCli 0 panic.

   244 

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

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

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

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

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

   250 type detail.

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

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

   253 @capability Note None required.

   254 @see TUid */

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

   256 	{

   257 	Queue(aStatus);

   258 	iGetType->Start(aType, iStatus);

   259 	SetActive();

   260 	}

   261 

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

   263 

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

   265 otherwise the function raises a LogCli 0 panic.

   266 

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

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

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

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

   271 and valid until the request is complete.

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

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

   274 @capability WriteDeviceData

   275 @see TUid */

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

   277 	{

   278 	Queue(aStatus);

   279 	iChangeType->Start(aType, iStatus);

   280 	SetActive();

   281 	}

   282 

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

   284 

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

   286 otherwise the function raises a LogCli 0 panic.

   287 

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

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

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

   291 is uninstalled.

   292 

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

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

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

   296 @capability WriteDeviceData

   297 */

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

   299 	{

   300 	Queue(aStatus);

   301 	iDeleteType->Start(aId, iStatus);

   302 	SetActive();

   303 	}

   304 

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

   306 

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

   308 otherwise the function raises a LogCli 0 panic.

   309 

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

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

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

   313 Engine configuration data.

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

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

   316 @capability Note None required.

   317 */

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

   319 	{

   320 	Queue(aStatus);

   321 	iGetConfig->Start(aConfig, iStatus);

   322 	SetActive();

   323 	}

   324 

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

   326 

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

   328 otherwise the function raises a LogCli 0 panic.

   329 

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

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

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

   333 @capability WriteDeviceData */

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

   335 	{

   336 	Queue(aStatus);

   337 	iChangeConfig->Start(aConfig, iStatus);

   338 	SetActive();

   339 	}

   340 

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

   342 date and time. This is an asynchronous request.

   343 

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

   345 otherwise the function raises a LogCli 0 panic.

   346 

   347 @param aDate The UTC date and time.

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

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

   350 @capability WriteDeviceData  */

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

   352 	{

   353 	Queue(aStatus);

   354 	iClearLog->Start(aDate, iStatus);

   355 	SetActive();

   356 	}

   357 

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

   359 

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

   361 otherwise the function raises a LogCli 0 panic.

   362 

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

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

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

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

   367 @capability WriteDeviceData  */

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

   369 	{

   370 	Queue(aStatus);

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

   372 	SetActive();

   373 	}

   374 

   375 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

   376 

   377 /** 

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

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

   380 

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

   382 otherwise the function raises a LogCli 0 panic.

   383 

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

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

   386 	disregarding the SimId event property.

   387 

   388 @param aDate   The UTC date and time.

   389 @param aSimId  SIM card short Id.

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

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

   392 @capability WriteDeviceData  

   393 */

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

   395 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is defined

   396 	Queue(aStatus);

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

   398 	SetActive();

   399 	}

   400 

   401 /** 

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

   403 This is an asynchronous request.

   404 

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

   406 otherwise the function raises a LogCli 0 panic.

   407 

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

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

   410 	disregarding the SimId event property.

   411 

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

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

   414 @param aSimId      SIM card short Id.

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

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

   417 @capability WriteDeviceData  

   418 */

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

   420 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is defined

   421 	Queue(aStatus);

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

   423 	SetActive();

   424 	}

   425 

   426 #else //SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

   427 

   428 #pragma BullseyeCoverage off

   429 

   430 /**

   431 Not supported. 

   432 */

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

   434 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is not defined

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

   436 	}

   437 

   438 /**

   439 Not supported. 

   440 */

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

   442 	{//Compiled when SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM is not defined

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

   444 	}

   445 

   446 #pragma BullseyeCoverage on

   447 

   448 #endif//SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM

   449 

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

   451 request.

   452 

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

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

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

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

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

   458 

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

   460 otherwise the function raises a LogCli 0 panic.

   461 

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

   463 called again to get further change notifications.

   464 

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

   466 request can complete.

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

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

   469 otherwise, one of the other system wide error codes. 

   470 @capability Note None required.

   471 */

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

   473 	{

   474 	aStatus = KRequestPending;

   475 

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

   477 }

   478 

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

   480 

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

   482 @capability Note None required  */

   483 EXPORT_C void CLogClient::NotifyChangeCancel()

   484 	{

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

   486 	}

   487 

   488 /**

   489 @capability Note None required

   490 */

   491 EXPORT_C void CLogClient::SetGlobalChangeObserverL(MLogClientChangeObserver* aObserver)

   492 	{

   493 	delete iChangeObserver;

   494 	iChangeObserver = NULL;

   495 	//

   496 	if	(aObserver)

   497 		{

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

   499 		}

   500 	}

   501 

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

   503 file.

   504 

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

   506 object before creating or changing an event.

   507 

   508 Note that TLogString is a modifiable buffer descriptor that is guaranteed 

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

   510 pass an instance of this type to this function.

   511 

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

   513 @param aId The resource id.

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

   515 codes.

   516 @capability Note None required.

   517 @see TLogString */

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

   519 	{

   520 	aString.Zero();

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

   522 	return err;

   523 	}

   524 

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

   526 	{

   527 	RResourceReader reader;

   528 #ifdef _DEBUG

   529 	const CResourceFile* rcFile = ResourceFile();

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

   531 #endif

   532 	reader.OpenLC(ResourceFile(), aId);

   533 	aString.Copy(reader.ReadTPtrCL());

   534 	CleanupStack::PopAndDestroy();			// reader

   535 	}

   536 

   537 void CLogClient::DoCancel()

   538 	{

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

   540 

   541 	iAddEvent->Cancel();

   542 	iChangeEvent->Cancel();

   543 	iGetEvent->Cancel();

   544 	iDeleteEvent->Cancel();

   545 	iAddType->Cancel();

   546 	iChangeType->Cancel();

   547 	iGetType->Cancel();

   548 	iDeleteType->Cancel();

   549 	iGetConfig->Cancel(); 

   550 	iChangeConfig->Cancel();

   551 	iClearLog->Cancel();

   552 	iClearRecent->Cancel();

   553 

   554 	CLogBase::DoCancel();

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

   556 	}

   557 

   558 void CLogClient::DoRunL()

   559 	{

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

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

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

   563 	}

   564 

   565 RLogSession& CLogClient::Session() const

   566 	{

   567 	return *iSession;

   568 	}

   569 

   570 #pragma BullseyeCoverage off

   571 

   572 EXPORT_C void CLogClient::CLogBase_Reserved1()

   573 	{

   574 	}

   575 

   576 #pragma BullseyeCoverage on