/*

* 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:  Test2Runtime

*

*/

#include "logger.h"

#include "javaprocessconstants.h"

#include "commsendpoint.h"

#include "coreinterface.h"

#include "pmcinterface.h"

#include "rtcmessages.h"

#include "test2runtime.h"

const int EXIT_TIMER_TIMEOUT    = 2;

const int LAUNCH_TIMER_TIMEOUT  = 5;

namespace java

{

namespace captain

{

Test2Runtime::Test2Runtime(const Uid& aUID,

                           CoreInterface* aCore)

        :mUid(aUID), mCore(aCore), mPid(-1),

        mRunning(false), mExiting(false),

        mRuntimeAddress(0), mTimerId(0)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

}

Test2Runtime::~Test2Runtime()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

}

const char* const APP_UID_ARGUMENT          = "-appid";

const char* const PUSH_ARGUMENT             = "-push";

const char* const PREWARM_ARGUMENT          = "-prewarm";

const char* const AUTO_INVOCATION_ARGUMENT  = "-autoinvocation";

const char* const DEBUG_ARGUMENT            = "-debug";

const char* const BG_START_ARGUMENT         = "-background";

// RtcRuntimeInterface

bool Test2Runtime::launch(const rtcLaunchInfo& aLaunchInfo)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    bool launchSuccess = false;

    std::vector<std::string> params;

    params.push_back("javatestruntime");

    params.push_back(java::runtime::JAVA_MIDP_STARTER_DLL); //The name of the dll, that runs MIDlets

    params.push_back(APP_UID_ARGUMENT);

    char* appUID = java::util::JavaCommonUtils::wstringToUtf8(mUid.toString());

    params.push_back(appUID);

    delete [] appUID;

    switch (aLaunchInfo.mLaunchType)

    {

    case RTC_LAUNCH_TYPE_PUSH_C:

        params.push_back(PUSH_ARGUMENT);

        break;

    case RTC_LAUNCH_TYPE_AUTO_INVOCATION_C:

        params.push_back(AUTO_INVOCATION_ARGUMENT);

        break;

    case RTC_LAUNCH_TYPE_BACKGROUND_C:

        params.push_back(BG_START_ARGUMENT);

        break;

    case RTC_LAUNCH_TYPE_NORMAL_C: // fall through

    default:

        break;

    }

    mPid = mCore->getPmc()->launch(params, 0);

    if (mPid > 0)

    {

        launchSuccess = true;

        startTimer(LAUNCH_TIMER_TIMEOUT);

    }

    return launchSuccess;

}

int Test2Runtime::pid() const

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return mPid;

}

Uid Test2Runtime::uid() const

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return mUid;

}

bool Test2Runtime::isRunning() const

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    return mRunning;

}

bool Test2Runtime::terminate(const rtcTerminateInfo& /*aTerminateInfo*/)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    bool alreadyTerminated = false;

    CommsMessage msg;

    setTerminateApplicationReqParams(msg, mUid, RTC_TERMINATE_OPTIONS_NONE_C);

    msg.setReceiver(mRuntimeAddress);

    if (0 == mCore->getComms()->send(msg))

    {

        startTimer(EXIT_TIMER_TIMEOUT);

        alreadyTerminated = false;

        mExiting = true;

    }

    else

    {

        if (mPid > 0 && mCore)

        {

            mCore->getPmc()->kill(mPid);

            alreadyTerminated = false;

            mExiting = true;

        }

        else

        {

            alreadyTerminated = true;

        }

    }

    return alreadyTerminated;

}

// ProcessManagementEventsInterface

void Test2Runtime::pmcTerminated(const int& /*aPid*/, const int& /*exitCode*/)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    stopTimer();

    mPid = -1;

    mRuntimeAddress = 0;

    mRunning = false;

    mExiting = false;

}

void Test2Runtime::runningInd(const int& aRuntimeAddress, const int& /*aStatus*/)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    mRuntimeAddress = aRuntimeAddress;

    if (!mExiting)

    {

        stopTimer();

        mRunning = true;

    }

}

void Test2Runtime::terminatedInd(const int& /*aStatus*/)

{

    if (!mExiting)

    {

        startTimer(EXIT_TIMER_TIMEOUT);

    }

}

// CommsListener

void Test2Runtime::processMessage(CommsMessage& aMessage)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    switch (aMessage.getMessageId())

    {

    default:

        ELOG1(EJavaCaptain, "Unknown message forwarded to Test2Runtime %d", aMessage.getMessageId());

    }

}

void Test2Runtime::startTimer(const int& aTimeout)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    // Only cancel if already started

    if (0 != mTimerId)

    {

        mCore->getTimerServer()->timerCancel(mTimerId);

        mTimerId = 0;

    }

    mTimerId = mCore->getTimerServer()->timerCreateSeconds(aTimeout, this);

}

void Test2Runtime::stopTimer()

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    if (0 != mTimerId)

    {

        mCore->getTimerServer()->timerCancel(mTimerId);

        mTimerId = 0;

    }

}

// TimerServerEventsInterface methods

void Test2Runtime::timerTimeout(const int& aTimerId)

{

    JELOG4(EJavaCaptain, EInfoHeavyLoad);

    if (aTimerId == mTimerId)

    {

        mTimerId = 0;

        if (mPid > 0 && mCore)

        {

            mCore->getPmc()->kill(mPid);

        }

    }

    else

    {

        LOG1WSTR(EJavaCaptain, EError, "timerTimeout(%s)", mUid.toString());

        ELOG2(EJavaCaptain, "Wrong timerId! ok:%d FAIL:%d", mTimerId, aTimerId);

    }

}

} // namespace captain

} // namespace java