/*
* Copyright (c) 2002 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: 
*       Provides methods for a wait note wrapper.
*
*/


// INCLUDE FILES
#include <CPbkWaitNoteWrapperBase.h>
#include <eikprogi.h>
#include <AknWaitDialog.h>
#include <MPbkBackgroundProcess.h>
#include <PbkDebug.h>

#ifdef __WINS__
// Disable warning from CPbkWaitNoteWrapperBase constructor
#pragma warning( disable : 4355 )
#endif

namespace {

#ifdef _DEBUG
// LOCAL CONSTANTS
enum TPanicCode
    {
    EPanicPreCond_ExecuteL_MPbkBackgroundProcess = 1
    };

// ================= LOCAL FUNCTIONS =======================
void Panic(TPanicCode aReason)
    {
    _LIT(KPanicText,"CPbkWaitNoteWrapperBase");
    User::Panic(KPanicText,aReason);
    }
#endif // _DEBUG
}


// ================= MEMBER FUNCTIONS =======================

// CPbkWaitNoteWrapperBase::CIdleCallback
inline CPbkWaitNoteWrapperBase::CIdleCallback::CIdleCallback
        (CPbkWaitNoteWrapperBase& aWaitNoteWrapper) :
    CActive(EPriorityIdle),
    iWaitNoteWrapper(aWaitNoteWrapper)
    {
    CActiveScheduler::Add(this);
    }

CPbkWaitNoteWrapperBase::CIdleCallback::~CIdleCallback()
    {
    Cancel();
    }

void CPbkWaitNoteWrapperBase::CIdleCallback::IssueRequest()
    {
    TRequestStatus* sp = &iStatus;
    User::RequestComplete(sp, KErrNone);
    SetActive();
    }

void CPbkWaitNoteWrapperBase::CIdleCallback::DoCancel()
    {
    }

void CPbkWaitNoteWrapperBase::CIdleCallback::RunL()
    {
    iWaitNoteWrapper.IdleRunL();
    }

TInt CPbkWaitNoteWrapperBase::CIdleCallback::RunError(TInt aError)
    {
    return iWaitNoteWrapper.IdleRunError(aError);
    }


// CPbkWaitNoteWrapperBase::TNoteParams
EXPORT_C CPbkWaitNoteWrapperBase::TNoteParams::TNoteParams() :
    iVisibilityDelayOff(EFalse),
    iTone(CAknNoteDialog::ENoTone),
    iText(NULL),
    iObserver(NULL)
    {
	}

// CPbkWaitNoteWrapperBase
CPbkWaitNoteWrapperBase::CPbkWaitNoteWrapperBase() :
    iIdleCallback(*this), iNoteOpen(EFalse)
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::CPbkWaitNoteWrapperBase(0x%x)"),this);
    }

CPbkWaitNoteWrapperBase::~CPbkWaitNoteWrapperBase()
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::~CPbkWaitNoteWrapperBase(0x%x)"),this);

	// Wait dialog gets deleted automatically, but delete it by force
	// if it somehow still exists
	if (iWaitDialog)
		{
		delete iWaitDialog;
		iWaitDialog=NULL;
		}
    Cancel();
    }

EXPORT_C void CPbkWaitNoteWrapperBase::DisplayL
        (TInt aResId, 
        const TNoteParams& aNoteParams /*=TNoteParams()*/)
    {
    PBK_DEBUG_PRINT
        (PBK_DEBUG_STRING("CPbkWaitNoteWrapperBase::DisplayL(0x%x,%d)"),
        this, aResId);

    Cancel();
    iObserver = aNoteParams.iObserver;
    iWaitDialog = CreateDialogL
        (reinterpret_cast<CEikDialog**>(&iWaitDialog),
		aNoteParams.iVisibilityDelayOff);
    iWaitDialog->SetCallback(this);
    iWaitDialog->SetTone(aNoteParams.iTone);
    iWaitDialog->PrepareLC(aResId);
    if (aNoteParams.iText)
        {
        iWaitDialog->SetTextL(*aNoteParams.iText);
        }
	iNoteOpen = ETrue;
    iWaitDialog->RunLD();
    }

EXPORT_C void CPbkWaitNoteWrapperBase::Execute
        (MPbkBackgroundProcess& aProcess)
    {
    PBK_DEBUG_PRINT
        (PBK_DEBUG_STRING("CPbkWaitNoteWrapperBase::Execute(0x%x,0x%x)"),
        this, &aProcess);
    __ASSERT_DEBUG(iWaitDialog && !iBackgroundProcess,
        Panic(EPanicPreCond_ExecuteL_MPbkBackgroundProcess));

    iBackgroundProcess = &aProcess;
    // Request IdleRunL call
    iIdleCallback.IssueRequest();
    }

EXPORT_C void CPbkWaitNoteWrapperBase::ExecuteL
        (MPbkBackgroundProcess& aProcess,
        TInt aResId, 
        const TNoteParams& aNoteParams /*=TNoteParams()*/)
    {
    DisplayL(aResId,aNoteParams);
    Execute(aProcess);
    }

EXPORT_C TBool CPbkWaitNoteWrapperBase::IsNoteClosed() const
    {
    return (!iNoteOpen);
    }

EXPORT_C void CPbkWaitNoteWrapperBase::SetProgressDialogCallback
        (MProgressDialogCallback& aCallback)
    {
    iDialogCallbackObserver = &aCallback;
    }

void CPbkWaitNoteWrapperBase::Cancel()
    {
    iIdleCallback.Cancel();
    ProcessCanceled();
    }

void CPbkWaitNoteWrapperBase::IdleRunL()
    {
    if (!iBackgroundProcess)
        {
        return;
        }

    if (ShowProgressInfo() && !iProgressInfoControl)
        {
		if (iNoteOpen)
			{
			iProgressInfoControl = iWaitDialog->GetProgressInfoL();
			}
        }
    if (iProgressInfoControl)
        {
        const TInt numberOfSteps = iBackgroundProcess->TotalNumberOfSteps();
        if (numberOfSteps > 0 && 
            iProgressInfoControl->Info().iFinalValue != numberOfSteps)
            {
            iProgressInfoControl->SetFinalValue(numberOfSteps);
            }
        }

    if (iBackgroundProcess->IsProcessDone())
        {
        ProcessFinished();
        }
    else if (!iNoteOpen)
        {
        ProcessCanceled();
        }
    else
        {
        // Do one step of processing
        iBackgroundProcess->StepL();
        // Update progress info
        if (iProgressInfoControl)
            {
            iProgressInfoControl->IncrementAndDraw(1);
            }
        // Request next cycle
        iIdleCallback.IssueRequest();
        }
    }

TInt CPbkWaitNoteWrapperBase::IdleRunError
        (TInt aError)
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::IdleRunError(0x%x,%d)"),this,aError);

    TInt translatedError = aError;
    if (iBackgroundProcess)
        {
        translatedError = iBackgroundProcess->HandleStepError(aError);
        }

    if (translatedError == KErrNone)
        {
        // Continue processing
        iIdleCallback.IssueRequest();
        }
    else
        {
        if (iBackgroundProcess)
            {
            MPbkBackgroundProcess& process = *iBackgroundProcess;
            iBackgroundProcess = NULL;
            KillNote();
            NotifyObserver(process);
            }
        }
 
    return translatedError;
    }

void CPbkWaitNoteWrapperBase::DialogDismissedL
        (TInt aButtonId)
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::DialogDismissedL(0x%x)"),this);
    
    if (iDialogCallbackObserver)
        {
        iDialogCallbackObserver->DialogDismissedL(aButtonId);
        }

	iNoteOpen = EFalse;
    ProcessCanceled();
    }

/**
 * Closes wait note gracefully.
 */
void CPbkWaitNoteWrapperBase::CloseNote()
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::CloseNote(0x%x)"),this);

    if (iWaitDialog)
        {
        iWaitDialog->SetCallback(NULL);
        TRAPD(err,iWaitDialog->ProcessFinishedL());
        if (err != KErrNone)
            {
            // Graceful close was unsuccesful -> stop
			// being nice and kill the dialog
            KillNote();
            }
		iNoteOpen = EFalse;
        }
	}

/**
 * Closes wait note immediately.
 */
void CPbkWaitNoteWrapperBase::KillNote()
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::KillNote(0x%x)"),this);

    if (iWaitDialog)
        {
        iWaitDialog->SetCallback(NULL);
		delete iWaitDialog;
		iWaitDialog=NULL;
        }

	iNoteOpen = EFalse;
    }

void CPbkWaitNoteWrapperBase::ProcessFinished()
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::ProcessFinished(0x%x)"),this);

    if (iBackgroundProcess)
        {
        MPbkBackgroundProcess& process = *iBackgroundProcess;
        iBackgroundProcess = NULL;
        process.ProcessFinished();
        CloseNote();
        NotifyObserver(process);
		}
    }

void CPbkWaitNoteWrapperBase::ProcessCanceled()
    {
    PBK_DEBUG_PRINT(PBK_DEBUG_STRING
		("CPbkWaitNoteWrapperBase::ProcessCanceled(0x%x)"),this);

    if (iBackgroundProcess)
        {
        MPbkBackgroundProcess& process = *iBackgroundProcess;
        iBackgroundProcess = NULL;
        process.ProcessCanceled();
		// Do not kill the note, if it already has been done
		if (iNoteOpen)
			{
			KillNote();
			}
        NotifyObserver(process);
        }
    }

/**
 * Notifies observer about process completion.
 */
void CPbkWaitNoteWrapperBase::NotifyObserver(MPbkBackgroundProcess& aProcess)
    {
    if (iObserver)
        {
        MPbkProcessObserver& observer = *iObserver;
        iObserver = NULL;
        observer.ProcessFinished(aProcess);
        }
    }

//  End of File