--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javamanager/javacaptain/src/amc.h	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,201 @@
+/*
+* 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:  Amc
+*
+*/
+
+#ifndef AMC_H
+#define AMC_H
+
+#include <list>
+#include <map>
+
+#include "logger.h"
+#include "scopedlocks.h"
+#include "javauid.h"
+
+#include "commslistener.h"
+#include "commsmessage.h"
+
+
+#include "applicationruntimeeventsinterface.h"
+#include "coreinterface.h"
+#include "rtcinterface.h"
+#include "amcinterface.h"
+#include "amcmessages.h"
+
+using namespace java::comms;
+using java::util::Uid;
+
+namespace java
+{
+
+namespace captain
+{
+
+class ApplicationManagementEventsInterface;
+
+using java::util::ScopedLock;
+
+class Amc : public AmcInterface,
+        public ApplicationRuntimeEventsInterface,
+        public CommsListener
+{
+public:
+    Amc();
+    virtual ~Amc();
+
+    bool start(CoreInterface* aCore,
+               ApplicationManagementEventsInterface* aAmEventsDispatcher);
+    bool stop();
+
+    // ApplicationRuntimeEventsInterface
+    virtual void arLaunched(const Uid& aUID, const int& aRuntimeCommsAddress);
+    virtual void arTerminated(const Uid& aUID, const int& aExitCode);
+
+    // CommsListener methods
+    virtual void processMessage(CommsMessage& aMessage);
+
+private:
+
+    // Helper functions for request handling
+    void handleStart(CommsMessage&);
+    void handleStop(CommsMessage&);
+    void handleUpdate(CommsMessage&);
+
+    class StopRequest
+    {
+    public:
+        StopRequest(CoreInterface* aCore, const int& aAddress, const int& aModuleId, const int& aMsgRef,
+                    const int& aNumOfUIDS, Uid* aUIDS)
+                :mCore(aCore), mAddress(aAddress), mModuleId(aModuleId), mMsgRef(aMsgRef)
+        {
+            JELOG2(EJavaCaptain);
+            java::util::ScopedLock lock(mUidsCollectionsMutex);
+            for (int i = 0 ; i<aNumOfUIDS ; i++)
+            {
+                mUidsToBeStopped.push_back(aUIDS[i]);
+            }
+        }
+
+        bool stopUids()
+        {
+            JELOG2(EJavaCaptain);
+            ScopedLock lock(mUidsCollectionsMutex);
+
+            uids_t::iterator iter = mUidsToBeStopped.begin();
+            while (iter != mUidsToBeStopped.end())
+            {
+                mCore->getRtc()->disable(*iter);
+                if (mCore->getRtc()->terminate(*iter))
+                {
+                    // Was not running in the first place can be directly put to stopped list
+                    mUidStatuses.insert(std::make_pair(*iter, 0));
+                    iter = mUidsToBeStopped.erase(iter);
+                }
+                else
+                {
+                    ++iter;
+                }
+            }
+
+            // Was the request fulfilled.
+            if (!mUidsToBeStopped.size())
+            {
+                notifyRequester();
+                return true;
+            }
+
+            return false; // Nope some requests are still pending.
+        }
+
+        bool updateStatus(const Uid& aUID, const int& status)
+        {
+            JELOG2(EJavaCaptain);
+            ScopedLock lock(mUidsCollectionsMutex);
+
+            for (uids_t::iterator iter = mUidsToBeStopped.begin() ;
+                    iter != mUidsToBeStopped.end() ; ++iter)
+            {
+                if (*iter == aUID)
+                {
+                    mUidStatuses.insert(std::make_pair(aUID, status));
+                    mUidsToBeStopped.erase(iter);
+                    break;
+                }
+            }
+
+            // Was this the last one ie. the request has been fulfilled.
+            if (!mUidsToBeStopped.size())
+            {
+                notifyRequester();
+                return true;
+            }
+
+            return false; // Nope some requests are still pending.
+        }
+
+        void notifyRequester()
+        {
+            JELOG2(EJavaCaptain);
+            CommsMessage message;
+            message.setReceiver(mAddress);
+            message.setModuleId(mModuleId);
+            message.setMessageRef(mMsgRef);
+            setAmcResponseParamaters(message, mUidStatuses.size());
+
+            for (uidStatuses_t::iterator iter = mUidStatuses.begin() ;
+                    iter != mUidStatuses.end() ; ++iter)
+            {
+                message << iter->first << iter->second;
+            }
+
+            mCore->getComms()->send(message);
+        }
+
+        void sendStopNotAllowed(const int& aNumOfUIDS, Uid* aUIDS)
+        {
+            JELOG2(EJavaCaptain);
+            for (int i = 0 ; i<aNumOfUIDS ; i++)
+            {
+                updateStatus(aUIDS[i], -1);
+            }
+        }
+
+
+    private:
+        typedef std::list<Uid>  uids_t;
+        uids_t                  mUidsToBeStopped;
+
+        typedef std::map<Uid, int> uidStatuses_t;
+        uidStatuses_t           mUidStatuses;
+        java::util::ScopedMutex mUidsCollectionsMutex;
+
+        CoreInterface*          mCore;
+
+        const int               mAddress;
+        const int               mModuleId;
+        const int               mMsgRef;
+    };
+
+    CoreInterface*                          mCore;
+    ApplicationManagementEventsInterface*   mAmEventsDispatcher;
+    StopRequest*                            mStopRequest; // only one at a time
+};
+
+} // namespace captain
+} // namespace java
+
+#endif // AMC_H
+