--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javamanager/javacaptain/src/rtc.h	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,182 @@
+/*
+* 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();
+
+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
+