/*
* 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()
    : CAsyncOneShot(EPriorityNormal)
    {
    }

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 = CreateTaskHandlerL(aEventSpec);

    // Add the handler to the list of active handlers
    iTaskHandlerList->AppendL(taskHandler);

    // And start performing the task
    taskHandler->Start();
    }

CTaskHandler* CTaskArrivalObserver::CreateTaskHandlerL(const TTaskArrivedEventData& aEventSpec)
    {
    LOG(Log::Printf(_L("CTaskArrivalObserver::CreateTaskHandlerL\n")));
    CTaskHandler* taskHandler = NULL;

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

    if (!taskHandler)
        {
        User::Panic(KSitName, EPanicUnknownEventType);
        }

    return taskHandler;
    }

TInt CTaskArrivalObserver::FindTaskHandler(CTaskHandler* aTaskHandler)
    {
    TInt foundIndex = KUnfoundIndex;
    
    for (TInt i = 0; i < iTaskHandlerList->Count(); i++)
        {
        if (iTaskHandlerList->At(i) == aTaskHandler)
            {
            foundIndex = i;
            break;
            };
        }

    return foundIndex;
    }
    
TInt CTaskArrivalObserver::FindAsyncCleaner(CAsyncCleaner* aAsyncCleaner)
    {
    TInt foundIndex = KUnfoundIndex;
    
    for (TInt i = 0; i < iAsyncCleanerList->Count(); i++)
        {
        if (iAsyncCleanerList->At(i) == aAsyncCleaner)
            {
            foundIndex = i;
            break;
            };
        }

    return foundIndex;
    }

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).
    
    // NOTE. Each asyncCleaner instance will cause itself to be deleted
    CAsyncCleaner* asyncCleaner = new CAsyncCleaner(this, aTaskHandler);
    if (asyncCleaner)
        {
        // Add the handler to a list of cleaners. This list
        // is needed to handle some rare cases where the SIT
        // thread dies before one or more async cleaners get
        // the chance to delete themselves. Such cleaner
        // instances get destroyed by the CTaskArrivalObserver
        // destructor.
        TRAP_IGNORE(iAsyncCleanerList->AppendL(asyncCleaner));
        // Initiate the task handler delete operation
        asyncCleaner->Start();
        }
    else
        {
        // Backup - just in case asyncCleaner could not be created
        AsyncDeleteTaskHandler(aTaskHandler);
        }
    }

void CTaskArrivalObserver::AsyncDeleteTaskHandler(CTaskHandler* aTaskHandler)
    {
    LOG(Log::Printf(_L("CTaskArrivalObserver::AsyncDeleteTaskHandler\n")));
    iTaskHandlerToDelete = aTaskHandler;
    Call();
    }

void CTaskArrivalObserver::RunL() // Called as a result of AsyncDeleteTaskHandler
    {
    LOG(Log::Printf(_L("CTaskArrivalObserver::RunL\n")));

    DeleteTaskHandler(iTaskHandlerToDelete);

    iTaskHandlerToDelete = NULL;    
    }

void CTaskArrivalObserver::DeleteTaskHandler(CTaskHandler* aTaskHandler)
    {
    LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler\n")));
    
    // The specified task handler has done its
    // job succesfully so it can be deleted
    TInt taskHandlerIndex = FindTaskHandler(aTaskHandler);
    
    if (taskHandlerIndex != KUnfoundIndex)
        {
        LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler - deleting task handler\n")));
        // Delete the task handler
        delete iTaskHandlerList->At(taskHandlerIndex);
        // Delete the list item
        iTaskHandlerList->Delete(taskHandlerIndex);
        // Deleting elements from the array does not cause
        // the array buffer to be automatically compressed.
        // Compress it to return excess space to the heap
        // as task handlers come and go.
        iTaskHandlerList->Compress();
        }
    else
        {
        // 
        delete aTaskHandler;
        }
    }
    
void CTaskArrivalObserver::DeleteAsyncCleaner(CAsyncCleaner* aAsyncCleaner)
    {
    LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteAsyncCleaner\n")));
    
    // The specified asynchronous cleaner
    // has done its job and be deleted
    TInt asyncCleanerIndex = FindAsyncCleaner(aAsyncCleaner);
    
    if (asyncCleanerIndex != KUnfoundIndex)
        {
        LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteAsyncCleaner - deleting async cleaner\n")));
        // Delete the cleaner object
        delete iAsyncCleanerList->At(asyncCleanerIndex);
        // Delete the list item
        iAsyncCleanerList->Delete(asyncCleanerIndex);
        // Deleting elements from the array does not cause
        // the array buffer to be automatically compressed.
        // Compress it to return excess space to the heap
        // as cleaner objects come and go.
        iAsyncCleanerList->Compress();
        }
    else
        {
        // Always delete the cleaner instance even
        // though it have not been added to the list
        delete aAsyncCleaner;
        }
    }

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);
    }