/*

* 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:  Rtc

*

*/

#ifndef RTC_H

#define RTC_H

#include <pthread.h>

#include <map>

#include <set>

#include "logger.h"

#include "scopedlocks.h"

#include "javauid.h"

#include "dynamiclibloader.h"

#include "rtcinterface.h"

#include "rtcplugininterface.h"

#include "rtcruntimeinterface.h"

#include "processmanagementeventsinterface.h"

#include "commslistener.h"

#include "eventconsumerinterface.h"

#include "applicationmanagementeventsinterface.h"

using namespace java::comms;

using java::util::Uid;

using java::util::DynamicLibLoader;

namespace java

{

namespace captain

{

class CoreInterface;

class ApplicationRuntimeEventsInterface;

class Rtc : public RtcInterface,

        public ProcessManagementEventsInterface,

        public CommsListener,

        public EventConsumerInterface,

        public ApplicationManagementEventsInterface

{

public:

    Rtc();

    virtual ~Rtc();

    bool start(CoreInterface* aCore,

               ApplicationRuntimeEventsInterface* aRuntimeEventsDispatcher);

    bool stop();

    // RtcInterface methods

    virtual bool launch(const rtcLaunchInfo& aLaunchInfo);

    virtual bool terminate(const rtcTerminateInfo& aTerminateInfo);

    virtual bool enable(const Uid& aUID);

    virtual bool disable(const Uid& aUID);

    virtual void setGlobalRuntimeArguments(const std::wstring& aArguments);

    virtual std::wstring getGlobalRuntimeArguments();

    virtual void setGlobalApplicationArguments(const std::wstring& aArguments);

    virtual std::wstring getGlobalApplicationArguments();

    // ProcessManagementEventsInterface methods

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

    // CommsListener methods

    virtual void processMessage(CommsMessage& aMessage);

    // EventConsumerInterface (needed for listening plugin events)

    virtual void event(const std::string& eventProvider,

                       java::comms::CommsMessage& aMsg);

    // ApplicationManagementEventsInterface methods

    virtual void amAdded(const uids_t& aUids);

    virtual void amUpdated(const uids_t& aUids);

    virtual void amDeleted(const uids_t& aUids);

    // Other public interface methods

    void terminateRtcRuntimes();

    bool routeMessage(CommsMessage& aMessage, const int& aRuntimeAddress);

    void routeMessageToAll(CommsMessage& aMessage);

    void launchPrewarm();

    void stopPrewarm();

    bool isPrewarmSupported();

private:

    // Internal versions supporting CommsMessage based extra indiation options

    bool launch(const rtcLaunchInfo& aLaunchInfo, const int& aOptions, CommsMessage& aRequester);

    bool terminate(const rtcTerminateInfo& aTerminateInfo, const int& aOptions, CommsMessage& aRequester);

    void sendOperationFailed(CommsMessage& aRequester, const Uid& aUid, const int& aOptions);

    void initialiseRuntimePlugins();

    void clearRuntimePlugins();

    RtcRuntimeInterface* getRtcRuntime(const Uid& aUID);

    RtcRuntimeInterface* getOrCreateRtcRuntime(const rtcLaunchInfo& aLaunchInfo);

    RtcRuntimeInterface* getPrewarmedRtcRuntime(const rtcLaunchInfo& aLaunchInfo);

    void deleteRuntime(const Uid& aUid);

    void clearDisabledList();

    void notifyLaunchers(const Uid& aUid, const int& aStatus, const int& aPid);

    void notifyTerminators(const Uid& aUid, const int& aStatus);

    bool isThereInstalledMidlets() const;

    CoreInterface*      mCore;

    class rtcPluginData

    {

    public:

        // Statically linked plugins

        rtcPluginData(RtcPluginInterface* aInterface)

                :mInterface(aInterface)

        {

        }

        // Dynamically linked plugins

        rtcPluginData(RtcPluginInterface* aInterface,

                      std::auto_ptr<DynamicLibLoader> aDllLoader)

                :mInterface(aInterface)

        {

            mDllLoader = aDllLoader;

        }

        virtual ~rtcPluginData()

        {

            delete mInterface;

        }

        RtcPluginInterface*             mInterface;

    private:

        std::auto_ptr<DynamicLibLoader> mDllLoader;

        rtcPluginData();

        rtcPluginData(const rtcPluginData&);

        rtcPluginData &operator=(const rtcPluginData&);

    };

    typedef std::map<std::string, rtcPluginData*> plugins_t;

    plugins_t           mPlugins;

    typedef std::map<Uid, RtcRuntimeInterface*> runtimes_t;

    runtimes_t          mRuntimes;

    typedef std::set<Uid> disabledUIDs_t;

    disabledUIDs_t      mDisabledUIDs;

    typedef std::multimap<Uid, CommsMessage> requesters_t;

    requesters_t        mLaunchers;

    requesters_t        mTerminators;

    std::wstring        mGlobalRuntimeArguments;

    std::wstring        mGlobalApplicationArguments;

    ApplicationRuntimeEventsInterface* mRuntimeEventsDispatcher;

    bool                mSupportPreWarming;

};

} // namespace captain

} // namespace java

#endif // RTC_H