diff -r bbd31066657e -r 8bb370ba6d1d testexecfw/stf/stffw/eventsystem/client/src/stfasynceventactive.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testexecfw/stf/stffw/eventsystem/client/src/stfasynceventactive.cpp	Fri Apr 09 10:46:28 2010 +0800
@@ -0,0 +1,193 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+#include <e32std.h>
+#include <e32svr.h>
+
+#include <stfeventsystemerrorcodes.h>
+#include "stfasynceventactive.h"
+#include <stfasynceventlist.h>
+
+
+// Implementation of asynchronous event Active Object
+
+/**
+* NewL is first phase of two-phased constructor.
+*/
+EXPORT_C CAsyncEventActive* CAsyncEventActive::NewL(const TInt aOwnerId)
+    {
+    //RDebug::Print(_L("STF [ESC]: CAsyncEventActive::NewL()"));
+    CAsyncEventActive* self = new (ELeave) CAsyncEventActive(aOwnerId);
+    CleanupStack::PushL(self);
+
+    // Construct the object
+    self->ConstructL();
+
+    // Remove from cleanup stack
+    CleanupStack::Pop(self);
+
+    return self;
+    }
+
+/** 
+* C++ default constructor.
+*/
+CAsyncEventActive::CAsyncEventActive(const TInt aOwnerId): CActive(CActive::EPriorityStandard), iOwnerId(aOwnerId)
+    {
+    CActiveScheduler::Add(this);
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::CAsyncEventActive() creating active object [%x]"), this);
+    }
+
+/**
+* By default Symbian OS constructor is private.
+*/
+void CAsyncEventActive::ConstructL()
+    {
+    //RDebug::Print(_L("STF [ESC]: CAsyncEventActive::ConstructL()"));
+    }
+
+/**
+* Destructor.
+*/
+CAsyncEventActive::~CAsyncEventActive()
+    {
+    Cancel();
+    iEventSystem.Close();
+    delete iEventName;
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::~CAsyncEventActive() deleting active object [%x]"), this);
+    }
+
+/** 
+* Start active object.
+* If list is provided, active object will cooperate with it adding and deleting itself from the list.
+* Also active object will delete itself if it's on the list.
+*/
+EXPORT_C void CAsyncEventActive::StartL(TRequestStatus* aStatus, TThreadId aStatusThreadId, const TDesC& aEventName, CAsyncEventList* aAsyncEventList)
+    {
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::StartL() eventName=[%S]"), &aEventName);
+    // Check if list of asynchronous objects and event name are not set.
+    // It would mean that method StartL was already called.
+    __ASSERT_ALWAYS(iAsyncEventList == NULL, User::Panic(_L("CAsyncEventActive1"), EEventSystemListAlreadySet));
+    __ASSERT_ALWAYS(iEventName == NULL, User::Panic(_L("CAsyncEventActive2"), EEventSystemListAlreadySet));
+    
+    // Set caller's status and other data
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::StartL() registering status [%x]"), aStatus);
+    iCallerStatus = aStatus;
+    *iCallerStatus = KRequestPending;
+    iStatusThreadId = aStatusThreadId;
+    iAsyncEventList = aAsyncEventList;
+    iEventName = aEventName.AllocL();
+     
+    // Open connection to server
+    User::LeaveIfError(iEventSystem.Connect());
+    
+    // Add object to list
+    if(iAsyncEventList)
+        {
+        iAsyncEventList->AddAsyncEventL(this);
+        }
+    
+    // Call wait event
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::StartL() SendReceive eventName=[%S]"), iEventName);
+    TIpcArgs args(iEventName, iOwnerId);
+    iEventSystem.SendReceive(EEventSystemWaitEvent, args, iStatus);
+    
+    // Activate object    
+    SetActive();
+    }
+
+/**
+* Handles active object and deletes itself!
+*/
+void CAsyncEventActive::RunL()
+    {
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::RunL()"));
+    // Complete request from caller
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::RunL() completing status [%x] with [%d]"), iCallerStatus, iStatus.Int());
+    User::LeaveIfError(CompleteCallerStatus(iStatus.Int()));
+    
+    // Remove from list
+    if(iAsyncEventList)
+        {
+        iAsyncEventList->RemoveAsyncEventL(this);
+        iAsyncEventList = NULL;
+        }
+    
+    // Close connection to server, as it's not longer required
+    iEventSystem.Close();
+    }
+
+/** 
+* DoCancel
+*/
+void CAsyncEventActive::DoCancel()
+    {
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::DoCancel()"));
+
+    // Cancelling wait event on the event server
+    TIpcArgs args(iEventName, iOwnerId);
+    if(iEventSystem.Handle())
+        {
+        TInt ret = iEventSystem.SendReceive(EEventSystemCancelWaitEvent, args);
+        }
+
+    // Complete request from caller
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::DoCancel() completing (KErrCancel) status [%x]"), iCallerStatus);
+    CompleteCallerStatus(KErrCancel);
+
+    // Remove from list
+    if(iAsyncEventList)
+        {
+        iAsyncEventList->RemoveAsyncEventL(this);
+        iAsyncEventList = NULL;
+        }
+    }
+
+/** 
+* RunError
+*/
+TInt CAsyncEventActive::RunError(TInt aError)
+    {
+    RDebug::Print(_L("STF [ESC]: CAsyncEventActive::RunError() aError=[%d]"), aError);    
+    return aError;
+    }
+
+/**
+* Checks if request to event server is in pending state
+*/
+EXPORT_C TBool CAsyncEventActive::IsPending()
+    {
+    return (iCallerStatus != NULL);
+    }
+
+/**
+* Complete caller status with specified code
+*/
+TInt CAsyncEventActive::CompleteCallerStatus(TInt aCode)
+    {
+    RThread thread;
+    TInt ret = thread.Open(iStatusThreadId);
+    
+    if(ret == KErrNone)
+        {
+        thread.RequestComplete(iCallerStatus, aCode);
+        iCallerStatus = NULL;
+        thread.Close();
+        }
+        
+    return ret;
+    }
+