/*

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

*

*/

package com.nokia.mj.impl.rt.midp;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.util.Timer;

import java.util.TimerTask;

import com.nokia.mj.impl.rt.utils.ExtensionUtil;

import com.nokia.mj.impl.rt.support.Jvm;

import com.nokia.mj.impl.rt.support.JvmInternal;

import com.nokia.mj.impl.rt.support.ThreadEventListener;

import com.nokia.mj.impl.rt.legacy.LegacySupport;

import com.nokia.mj.impl.gcf.PushSecurityUtils;

import com.nokia.mj.impl.security.packageprotection.PackageProtector;

import com.nokia.mj.impl.security.common.RuntimeSecurityException;

import com.nokia.mj.impl.security.midp.authentication.AuthenticationModule;

import com.nokia.mj.impl.security.midp.storage.AuthenticationStorageData;

import com.nokia.mj.impl.fileutils.FileUtility;

import com.nokia.mj.impl.coreui.CoreUi;

import com.nokia.mj.impl.utils.LineReader;

import com.nokia.mj.impl.utils.TaskQueue;

import com.nokia.mj.impl.utils.Uid;

import com.nokia.mj.impl.utils.StartUpTrace;

/**

 * A core of the MIDP life cycle. This class controls the life time of the

 * MIDlet.

 * <p>

 * The implementation of this class can be divided into three catgories:

 *   -The initializing of the life cycle.

 *   -The state machine.

 *   -The shut down of the life cycle.

 * <p>

 * Initialization can be divided into three different phases. The pre init

 * are the actions that can be done without knowing the MIDlet to be started.

 * The pre init phase is done always - even when going into pre warm state.

 * The last phase is the post actions which require knowing the MIDlet.

 * The pre warm init is a special phase, which is done only when the MIDlet

 * after firstly started into pre-warmed state. When the life cycle receves

 * indication that the MIDlet should be started and receives the MIDlet UID,

 * the life cycle will do first the pre-warm init phae and finally does the

 * post initial phase.

 * <p>

 * The state machine is based on a simple FIFO style thread safe task queue.

 * When the life cycle enters into state machine phase it starts wait for

 * various tasks. It should be noted that in order to ensure thread safeness

 * of the life cycle all most all actions should be done via sending a task

 * queue. Once the state machine is exited a shut down phase begins.

 * <p>

 * In the shut down phase the life cycle will firstly inform Java Captain that

 * it is about to start the shut down procedures. If anything should fail in

 * shut down procedure, it is a responsibility of the Java Captain to terminate

 * the MIDP process. The MIDP runtime tries to close gracefully the JVM, but

 * that will fail if any of the started Java threads dont stop as a result of

 * shut down notifications. That is considered a failure in the shut down phase

 * and the Java Captain will terminate forcefully the process.

 */

final class MidletLifeCycle

{

    /**

     * Possible states of the state machine

     */

    private static final int STARTING_INIT   = 0x1;

    private static final int PRE_INIT_DONE   = 0x2;

    private static final int POST_INIT_DONE  = 0x4;

    private static final int STARTING_MIDLET = 0x8;

    private static final int RUNNING         = 0x10;

    private static final int PAUSED          = 0x20;

    private static final int STOPPING_MIDLET = 0x40;

    private static final int CLOSED          = 0x80;

    private static final int RESUMING        = 0x100;

    /**

     * A singleton instance of the life cycle.

     */

    private static MidletLifeCycle       mInstance = new MidletLifeCycle();

    /**

     * Timers for ensuring that correct actions are done if MIDlet doesn't

     * return from destroyApp().

     */

    private        Timer                 mTimer;

    private        ShutDownTimerTask     mShutDownTimerTask;

    /**

     * Arguments recived from native starter.

     */

    private        MainArgs              mMainArgs;

    /**

     * The task queue of the life cycle.

     */

    private        TaskQueue             mTaskQueue;

    /**

     * The state of the state machine of the life cycle.

     */

    private        int                   mState;

    /**

     * A comms connection to Java Captain.

     */

    private        MidpComms             mMidpcomms;

    /**

     * The gate to the MIDlet. All the MIDP runtime specific actions from

     * and to MIDlet are done by using this object.

     */

    private        MidletApplicationBase mMidletApplication;

    /**

     * The UID of the MIDlet. Is not be available in pre-warm start.

     */

    private        Uid                   mMidletUid;

    /**

     * A pointer to native peer.

     */

    private        int                   mNativeRuntimeStarterHandle;

    /**

     * On error cases that require showing error dialogs an instace of

     * RuntimeErrorDialog will be created. Before starting shut down procedures

     * the life cycle will check if this contains a valid reference. On normal

     * case this is null, but if not then the dialog is prompted before

     * continuing shut down procedures.

     */

    private        RuntimeErrorDialog    mRuntimeErrDialog;

    /**

     * Flag for identifying if the life cycle should be started into pre-warmed

     * state.

     */

    private        boolean               mPrewarmStart = false;

    /**

     * Flag for identifying whether the MIDlet should be started to background.

     */

    private        boolean               mBackGroundStart = false;

    /**

     * How many times MIDlet has been 're-started'

     */

    private        int                   mRelaunchCount = 0;

    /**

     * This is set to true if the MIDlet is started with url and

     * the url contains MIDlet argument 'PromptAppStartup'

     */

    private        boolean               mAutoinvocationFromUrl = false;

    /**

     * Flag for identifying whether the MIDlet is a standalone MIDlet.

     */

    private        boolean               mStandAlone = false;

    /*** ----------------------------- PRIVATE ---------------------------- */

    /**

     * The constructor of the MidletLifeCycle.

     */

    private MidletLifeCycle()

    {

        mState = STARTING_INIT;

    }

    /*** ----------------------------- PACKAGE ---------------------------- */

    /**

     * Will return a singleton instance of the life cycle.

     * @return a singleton instance of the life cycle.

     */

    static MidletLifeCycle getInstance()

    {

        return mInstance;

    }

    /**

     * Can be used for ensuring that important cleanings has been done if some

     * exception has occured during the shut down procedures. It also destroys

     * the singelton instance of the life cycle.

     */

    static void destroyInstance()

    {

        if (mInstance != null)

        {

            // Ensure that DRM rights are consumed when the MIDlet is

            // closed.

            DrmUtil.consumeRightsStop();

            if (mInstance.mState != CLOSED)

            {

                _closeInd(mInstance.mNativeRuntimeStarterHandle);

            }

            if (mInstance.mMidpcomms != null)

            {

                mInstance.mMidpcomms.close();

            }

            mInstance = null;

        }

    }

    /**

     * Entry point for starting the life cycle.

     * @param args The arguments provided to MIDP runtime.

     */

    void doRun(String[] args)

    {

        // Parse given args.

        mMainArgs = new MainArgs(args);

        // Make intializations that can be done without knowing the MIDlet to

        // be launched.

        doPreInit();

        startStateMachine();

        DrmUtil.consumeRightsStop();

        if (mRuntimeErrDialog != null)

        {

            mRuntimeErrDialog.showDialog();

        }

        if (!mStandAlone)

        {

            if (Log.mOn) Log.logI("Sending termination indication to Captain.");

            mMidpcomms.sendTerminatedIndication(0);

            if (Log.mOn) Log.logI("Closing COMMS.");

            mMidpcomms.close();

            mMidpcomms = null;

        }

        if (Log.mOn) Log.logI("Sending shutdown notifications to listeners.");

        ApplicationUtilsImpl.doShutdownImpl();

        if (Log.mOn) Log.logI("Sending close indication to runtime starter.");

        _closeInd(mNativeRuntimeStarterHandle);

        if (Log.mOn) Log.logI("Short pause before closing LegacySupport.");

        try

        {

            Thread.sleep(200);

        }

        catch (Exception e)

        {

        }

        if (Log.mOn) Log.logI("Closing LegacySupport.");

        LegacySupport.close();

        // Setting state to closed.

        mState = CLOSED;

    }

    /**

     * For setting the MidletApplication. This is set by the constructor of

     * the MidletApplicationBase clase during the construction of the MIDlet

     * class. See description of the MidletApplicationBase and the

     * mMidletApplication.

     * @param midletApplication The MidletApplication to be set.

     */

    void setMidletApplication(MidletApplicationBase midletApplication)

    {

        mMidletApplication = midletApplication;

    }

    /**

     * For getting the MidletApplication. See description of the

     * MidletApplicationBase and the mMidletApplication.

     * @return The MidletApplication.

     */

    MidletApplicationBase getMidletApplication()

    {

        return mMidletApplication;

    }

    /**

     * For notifying that MIDlet is entering into destroyed state. The

     * originator of this call is the MIDlet itself.

     */

    void notifyDestroyed()

    {

        if (Log.mOn) Log.logI("notifyDestroyed() called.");

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.STOP_REQUEST,

                                             LifeCycleTask.APP_STOP_REQUEST));

    }

    /**

     * For notifying that MIDlet is entering into paused state. The

     * originator of this call is the MIDlet itself.

     */

    void notifyPaused()

    {

        if (Log.mOn) Log.logI("Pause notification from MIDlet received.");

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.PAUSE_REQUEST));

    }

    /**

     * For notifying the MIDlet that something int the device has happened

     * that would require MIDlet to enter into   entering into actice state from paused

     * state. The originator of this call is the MIDlet itself or the user

     * of the ApplicationUtils.resumeApplication method of the Runtime support

     */

    void pauseApplication()

    {

        if (Log.mOn) Log.logI("Pause application request received.");

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.PAUSE_APP_REQUEST));

    }

    /**

     * For notifying that MIDlet is entering into actice state from paused

     * state. The originator of this call is the MIDlet itself or the user

     * of the ApplicationUtils.resumeApplication method of the Runtime support.

     */

    void resumeRequest()

    {

        if (Log.mOn) Log.logI("Resume request received.");

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.RESUME_REQUEST));

    }

    /**

     * For handling the start request received from the Java Captain. There are

     * two use cases when this could happen:

     *   - The MIDP runtime was in pre-warmed state and received a start cmd.

     *   - The MIDlet is already running and user "re-starts" the MIDlet.

     */

    void launchMidletRequest(Uid uid, boolean backGroundStart, String applicationArgs)

    {

        if (Log.mOn) Log.logI("Request for launching MIDlet received.");

        // Store the info whether MIDlet should be started to back ground.

        mBackGroundStart = backGroundStart;

        // Update relaunch count if really relaunching (not when activating

        // prewarmed MIDlet)

        if (mState != PRE_INIT_DONE)

        {

            mRelaunchCount++;

        }

        JvmInternal.setSystemProperty("com.nokia.mid.cmdline.instance",

                                      Integer.toString(mRelaunchCount + 1));

        if (Log.mOn)

            Log.logI("MIDlet launch count is : " + Integer.toString(mRelaunchCount + 1));

        if (mState == PRE_INIT_DONE)

        {

            // We were waiting in prewarmed state the launch request

            // and now got it.

            StartUpTrace.doTrace("Start request in pre-warm state received.");

            mMidletUid = uid;

            mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.START_REQUEST,

                                                 LifeCycleTask.PRE_WARM_START));

        }

        else

        {

            // Bring the MIDlet to foreground

            CoreUi.foregroundRequest();

        }

    }

    /**

     * For handling the terminate request originated by the system. There are

     * two sources for entering into this method - Java Captain sends a message

     * to the MIDP runtime that the MIDlet should be closed. In that case the

     * Captain has already a timer running for failures in shut down

     * procedures. In that case the internal timer won't be started.

     * The second option is that some one has called notifyExitCmd() of the

     * Runtime Support APIs. In that case a timer will be started to ensure

     * the shut down also in case the MIDlet doesn't return from the

     * destroyApp() call.

     * @param useTimer Info whether to start the interna timer for ensuring

     *                  proper shut down.

     */

    void terminateMidletRequest(boolean useTimer)

    {

        Log.logP("Request for terminating MIDlet " + mMidletUid +

                 "  received.");

        if (Log.mOn) Log.logI("  Internal timer used: " + useTimer);

        if (mState != STOPPING_MIDLET && mState != CLOSED)

        {

            if (useTimer)

            {

                startShutDownTimer();

            }

            mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.STOP_REQUEST,

                                                 LifeCycleTask.SYSTEM_STOP_REQUEST));

        }

        else

        {

            if (Log.mOn) Log.logI("  Already doing shutdown.");

        }

    }

    /**

     * For notifying that the MIDletInvoker has succesfully returned from

     * startApp() call of the MIDlet.

     */

    void midletStarted()

    {

        if (Log.mOn) Log.logI("MIDlet started indication received.");

        mTaskQueue.addTask(

            new LifeCycleTask(LifeCycleTask.MIDLET_RUNNING_IND));

    }

    /**

     * For notifying that the MIDletInvoker has succesfully returned from

     * startApp() call of the MIDlet as a result of resumeRequest.

     */

    void midletResumed(boolean ok)

    {

        if (Log.mOn) Log.logI("MIDlet resumed indication received. " + ok);

        if (ok)

        {

            mTaskQueue.addTask(

                new LifeCycleTask(LifeCycleTask.MIDLET_RUNNING_IND));

        }

    }

    /**

     * For notifying that the MIDletInvoker has succesfully returned from

     * destroyApp() call.

     */

    void midletDestroyed()

    {

        Log.logP("MIDlet " + mMidletUid + " has been destroyed.");

        if (Log.mOn) Log.logI("MIDlet destroyed indication received.");

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.STOPPED_IND));

    }

    /**

     * For notifying that an exception has occured during the MIDlet start.

     * @param th The throwable that was catched during the start.

     */

    void handleMidletStartUpFailure(Throwable th)

    {

        Log.logE("Failed to start MIDlet! ", th);

        mRuntimeErrDialog = RuntimeErrorDialog.getStartUpErrorDialog(th);

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.STARTUP_FAILURE));

    }

    /**

     * For notifying that an exception has occured during pausing the MIDlet.

     * The MIDlet will be destroyed.

     */

    void handleMidletPauseAppFailure()

    {

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.PAUSE_FAILURE));

    }

    /**

     * For notifying that some thread didn't catch a throwable.

     * @param th The throwable that some thread didn't catch.

     */

    void handleUncaughtException(Throwable th)

    {

        Log.logE("Uncaught exception! ", th);

        mRuntimeErrDialog = RuntimeErrorDialog.getUnhandledDialog(th);

        mTaskQueue.addTask(new LifeCycleTask(LifeCycleTask.UNCAUGHT_EXCEPTION));

    }

    /**

     * A getter for info whether the MIDlet should be started into background.

     * @return true if application should be started into back ground, false

     *         otherwise.

     */

    boolean isBackGroundStart()

    {

        // If the background flag has already been set by starter just return

        // If not then we need to check if the user has been set the UI into

        // background before the UI toolkit has been activated.

        if (!mBackGroundStart)

        {

            mBackGroundStart = !CoreUi.isUiInForeground();

        }

        return mBackGroundStart;

    }

    /*** ----------------------------- PRIVATE ---------------------------- */

    /**

     * For starting the state machine of the life cycle