/*

* Copyright (c) 2008 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:  Pmc

*

*/

#ifndef PMC_H

#define PMC_H

#include <e32std.h>

#include <e32base.h>

#include <map>

#include <AknGlobalNote.h>

#include "javaoslayer.h"

#include "logger.h"

#include "scopedlocks.h"

#include "pmcinterface.h"

using namespace java::util;

namespace java

{

namespace captain

{

class CoreInterface;

class ProcessManagementEventsInterface;

class ProcessEvents

{

public:

    virtual ~ProcessEvents() {}

    virtual void handleTerminated(const int& pid, const int& exitCode) = 0;

};

class Pmc : public PmcInterface,

        public ProcessEvents

{

public:

    Pmc();

    virtual ~Pmc();

    bool start(CoreInterface* aCore,

               ProcessManagementEventsInterface* aProcessManagementEventsDispatcher);

    bool stop();

    // PmcInterface

    virtual int launch(const cmdLine_t& cmdLine, const int& options);

    virtual int terminate(const int& pid);

    virtual int kill(const int& pid);

    // ProcessEvents

    virtual void handleTerminated(const int& pid, const int& exitCode);

protected:

    class ProcessActive : public CActive

    {

        ProcessActive(); // cannot be used

    public:

        ProcessActive(RProcess* aProcess, ProcessEvents* aEvents, bool aPrewarm)

                :CActive(EPriorityStandard), mRProcess(aProcess), mEvents(aEvents), mExited(false)

        {

            JELOG4(EJavaCaptain, EInfo);

            CActiveScheduler::Add(this);

            mRProcess->Logon(iStatus);

            SetActive();

            JavaOsLayer::startUpTrace("CAPTAIN: Process resume", -1, -1);

            if (aPrewarm)

            {

                // Can't use EPriorityLow, because the compiler takes wrong

                // enum from CActive.

                mRProcess->SetPriority(/*EPriorityLow*/ (TProcessPriority)150);

            }

            mRProcess->Resume();

        }

        virtual ~ProcessActive()

        {

            JELOG4(EJavaCaptain, EInfo);

            Cancel();

            if (!mExited)

            {

                mRProcess->Close();

                delete mRProcess;

            }

        }

        virtual void RunL()

        {

            JELOG4(EJavaCaptain, EInfo);

            mEvents->handleTerminated(mRProcess->Id(), mRProcess->ExitReason());

            mRProcess->Close();

            delete mRProcess;

            mExited = true;

        }

        virtual void DoCancel()

        {

            JELOG4(EJavaCaptain, EInfo);

            mRProcess->LogonCancel(iStatus);

        }

        virtual bool isExited() const

        {

            JELOG4(EJavaCaptain, EInfo);

            return mExited;

        }

        virtual void Terminate(const int& reason)

        {

            JELOG4(EJavaCaptain, EInfo);

            if (!mExited)

            {

                mRProcess->Terminate(reason);

                showErrorNote();

            }

        }

        virtual void Kill(const int& reason)

        {

            JELOG4(EJavaCaptain, EInfo);

            if (!mExited)

            {

                mRProcess->Kill(reason);

                showErrorNote();

            }

        }

    private:

        void showErrorNote()

        {

            LOG(EJavaCaptain, EInfo, "Process failed to exit gracefully");

#ifdef RD_JAVA_EXIT_ERROR_DIALOG

            //Print the dialog showing that force process kill was done.

            CAknGlobalNote* globalNote = CAknGlobalNote::NewL();

            globalNote->ShowNoteL(EAknGlobalErrorNote,

                                  _L("Midp process failed to exit gracefully."));

            delete globalNote;

#endif

        }

    private:

        RProcess*       mRProcess;

        ProcessEvents*  mEvents;

        bool            mExited;

    };

    CoreInterface*                          mCore;

    ProcessManagementEventsInterface*       mProcessManagementEventsDispatcher;

    typedef std::map<int, ProcessActive*>   processes_t;

    processes_t                             mProcesses;

    java::util::ScopedMutex                 mProcessesMutex;

};

} // namespace captain

} // namespace java

#endif // PMC_H