/*
* 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: Base class for all task handlers.
*
*/



#include "taskhandler.h"
#include "log.h"

CTaskHandler::CTaskHandler(MTaskHandlerManager* aManager, const TTaskArrivedEventData& aTaskInfo,
                           TEventType aCancelEventType, TDes8* aEventSpecPtr)
    : CActive(EPriorityNormal), iManager(aManager), iTaskInfo(aTaskInfo),
      iCancelEventType(aCancelEventType), iEventSpecPtr(aEventSpecPtr)
    {
    LOG(Log::Printf(_L("CTaskHandler::CTaskHandler - iCancelEventType = %d\n"), iCancelEventType));
    }

void CTaskHandler::Start()
    {
    LOG(Log::Printf(_L("CTaskHandler::Start\n")));
    // First fetch the event specification of the
    // task request that we are supposed to fulfill
    TPckg<TTaskArrivedEventData> taskInfoDes(iTaskInfo);
    iEventMediator.ListenToEvent(EFetchTaskInfoEvent, taskInfoDes, *this);
    // Operation continues from CTaskHandler::EventOccured
    // that calls StartTaskHandlingL if all goes well
    }

void CTaskHandler::RunL()
    {
    ChangeStateL();
    }

void CTaskHandler::GotoState(TInt aState)
    {
    SetNextState(aState);
    SetActive();
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status, KErrNone);
    }
    
void CTaskHandler::SetCurrState(TInt aState)
    {
    iCurrState = aState;
    }

void CTaskHandler::SetNextState(TInt aState)
    {
    iNextState = aState;
    }

TInt CTaskHandler::CurrState()
    {
    return iCurrState;
    }

TInt CTaskHandler::NextState()
    {
    return iNextState;
    }

void CTaskHandler::DoCancel()
    {
    LOG(Log::Printf(_L("CTaskHandler::DoCancel\n")));
    // Cancel listening to the task cancellation
    iEventMediator.CancelListening(iCancelEventType, *iEventSpecPtr);

    CancelOngoingOperation();
            
    TaskDone();
    }

TInt CTaskHandler::RunError(TInt aError)
    {
    LOG(Log::Printf(_L("CTaskHandler::RunError - error = %d\n"), aError));
    TaskComplete(aError);
    return KErrNone;
    }

void CTaskHandler::EventOccured(TInt aStatus, TEventType aType, TDesC8* aData)
    {
    LOG(Log::Printf(_L("CTaskHandler::EventOccured\n")));
    if (aType == EFetchTaskInfoEvent)
        {
        OnFetchTaskInfoEvent(aStatus, aData);
        }
    else if (aType == iCancelEventType)
        {
        OnTaskRequestCancelledEvent(aStatus);
        }
    else
        {
        User::Panic(KSitName, EPanicUnexpectedEventOccured);
        }
    }

void CTaskHandler::OnFetchTaskInfoEvent(TInt aStatus, TDesC8* aData)
    {
    LOG(Log::Printf(_L("CTaskHandler::OnFetchTaskInfoEvent\n")));
    if (aStatus == KErrNone && aData)
        {
        // Copy the task request event specification
        // so that the actual task handler can start using it
        iEventSpecPtr->Copy(*aData);
        
        // Listen to the cancellation of this task
        iEventMediator.ListenToEvent(iCancelEventType, *iEventSpecPtr, *this);
        
        StartTaskHandling();
        }
    else if (aStatus == KErrNotFound)
        {
        // The task request was cancelled before 
        // we had the change to get its data
        TaskDone();
        }
    else
        {
        FatalError(aStatus);
        }
    }

void CTaskHandler::OnTaskRequestCancelledEvent(TInt aStatus)
    {
    LOG(Log::Printf(_L("CTaskHandler::OnTaskRequestCancelledEvent\n")));
    if (aStatus == KErrNone)
        {
        // Event Mediator tells that the task request
        // has been cancelled so we stop performing the task
        Cancel();
        }
    else if (aStatus != KErrCancel)
        {
        FatalError(aStatus);
        }
    }

void CTaskHandler::TaskComplete(TInt aError)
    {
    LOG(Log::Printf(_L("CTaskHandler::TaskComplete - aError = %d\n"), aError));
    // Cancel listening to the task cancellation
    iEventMediator.CancelListening(iCancelEventType, *iEventSpecPtr);

    ReportResult(aError);
    }
    
void CTaskHandler::ReportEvent(TEventType aEventType, TDesC8& aEventSpec, TDesC8& aEventData)
    {
    LOG(Log::Printf(_L("CTaskHandler::ReportEvent - aEventType = %d\n"), aEventType));
    TInt ret = iEventMediator.ReportEvent(aEventType, aEventSpec, aEventData);

    if (ret != KErrNone)
        {
        FatalError(ret);
        }
    else
        {
        TaskDone();
        }
    }

void CTaskHandler::TaskDone()
    {
    LOG(Log::Printf(_L("CTaskHandler::TaskDone\n")));
    if (!iDelayedTaskEnd)
        {
        LOG(Log::Printf(_L("CTaskHandler::TaskDone - calling iManager->TaskHandlerComplete\n")));
        iManager->TaskHandlerComplete(this);
        }
    }

void CTaskHandler::FatalError(TInt aError)
    {
    LOG(Log::Printf(_L("CTaskHandler::FatalError - error = %d\n"), aError));
    iManager->TaskHandlerFatalError(this, aError);
    }

void CTaskHandler::SetDelayedTaskEnd(TBool aDelayedTaskEnd)
    {
    iDelayedTaskEnd = aDelayedTaskEnd;
    }