/*

* Copyright (c) 2003 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: Combined task arrival observer and task handler manager.

*

*/

#include "taskarrivalobserver.h"

#include "taskhandlercreator.h"

#include "log.h"

CTaskArrivalObserver* CTaskArrivalObserver::NewL()

    {

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

    CTaskArrivalObserver* self = new (ELeave) CTaskArrivalObserver();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

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

    return self;

    }

CTaskArrivalObserver::CTaskArrivalObserver()

    {

    }

void CTaskArrivalObserver::ConstructL()

    {

    User::LeaveIfError(iEventMediator.Connect());

    iTaskHandlerList = new (ELeave) CArrayPtrFlat<CTaskHandler>(2);

    iAsyncCleanerList = new (ELeave) CArrayPtrFlat<CAsyncCleaner>(2);

    }

CTaskArrivalObserver::~CTaskArrivalObserver()

    {

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

    Cancel();

    iEventMediator.Close();

    if (iTaskHandlerList)

        {    

        iTaskHandlerList->ResetAndDestroy();

        delete iTaskHandlerList;

        }

    if (iAsyncCleanerList)

        {

        iAsyncCleanerList->ResetAndDestroy();

        delete iAsyncCleanerList;

        }

    }

void CTaskArrivalObserver::Start()

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::Start\n")));

    iEventMediator.ListenToEvent(ETaskArrivedEvent, *this);

    }

void CTaskArrivalObserver::Cancel()

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::Cancel\n")));

    iEventMediator.CancelListening(ETaskArrivedEvent);

    }

void CTaskArrivalObserver::EventOccured(TInt aStatus, TEventType /*aType*/, TDesC8* aData)

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::EventOccured\n")));

    if (aStatus == KErrNone && aData)

        {

        LOG(Log::Printf(_L("CTaskArrivalObserver::EventOccured - launching a new task handler\n")));

        // The event specification of the task request is delivered

        // to us as the event data of the task arrivat event

        TTaskArrivedEventData eventSpec;

        TPckg<TTaskArrivedEventData> eventSpecDes(eventSpec);

        eventSpecDes.Copy(*aData);

        TRAPD(ret, LaunchTaskHandlerL(eventSpec));

        // Not being able to create a task handler means that

        // the client that has issued the corresponding task

        // request would never be served. This is a fatal error

        // and not acceptable. Thus, we we need to terminate the

        // SIT thread in order to notify the Event Mediator and

        // its clients about problems.

        if (ret != KErrNone)

            {

            CActiveScheduler::Stop();

            return;

            }

        // Continue observing the

        // arrival of new tasks

        Start();

        }

    else

        {

        LOG(Log::Printf(_L("CTaskArrivalObserver::EventOccured - stopping the scheduler and thus the SIT\n")));

        // We cannot receive new tasks anymore

        // so the SIT can be terminated

        CActiveScheduler::Stop();

        }

    }

void CTaskArrivalObserver::LaunchTaskHandlerL(const TTaskArrivedEventData& aEventSpec)

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::LaunchTaskHandlerL\n")));

    // A new task has arrived so create a task handler for it

    CTaskHandler* taskHandler = TaskHandlerCreator::CreateTaskHandlerL(this, aEventSpec);

    if (!taskHandler)

        {

        User::Panic(KSitName, EPanicUnknownEventType);

        }

    // Add the handler to the list of active handlers

    iTaskHandlerList->AppendL(taskHandler);

    //Create the asyncleaner for cleaning the task handler, when the

    //task is done.

    CAsyncCleaner* asyncCleaner = new (ELeave) CAsyncCleaner(this, taskHandler);    

    iAsyncCleanerList->AppendL(asyncCleaner);

    // And start performing the task

    taskHandler->Start();

    }

void CTaskArrivalObserver::TaskHandlerComplete(CTaskHandler* aTaskHandler)

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::TaskHandlerComplete\n")));

    // In the case several task handlers delete themselves at about the

    // same time, we need to have a separate cleaner instance for each.

    // Otherwise we'll get panic E32USER-CBase 42 (SetActive called

    // while active object is already active).

    //Find the async cleaner for the task handler:

    TInt i = 0;

    for (i = 0; i < iAsyncCleanerList->Count(); ++i)

        {

        if (iAsyncCleanerList->At(i)->IsMatchingCleaner(*aTaskHandler))

            {

            iAsyncCleanerList->At(i)->Start();

            }

        }

    __ASSERT_DEBUG(i <= iAsyncCleanerList->Count(), User::Invariant());

    }

void CTaskArrivalObserver::DeleteTaskHandler(CTaskHandler* aTaskHandler)

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler\n")));

    __ASSERT_DEBUG(aTaskHandler != NULL, User::Invariant());

    // The specified task handler has done its

    // job succesfully so it can be deleted

    TInt taskHandlerIndex = KErrNotFound;

    for (TInt i = 0; i < iTaskHandlerList->Count(); i++)

        {

        if (iTaskHandlerList->At(i) == aTaskHandler)

            {

            taskHandlerIndex = i;

            break;

            };

        }

    __ASSERT_DEBUG(taskHandlerIndex >= 0, User::Invariant());

    LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler - deleting task handler\n")));

    // Delete the task handler

    delete aTaskHandler;

    iTaskHandlerList->Delete(taskHandlerIndex);

    iTaskHandlerList->Compress();

    }

void CTaskArrivalObserver::DeleteAsyncCleaner(CAsyncCleaner* aAsyncCleaner)

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteAsyncCleaner\n")));

    __ASSERT_DEBUG(aAsyncCleaner != NULL, User::Invariant());

    // The specified asynchronous cleaner

    // has done its job and be deleted

    TInt asyncCleanerIndex = KErrNotFound;

    for (TInt i = 0; i < iAsyncCleanerList->Count(); i++)

        {

        if (iAsyncCleanerList->At(i) == aAsyncCleaner)

            {

            asyncCleanerIndex = i;

            break;

            };

        }

    __ASSERT_DEBUG(asyncCleanerIndex >= 0, User::Invariant());

    // Delete the cleaner object

    delete aAsyncCleaner;

    iAsyncCleanerList->Delete(asyncCleanerIndex);

    iAsyncCleanerList->Compress();

    }

void CTaskArrivalObserver::TaskHandlerFatalError(CTaskHandler* /*aTaskHandler*/, TInt /*aError*/)

    {

    LOG(Log::Printf(_L("CTaskArrivalObserver::TaskHandlerFatalError - stopping the scheduler and thus the SIT\n")));

    // The specified task handler has encountered a fatal error

    // indicating that it cannot fulfill the task request it was

    // created to fulfill, meaning that the client that has issued

    // the corresponding task request would never be served. This

    // is a fatal error and not acceptable. Thus, we we need to

    // terminate the SIT thread in order to notify the Event Mediator

    // and its clients about problems.

    CActiveScheduler::Stop();

    }

// CAsyncCleaner

CAsyncCleaner::CAsyncCleaner(CTaskArrivalObserver* aTaskArrivalObserver,

                             CTaskHandler* aTaskHandlerToDelete)

    : CAsyncOneShot(EPriorityNormal), iTaskArrivalObserver(aTaskArrivalObserver),

      iTaskHandlerToDelete(aTaskHandlerToDelete)

    {

    }

void CAsyncCleaner::Start()

    {

    Call();

    }

void CAsyncCleaner::RunL()

    {

    // Delete the task handler

    iTaskArrivalObserver->DeleteTaskHandler(iTaskHandlerToDelete);

    // Delete this cleaner object instance as well

    iTaskArrivalObserver->DeleteAsyncCleaner(this);

    }

TBool CAsyncCleaner::IsMatchingCleaner(const CTaskHandler& aTaskHandler) const

    {

    return iTaskHandlerToDelete == &aTaskHandler;

    }