diff -r f5050f1da672 -r 04becd199f91 javamanager/javainstaller/javasifplugin/src/resultsserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javamanager/javainstaller/javasifplugin/src/resultsserver.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,354 @@
+/*
+* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:  Comms server,
+*    part of Java platform 2.0 javarestoreconverter process
+*
+*/
+
+
+#include <iostream>
+#include <unistd.h>
+
+#include "comms.h"
+#include "javasymbianoslayer.h"
+#include "logger.h"
+#include "resultsserver.h"
+
+using namespace java::comms;
+using namespace std;
+
+ResultsServer::ResultsServer(COpaqueNamedParams& aResults, CComponentInfo& aInfo) :
+        iResults(aResults), iInfo(aInfo)
+{
+}
+
+ResultsServer::~ResultsServer()
+{
+    // Stop server if running
+    stop();
+
+    iIntPairs.clear();
+    iStringPairs.clear();
+}
+
+int ResultsServer::start()
+{
+    iRunning = 1;
+    iComms.registerDefaultListener(this);
+    return iComms.start(IPC_ADDRESS_JAVA_SIF_PLUGIN_C);
+}
+
+int ResultsServer::stop()
+{
+    if (iRunning > 0)
+    {
+        iRunning = 0;
+        iComms.unregisterDefaultListener(this);
+        return iComms.stop();
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+/**
+ * Communicates with Java Installer. The following messages are used.
+ *
+ * Message Name        Id      Contents
+ *
+ *
+ * Installer Result    601     message := length named_int_value* length named_string_value*
+ *                             length := <int telling how many entries the following table has>
+ *                             named_int_value := name int_value
+ *                             named_string_value := name string_value
+ *                             name := <string>
+ *                             int_value := <int>
+ *                             string_value := <string>
+ * Installer Result
+ *   Response          602     int response    (always 0)
+ *
+ *
+ */
+void ResultsServer::processMessage(CommsMessage& aMessage)
+{
+    TInt err = KErrNone;
+
+    switch (aMessage.getMessageId())
+    {
+        case INSTALLER_RESULT_MESSAGE_ID:
+        {
+            int int_table_len;
+            int string_table_len;
+            int int_value;
+            std::wstring name;
+            std::wstring value;
+
+            // Read raw message data
+            aMessage >> int_table_len;
+            for (int idx = 0; idx < int_table_len; idx++)
+            {
+                aMessage >> name >> int_value;
+                iIntPairs.insert(std::make_pair(name, int_value));
+            }
+
+            aMessage >> string_table_len;
+            for (int idx = 0; idx < string_table_len; idx++)
+            {
+                aMessage >> name >> value;
+                iStringPairs.insert(std::make_pair(name, value));
+            }
+
+            // Which operation the Java Installer has executed
+            int operation = iIntPairs[L"operation"];
+            // result is KErrNone if the operation succeeded
+            int result = iIntPairs[L"result"];
+
+            if (KErrNone != result)
+            {
+                // return common error information
+                TRAP(err, iResults.AddIntL(KSifOutParam_ExtendedErrCode, result));
+                if (KErrNone != err)
+                {
+                    ELOG1(EJavaInstaller,
+                        "ResultsServer::processMessage iResults.AddIntL ExtendedErrCode err %d",
+                        err);
+                }
+
+                TRAP(err, iResults.AddIntL(KSifOutParam_ErrCode, result));
+                if (KErrNone != err)
+                {
+                    ELOG1(EJavaInstaller,
+                        "ResultsServer::processMessage iResults.AddIntL ErrCode err %d", err);
+                }
+
+                TRAP(err, iResults.AddIntL(
+                    KSifOutParam_ErrCategory, iIntPairs[L"error-category"]));
+                if (KErrNone != err)
+                {
+                    ELOG1(EJavaInstaller,
+                        "ResultsServer::processMessage iResults.AddIntL ErrCategory err %d",
+                        err);
+                }
+
+                HBufC *message = wstringToBuf(iStringPairs[L"error-message"]);
+                if (message == NULL)
+                {
+                    ELOG(EJavaInstaller,
+                          "ResultsServer::processMessage iResults.wstringToBuf returned NULL ");
+                }
+                else
+                {
+                    TRAP(err, iResults.AddStringL(KSifOutParam_ErrMessage, *message));
+                    if (KErrNone != err)
+                    {
+                        ELOG1(EJavaInstaller,
+                            "ResultsServer::processMessage iResults.AddStringL ErrMessage err %d",
+                            err);
+                    }
+                    delete message;
+                }
+
+                message = wstringToBuf(iStringPairs[L"error-details"]);
+                if (message == NULL)
+                {
+                    ELOG(EJavaInstaller,
+                          "ResultsServer::processMessage iResults.wstringToBuf 2 returned NULL ");
+                }
+                else
+                {
+                    TRAP(err, iResults.AddStringL(KSifOutParam_ErrMessageDetails, *message));
+                    if (KErrNone != err)
+                    {
+                        ELOG1(EJavaInstaller,
+                            "ResultsServer::processMessage iResults.AddStringL ErrMessageDetails "
+                            "err %d", err);
+                    }
+                    delete message;
+                }
+
+                if (INSTALL_OPERATION == operation)
+                {
+                    ELOG1(EJavaInstaller,
+                        "ResultsServer::processMessage, Install failed with error %d", result);
+                }
+                else if (UNINSTALL_OPERATION == operation)
+                {
+                    ELOG1(EJavaInstaller,
+                        "ResultsServer::processMessage, Uninstall failed with error %d", result);
+                }
+                else if (COMPONENT_INFO_OPERATION == operation)
+                {
+                    ELOG1(EJavaInstaller,
+                        "ResultsServer::processMessage, Component info failed with error %d",
+                        result);
+                }
+            }
+            else
+            {
+                // operation succeeded
+
+                if (INSTALL_OPERATION == operation)
+                {
+                    // Return the component ids of the installed Java application.
+                    TComponentId resultComponentId = iIntPairs[L"suite-cid"];
+                    TRAP(err, iResults.AddIntL(KSifOutParam_ComponentId, resultComponentId));
+                    if (KErrNone != err)
+                    {
+                        ELOG1(EJavaInstaller,
+                              "ResultsServer::processMessage iResults.AddIntL cid error %d", err);
+                    }
+                }
+                else if (UNINSTALL_OPERATION == operation)
+                {
+                    // Return nothing if uninstall succeeds
+                }
+                else if (COMPONENT_INFO_OPERATION == operation)
+                {
+                    TRAP(err, setComponentInfoL());
+                    if (KErrNone != err)
+                    {
+                        ELOG1(EJavaInstaller,
+                              "ResultsServer::processMessage Cannot set CComponentInfo, error %d",
+                              err);
+                    }
+                }
+                else
+                {
+                    // Unknown operation
+                    WLOG1(EJavaInstaller,
+                        "ResultsServer::processMessage: Unknown operation (%d) executed",
+                        operation);
+                }
+            }
+
+            // Reply always with 'Response' message.
+            CommsMessage reply;
+            reply.replyTo(aMessage);
+            reply.setMessageId(INSTALLER_RESULT_RESPONSE_MESSAGE_ID);
+            reply << 0;
+
+            int err = iComms.send(reply);
+            if (err != 0)
+            {
+                ELOG1(EJavaInstaller,
+                    "ResultsServer: Sending reply to Java Installer failed, err %d", err);
+            }
+        }
+        break;
+
+        default:
+        {
+            // Unknown message. Ignore it.
+            WLOG1(EJavaInstaller,
+                "ResultsServer: Unknown message received. Msg Id = %d",
+                aMessage.getMessageId());
+        }
+        break;
+    }
+
+    clearData();
+}
+
+
+void ResultsServer::clearData()
+{
+    iIntPairs.clear();
+    iStringPairs.clear();
+}
+
+
+void ResultsServer::setComponentInfoL()
+{
+    // Component == MIDlet Suite
+    TCapabilitySet emptySet;
+    emptySet.SetEmpty();
+
+    std::wstring wSuiteName = iStringPairs[L"suite-name"];
+    TPtr16 suiteName((TUint16 *)wSuiteName.c_str(), wSuiteName.size(), wSuiteName.size());
+
+    std::wstring wVersion = iStringPairs[L"version"];
+    TPtr16 version((TUint16 *)wVersion.c_str(), wVersion.size(), wVersion.size());
+
+    std::wstring wVendor = iStringPairs[L"vendor"];
+    TPtr16 vendor((TUint16 *)wVendor.c_str(), wVendor.size(), wVendor.size());
+
+    std::wstring wSuiteGid = iStringPairs[L"suite-gid"];
+    TPtr16 suiteGid((TUint16 *)wSuiteGid.c_str(), wSuiteGid.size(), wSuiteGid.size());
+
+    RPointerArray<CComponentInfo::CApplicationInfo> applications;
+    CleanupResetAndDestroyPushL(applications);
+    int n = 1;
+    do
+    {
+        // construct wstring 'midlet-uid-<n>'. e.g. 'midlet-uid-1'
+        std::wstring midletUidN(L"midlet-uid-");
+        std::wstringstream ss;
+        ss << midletUidN;
+        ss << n;
+        ss >> midletUidN;
+
+        //LOG1WSTR(EJavaInstaller, EInfo,
+        //         "ResultsServer::processMessage: checking %s", midletUidN.c_str());
+
+        int uid = iIntPairs[midletUidN];
+        if (uid == 0)
+        {
+            // no more midlets in the suite
+            break;
+        }
+
+        // construct wstring 'midlet-name-<n>'. e.g. 'midlet-name-1'
+        std::wstring midletNameN(L"midlet-name-");
+        std::wstringstream ss2;
+        ss2 << midletNameN;
+        ss2 << n;
+        ss2 >> midletNameN;
+        std::wstring wMidletName = iStringPairs[midletNameN];
+        TPtr16 midletName((TUint16 *)wMidletName.c_str(), wMidletName.size(), wMidletName.size());
+
+        // Construct application information and append it to applications list.
+        CComponentInfo::CApplicationInfo* applicationInfo =
+            CComponentInfo::CApplicationInfo::NewLC(
+                TUid::Uid(uid), midletName, KNullDesC(), KNullDesC());
+        applications.AppendL(applicationInfo);
+        CleanupStack::Pop(applicationInfo);
+
+        n++;
+    }
+    while (n < 10000);  // sanity check: no suite can have 10000 midlets
+
+    CComponentInfo::CNode *rootNode = NULL;
+    rootNode = CComponentInfo::CNode::NewLC(
+                   KSoftwareTypeJava,
+                   suiteName,
+                   version,
+                   vendor,
+                   EActivated, // Java applications are always active
+                   (Usif::TInstallStatus)(iIntPairs[L"install-status"]),
+                   iIntPairs[L"suite-cid"],  // TComponentId
+                   suiteGid,
+                   (Usif::TAuthenticity)(iIntPairs[L"authenticity"]),
+                   emptySet, // Java applications use J2ME permissions, not capabilities
+                   iIntPairs[L"component-size"], // max installed size is given by java installer
+                   ETrue, // suite has always at least one MIDlet
+                   EFalse, // drive selection is not required
+                   &applications
+               );
+
+    // Store whole component info tree
+    iInfo.SetRootNodeL(rootNode);
+    CleanupStack::Pop(rootNode);
+    CleanupStack::PopAndDestroy(&applications);
+}