/*

* Copyright (c) 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 Sif plugin.

*               When started  in 'commsresult' mode from Java Sif plugin

*               Java Installer sends the results of the operation

*               it executes (install, uninstall or component info)

*               to this server.

*

*/

#include <iostream>

#include <unistd.h>

#include <usif/usiferror.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) :

        mResults(aResults), mInfo(aInfo)

{

}

ResultsServer::~ResultsServer()

{

    // Stop server if running

    stop();

    iIntPairs.clear();

    iStringPairs.clear();

}

int ResultsServer::start()

{

    // Write reasonable error codes to mResults that can be used if

    // Java Installer never returns InstallerResultMessage.

    // If InstallerResultMessage is received the values will be overwritten.

    TRAPD(err, mResults.AddIntL(KSifOutParam_ErrCategory, EUnexpectedError));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

            "ResultsServer::start mResults.AddIntL ErrCategory err %d", err);

    }

    TRAP(err, mResults.AddIntL(KSifOutParam_ErrCode, KErrUnknown));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

            "ResultsServer::start mResults.AddIntL ErrCode err %d", err);

    }

    // TODO: return also localized error message (KSifOutParam_ErrMessage and

    // perhaps also KSifOutParam_ErrMessageDetails) from usif

    // common localization file after the localized strings are available

    mComms.registerDefaultListener(this);

    return mComms.start(IPC_ADDRESS_JAVA_SIF_PLUGIN_C);

}

int ResultsServer::stop()

{

    mComms.unregisterDefaultListener(this);

    return mComms.stop();

}

/**

 * 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;

                setCommonErrorInfo();

                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

                // Overwrite (reset) the default error values set for the case where no

                // InstallerResultMessage is never received

                resetDefaultErrorValues();

                if (INSTALL_OPERATION == operation)

                {

                    // Return the component ids of the installed Java application.

                    TComponentId resultComponentId = iIntPairs[L"suite-cid"];

                    TRAP(err, mResults.AddIntL(KSifOutParam_ComponentId, resultComponentId));

                    if (KErrNone != err)

                    {

                        ELOG1(EJavaInstaller,

                              "ResultsServer::processMessage mResults.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 = mComms.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();

}

/**

 * Set common error information.

 * Note that the information is in member variables

 * iIntPairs and iStringPairs

 */

void ResultsServer::setCommonErrorInfo()

{

    // return common error information

    TRAPD(err, mResults.AddIntL(KSifOutParam_ErrCode, iIntPairs[L"error-code"]));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

            "ResultsServer::setCommonErrorInfo mResults.AddIntL ErrCode err %d", err);

    }

    TRAP(err, mResults.AddIntL(

        KSifOutParam_ErrCategory, iIntPairs[L"error-category"]));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

            "ResultsServer::setCommonErrorInfo mResults.AddIntL ErrCategory err %d",

            err);

    }

    HBufC *message = wstringToBuf(iStringPairs[L"error-message"]);

    if (!message)

    {

        ELOG(EJavaInstaller,

              "ResultsServer::setCommonErrorInfo mResults.wstringToBuf returned NULL ");

    }

    else

    {

        TRAP(err, mResults.AddStringL(KSifOutParam_ErrMessage, *message));

        if (KErrNone != err)

        {

            ELOG1(EJavaInstaller,

                "ResultsServer::setCommonErrorInfo mResults.AddStringL ErrMessage err %d",

                err);

        }

        delete message;

    }

    message = wstringToBuf(iStringPairs[L"error-details"]);

    if (!message)

    {

        ELOG(EJavaInstaller,

              "ResultsServer::setCommonErrorInfo mResults.wstringToBuf 2 returned NULL ");

    }

    else

    {

        TRAP(err, mResults.AddStringL(KSifOutParam_ErrMessageDetails, *message));

        if (KErrNone != err)

        {

            ELOG1(EJavaInstaller,

                "ResultsServer::setCommonErrorInfo mResults.AddStringL ErrMessageDetails "

                "err %d", err);

        }

        delete message;

    }

}

/**

 * Overwrite (reset) the default error values to 'no error'.

 * The default error values were originally set for the case

 * where no InstallerResultMessage is never received and we must

 * return sensible error information.

 */

void ResultsServer::resetDefaultErrorValues()

{

    TRAPD(err, mResults.AddIntL(KSifOutParam_ErrCategory, 0));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

            "ResultsServer::resetDefaultErrorValues mResults.AddIntL ErrCategory err %d", err);

    }

    TRAP(err, mResults.AddIntL(KSifOutParam_ErrCode, 0));

    if (KErrNone != err)

    {

        ELOG1(EJavaInstaller,

            "ResultsServer::resetDefaultErrorValues mResults.AddIntL ErrCode err %d", err);

    }

    // TODO: reset also localized error message KSifOutParam_ErrMessage and

    // perhaps also KSifOutParam_ErrMessageDetails if they have been set in start()

}

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++;

    } // sanity check: no suite can have 10000 midlets

    while (n < 10000);   // codescanner::magicnumbers

    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

    mInfo.SetRootNodeL(rootNode);

    CleanupStack::Pop(rootNode);

    CleanupStack::PopAndDestroy(&applications);

}