1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/loggingservices/eventlogger/LogServ/src/LogServOperations.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,685 @@
1.4 +// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "LogServOperations.h"
1.20 +#include "logservpanic.h"
1.21 +#include "LogServView.h"
1.22 +#include "LogServTaskInterface.h"
1.23 +
1.24 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.25 +////////////////////////////// CLogServOpEventAdd ////////////////////////////////////////////////////////////
1.26 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.27 +
1.28 +//
1.29 +// Create an operation to add an event to the log
1.30 +//
1.31 +CLogServOpEventAdd::CLogServOpEventAdd(MLogServTaskInterface& aTaskInterface,
1.32 + MLogServOperationManager& aOperationManager,
1.33 + const RMessage2& aMessage,
1.34 + CLogPackage& aPackage,
1.35 + const TLogClientServerData& aCliServData,
1.36 + TLogServSessionId aSessionId):
1.37 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.38 + {
1.39 + }
1.40 +
1.41 +CLogServOpEventAdd::~CLogServOpEventAdd()
1.42 + {
1.43 + delete iEvent;
1.44 + }
1.45 +
1.46 +//
1.47 +// Get stuff from the client and start doing the work
1.48 +//
1.49 +void CLogServOpEventAdd::StartL(TRequestStatus& aStatus)
1.50 + {
1.51 + // Read stuff from the client
1.52 + const TInt length = Message().GetDesLengthL(1);
1.53 +
1.54 + Package().ResizeL(length);
1.55 + TPtr8 pPackage(Package().Ptr());
1.56 + Message().ReadL(1,pPackage);
1.57 +
1.58 + // Decode the parameters we've read from the client
1.59 + iEvent = CLogEvent::NewL();
1.60 + Package().GetLogEventL(*iEvent);
1.61 +
1.62 + // Do the actual work
1.63 + TaskInterface().TaskEventAddL(aStatus, *iEvent, Message());
1.64 + }
1.65 +
1.66 +//
1.67 +// Complete the client request - we need to wait for the client to request a response
1.68 +//
1.69 +CLogServOperationBase::TCompletionStatus CLogServOpEventAdd::CompleteProcessingL(TInt /*aFinalCompletionCode*/)
1.70 + {
1.71 + Package().SetLogEventL(*iEvent);
1.72 + const TInt size = Package().Ptr().Size();
1.73 + Complete(size);
1.74 + //
1.75 + return CLogServOperationBase::EOperationCompleteWaitForClient;
1.76 + }
1.77 +
1.78 +//
1.79 +// Write stuff back to the client
1.80 +//
1.81 +void CLogServOpEventAdd::WriteL(const RMessage2& aMessage)
1.82 + {
1.83 + aMessage.WriteL(1, Package().Ptr());
1.84 + }
1.85 +
1.86 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.87 +////////////////////////////// CLogServOpEventChange /////////////////////////////////////////////////////////
1.88 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.89 +
1.90 +//
1.91 +// Create an operation to change an event in the log
1.92 +//
1.93 +CLogServOpEventChange::CLogServOpEventChange(MLogServTaskInterface& aTaskInterface,
1.94 + MLogServOperationManager& aOperationManager,
1.95 + const RMessage2& aMessage,
1.96 + CLogPackage& aPackage,
1.97 + const TLogClientServerData& aCliServData,
1.98 + TLogServSessionId aSessionId) :
1.99 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.100 + {
1.101 + }
1.102 +
1.103 +CLogServOpEventChange::~CLogServOpEventChange()
1.104 + {
1.105 + delete iEvent;
1.106 + }
1.107 +
1.108 +//
1.109 +// Get stuff from the client and start doing the work
1.110 +//
1.111 +void CLogServOpEventChange::StartL(TRequestStatus& aStatus)
1.112 + {
1.113 + // Read stuff from the client
1.114 + Package().ResizeL(Message().GetDesLengthL(1));
1.115 + Message().ReadL(1, Package().Ptr());
1.116 +
1.117 + // Decode the parameters we've read from the client
1.118 + iEvent = CLogEvent::NewL();
1.119 + Package().GetLogEventL(*iEvent);
1.120 +
1.121 + // Do the actual work
1.122 + TaskInterface().TaskEventChangeL(aStatus, *iEvent, Message());
1.123 + }
1.124 +
1.125 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.126 +////////////////////////////// CLogServOpEventGet ////////////////////////////////////////////////////////////
1.127 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.128 +
1.129 +//
1.130 +// Create an operation to get an event in the log
1.131 +//
1.132 +CLogServOpEventGet::CLogServOpEventGet(MLogServTaskInterface& aTaskInterface,
1.133 + MLogServOperationManager& aOperationManager,
1.134 + const RMessage2& aMessage,
1.135 + CLogPackage& aPackage,
1.136 + const TLogClientServerData& aCliServData,
1.137 + TLogServSessionId aSessionId) :
1.138 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.139 + {
1.140 + }
1.141 +
1.142 +CLogServOpEventGet::~CLogServOpEventGet()
1.143 + {
1.144 + delete iEvent;
1.145 + }
1.146 +
1.147 +//
1.148 +// Get stuff from the client and start doing the work
1.149 +//
1.150 +void CLogServOpEventGet::StartL(TRequestStatus& aStatus)
1.151 + {
1.152 + // Setup the event
1.153 + iEvent = CLogEvent::NewL();
1.154 + iEvent->SetId((TLogId)Message().Ptr1());
1.155 +
1.156 + // Do the actual work
1.157 + TaskInterface().TaskEventGetL(aStatus, *iEvent, Message());
1.158 + }
1.159 +
1.160 +//
1.161 +// Complete the client request - we need to wait for the client to request a response
1.162 +//
1.163 +CLogServOperationBase::TCompletionStatus CLogServOpEventGet::CompleteProcessingL(TInt /*aFinalCompletionCode*/)
1.164 + {
1.165 + Package().SetLogEventL(*iEvent);
1.166 + const TInt size = Package().Ptr().Size();
1.167 + Complete(size);
1.168 + //
1.169 + return CLogServOperationBase::EOperationCompleteWaitForClient;
1.170 + }
1.171 +
1.172 +//
1.173 +// Write stuff back to the client
1.174 +//
1.175 +void CLogServOpEventGet::WriteL(const RMessage2& aMessage)
1.176 + {
1.177 + aMessage.WriteL(1, Package().Ptr());
1.178 + }
1.179 +
1.180 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.181 +////////////////////////////// CLogServOpEventDelete /////////////////////////////////////////////////////////
1.182 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.183 +
1.184 +//
1.185 +// Create an operation to delete an event from the log
1.186 +//
1.187 +CLogServOpEventDelete::CLogServOpEventDelete(MLogServTaskInterface& aTaskInterface,
1.188 + MLogServOperationManager& aOperationManager,
1.189 + const RMessage2& aMessage,
1.190 + CLogPackage& aPackage,
1.191 + const TLogClientServerData& aCliServData,
1.192 + TLogServSessionId aSessionId) :
1.193 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.194 + {
1.195 + }
1.196 +
1.197 +void CLogServOpEventDelete::StartL(TRequestStatus& aStatus)
1.198 + {
1.199 + // Do the actual work
1.200 + const TLogId eventId = static_cast<TLogId>(Message().Int1());
1.201 + TaskInterface().TaskEventDeleteL(aStatus, eventId, Message());
1.202 + }
1.203 +
1.204 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.205 +////////////////////////////// CLogServOpTypeAdd /////////////////////////////////////////////////////////////
1.206 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.207 +
1.208 +//
1.209 +// Add a new event type to the database
1.210 +//
1.211 +CLogServOpTypeAdd::CLogServOpTypeAdd(MLogServTaskInterface& aTaskInterface,
1.212 + MLogServOperationManager& aOperationManager,
1.213 + const RMessage2& aMessage,
1.214 + CLogPackage& aPackage,
1.215 + const TLogClientServerData& aCliServData,
1.216 + TLogServSessionId aSessionId) :
1.217 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.218 + {
1.219 + }
1.220 +
1.221 +CLogServOpTypeAdd::~CLogServOpTypeAdd()
1.222 + {
1.223 + delete iEventType;
1.224 + }
1.225 +
1.226 +//
1.227 +// Get stuff from the client and start doing the work
1.228 +//
1.229 +void CLogServOpTypeAdd::StartL(TRequestStatus& aStatus)
1.230 + {
1.231 + // Read stuff from the client
1.232 + Package().ResizeL(Message().GetDesLengthL(1));
1.233 + Message().ReadL(1, Package().Ptr());
1.234 +
1.235 +
1.236 + // Decode the parameters we've read from the client
1.237 + iEventType = CLogEventType::NewL();
1.238 + Package().GetLogEventTypeL(*iEventType);
1.239 +
1.240 + // Do the actual work
1.241 + TaskInterface().TaskEventTypeAddL(aStatus, *iEventType);
1.242 + }
1.243 +
1.244 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.245 +////////////////////////////// CLogServOpTypeGet /////////////////////////////////////////////////////////////
1.246 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.247 +
1.248 +//
1.249 +// Get event type details from the database
1.250 +//
1.251 +CLogServOpTypeGet::CLogServOpTypeGet(MLogServTaskInterface& aTaskInterface,
1.252 + MLogServOperationManager& aOperationManager,
1.253 + const RMessage2& aMessage,
1.254 + CLogPackage& aPackage,
1.255 + const TLogClientServerData& aCliServData,
1.256 + TLogServSessionId aSessionId) :
1.257 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.258 + {
1.259 + }
1.260 +
1.261 +//
1.262 +// Get stuff from the client and start doing the work
1.263 +//
1.264 +void CLogServOpTypeGet::StartL(TRequestStatus& aStatus)
1.265 + {
1.266 + // Do the actual work
1.267 + const TUid eventTypeUid = { Message().Int1() };
1.268 + const CLogEventType *eventType;
1.269 + TaskInterface().TaskEventTypeGetL(aStatus, eventType, eventTypeUid);
1.270 + iEventType = const_cast<CLogEventType*>(eventType);
1.271 + }
1.272 +
1.273 +//
1.274 +// Complete the client request - we need to wait for the client to request a response
1.275 +//
1.276 +CLogServOperationBase::TCompletionStatus CLogServOpTypeGet::CompleteProcessingL(TInt /*aFinalCompletionCode*/)
1.277 + {
1.278 + Package().SetLogEventTypeL(*iEventType);
1.279 + const TInt size = Package().Ptr().Size();
1.280 + Complete(size);
1.281 + //
1.282 + return CLogServOperationBase::EOperationCompleteWaitForClient;
1.283 + }
1.284 +
1.285 +//
1.286 +// Write stuff back to the client
1.287 +//
1.288 +void CLogServOpTypeGet::WriteL(const RMessage2& aMessage)
1.289 + {
1.290 + aMessage.WriteL(1, Package().Ptr());
1.291 + }
1.292 +
1.293 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.294 +////////////////////////////// CLogServOpTypeChange //////////////////////////////////////////////////////////
1.295 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.296 +
1.297 +//
1.298 +// Change event type details in the database
1.299 +//
1.300 +CLogServOpTypeChange::CLogServOpTypeChange(MLogServTaskInterface& aTaskInterface,
1.301 + MLogServOperationManager& aOperationManager,
1.302 + const RMessage2& aMessage,
1.303 + CLogPackage& aPackage,
1.304 + const TLogClientServerData& aCliServData,
1.305 + TLogServSessionId aSessionId) :
1.306 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.307 + {
1.308 + }
1.309 +
1.310 +CLogServOpTypeChange::~CLogServOpTypeChange()
1.311 + {
1.312 + delete iEventType;
1.313 + }
1.314 +
1.315 +//
1.316 +// Get stuff from the client and start doing the work
1.317 +//
1.318 +void CLogServOpTypeChange::StartL(TRequestStatus& aStatus)
1.319 + {
1.320 + // Read stuff from the client
1.321 + Package().ResizeL(Message().GetDesLengthL(1));
1.322 + Message().ReadL(1, Package().Ptr());
1.323 +
1.324 + // Decode the parameters we've read from the client
1.325 + iEventType = CLogEventType::NewL();
1.326 + Package().GetLogEventTypeL(*iEventType);
1.327 +
1.328 + // Do the actual work
1.329 + TaskInterface().TaskEventTypeChangeL(aStatus, *iEventType);
1.330 + }
1.331 +
1.332 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.333 +////////////////////////////// CLogServOpTypeDelete //////////////////////////////////////////////////////////
1.334 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.335 +
1.336 +//
1.337 +// Delete event type details from the database
1.338 +//
1.339 +CLogServOpTypeDelete::CLogServOpTypeDelete(MLogServTaskInterface& aTaskInterface,
1.340 + MLogServOperationManager& aOperationManager,
1.341 + const RMessage2& aMessage,
1.342 + CLogPackage& aPackage,
1.343 + const TLogClientServerData& aCliServData,
1.344 + TLogServSessionId aSessionId) :
1.345 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.346 + {
1.347 + }
1.348 +
1.349 +//
1.350 +// Get stuff from the client and start doing the work
1.351 +//
1.352 +void CLogServOpTypeDelete::StartL(TRequestStatus& aStatus)
1.353 + {
1.354 + // Do the actual work
1.355 + const TUid eventTypeUid = { Message().Int1() };
1.356 + TaskInterface().TaskEventTypeDeleteL(aStatus, eventTypeUid);
1.357 + }
1.358 +
1.359 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.360 +////////////////////////////// CLogServOpConfigGet ///////////////////////////////////////////////////////////
1.361 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.362 +
1.363 +//
1.364 +// Get database config
1.365 +//
1.366 +CLogServOpConfigGet::CLogServOpConfigGet(MLogServTaskInterface& aTaskInterface,
1.367 + MLogServOperationManager& aOperationManager,
1.368 + const RMessage2& aMessage,
1.369 + CLogPackage& aPackage,
1.370 + const TLogClientServerData& aCliServData,
1.371 + TLogServSessionId aSessionId) :
1.372 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.373 + {
1.374 + }
1.375 +
1.376 +//
1.377 +// Start doing the work
1.378 +//
1.379 +void CLogServOpConfigGet::StartL(TRequestStatus& aStatus)
1.380 + {
1.381 + // Do the actual work
1.382 + TaskInterface().TaskConfigGetL(aStatus, iConfig);
1.383 + }
1.384 +
1.385 +//
1.386 +// Complete the client request - we need to wait for the client to request a response
1.387 +//
1.388 +CLogServOperationBase::TCompletionStatus CLogServOpConfigGet::CompleteProcessingL(TInt /*aFinalCompletionCode*/)
1.389 + {
1.390 + Package().SetLogConfigL(iConfig);
1.391 + const TInt size = Package().Ptr().Size();
1.392 + Complete(size);
1.393 + //
1.394 + return CLogServOperationBase::EOperationCompleteWaitForClient;
1.395 + }
1.396 +
1.397 +// Write stuff back to the client
1.398 +void CLogServOpConfigGet::WriteL(const RMessage2& aMessage)
1.399 + {
1.400 + aMessage.WriteL(1, Package().Ptr());
1.401 + }
1.402 +
1.403 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.404 +////////////////////////////// CLogServOpConfigChange ////////////////////////////////////////////////////////
1.405 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.406 +
1.407 +//
1.408 +// Change database config
1.409 +//
1.410 +CLogServOpConfigChange::CLogServOpConfigChange(MLogServTaskInterface& aTaskInterface,
1.411 + MLogServOperationManager& aOperationManager,
1.412 + const RMessage2& aMessage,
1.413 + CLogPackage& aPackage,
1.414 + const TLogClientServerData& aCliServData,
1.415 + TLogServSessionId aSessionId) :
1.416 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.417 + {
1.418 + }
1.419 +
1.420 +//
1.421 +// Decode parameters from a client and start doing the work
1.422 +//
1.423 +void CLogServOpConfigChange::StartL(TRequestStatus& aStatus)
1.424 + {
1.425 + // Read stuff from the client
1.426 + Package().ResizeL(Message().GetDesLengthL(1));
1.427 + Message().ReadL(1, Package().Ptr());
1.428 +
1.429 + // Decode the parameters we've read from the client
1.430 + Package().GetLogConfigL(iConfig);
1.431 +
1.432 + // Do the actual work
1.433 + TaskInterface().TaskConfigChangeL(aStatus, iConfig);
1.434 + }
1.435 +
1.436 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.437 +////////////////////////////// CLogServOpClearLog ////////////////////////////////////////////////////////////
1.438 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.439 +
1.440 +//
1.441 +// Clear the event log
1.442 +//
1.443 +CLogServOpClearLog::CLogServOpClearLog(MLogServTaskInterface& aTaskInterface,
1.444 + MLogServOperationManager& aOperationManager,
1.445 + const RMessage2& aMessage,
1.446 + CLogPackage& aPackage,
1.447 + const TLogClientServerData& aCliServData,
1.448 + TLogServSessionId aSessionId) :
1.449 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.450 + {
1.451 + }
1.452 +
1.453 +//
1.454 +// Decode parameters from the client and start doing the work
1.455 +//
1.456 +void CLogServOpClearLog::StartL(TRequestStatus& aStatus)
1.457 + {
1.458 + // Do the actual work
1.459 + TUint p2 = (TUint)Message().Ptr2();
1.460 + TUint p1 = (TUint)Message().Ptr1();
1.461 + const TTime time(MAKE_TINT64(p2, p1));
1.462 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.463 + TSimId simId = (TSimId)Message().Int3();
1.464 + TaskInterface().TaskClearLogL(aStatus, time, simId);
1.465 +#else
1.466 + TaskInterface().TaskClearLogL(aStatus, time);
1.467 +#endif
1.468 + }
1.469 +
1.470 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.471 +////////////////////////////// CLogServOpClearRecent /////////////////////////////////////////////////////////
1.472 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.473 +
1.474 +//
1.475 +// Clear a recent list
1.476 +//
1.477 +CLogServOpClearRecent::CLogServOpClearRecent(MLogServTaskInterface& aTaskInterface,
1.478 + MLogServOperationManager& aOperationManager,
1.479 + const RMessage2& aMessage,
1.480 + CLogPackage& aPackage,
1.481 + const TLogClientServerData& aCliServData,
1.482 + TLogServSessionId aSessionId) :
1.483 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.484 + {
1.485 + }
1.486 +
1.487 +//
1.488 +// Decode parameters from the client and start doing the work
1.489 +//
1.490 +void CLogServOpClearRecent::StartL(TRequestStatus& aStatus)
1.491 + {
1.492 + // Do the actual work
1.493 + const TLogRecentList recentList = static_cast<TLogRecentList>(Message().Int1());
1.494 +#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
1.495 + TSimId simId = (TSimId)Message().Int2();
1.496 + TaskInterface().TaskClearRecentL(aStatus, recentList, simId);
1.497 +#else
1.498 + TaskInterface().TaskClearRecentL(aStatus, recentList);
1.499 +#endif
1.500 + }
1.501 +
1.502 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.503 +////////////////////////////// CLogServOpMaintenance /////////////////////////////////////////////////////////
1.504 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.505 +
1.506 +//
1.507 +// Kicks the server to perform a maintain on the database.
1.508 +// Always done after an op as necessary
1.509 +//
1.510 +CLogServOpMaintenance::CLogServOpMaintenance(MLogServTaskInterface& aTaskInterface,
1.511 + MLogServOperationManager& aOperationManager,
1.512 + const RMessage2& aMessage,
1.513 + CLogPackage& aPackage,
1.514 + const TLogClientServerData& aCliServData,
1.515 + TLogServSessionId aSessionId) :
1.516 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId)
1.517 + {
1.518 + }
1.519 +
1.520 +//
1.521 +// Just complete ourselves
1.522 +//
1.523 +void CLogServOpMaintenance::StartL(TRequestStatus& aStatus)
1.524 + {
1.525 + TRequestStatus* status = &aStatus;
1.526 + User::RequestComplete(status, KErrNone);
1.527 + }
1.528 +
1.529 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.530 +////////////////////////////// CLogServOpViewSetup ///////////////////////////////////////////////////////////
1.531 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.532 +
1.533 +// Setup a view
1.534 +CLogServOpViewSetup::CLogServOpViewSetup(MLogServTaskInterface& aTaskInterface,
1.535 + MLogServOperationManager& aOperationManager,
1.536 + const RMessage2& aMessage,
1.537 + CLogPackage& aPackage,
1.538 + CLogServViewBase& aView,
1.539 + const TLogClientServerData& aCliServData,
1.540 + TLogServSessionId aSessionId) :
1.541 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId),
1.542 + iView(aView)
1.543 + {
1.544 + }
1.545 +
1.546 +//
1.547 +// Decode parameters from the client and start doing the work
1.548 +//
1.549 +void CLogServOpViewSetup::StartL(TRequestStatus& aStatus)
1.550 + {
1.551 + // Read the filter construction type from the shared data slot
1.552 + const TInt filterConstructionType = ClientServerData().iDataSlot1;
1.553 + if (filterConstructionType == ELogFilterConstructFilterByFilterFieldByField || filterConstructionType == ELogFilterConstructFieldByFieldFilterByFilter)
1.554 + {
1.555 + // Do the actual work
1.556 + iView.SetupL(Message(), static_cast<TLogFilterConstructionType>(filterConstructionType));
1.557 + TRequestStatus* status = &aStatus;
1.558 + User::RequestComplete(status, KErrNone);
1.559 + }
1.560 + else
1.561 + ::PanicClientL(Message(), ELogBadFilterConstructionType);
1.562 + }
1.563 +
1.564 +//
1.565 +// Complete the client request telling it the number of entries in the view
1.566 +//
1.567 +CLogServOperationBase::TCompletionStatus CLogServOpViewSetup::CompleteProcessingL(TInt /*aFinalCompletionCode*/)
1.568 + {
1.569 + const TInt viewCount = iView.Count();
1.570 + Complete(viewCount);
1.571 + //
1.572 + return CLogServOperationBase::EOperationComplete;
1.573 + }
1.574 +
1.575 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.576 +////////////////////////////// CLogServOpViewEventRemove /////////////////////////////////////////////////////
1.577 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.578 +
1.579 +//
1.580 +// Remove an event from a view
1.581 +//
1.582 +CLogServOpViewEventRemove::CLogServOpViewEventRemove(MLogServTaskInterface& aTaskInterface,
1.583 + MLogServOperationManager& aOperationManager,
1.584 + const RMessage2& aMessage,
1.585 + CLogPackage& aPackage,
1.586 + CLogServViewBase& aView,
1.587 + const TLogClientServerData& aCliServData,
1.588 + TLogServSessionId aSessionId):
1.589 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId),
1.590 + iView(aView)
1.591 + {
1.592 + }
1.593 +
1.594 +//
1.595 +// Decode parameters from the client and start doing the work
1.596 +//
1.597 +void CLogServOpViewEventRemove::StartL(TRequestStatus& aStatus)
1.598 + {
1.599 + iView.RemoveL(Message());
1.600 + TRequestStatus* status = &aStatus;
1.601 + User::RequestComplete(status, KErrNone);
1.602 + }
1.603 +
1.604 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.605 +////////////////////////////// CLogServOpViewClearDuplicates /////////////////////////////////////////////////
1.606 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.607 +
1.608 +CLogServOpViewClearDuplicates::CLogServOpViewClearDuplicates(MLogServTaskInterface& aTaskInterface,
1.609 + MLogServOperationManager& aOperationManager,
1.610 + const RMessage2& aMessage,
1.611 + CLogPackage& aPackage,
1.612 + CLogServViewBase& aView,
1.613 + const TLogClientServerData& aCliServData,
1.614 + TLogServSessionId aSessionId):
1.615 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId),
1.616 + iView(aView)
1.617 + {
1.618 + }
1.619 +
1.620 +void CLogServOpViewClearDuplicates::StartL(TRequestStatus& aStatus)
1.621 + {
1.622 + iView.ClearDuplicatesL(Message());
1.623 + TRequestStatus* status = &aStatus;
1.624 + User::RequestComplete(status, KErrNone);
1.625 + }
1.626 +
1.627 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.628 +////////////////////////////// CLogServOpViewSetFlags ////////////////////////////////////////////////////////
1.629 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.630 +
1.631 +CLogServOpViewSetFlags::CLogServOpViewSetFlags(MLogServTaskInterface& aTaskInterface,
1.632 + MLogServOperationManager& aOperationManager,
1.633 + const RMessage2& aMessage,
1.634 + CLogPackage& aPackage,
1.635 + CLogServViewBase& aView,
1.636 + const TLogClientServerData& aCliServData,
1.637 + TLogServSessionId aSessionId) :
1.638 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId),
1.639 + iView(aView)
1.640 + {
1.641 + }
1.642 +
1.643 +void CLogServOpViewSetFlags::StartL(TRequestStatus& aStatus)
1.644 + {
1.645 + iView.SetFlagsL(Message());
1.646 + TRequestStatus* status = &aStatus;
1.647 + User::RequestComplete(status, KErrNone);
1.648 + }
1.649 +
1.650 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.651 +////////////////////////////// CLogServOpViewWindowFetcher ///////////////////////////////////////////////////
1.652 +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.653 +
1.654 +CLogServOpViewWindowFetcher::CLogServOpViewWindowFetcher(MLogServTaskInterface& aTaskInterface,
1.655 + MLogServOperationManager& aOperationManager,
1.656 + const RMessage2& aMessage,
1.657 + CLogPackage& aPackage,
1.658 + CLogServViewBase& aView,
1.659 + const TLogClientServerData& aCliServData,
1.660 + TLogServSessionId aSessionId) :
1.661 + CLogServOperationBase(aTaskInterface, aOperationManager, aMessage, aPackage, aCliServData, aSessionId),
1.662 + iView(aView)
1.663 + {
1.664 + }
1.665 +
1.666 +void CLogServOpViewWindowFetcher::StartL(TRequestStatus& aStatus)
1.667 + {
1.668 + // Get the window
1.669 + TLogTransferWindow window;
1.670 + TPckg<TLogTransferWindow> pWindow(window);
1.671 + Message().ReadL(2, pWindow);
1.672 +
1.673 + // Do the actual work
1.674 + TaskInterface().TaskBuildWindowL(aStatus, iView, window, Message());
1.675 + }
1.676 +
1.677 +//
1.678 +// Complete the client request - the final completion code tells us, in this instance, how many records were
1.679 +// read from the view.
1.680 +//
1.681 +CLogServOperationBase::TCompletionStatus CLogServOpViewWindowFetcher::CompleteProcessingL(TInt aFinalCompletionCode)
1.682 + {
1.683 + Complete(aFinalCompletionCode);
1.684 +
1.685 + // Don't need to wait for anything - we've already written back to the client's address space
1.686 + // when we built the window.
1.687 + return CLogServOperationBase::EOperationComplete;
1.688 + }