/*

* 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;

    }