/*

* Copyright (c) 2009 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:  This class provides container for message.

*

*/

#include <string>

#include <string.h>

#include <algorithm>

#include <iostream>

#include <fstream>

#include <unistd.h>

#include "midpruntimestarter.h"

#include "applicationinfosetter.h"

#include "runtimeexception.h"

#include "runtimestarterutils.h"

#include "midpruntimearguments.h"

#include "dynamiclibloader.h"

#include "javainifileutils.h"

#include "javacommonutils.h"

#include "javaoslayer.h"

#include "logger.h"

#include "commsmessage.h"

#include "rtcmessages.h"

#include "pushcontrollerstarter.h"

#include "javastoragenames.h"

#include "javacoreui.h"

#include "javacoreuiparams.h"

#include "com_nokia_mj_impl_rt_midp_MemoryLogger.h"

using namespace java::runtime;

using namespace java::util;

using namespace java::push;

using namespace java::storage;

using namespace java::captain;

using namespace java::ui;

const wchar_t* const RUNTIME_MAIN_CLASS = L"com.nokia.mj.impl.rt.midp.Main";

const wchar_t* const TRUE_WSTR          = L"true";

MidpRuntimeStarter::MidpRuntimeStarter(): mMidletInfo(new MidletInfo()), // codescanner::nonleavenew

{

    JELOG2(EJavaRuntime);

}

MidpRuntimeStarter::~MidpRuntimeStarter()

{

    JELOG2(EJavaRuntime);

    if (mPushLib.get())

    {

        mPushLib->closeLib();

    }

}

int MidpRuntimeStarter::start(int argc, char *argv[])

{

    JELOG2(EJavaRuntime);

    // Create instance of RuntimeStarterUtils for thread supervisioning.

    std::auto_ptr<RuntimeStarterUtils> starterUtils(new RuntimeStarterUtils()); // codescanner::nonleavenew

    starterUtils->startThreadSupervisor();

    // Parse the args received from Captain.

    parseArgs(argc, argv);

    initComms();

    // Some push plugins needs to get the UID of the MIDlet and the root

    // path. Setting MidpRuntimeStarter as a service provider.

    setApplicationInfoProvider(*this);

    // Check if push command was receieved.

    if (mMidletInfo->mPushStart)

    {

        // In order ot serve ApplicationInfo we need to solve the

        // MIDlet suite UID.

        std::auto_ptr<JavaStorage> storage(JavaStorage::createInstance());

        storage->open();

        getMIDletSuiteUidFromStorage(*storage.get());

        storage->close();

        storage.reset(0);

        handlePushStart();

        // Handle case where during the push listening we receive a close cmd.

        if (mRuntimeState == Closing)

        {

            closePush();

            return 0;

        }

    }

    // Load the core UI

    std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

    startCoreUi(coreUiLoader);

    // Create starter for starting the JVM

    std::auto_ptr<JvmStarter>

    jvm(JvmStarter::getJvmStarterInstance(JvmStarter::CLDC,

                                          L"Midp"));

    // Don't know the class path in pre-warm state.

    if (!mMidletInfo->mPreWarmStart)

    {

        jvm->appendClassPath(mMidletInfo->mClassPath);

        jvm->appendApplicationArgument(L"-uid");

        jvm->appendApplicationArgument(mMidletInfo->mMIDletUid.toString());

        // Get the heap size recorded from the previous runs.

        int heapSize = getHeapSize();

        if (heapSize > com_nokia_mj_impl_rt_midp_MemoryLogger_MAX_OLD_SPACE)

        {

            heapSize = com_nokia_mj_impl_rt_midp_MemoryLogger_MAX_OLD_SPACE;

        }

        if (heapSize > com_nokia_mj_impl_rt_midp_MemoryLogger_DEFAULT_OLD_SPACE)

        {

            jvm->overrideOldHeapSize(heapSize / 1024);

        }

    }

    jvm->setMainClass(RUNTIME_MAIN_CLASS);

    jvm->enableThreadDumping();

    jvm->appendSystemProperty(L"-Dcom.nokia.rt.port=midp");

#ifndef RD_JAVA_UI_QT

    jvm->appendSystemProperty(L"-Dcom.nokia.legacy.support=LegacySymbian");

#endif // RD_JAVA_UI_QT

    // Provide access to this object by Java peer via delivering a pointer

    // to this object.

    jvm->appendApplicationArgument(L"-handle");

    MidpStarterInternalSupport* internalSupport = this;

    int handle = reinterpret_cast<int>(internalSupport);

    jvm->appendApplicationArgument(JavaCommonUtils::intToWstring(handle));

    // If the intention is to go to prewarmed state pass the info to Java peer.

    if (mMidletInfo->mPreWarmStart)

    {

        jvm->appendApplicationArgument(L"-prewarm");

        // Captain needs a pid in order to identify the prewarmed runtime.

        jvm->appendApplicationArgument(JavaCommonUtils::intToWstring(getpid()));

        // Starting with lower old space in pre warm case.

        jvm->overrideOldHeapSize(36);

    }

    // If the requested to go to back ground, pass the info to Java peer.

    if (mMidletInfo->mBackGroundRequested)

    {

        jvm->appendApplicationArgument(L"-background");

        jvm->appendApplicationArgument(TRUE_WSTR);

    }

    // If the autoinvocation happened pass the info to Java peer.

    if (mMidletInfo->mAutoInvocationRequested)

    {

        jvm->appendApplicationArgument(L"-autoinvocation");

        jvm->appendApplicationArgument(TRUE_WSTR);

        jvm->appendApplicationArgument(L"-autoInvocationAdditional");

        jvm->appendApplicationArgument(mPushAdditionalInfo);

    }

    // Enable thread dumping. If the captain informed about debug mode

    // or arguments for MIDlet set the arguments provided by the captain.

    std::wstring midletArgs;

    starterUtils->enableDevelopmentFeatures(*jvm.get(),

                                            mMidletInfo->mDebugRequested || mMidletInfo->mMIDletHasArgs,

                                            &midletArgs);

    if (midletArgs.length() == 0)

    {

        // If MIDlet was waiting for push or was pre-warmed,

        // the arguments can be already in midlet info

        midletArgs = mMidletInfo->mMIDletArgs;

    }

    if (midletArgs.length() > 0)

    {

        // Pass the arguments to 'Java side' in encoded form.

        // Encoding is done to prevent security risks.

        std::wstring encodedArgs = L"-Dcom.nokia.mid.cmdline=";

        encodedArgs.append(encodeArgs(midletArgs));

        jvm->appendSystemProperty(encodedArgs);

        // remember the args

        mMidletInfo->mMIDletArgs = encodedArgs;

    }

    // When starting this property has always value "1"

    jvm->appendSystemProperty(L"-Dcom.nokia.mid.cmdline.instance=1");

    // There might be extensions available. Solving if those exist.

    std::wstring extendedBootClassPath;

    // This call is platform dependent.

    starterUtils->getExtBootClassPath(extendedBootClassPath);

    if (extendedBootClassPath.length() > 0)

    {

        // Append the extensions to bootclasspath.

        jvm->appendBootClassPath(extendedBootClassPath);

        // Provide the bootclasspath also as a system propery

        // for solving the protected and restricted packages.

        std::wstring addOnList(L"-Dcom.nokia.mj.addon.list=");

        addOnList += extendedBootClassPath;

        jvm->appendSystemProperty(addOnList);

    }

    mRuntimeState = Active;

    // Start the JVM.

    int status = jvm->startJvm();

    if (mComms.get())

    {

        mComms->disconnect();

    }

    CoreUi::releaseUi(coreUiLoader);

    return status;

}

void MidpRuntimeStarter::parseArgs(int argc, char* argv[])

{

    JELOG2(EJavaRuntime);

    bool appUidFound = false;

    // Loop through the arguments. First one can be skipped, because it

    // contains the name of the executable.

    for (int index = 1 ; index < argc; index++)

    {

        const char* key = argv[index];

        const char* value = 0;

        // Checking if there is value available.

        if (index+1 < argc)

        {

            value = argv[index+1];

        }

        LOG2(EJavaRuntime, EInfo,"MidpRuntimeStarter::parseArgs(). "

             "Handling key %s with value %s",

             key,

             value==0?"<No Value>":value);

        if (strcmp(key, APP_UID_ARGUMENT) == 0)

        {

            if (value)

            {

                mMidletInfo->mMIDletUid =

                    Uid(java::util::JavaCommonUtils::utf8ToWstring(value));

                appUidFound = true;

                index++;

            }

        }

        else if (strcmp(key, PREWARM_ARGUMENT) == 0)

        {

            mMidletInfo->mPreWarmStart = true;

            LOG1(EJavaRuntime, EInfo,"PREWARM_ARGUMENT = %d ",  mMidletInfo->mPreWarmStart);

        }

        else if (strcmp(key, PUSH_ARGUMENT) == 0)

        {

            mMidletInfo->mPushStart = true;

            LOG1(EJavaRuntime, EInfo,"PUSH_ARGUMENT = %d ",  mMidletInfo->mPushStart);

        }

        else if (strcmp(key, AUTO_INVOCATION_ARGUMENT) == 0)

        {

            mMidletInfo->mAutoInvocationRequested = true;

            LOG1(EJavaRuntime, EInfo,"AUTO_INVOCATION_ARGUMENT = %d ",  mMidletInfo->mAutoInvocationRequested);

        }

        else if (strcmp(key, DEBUG_ARGUMENT) == 0)

        {

            mMidletInfo->mDebugRequested = true;

            LOG1(EJavaRuntime, EInfo,"DEBUG_ARGUMENT = %d ",  mMidletInfo->mDebugRequested);

        }

        else if (strcmp(key, EXTRA_ARGUMENTS) == 0)

        {

            mMidletInfo->mMIDletHasArgs = true;

            LOG1(EJavaRuntime, EInfo,"EXTRA_ARGUMENTS = %d ",  mMidletInfo->mMIDletHasArgs);

        }

        else if (strcmp(key, BG_START_ARGUMENT) == 0)

        {

            mMidletInfo->mBackGroundRequested = true;

            LOG1(EJavaRuntime, EInfo,"BG_START_ARGUMENT = %d ",  mMidletInfo->mBackGroundRequested);

        }

        else

        {

            std::string errorStr("Unknown argument received: ");

            errorStr.append(key);

            throw RuntimeException(errorStr, __FILE__, __FUNCTION__, __LINE__);

        }

    }

    if (appUidFound == false && mMidletInfo->mPreWarmStart == false)

    {

        std::string errorStr("Argument ");

        errorStr.append(APP_UID_ARGUMENT);

        errorStr.append(" not defined!");

        throw RuntimeException(errorStr, __FILE__, __FUNCTION__, __LINE__);

    }

}

void MidpRuntimeStarter::startCoreUi(std::auto_ptr<java::util::DynamicLibLoader>& coreUiLoader)

{

    CoreUi& coreUi = CoreUi::getUiInstance(coreUiLoader);

    // Create the default UI only if not going into pre-warmed state.

    if (!mMidletInfo->mPreWarmStart)

    {

        // Open a session to JavaStorage.

        std::auto_ptr<JavaStorage> javaStorage(JavaStorage::createInstance());

        javaStorage->open();

        CoreUiParams uiParams;

        // Get the MIDlet suite UID from storage.

        if (mMidletInfo->mMIDletSuiteUid.toString() == L"")

        {

            getMIDletSuiteUidFromStorage(*javaStorage.get());

        }

        // Check if the MIDlet has defined the Nokia-MIDlet-App-Orientation

        // JAD attribute.

        std::auto_ptr<std::wstring> appOrientation

        (getMidletAttributeFromStorage(*javaStorage.get(),

                                       L"Nokia-MIDlet-App-Orientation"));

        if (appOrientation.get() != 0)

        {

            std::transform(appOrientation->begin(), appOrientation->end(),

                           appOrientation->begin(), tolower);

            if (*appOrientation == L"portrait")

            {

                uiParams.setOrientation(PORTRAIT);

            }

            else if (*appOrientation == L"landscape")

            {

                uiParams.setOrientation(LANDSCAPE);

            }

            else

            {

                WLOG1(EJavaRuntime, "appOrientation contained unknown value: %S",

                      appOrientation->c_str());

            }

        }

        else

        {

            LOG(EJavaRuntime, EInfo, "Nokia-MIDlet-App-Orientation not defined");

        }

        // Check if the MIDlet has defined the MIDlet-Splash-Screen-Image

        // JAD attribute.

        std::auto_ptr<std::wstring> splashScreen

        (getMidletAttributeFromStorage(*javaStorage.get(),

                                       L"MIDlet-Splash-Screen-Image"));

        if (splashScreen.get() != 0)

        {

            std::transform(splashScreen->begin(), splashScreen->end(),

                           splashScreen->begin(), tolower);

            if (*splashScreen == L"suppress")

            {

                // If MIDlet-Splash-Screen-Image JAD attribute is suppress then

                // we start the UI into background.

                LOG(EJavaRuntime, EInfo, "MIDlet-Splash-Screen-Image is suppress");

                uiParams.setScreenMode(NO_START_SCREEN);

                uiParams.setBackgroundStart(true);

            }

            else

            {

                // If MIDlet-Splash-Screen-Image JAD attribute is not suppress then

                // we need to solve the root path of the MIDlet and provide that

                // to the coreUI.

                uiParams.setScreenMode(MIDLET_DEFINED_SCREEN);

                LOG1(EJavaRuntime, EInfo, "MIDlet-Splash-Screen-Image, setPath to %S",

                     mMidletInfo->mMIDletRootPath.c_str());

            }

        }

        else

        {

            LOG(EJavaRuntime, EInfo, "MIDlet-Splash-Screen-Image not defined");

            uiParams.setScreenMode(DEFAULT_START_SCREEN);

        }

        getRootPath();

        uiParams.setImagePath(mMidletInfo->mMIDletRootPath);

        // If there was a background start requst pass the info to coreUi.

        // Also the autoinvocation start puts the screen into BG.

        if (mMidletInfo->mBackGroundRequested || mMidletInfo->mAutoInvocationRequested)

        {

            uiParams.setBackgroundStart(true);

        }

        // Start the coreUI.

        JavaOsLayer::startUpTrace("Starting CoreUI", -1, -1);

        coreUi.start(mMidletInfo->mMIDletUid, &uiParams);

        JavaOsLayer::startUpTrace("CoreUI started", -1, -1);

        getMIDletSuiteInfoFromStorage(javaStorage.get(), JAR_PATH,

                                      mMidletInfo->mClassPath);

    }

}

void MidpRuntimeStarter::

ApplicationStateChangeRequest(ApplicationState state)

{

    JELOG2(EJavaRuntime);

    LOG1(EJavaRuntime, EInfo, "ApplicationStateChangeRequest: %d", state);

    switch (state)

    {

    case START_APPLICATION:

    case CONTINUE_APPLICATION_STARTUP:

        doStateChange(Start);

        break;

    case CLOSE_APPLICATION:

        doStateChange(Stop);

        break;

    default:

        std::string errorStr("Illegal state ");

        errorStr.append(JavaCommonUtils::intToString(state));

        throw RuntimeException(errorStr, __FILE__, __FUNCTION__, __LINE__);

    }

}

void MidpRuntimeStarter::doStateChange(StateChangeRequest request)

{

    JELOG2(EJavaRuntime);

    LOG2(EJavaRuntime, EInfo, "MidpRuntimeStarter::doStateChange. Request: %d,"

         " current state: %d", request, mRuntimeState);

    ScopedLock lock(mProcessesMutex); // Making the method thread safe

    switch (request)

    {

    case Start:

        // Check if we are still waiting start command.

        if (mRuntimeState == PushListen)

        {

            mRuntimeState = Active;

            //Allow application startUp.

            mMonitor->notify();

        }

        break;

    case Stop:

        // Check if we are still waiting start command.

        if (mRuntimeState == PushListen)

        {

            //Allow application to close.

            mRuntimeState = Closing;

            mMonitor->notify();

        }

        break;

    default:

        std::string errorStr("Illegal request ");

        errorStr.append(JavaCommonUtils::intToString(request));

        throw RuntimeException(errorStr, __FILE__, __FUNCTION__, __LINE__);

    }

}