1 /*

     2 * Copyright (c) 2010 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: 

    15 *

    16 */

    17 #include <e32std.h>

    18 #include <e32svr.h>

    19 

    20 #include <stfeventsystemdefs.h>

    21 #include "stfeventsystem.h"

    22 #include <stfasynceventactive.h>

    23 

    24 // Implementation of session class

    25 

    26 /**

    27 Connects to event server.

    28 */

    29 EXPORT_C TInt REventSystem::Connect()

    30     {

    31     //RDebug::Print(_L("STF [ESC]: REventSystem::Connect start"));

    32     TInt err;

    33     

    34     // Check if server is not running

    35     err = CreateSession(KEventSystemServName, Version());

    36     //RDebug::Print(_L("STF [ESC]: REventSystem::Connect session creation [%d]"), err);

    37     

    38     if(err == KErrNotFound) //Server is not yet started

    39         {

    40         RProcess p;

    41         err = p.Create(KEventSystemServNameExe, KEventSystemServNameExe);

    42         RDebug::Print(_L("STF [ESC]: REventSystem::Connect process creation [%d]"), err);

    43         if(err == KErrNone)

    44             {

    45             p.Resume();

    46             

    47             TRequestStatus eventServerStartup;

    48             p.Rendezvous(eventServerStartup);

    49             User::WaitForRequest(eventServerStartup);

    50             RDebug::Print(_L("STF [ESC]: REventSystem::Connect randezvous with server [%d]"), eventServerStartup.Int());

    51             p.Close();

    52 

    53             err = CreateSession(KEventSystemServName, Version());

    54             //RDebug::Print(_L("STF [ESC]: REventSystem::Connect session creation [%d]"), err);

    55             }

    56         }

    57     else if(err != KErrNone)

    58         {

    59         return err;

    60         }

    61     //RDebug::Print(_L("STF [ESC]: REventSystem::Connect end"));

    62     return err; 

    63     }

    64 

    65 /**

    66 Closes connection.

    67 */

    68 EXPORT_C void REventSystem::Close()

    69     {

    70     //RDebug::Print(_L("STF [ESC]: REventSystem::Close()"));

    71     if(Handle())

    72         {

    73         SendReceive(EEventSystemServCloseSession);

    74         RHandleBase::Close();

    75         }

    76     //RDebug::Print(_L("STF [ESC]: REventSystem::Close end"));

    77     }

    78 

    79 /**

    80 Returns version of event system.

    81 */

    82 EXPORT_C TVersion REventSystem::Version(void) const

    83     {

    84     return TVersion(KEventSystemServMajorVersionNumber, KEventSystemServMinorVersionNumber, KEventSystemServBuildVersionNumber);

    85     }

    86 

    87 /**

    88 Set indication event.

    89 */

    90 EXPORT_C void REventSystem::SetIndicationEventL(const TDesC& aEventName)

    91     {

    92     SetIndicationEventL(aEventName, NULL);

    93     }

    94 

    95 /**

    96 Set indication event.

    97 */

    98 EXPORT_C void REventSystem::SetIndicationEventL(const TDesC& aEventName, TRequestStatus *aStatus)

    99     {

   100     RDebug::Print(_L("STF [ESC]: REventSystem::SetIndicationEventL"));

   101     if(aStatus)

   102         *aStatus = KRequestPending;

   103 

   104     User::LeaveIfError(Connect());

   105     TIpcArgs args(&aEventName);

   106     TInt ret = SendReceive(EEventSystemSetIndicationEvent, args);

   107     RDebug::Print(_L("STF [ESC]: REventSystem::SetIndicationEventL completed with [%d]"), ret);

   108     Close();

   109     

   110     if(aStatus)

   111         User::RequestComplete(aStatus, ret);

   112 

   113     User::LeaveIfError(ret);

   114     }

   115 

   116 /**

   117 Wait for event

   118 */

   119 EXPORT_C void REventSystem::WaitEventL(const TDesC& aEventName, const TInt aOwner)

   120     {    

   121     RDebug::Print(_L("STF [ESC]: REventSystem::WaitEventL eventname=[%S]"), &aEventName);

   122     User::LeaveIfError(Connect());

   123     TIpcArgs args(&aEventName, aOwner);

   124     TInt ret = SendReceive(EEventSystemWaitEvent, args);

   125     RDebug::Print(_L("STF [ESC]: REventSystem::WaitEventL completed with [%d]"), ret);

   126     Close();

   127     User::LeaveIfError(ret);

   128     }

   129 

   130 /**

   131 Set state event.

   132 */

   133 EXPORT_C void REventSystem::SetEventL(const TDesC& aEventName)

   134     {

   135     SetEventL(aEventName, NULL);

   136     }

   137 

   138 /**

   139 Request event

   140 */

   141 EXPORT_C void REventSystem::RequestEventL(const TDesC& aEventName, const TInt aOwner)

   142     {    

   143     RDebug::Print(_L("STF [ESC]: REventSystem::RequestEventL eventname=[%S]"), &aEventName);

   144     User::LeaveIfError(Connect());

   145     TIpcArgs args(&aEventName, aOwner);

   146     TInt ret = SendReceive(EEventSystemRequestEvent, args);

   147     RDebug::Print(_L("STF [ESC]: REventSystem::RequestEventL completed with [%d]"), ret);

   148     Close();

   149     User::LeaveIfError(ret);

   150     }

   151 

   152 /**

   153 Release event

   154 */

   155 EXPORT_C void REventSystem::ReleaseEventL(const TDesC& aEventName, const TInt aOwner)

   156     {    

   157     RDebug::Print(_L("STF [ESC]: REventSystem::ReleaseEventL eventname=[%S]"), &aEventName);

   158     User::LeaveIfError(Connect());

   159     TIpcArgs args(&aEventName, aOwner);

   160     TInt ret = SendReceive(EEventSystemReleaseEvent, args);

   161     RDebug::Print(_L("STF [ESC]: REventSystem::ReleaseEventL completed with [%d]"), ret);

   162     Close();

   163     User::LeaveIfError(ret);

   164     }

   165 

   166 /**

   167 Set state event.

   168 */

   169 EXPORT_C void REventSystem::SetEventL(const TDesC& aEventName, TRequestStatus *aStatus)

   170     {

   171     RDebug::Print(_L("STF [ESC]: REventSystem::SetStateEventL eventname=[%S]"), &aEventName);

   172     

   173     if(aStatus)

   174         *aStatus = KRequestPending;

   175     

   176     User::LeaveIfError(Connect());

   177     TIpcArgs args(&aEventName);

   178     TInt ret = SendReceive(EEventSystemSetEvent, args);

   179     RDebug::Print(_L("STF [ESC]: REventSystem::SetStateEventL completed with [%d]"), ret);

   180     Close();

   181     

   182     if(aStatus)

   183         User::RequestComplete(aStatus, ret);

   184         

   185     User::LeaveIfError(ret);

   186     }

   187     

   188 /**

   189 Unset state event.

   190 */

   191 EXPORT_C void REventSystem::UnsetEventL(const TDesC& aEventName)

   192     {

   193     UnsetEventL(aEventName, NULL);

   194     }

   195     

   196 /**

   197 Unset state event.

   198 */

   199 EXPORT_C void REventSystem::UnsetEventL(const TDesC& aEventName, TRequestStatus* aStatus)

   200     {

   201     RDebug::Print(_L("STF [ESC]: REventSystem::UnsetStateEventL eventname=[%S]"), &aEventName);

   202     

   203     if(aStatus)

   204         *aStatus = KRequestPending;

   205             

   206     User::LeaveIfError(Connect());

   207     TIpcArgs args(&aEventName);

   208     TInt ret = SendReceive(EEventSystemUnsetEvent, args);

   209     RDebug::Print(_L("STF [ESC]: REventSystem::UnsetStateEventL completed with [%d]"), ret);

   210     Close();

   211     

   212     if(aStatus)

   213         User::RequestComplete(aStatus, ret);

   214     

   215     User::LeaveIfError(ret);

   216     }

   217 

   218 /**

   219 Cancel (remove) all requested events of given owner.

   220 */

   221 EXPORT_C TInt REventSystem::RemoveInRequestedState(const TInt aOwner)

   222     {

   223     RDebug::Print(_L("STF [ESC]: REventSystem::RemoveInRequestedState"));

   224 

   225     User::LeaveIfError(Connect());

   226     TIpcArgs args(aOwner);

   227     TInt ret = SendReceive(EEventSystemRemoveInRequestedState, args);

   228     RDebug::Print(_L("STF [ESC]: REventSystem::RemoveInRequestedState completed with [%d]"), ret);

   229     Close();

   230     

   231     return ret;    

   232     }

   233     

   234 // EOF