1 /*

     2 * Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   This module contains eventmediator and the services of it.

    15 *

    16 */

    17 

    18 

    19 

    20 /**  

    21  * @file eventmediator.cpp

    22  *

    23  * This module contains eventmediator and the services of it.

    24  *

    25  */

    26 #include <es_sock.h>

    27 #include "eventmediator.h"

    28 #include "eventlogger.h"

    29 #include "eventmediatordefs.h"

    30 #include "sit.h"

    31 #include "log_em.h"

    32 

    33 #define FIRST_ARGUMENT 0

    34 #define SECOND_ARGUMENT 1

    35 #define THIRD_ARGUMENT 2

    36 #define FOURTH_ARGUMENT 3

    37 

    38 // ============================= CEventMediatorServer =============================

    39 

    40 const TUint CEventMediatorServer::iRangeCount = 2;

    41     

    42 const TInt CEventMediatorServer::iRanges[iRangeCount] = 

    43     {

    44     CEventMediatorSession::KEventMediatorListen,

    45     CEventMediatorSession::KEventMediatorClearEventLog+1

    46     };

    47 

    48 const TUint8 CEventMediatorServer::iElementIndex[iRangeCount] = 

    49     {

    50     0,

    51     CPolicyServer::ENotSupported

    52     };

    53 

    54 const CPolicyServer::TPolicyElement CEventMediatorServer::iElements[] =

    55     {

    56     {_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl), CPolicyServer::EFailClient},

    57     };

    58 

    59 const CPolicyServer::TPolicy CEventMediatorServer::iPolicy =

    60     {

    61     0,              // All connect attempts are checked

    62     iRangeCount,    // Count of ranges

    63     iRanges,        // 0...9, 9...

    64     iElementIndex,  // Only range 1000-1008 are checked

    65     iElements       // The list of policy elements

    66     };

    67 

    68 

    69 CEventMediatorServer::CEventMediatorServer(void)

    70     : CPolicyServer(EPriorityNormal,iPolicy), iStoredEvents(1)

    71     {

    72     }

    73 

    74 CEventMediatorServer* CEventMediatorServer::NewL()

    75     {

    76     LOG(Log::Printf(_L("CEventMediatorServer::NewL - begin\n")));

    77     CEventMediatorServer* server = CEventMediatorServer::NewLC();

    78     CleanupStack::Pop(); // server

    79     LOG(Log::Printf(_L("CEventMediatorServer::NewL - end\n")));

    80     return server;

    81     }

    82 

    83 CEventMediatorServer* CEventMediatorServer::NewLC()

    84     {

    85     LOG(Log::Printf(_L("CEventMediatorServer::NewLC - begin\n")));

    86     CEventMediatorServer* server = new (ELeave) CEventMediatorServer();

    87     CleanupStack::PushL(server); 

    88     server->ConstructL(server);

    89     LOG(Log::Printf(_L("CEventMediatorServer::NewLC - end\n")));

    90     return server;

    91     }

    92 

    93 void CEventMediatorServer::ConstructL(CEventMediatorServer* aServer)

    94     {

    95     RFs fs;

    96     User::LeaveIfError(fs.Connect());

    97     CleanupClosePushL(fs);

    98 

    99     fs.CreatePrivatePath(EDriveC);

   100     

   101     TPath privateDir;

   102     User::LeaveIfError(fs.PrivatePath(privateDir));

   103     iEventLogFileName.Copy(privateDir);

   104     iEventLogFileName.Append(KEventLogFile);

   105     

   106     CleanupStack::PopAndDestroy(); // fs

   107     

   108     aServer->iLogger = CEventLogger::NewL(this);

   109     iSit = new (ELeave) CSit(this);

   110     StartL(KEventMediatorServer);

   111     }

   112 

   113 CEventMediatorServer::~CEventMediatorServer(void)

   114     {

   115     LOG(Log::Printf(_L("CEventMediatorServer::~CEventMediatorServer\n")));

   116     // Delete stored events

   117     TInt nEvents = this->iStoredEvents.Count();

   118     for (TInt i = 0; i < nEvents; i++)  

   119         {

   120         delete iStoredEvents.At(i)->iData;

   121         delete iStoredEvents.At(i);

   122         }

   123     iStoredEvents.Delete(0, iStoredEvents.Count());

   124 

   125     // Delete log writer

   126     delete iLogger;

   127 

   128     delete iSit;

   129     }

   130 

   131 // ----------------------------------------------------------------------------

   132 // CEventMediatorServer::StopEventMediator

   133 // Stops Event Mediator service if there are no sessions left.

   134 // ----------------------------------------------------------------------------

   135 //

   136 void CEventMediatorServer::StopEventMediator(void)

   137     {

   138     if (iSessionCount == 0) 

   139         {

   140         LOG(Log::Printf(_L("CEventMediatorServer::StopEventMediator - session count 0, stopping scheduler and thus the server\n")));

   141         CActiveScheduler::Stop();   

   142         }   

   143     }

   144 

   145 TInt CEventMediatorServer::RunError(TInt aError)

   146     {

   147     LOG(Log::Printf(_L("CEventMediatorServer::RunError - error = %d\n"), aError));

   148     Message().Complete(aError);

   149 

   150     // The leave will result in an early return from CServer::RunL(),

   151     // skipping the call to request another message. So we issue the

   152     // request here in order to keep the server running.

   153     ReStart();

   154 

   155     // Handled the error fully

   156     return KErrNone;    

   157     }

   158 

   159 // ----------------------------------------------------------------------------

   160 // CEventMediatorServer::NewSessionL

   161 // Creates a new session and returns the handle to the session.

   162 // ----------------------------------------------------------------------------

   163 //

   164 CSession2* CEventMediatorServer::NewSessionL(

   165     const TVersion& /*aVersion*/,

   166     const RMessage2& aMessage) const

   167     {

   168     // New sessions are not accepted if the server is shutting down

   169     // (it's just waiting for the last session (from SIT) to die)

   170     if (iShuttingDown)

   171         {

   172         User::Leave(KErrServerTerminated);

   173         }

   174     

   175     CSession2* session = CEventMediatorSession::NewL(CONST_CAST(CEventMediatorServer*, this), aMessage);

   176     return session;

   177     }

   178 

   179 void CEventMediatorServer::ReportEventL(const TEventType aType, TDesC8* aSpec,

   180                                         TDesC8* aData, TInt aStatus)

   181     {

   182     LOG(Log::Printf(_L("CEventMediatorServer::ReportEventL - event type = %d\n"), aType));

   183     TInt listenerCount = 0;

   184     CEventMediatorSession* session;

   185     iSessionIter.SetToFirst();

   186     session = (CEventMediatorSession*) iSessionIter++;

   187 

   188     while (session != NULL)

   189         {

   190         // Some listeners listen this event with specification

   191         listenerCount += session->CheckEventL(aType, aSpec, aData, aStatus); 

   192         // Some without specification, all events are good for them

   193         if (aSpec != NULL)

   194             {

   195             listenerCount += session->CheckEventL(aType, NULL, aData, aStatus);

   196             }

   197         session = (CEventMediatorSession*) iSessionIter++;

   198         }

   199     if (listenerCount)

   200         {

   201         // Need to save the event data as it may/will be fetched later

   202         TEventContainer* container = new (ELeave) TEventContainer(listenerCount, aData);

   203         CleanupStack::PushL(container);

   204         iStoredEvents.AppendL(container);

   205         CleanupStack::Pop();

   206         }

   207     // Write event to log

   208     if (aType == ELogEvent && iLogger)

   209         {

   210         LOG(Log::Printf(_L("CEventMediatorServer::ReportEventL - calling iLogger->LogEvent\n")));

   211         iLogger->LogEvent(*aData);

   212         }

   213 

   214     // If there are no listeners, delete data

   215     if (listenerCount == 0)

   216         {

   217         delete aData;

   218         }

   219     }

   220 

   221 TInt CEventMediatorServer::CopyEventDataL(const RMessage2& aMessage)

   222     {

   223     TBool found = EFalse;

   224     TInt i = 0;

   225     TInt err = KErrNone;

   226     while (!found && i < iStoredEvents.Count())

   227         {

   228         if (iStoredEvents.At(i)->iData == aMessage.Ptr0())

   229             {

   230             found = ETrue;

   231             }

   232         else

   233             {

   234             i++;

   235             }

   236         }

   237     if (found)

   238         {

   239         aMessage.WriteL(SECOND_ARGUMENT, *(iStoredEvents.At(i)->iData));

   240         MarkStoredEventListened(i);

   241         }

   242     else

   243         {

   244         err = KErrNotFound;

   245         }

   246     return err;

   247     }

   248 

   249 void CEventMediatorServer::MarkStoredEventListened(TInt aIndex)

   250     {

   251     iStoredEvents.At(aIndex)->iListenerCount--;

   252     if (iStoredEvents.At(aIndex)->iListenerCount == 0)

   253         {

   254         delete iStoredEvents.At(aIndex)->iData;

   255         delete iStoredEvents.At(aIndex);

   256         iStoredEvents.Delete(aIndex);

   257         }

   258     }

   259 

   260 TBool CEventMediatorServer::IsClientTheSitL(const RMessage2& aMessage)

   261     {

   262     LOG(Log::Printf(_L("CEventMediatorServer::IsClientTheSitL\n")));

   263     TBool isClientTheSit = EFalse;

   264     

   265     RThread clientThread;

   266     User::LeaveIfError(aMessage.Client(clientThread));

   267     

   268     if (clientThread.Id() == iSit->ThreadId())

   269         {

   270         LOG(Log::Printf(_L("CEventMediatorServer::IsClientTheSitL - YES\n")));

   271         isClientTheSit = ETrue;

   272         }

   273 

   274     clientThread.Close();

   275 

   276     return isClientTheSit;

   277     }

   278     

   279 void CEventMediatorServer::MakeSureSitIsRunningL()

   280     {

   281     LOG(Log::Printf(_L("CEventMediatorServer::MakeSureSitIsRunningL\n")));

   282     // If the SIT has not yet been started

   283     // or has died, try to start it

   284     iSit->StartL();

   285     }

   286 

   287 void CEventMediatorServer::SetTaskArrivalListenerL(CListenerContainer* aListener)

   288     {

   289     LOG(Log::Printf(_L("CEventMediatorServer::SetTaskArrivalListenerL\n")));

   290     if (aListener)

   291         {

   292         // Task arrival observation requests must

   293         // come from the SIT

   294         if (!IsClientTheSitL(aListener->Message()))

   295             {

   296             User::Leave(KErrNotSupported);

   297             }

   298 

   299         // Only one task arrival observation request

   300         // is allowed to be present at the same time

   301         if (iTaskArrivalListener && (aListener != iTaskArrivalListener))

   302             {

   303             User::Leave(KErrNotSupported);

   304             }

   305         }

   306 

   307     iTaskArrivalListener = aListener;

   308     }

   309 

   310 void CEventMediatorServer::ClearTaskArrivalListener()

   311     {

   312     LOG(Log::Printf(_L("CEventMediatorServer::ClearTaskArrivalListener\n")));

   313     iTaskArrivalListener = NULL;

   314     }

   315 

   316 CListenerContainer* CEventMediatorServer::TaskArrivalListener()

   317     {

   318     return iTaskArrivalListener;

   319     }

   320 

   321 void CEventMediatorServer::TaskRequestArrivedL(CListenerContainer* aTaskRequest)

   322     {

   323     LOG(Log::Printf(_L("CEventMediatorServer::TaskRequestArrivedL\n")));

   324     CompleteTaskArrivalObservationRequestL(aTaskRequest->Type(), aTaskRequest->Specification());

   325     }

   326 

   327 void CEventMediatorServer::TaskArrivalObservationRequestArrivedL()

   328     {

   329     LOG(Log::Printf(_L("CEventMediatorServer::TaskArrivalObservationRequestArrivedL\n")));

   330     // Go through all pending event listening requests to see if any

   331     // one of those should be passed to the SIT (i.e. if the task

   332     // arrival observation request should be completed immediately)

   333     

   334     CListenerContainer* taskRequest = FindWaitingTaskRequest();

   335     

   336     if (taskRequest)

   337         {

   338         CompleteTaskArrivalObservationRequestL(taskRequest->Type(), taskRequest->Specification());

   339         }

   340     }

   341 

   342 void CEventMediatorServer::TaskRequestEventSpecFetchingRequestArrivedL(CListenerContainer* aFetchingRequest)

   343     {

   344     LOG(Log::Printf(_L("CEventMediatorServer::TaskRequestEventSpecFetchingRequestArrivedL\n")));

   345     TFetchTaskInfoEventSpec taskRequestInfo;

   346     TPckg<TFetchTaskInfoEventSpec> taskRequestInfoDes(taskRequestInfo);

   347     taskRequestInfoDes.Copy(*(aFetchingRequest->Specification()));

   348 

   349     // Find the task request whose event specification

   350     // we should return to the SIT TH

   351     CListenerContainer* taskRequest = FindListener(taskRequestInfo.iEventType, taskRequestInfo.iEventSpecId);

   352 

   353     if (taskRequest && !taskRequest->BeingFulfilled())

   354         {

   355         CompleteTaskRequestEventSpecFetchingRequestL(KErrNone, aFetchingRequest->Specification(),

   356                                                      taskRequest->Specification());

   357         taskRequest->MarkAsBeingFulfilled();

   358         }

   359     else

   360         {

   361         CompleteTaskRequestEventSpecFetchingRequestL(KErrNotFound, aFetchingRequest->Specification(), NULL);

   362         }

   363     }

   364 

   365 void CEventMediatorServer::TaskCancellationObservationRequestArrivedL(CListenerContainer* aRequest)

   366     {

   367     LOG(Log::Printf(_L("CEventMediatorServer::TaskCancellationObservationRequestArrivedL\n")));

   368     // Try to find a task request event type that corresponds to the received

   369     // event type. This will only succeed if the received event type is

   370     // one that is used to listen to the cancellation of a task request.

   371     TEventType taskRequestEventType = CSit::FindTaskRequestEventType(aRequest->Type());

   372 

   373     // If a corresponding task request type was found...

   374     if (taskRequestEventType != EUnfoundEvent)

   375         {

   376         // Try to find the listener container of the task request

   377         CListenerContainer* taskRequest = FindListener(taskRequestEventType, aRequest->Specification());

   378 

   379         // The listener container for the task request was not found

   380         // (i.e. the task request has been cancelled or the

   381         // corresponding client session has been closed), so we

   382         // complete the cancellation observation request right away

   383         if (taskRequest == NULL)

   384             {

   385             ReportEventL(aRequest->Type(), aRequest->Specification(), NULL);

   386             }

   387         }

   388     }

   389 

   390 void CEventMediatorServer::CompleteTaskArrivalObservationRequestL(TEventType aEventType, TDesC8* aSpec)

   391     {

   392     LOG(Log::Printf(_L("CEventMediatorServer::CompleteTaskArrivalObservationRequestL\n")));

   393     if (iTaskArrivalListener)

   394         {

   395         // In SIT events, the event specification

   396         // begins with the event specification ID

   397         TEventSpec* sitEventSpec = (TEventSpec*)(aSpec->Ptr());

   398         

   399         TTaskArrivedEventData eventData;

   400         eventData.iEventType = aEventType;

   401         eventData.iEventSpecId = sitEventSpec->iId;

   402         TPckg<TTaskArrivedEventData> eventDataDes(eventData);

   403         

   404         HBufC8* eventDataCopy = eventDataDes.AllocL();

   405         CleanupStack::PushL(eventDataCopy);

   406 

   407         ReportEventL(ETaskArrivedEvent, NULL, eventDataCopy);

   408         

   409         CleanupStack::Pop(); // eventDataCopy, freed elsewhere

   410         }

   411     }

   412 

   413 void CEventMediatorServer::CompleteTaskRequestEventSpecFetchingRequestL(TInt aStatus, TDesC8* aEventSpec,

   414                                                                         TDesC8* aTaskRequestEventSpec)

   415     {

   416     LOG(Log::Printf(_L("CEventMediatorServer::CompleteTaskRequestEventSpecFetchingRequestL\n")));

   417     // The event specification of the task request

   418     // is returned to the SIT TH as event data

   419     if (aTaskRequestEventSpec)

   420         {

   421         HBufC8* eventData = aTaskRequestEventSpec->AllocL();

   422         CleanupStack::PushL(eventData);

   423 

   424         ReportEventL(EFetchTaskInfoEvent, aEventSpec, eventData, aStatus);

   425 

   426         CleanupStack::Pop(); // eventData, freed elsewhere

   427         }

   428     else

   429         {

   430         ReportEventL(EFetchTaskInfoEvent, aEventSpec, NULL, aStatus);

   431         }

   432     }

   433     

   434 CListenerContainer* CEventMediatorServer::FindWaitingTaskRequest()

   435     {

   436     CEventMediatorSession* session;

   437     iSessionIter.SetToFirst();

   438     session = (CEventMediatorSession*) iSessionIter++;

   439 

   440     CListenerContainer* listener = NULL;

   441     

   442     while (session != NULL)

   443         {

   444         listener = session->FindWaitingTaskRequest();

   445         if (listener != NULL)

   446             {

   447             break;

   448             }

   449         session = (CEventMediatorSession*) iSessionIter++;

   450         }

   451 

   452     return listener;

   453     }

   454 

   455 CListenerContainer* CEventMediatorServer::FindListener(TEventType aEventType,    

   456                                                        TInt aEventSpecId)

   457     {

   458     CEventMediatorSession* session;

   459     iSessionIter.SetToFirst();

   460     session = (CEventMediatorSession*) iSessionIter++;

   461 

   462     CListenerContainer* listener = NULL;

   463     

   464     while (session != NULL)

   465         {

   466         listener = session->FindListener(aEventType, aEventSpecId);

   467         if (listener != NULL)

   468             {

   469             break;

   470             }

   471         session = (CEventMediatorSession*) iSessionIter++;

   472         }

   473 

   474     return listener;

   475     }

   476     

   477 CListenerContainer* CEventMediatorServer::FindListener(TEventType aEventType,    

   478                                                        const TDesC8* aEventSpec)

   479     {

   480     CEventMediatorSession* session;

   481     iSessionIter.SetToFirst();

   482     session = (CEventMediatorSession*) iSessionIter++;

   483 

   484     CListenerContainer* listener = NULL;

   485     

   486     while (session != NULL)

   487         {

   488         listener = session->FindListener(aEventType, aEventSpec);

   489         if (listener != NULL)

   490             {

   491             break;

   492             }

   493         session = (CEventMediatorSession*) iSessionIter++;

   494         }

   495 

   496     return listener;

   497     }

   498 

   499 void CEventMediatorServer::CompleteListener(TEventType aEventType, const TDesC8* aEventSpec, TInt aStatus)

   500     {

   501     CEventMediatorSession* session;

   502     iSessionIter.SetToFirst();

   503     session = (CEventMediatorSession*) iSessionIter++;

   504 

   505     while (session != NULL)

   506         {

   507         session->CompleteListener(aEventType, aEventSpec, aStatus);

   508         session = (CEventMediatorSession*) iSessionIter++;

   509         }

   510     }

   511 

   512 TInt CEventMediatorServer::NormalSessionCount()

   513     {

   514     TInt normalSessionCount = 0;

   515     

   516     CEventMediatorSession* session;

   517     iSessionIter.SetToFirst();

   518     session = (CEventMediatorSession*) iSessionIter++;

   519 

   520     while (session != NULL)

   521         {

   522         if (!(session->IsASitSession()))

   523             {

   524             normalSessionCount++;

   525             }

   526         session = (CEventMediatorSession*) iSessionIter++;

   527         }

   528 

   529     return normalSessionCount;

   530     }

   531 

   532 TInt CEventMediatorServer::NewEventSpecId()

   533     {

   534     return ++iNextEventSpecId;

   535     }

   536 

   537 TPtrC CEventMediatorServer::EventLogFileName(void)

   538     {

   539     TPtrC name(iEventLogFileName);

   540     return name;

   541     }

   542     

   543 void CEventMediatorServer::SitDied()

   544     {

   545     LOG(Log::Printf(_L("CEventMediatorServer::SitDied\n")));

   546     CompleteTaskRequests(KErrDied);

   547     }

   548     

   549 void CEventMediatorServer::CompleteTaskRequests(TInt aStatus)

   550     {

   551     LOG(Log::Printf(_L("CEventMediatorServer::CompleteTaskRequests\n")));    

   552     CEventMediatorSession* session;

   553     iSessionIter.SetToFirst();

   554     session = (CEventMediatorSession*) iSessionIter++;

   555 

   556     while (session != NULL)

   557         {

   558         session->CompleteTaskRequests(aStatus);

   559         session = (CEventMediatorSession*) iSessionIter++;

   560         }

   561     }

   562 

   563 void CEventMediatorServer::SetShuttingDown(TBool aShuttingDown)

   564     {

   565     iShuttingDown = aShuttingDown;

   566     }

   567 

   568 // ============================= CEventMediatorSession =============================     

   569 

   570 CEventMediatorSession* CEventMediatorSession::NewL(CEventMediatorServer* aServer, const RMessage2& aMessage)

   571     {

   572     LOG(Log::Printf(_L("CEventMediatorSession::NewL - begin\n")));

   573     CEventMediatorSession* self;

   574     self = new (ELeave) CEventMediatorSession(aServer);

   575     CleanupStack::PushL(self);

   576 

   577     // Marks the session as a "SIT session"

   578     // if the client is the SIT thread

   579     self->iIsSitSession = aServer->IsClientTheSitL(aMessage);

   580 

   581     aServer->iSessionCount++;

   582 

   583     if ( !self->IsASitSession() )

   584         {

   585         User::LeaveIfError(self->iFs.Connect()); // For EventLog

   586         self->iEventLogFileOpen = EFalse;

   587         }

   588 

   589     CleanupStack::Pop(); // self

   590 

   591     LOG(Log::Printf(_L("CEventMediatorSession::NewL - end\n")));

   592     return self;

   593     }

   594 

   595 CEventMediatorSession::CEventMediatorSession(CEventMediatorServer* aServer)

   596     : iListenedEvents(2), iServer(aServer)

   597     {

   598     }

   599 

   600 CEventMediatorSession::~CEventMediatorSession(void)

   601     {

   602     LOG(Log::Printf(_L("CEventMediatorSession::~CEventMediatorSession\n")));

   603     CancelAll();

   604     if (iServer)

   605         {        

   606         TInt normalSessionCount = iServer->NormalSessionCount();

   607 

   608         // If this too is a normal session and is dying,

   609         // decrement the normal session count by one

   610         if (!IsASitSession())

   611             {

   612             normalSessionCount--;

   613             

   614             if (iEventLogFileOpen)

   615                 {

   616                 iEventLogFile.Close();

   617                 iEventLogFileOpen = EFalse;

   618                 }

   619             iFs.Close(); // For EventLog

   620             

   621             }

   622 

   623         if (normalSessionCount == 0)

   624             {

   625             // If "normal" (non-sit) sessions are no longer present,

   626             // we complete the task arrival observation request, thus

   627             // causing the SIT to terminate and close its connection

   628             // to this server. This should be the last connection whose

   629             // closing will cause this server to terminate.

   630             // NOTE. KErrCancel cannot be used here as the Event Mediator 

   631             // does not report it to the caller

   632             LOG(Log::Printf(_L("CEventMediatorSession::~CEventMediatorSession - normal session count = 0\n")));

   633             iServer->CompleteListener(ETaskArrivedEvent, NULL, KErrAbort);

   634 

   635             // Set the server state to "shutting down". This will

   636             // cause the server to discard any new connect requests

   637             // with KErrServerTerminated.

   638             iServer->SetShuttingDown(ETrue);

   639             }

   640 

   641         if (iServer->iSessionCount)

   642             {

   643             iServer->iSessionCount--;

   644             }

   645 

   646         iServer->StopEventMediator();

   647         }

   648     }

   649 

   650 void CEventMediatorSession::ServiceL(const RMessage2& aMessage)

   651     {

   652     TInt status = 0;

   653 

   654     switch (aMessage.Function())

   655         {

   656         case KEventMediatorListen:

   657             ListenToEventL(aMessage);

   658             break;

   659 

   660         case KEventMediatorListenWithSpec:

   661             ListenToEventWithSpecL(aMessage);

   662             break;

   663 

   664         case KEventMediatorCancel:

   665             CancelListening(aMessage);        

   666             aMessage.Complete(KErrNone);

   667             break;

   668 

   669         case KEventMediatorCancelWithSpec:

   670             CancelListeningWithSpecL(aMessage);        

   671             aMessage.Complete(KErrNone);

   672             break;

   673 

   674         case KEventMediatorCancelAll:

   675             CancelAll();        

   676             aMessage.Complete(KErrNone);

   677             break;

   678 

   679         case KEventMediatorReportEvent:

   680             ReportEventL(aMessage);

   681             aMessage.Complete(KErrNone);

   682             break;

   683 

   684         case KEventMediatorReportEventWithSpec:

   685             ReportEventWithSpecL(aMessage);

   686             aMessage.Complete(KErrNone);

   687             break;

   688 

   689         case KEventMediatorFetchData:

   690             status = FetchDataL(aMessage);

   691             aMessage.Complete(status);

   692             break;

   693 

   694         case KEventMediatorReportLogEvent:

   695             ReportLogEventL(aMessage);

   696             aMessage.Complete(KErrNone);

   697             break;

   698 

   699         case KEventMediatorNewEventSpecId:

   700             NewEventSpecIdL(aMessage);

   701             aMessage.Complete(KErrNone);

   702             break;

   703         case KEventMediatorDeletePrivateFiles:

   704             status = DeletePrivateFiles();

   705             aMessage.Complete(status);

   706             break;

   707 

   708         case KEventMediatorGetEventLogSize:

   709             status = GetEventLogSize(aMessage);

   710             aMessage.Complete(status);

   711             break;

   712 

   713         case KEventMediatorGetEventLogHeader:

   714             status = GetEventLogHeader(aMessage);

   715             aMessage.Complete(status);

   716             break;

   717         case KEventMediatorGetEventLogData:

   718             status = GetEventLogData(aMessage);

   719             aMessage.Complete(status);

   720             break;

   721         case KEventMediatorClearEventLog:

   722             status = ClearEventLog();

   723             aMessage.Complete(status);

   724             break;

   725         default:

   726             aMessage.Complete(KErrGeneral);

   727             break;

   728         }

   729     }

   730 

   731 TInt CEventMediatorSession::ListenToEventL(const RMessage2& aMessage)

   732     {

   733     CListenerContainer* listener = new (ELeave) CListenerContainer(aMessage, NULL, iServer);

   734     CleanupStack::PushL(listener);

   735 

   736     iListenedEvents.AppendL(listener);

   737     CleanupStack::Pop(); // listener

   738 

   739     listener->AnalyzeRequestL();

   740 

   741     return KErrNone;

   742     }

   743 

   744 TInt CEventMediatorSession::ListenToEventWithSpecL(const RMessage2& aMessage)

   745     {

   746     HBufC8* specBuf = NULL;

   747 

   748     // Read specification

   749     specBuf = ReadSpecificationFromClientL(aMessage);

   750     CleanupStack::PushL(specBuf);

   751 

   752     // Ownership of specBuf is given to listener

   753     CListenerContainer* listener = new (ELeave) CListenerContainer(aMessage, specBuf, iServer);

   754     CleanupStack::Pop(); // specBuf

   755     CleanupStack::PushL(listener);

   756         

   757     iListenedEvents.AppendL(listener);

   758     CleanupStack::Pop(); // listener

   759 

   760     listener->AnalyzeRequestL();

   761 

   762     return KErrNone;

   763     }

   764 

   765 void CEventMediatorSession::CancelListening(const RMessage2& aMessage)

   766     {

   767     TInt index;

   768     

   769     while (FindListenerMsg((TEventType)aMessage.Int0(), index))

   770         {

   771         CompleteListener(index, KErrCancel);

   772         }

   773     }

   774 

   775 void CEventMediatorSession::CancelListeningWithSpecL(const RMessage2& aMessage)

   776     {

   777     HBufC8* specBuf = NULL;

   778     TInt index;

   779     

   780     // Read specification

   781     specBuf = ReadSpecificationFromClientL(aMessage);

   782     CleanupStack::PushL(specBuf);

   783 

   784     // Cancel listeners

   785     while (FindListenerMsg((TEventType)aMessage.Int0(), specBuf, index))

   786         {

   787         CompleteListener(index, KErrCancel);

   788         }

   789     CleanupStack::PopAndDestroy(); // specBuf

   790     }

   791 

   792 void CEventMediatorSession::CancelAll()

   793     {

   794     TInt nEvents = iListenedEvents.Count();

   795     for (TInt i = 0; i < nEvents; i++)  

   796         {

   797         iListenedEvents.At(i)->Complete(KErrCancel);

   798         delete iListenedEvents.At(i);

   799         iListenedEvents.At(i) = NULL;

   800         }

   801     iListenedEvents.Reset();

   802     }

   803 

   804 void CEventMediatorSession::ReportEventL(const RMessage2& aMessage)

   805     {

   806     TEventType eventType = (TEventType)aMessage.Int0();

   807     LOG(Log::Printf(_L("CEventMediatorSession::ReportEventL - event type = %d\n"), eventType));

   808     // Read data

   809     HBufC8* dataBuf = ReadEventDataFromClientL(aMessage);

   810     CleanupStack::PushL(dataBuf);

   811     // Report event to server

   812     iServer->ReportEventL(eventType, NULL, dataBuf);

   813     CleanupStack::Pop();

   814     }

   815 

   816 void CEventMediatorSession::ReportEventWithSpecL(const RMessage2& aMessage)

   817     {

   818     TEventType eventType=(TEventType) aMessage.Int0();

   819     LOG(Log::Printf(_L("CEventMediatorSession::ReportEventWithSpecL - event type = %d\n"), eventType));

   820     // Read data

   821     HBufC8* dataBuf = ReadEventDataFromClientL(aMessage);

   822     CleanupStack::PushL(dataBuf);

   823     // Read specification

   824     HBufC8* specBuf = ReadSpecificationFromClientL(aMessage);

   825     CleanupStack::PushL(specBuf);

   826     // Report event to server

   827     iServer->ReportEventL(eventType, specBuf, dataBuf);

   828     CleanupStack::PopAndDestroy(); // specBuf

   829     CleanupStack::Pop(); // dataBuf 

   830     }

   831 

   832 void CEventMediatorSession::ReportLogEventL(const RMessage2& aMessage)

   833     {

   834     LOG(Log::Printf(_L("CEventMediatorSession::ReportLogEventL\n")));

   835     // Read event

   836     TLogEvent event;

   837     TPckg<TLogEvent> eventPckg(event);

   838     aMessage.ReadL(FIRST_ARGUMENT, eventPckg);

   839 

   840     // Create one buffer to contain put everything in a normal buffer and

   841     TInt lengthsDesLth = event.iDesCount * sizeof(TInt);

   842     TInt position = eventPckg.Length();

   843     TInt dataLength = position + lengthsDesLth + aMessage.Int2();

   844     HBufC8* dataBuf = HBufC8::NewLC(dataLength);

   845     TPtr8 dataPtr = dataBuf->Des();

   846 

   847     // Copy event to buffer

   848     dataPtr.Append(eventPckg);

   849     // Read lengths to buffer

   850     TPtr8 tmpPtr(&dataPtr[position], 0, dataLength - position);

   851     aMessage.ReadL(SECOND_ARGUMENT, tmpPtr);

   852     // Read descriptors to the buffer

   853     position= dataPtr.Length();

   854     tmpPtr.Set(&dataPtr[position], 0, dataLength - position);

   855     aMessage.ReadL(THIRD_ARGUMENT, tmpPtr);

   856 

   857     // Report event to server

   858     iServer->ReportEventL(ELogEvent, NULL, dataBuf);

   859     CleanupStack::Pop();

   860     }

   861 

   862 TInt CEventMediatorSession::FetchDataL(const RMessage2& aMessage)

   863     {

   864     LOG(Log::Printf(_L("CEventMediatorSession::FetchDataL\n")));

   865     return iServer->CopyEventDataL(aMessage);

   866     }

   867 

   868 TInt CEventMediatorSession::CheckEventL(const TEventType aType, const TDesC8* aSpec,

   869                                         const TDesC8* aData, TInt aStatus)

   870     {

   871     TInt index;

   872     TInt listenerCount = 0;

   873     TInt dataLth = 0;

   874     // Some events don't not have data

   875     if (aData)

   876         {

   877         dataLth = aData->Length();

   878         }

   879     TPckg<TInt> lengthpckg(dataLth);

   880     TPckgC<const TAny*> ptrpckg(aData);

   881 

   882     while (FindListenerMsg(aType, aSpec, index))

   883         {

   884         RMessage2& listener = iListenedEvents.At(index)->Message();

   885 

   886         if (aStatus == KErrNone)

   887             {

   888             // Write info about data

   889             listener.WriteL(SECOND_ARGUMENT, lengthpckg);

   890             listener.WriteL(THIRD_ARGUMENT, ptrpckg);

   891 

   892             // Complete listener

   893             listener.Complete(KErrNone);

   894             }

   895         else

   896             {

   897             listener.Complete(aStatus);

   898             }

   899         

   900         delete iListenedEvents.At(index);

   901         iListenedEvents.Delete(index);

   902         listenerCount++;    

   903         }

   904 

   905     return listenerCount;

   906     }

   907 

   908 TBool CEventMediatorSession::FindListenerMsg(const TEventType aType, TInt& index)

   909     {

   910     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   911         {

   912         if (iListenedEvents.At(i)->Type() == aType)

   913             {

   914             index=i;

   915             return ETrue;

   916             }

   917         }

   918     return EFalse;

   919     }

   920 

   921 TBool CEventMediatorSession::FindListenerMsg(const TEventType aType, const TDesC8* aSpec, TInt& index)

   922     {

   923     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   924         {

   925         if (iListenedEvents.At(i)->HandlesEvent(aType, aSpec))

   926             {

   927             index = i;

   928             return ETrue;

   929             }

   930         }

   931     return EFalse;

   932     }

   933 

   934 TBool CEventMediatorSession::FindTaskRequestListenerMsg(TInt& index)

   935     {

   936     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   937         {

   938         if (CSit::EventRequiresSit(iListenedEvents.At(i)->Type()))

   939             {

   940             index = i;

   941             return ETrue;

   942             }

   943         }

   944     return EFalse;

   945     }

   946     

   947 HBufC8* CEventMediatorSession::ReadSpecificationFromClientL(const RMessage2& aMessage)

   948     {

   949     HBufC8* specBuf;

   950     // Read specification descriptor length from client, create specification buffer

   951     const TAny* desPtr = aMessage.Ptr3();

   952     if (desPtr == NULL)

   953         {

   954         return NULL;

   955         }

   956     TInt specLength = aMessage.GetDesLength(FOURTH_ARGUMENT);

   957     // Create spcification buffer

   958     specBuf = HBufC8::NewLC(specLength);

   959     TPtr8 ptr = specBuf->Des();

   960     // Read specification

   961     aMessage.ReadL(FOURTH_ARGUMENT, ptr);

   962     CleanupStack::Pop(); // specBuf

   963     return specBuf;

   964     }

   965 

   966 HBufC8* CEventMediatorSession::ReadEventDataFromClientL(const RMessage2& aMessage)

   967     {

   968     HBufC8* dataBuf = NULL;

   969     TInt desLength = aMessage.Int1();

   970     

   971     if (desLength != 0) // Some events have no data 

   972         {

   973         dataBuf = HBufC8::NewLC(desLength);

   974         TPtr8 ptr = dataBuf->Des();

   975         aMessage.ReadL(THIRD_ARGUMENT, ptr);

   976         CleanupStack::Pop(); // dataBuf

   977         }

   978     return dataBuf;

   979     }

   980 

   981 CListenerContainer* CEventMediatorSession::FindWaitingTaskRequest()

   982     {

   983     CListenerContainer* listener = NULL;

   984     

   985     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   986         {

   987         if (iListenedEvents.At(i)->WaitingForFulfilling())

   988             {

   989             listener = iListenedEvents.At(i);

   990             break;

   991             }

   992         }

   993 

   994     return listener;

   995     }

   996 

   997 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType,

   998                                                         TInt aEventSpecId)

   999     {

  1000     CListenerContainer* listener = NULL;

  1001     

  1002     for (TInt i = 0; i < iListenedEvents.Count(); i++)

  1003         {

  1004         if (iListenedEvents.At(i)->Type() == aEventType)

  1005             {

  1006             TEventSpec* eventSpec = (TEventSpec*)(iListenedEvents.At(i)->Specification()->Ptr());

  1007 

  1008             if (eventSpec->iId == aEventSpecId)

  1009                 {

  1010                 listener = iListenedEvents.At(i);

  1011                 break;

  1012                 }

  1013             }

  1014         }

  1015 

  1016     return listener;

  1017     }

  1018     

  1019 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType,

  1020                                                         const TDesC8* aEventSpec)

  1021     {

  1022     CListenerContainer* listener = NULL;

  1023     

  1024     for (TInt i = 0; i < iListenedEvents.Count(); i++)

  1025         {

  1026         if (iListenedEvents.At(i)->HandlesEvent(aEventType, aEventSpec))

  1027             {

  1028             listener = iListenedEvents.At(i);

  1029             break;

  1030             }

  1031         }

  1032 

  1033     return listener;

  1034     }

  1035 

  1036 void CEventMediatorSession::CompleteListener(TEventType aEventType,

  1037                                              const TDesC8* aEventSpec,

  1038                                              TInt aStatus)

  1039     {

  1040     TInt index;

  1041     while (FindListenerMsg(aEventType, aEventSpec, index))

  1042         {

  1043         CompleteListener(index, aStatus);

  1044         }

  1045     }

  1046         

  1047 void CEventMediatorSession::CompleteListener(TInt aIndex, TInt aStatus)

  1048     {

  1049     iListenedEvents.At(aIndex)->Complete(aStatus);

  1050     delete iListenedEvents.At(aIndex);

  1051     iListenedEvents.Delete(aIndex);

  1052     }

  1053 

  1054 void CEventMediatorSession::CompleteTaskRequests(TInt aStatus)

  1055     {

  1056     LOG(Log::Printf(_L("CEventMediatorSession::CompleteTaskRequests\n")));

  1057     TInt index;

  1058     while (FindTaskRequestListenerMsg(index))

  1059         {

  1060         CompleteListener(index, aStatus);

  1061         }

  1062     }

  1063 

  1064 TBool CEventMediatorSession::IsASitSession()

  1065     {

  1066     return iIsSitSession;

  1067     }

  1068 

  1069 void CEventMediatorSession::NewEventSpecIdL(const RMessage2& aMessage)

  1070     {

  1071     TInt newEventSpecId = iServer->NewEventSpecId();

  1072     TPckg<TInt> newEventSpecIdDes(newEventSpecId);

  1073     aMessage.WriteL(FIRST_ARGUMENT, newEventSpecIdDes);

  1074     }

  1075 

  1076 TInt CEventMediatorSession::DeletePrivateFiles()

  1077     {

  1078     TRAPD(err, DeletePrivateFilesL());

  1079     if ( err )

  1080         {

  1081         LOG(Log::Printf(_L("DeletePrivateFilesL() leave error %d\n"), err));

  1082         return err;

  1083         }

  1084 

  1085     return KErrNone;

  1086     }

  1087 

  1088 void CEventMediatorSession::DeletePrivateFilesL()

  1089     {

  1090     LOG(Log::Printf(_L("DeletePrivateFilesL() called\n")));

  1091 

  1092     CFileMan* fileMan = CFileMan::NewL(iFs);

  1093     CleanupStack::PushL(fileMan);

  1094 

  1095     TPath privateDir;

  1096     User::LeaveIfError(iFs.PrivatePath(privateDir));

  1097 

  1098     TInt err = fileMan->RmDir(privateDir);

  1099     if (err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)

  1100         {

  1101         User::Leave(err);

  1102         }

  1103     CleanupStack::PopAndDestroy(); //fileMan

  1104     }

  1105 

  1106 TInt CEventMediatorSession::GetEventLogSize(

  1107     const RMessage2& aMessage)

  1108     {

  1109     if ( iEventLogFileOpen )

  1110         {

  1111         iEventLogFile.Close();

  1112         iEventLogFileOpen = EFalse;

  1113         }

  1114 

  1115     TInt err = iEventLogFile.Open(iFs, iServer->EventLogFileName(), EFileRead | EFileShareAny);

  1116     if ( err )

  1117         return err;

  1118 

  1119     TInt size(0);

  1120     err = iEventLogFile.Size(size);

  1121     if ( err )

  1122         {

  1123         iEventLogFile.Close();

  1124         return err;

  1125         }

  1126     

  1127     TPckg<TInt> sizePckg(size);

  1128     err = aMessage.Write(FIRST_ARGUMENT, sizePckg);

  1129     if ( err )

  1130         {

  1131         iEventLogFile.Close();

  1132         return err;

  1133         }

  1134