commandprocessor.java

用于移动设备上的java虚拟机源代码

/*
 * @(#)CommandProcessor.java	1.27 02/10/03 @(#)
 *
 * Copyright (c) 2001-2002 Sun Microsystems, Inc.  All rights reserved.
 * PROPRIETARY/CONFIDENTIAL
 * Use is subject to license terms.
 */

package com.sun.midp.main;

import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.lang.String;

import com.sun.midp.midlet.MIDletSuite;
import com.sun.midp.midlet.Scheduler;

import com.sun.midp.midletsuite.Installer;
import com.sun.midp.midletsuite.InvalidJadException;

/**
 * Performs basic MIDlet Suite management commands.
 * <p>
 * The <code>Main</code> class performs four basic operations:
 * <ul>
 * <li>Application installation
 * <li>Application removal
 * <li>Application listing
 * <li>Application execution
 * </ul>
 * <p>
 * Together, these operations are refered to as the Java Application
 * Manager or <em>JAM</em>.
 *
 */
public class CommandProcessor {
    /** return value from Main, so we know that Main exited normally */
    static final int MAIN_EXIT = 2001;

    /** status for success */
    static final int OK = 0;

    /** status when an error occurs */
    static final int ERROR = -1;

    /** status when the MIDlet suite is not found */
    static final int MIDLET_SUITE_NOT_FOUND = -2;

    /** command code for exit */
    static final int EXIT        = 1;

    /** command code for Graphical MIDlet Suite Manager in a dev environment */
    static final int MANAGE      = 2;

    /** command code for installing a suite */
    static final int INSTALL     = 3;

    /** command code for installing and running a suite */
    static final int INSTALL_RUN = 4;

    /** command code for running a suite */
    static final int RUN         = 5;

    /** command code for removing a suite */
    static final int REMOVE      = 6;

    /** command code for listing all installed suites in dev environment */
    static final int LIST        = 7;

    /** command code for running a class directly */
    static final int RUN_CLASS   = 8;

    /** command code for listing the only the storage names of suites  */
    static final int STORAGE_NAMES = 9;

    /** whether-or-not we are peforming a command */
    private static boolean performing = false;

    /** Application Installer */
    private static Installer installer = null;

    /**
     * Perform the specified command.
     * <p>
     * The operation is specified in the initialCommand field of the
     * command state. The nextCommand state will be set to next command or
     * EXIT. The status will also be set.
     * <p>
     * The command state also contains the arguments needed a command.
     * <pre>
     * Command     Argument(s)
     * ----------- -----------
     * install     suiteURL
     * remove      suiteStorageName
     * run         suiteStorageName and optionally (midletName and runOnce)
     * install-run suiteURL and optionally (midletName, autotest, and runOnce)
     * </pre>
     * <p>
     * The <code>list</code> command displays a list of the currently
     * installed applications.
     * <p>
     * The <code>install</code> command will install the given application.
     * The URL used for installation must point to a valid application
     * descriptor file. Only HTTP URLs are accepted. If any errors were
     * encountered during installtion, the status will be ERROR or
     * MIDLET_SUITE_NOT_FOUND. if forceOverwrite in the command state is
     * set MIDlet suite will be forcibly installed. See
     * <a href="Installer.html#installJad(java.lang.String, boolean)">
     * Installer.installJad()</a> for a description.
     * <p>
     * The <code>remove</code> command will remove the given application
     * suite or storage used when running single class of local descriptor.
     * If you specify the special keywork <code>all</code> as the
     * suite name, <em>all</em> application suites will be removed.
     * <p>
     * The <code>run</code> command will execute the given MIDlet from
     * a suite, or if not MIDlet is given, let the user select one.
     * If runOnce in the command state is the next command will be
     * remove.
     * <p>
     * The <code>install-run</code> command performs the <code>install</code>
     * and then the <code>run</code> command. If autotest and runOnce are
     * set in the command state, then after removing the suite the next
     * command will be install. The autotest cycle is broken when the 
     * suite at the URL is not found.
     *
     * @param state command state containing the command to perform and
     *      any arguments that the command may require.
     *
     * @exception IOException is thrown, if an error occurs fetching the 
     *              descriptor or jar file
     * @exception InvalidJadException is thrown, if an error is detected in the 
     *                  descriptor file
     * @exception ClassNotFoundException is thrown, if the desginated MIDlet is 
     *                    not  found in the downloaded bundle
     * @exception InstantiationException is thrown, installer can not be 
     *                    constructed
     * @exception IllegalAccessException is thrown,if the caller does not have 
     *              sufficient authority  to perorm the requested 
     *              operation
     */
    public static void perform(CommandState state) throws IOException,
            InvalidJadException, ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        String nextMidletSuiteToRun;

        // don't run twice, a sneaky untrusted MIDlet may try this
        if (performing) {
            return;
        }

        performing = true;

        // we need to get the installer now, before the security level drops
        if (installer == null) {
            installer = Installer.getInstaller();
        }

        dispatch(state);

        nextMidletSuiteToRun = installer.getNextMIDletSuiteToRun();
        if (nextMidletSuiteToRun != null) {
            state.nextCommand = RUN;
            state.suiteStorageName = nextMidletSuiteToRun;

            // the run method should clear this
            state.midletName = installer.getNextMIDletToRun();
        }

        performing = false;
    }

    /**
     * Dispatches the command for processing.
     *
     * @param state command state containing the command to perform and
     *      any arguments that the command may require.
     */
    private static void dispatch(CommandState state) throws IOException,
            InvalidJadException, ClassNotFoundException,
            InstantiationException, IllegalAccessException {
        int currentCommand;

        currentCommand = state.nextCommand;
        state.nextCommand = EXIT;

        if (currentCommand == INSTALL || currentCommand == INSTALL_RUN) {
            install(state);
        } else if (currentCommand == RUN) {
            // keep the Manager around if that was initial command
            if (state.initialCommand == MANAGE) {
                state.nextCommand = MANAGE;
            }

            run(state);
        } else if (currentCommand == REMOVE) {
            remove(state);
        }
    }

    /**
     * Installs a MIDlet Suite.
     *
     * @param state command state containing the URL of the suite to install
     *
     * @exception IllegalArgumentException if the JAD URL in the state is
     *   not valid
     */
    private static void install(CommandState state) throws IOException,
            InvalidJadException {
        try {
            state.status = ERROR;

            if (state.securityDomain != null) {
                installer.setUnsignedSecurityDomain(state.securityDomain);
            }

            // save the suite name for "run" command
            state.suiteStorageName = installer.installJad(state.suiteURL,
                                            state.forceOverwrite,
                                            state.removeRMS, null);
            state.status = OK;

            // this may be a one of a set of commands to execute
            if (state.initialCommand == INSTALL_RUN) {
                state.nextCommand = RUN;
            }

            return;
        } catch (InvalidJadException ije) {
            if (ije.getReason() == InvalidJadException.INVALID_JAD_URL) {
                state.status = MIDLET_SUITE_NOT_FOUND;
                throw new IllegalArgumentException("The JAD URL is not valid");
            }

            if (ije.getReason() == InvalidJadException.JAD_SERVER_NOT_FOUND ||
                ije.getReason() == InvalidJadException.JAD_NOT_FOUND) {

                state.status = MIDLET_SUITE_NOT_FOUND;

                if (state.autotest && state.suiteStorageName != null) {
                    // This end of the tests, remove the last test installed
                    state.nextCommand = REMOVE;
                }

                return;
            }

            if (ije.getReason() == InvalidJadException.INVALID_JAD_TYPE) {
                // media type of JAD was wrong, it could be a JAR
                String mediaType = (String)ije.getExtraData();

                if (Installer.JAR_MT_1.equals(mediaType) ||
                        Installer.JAR_MT_2.equals(mediaType)) {
                    // re-run as a JAR only install
                    state.suiteStorageName =
                        installer.installJar(state.suiteURL,
                                             state.forceOverwrite,
                                             state.removeRMS, null);
                    state.status = OK;

                    // this may be a one of a set of commands to execute
                    if (state.initialCommand == INSTALL_RUN) {
                        state.nextCommand = RUN;
                    }

                    return;
                }
            }

            throw ije;
        } catch (IllegalArgumentException iae) {
            // the suite was not found be case of an illegal argument
            state.status = MIDLET_SUITE_NOT_FOUND;
            throw iae;
        } finally {
            if (state.status == ERROR) {
                // during autotest mode, only exit if we cannot get the suite
                if (state.autotest) {
                    state.nextCommand = INSTALL;
                }
            }
        }
    }

    /**
     * Runs a MIDlet suite.
     *
     * @param state command state containing the name of the suite to run
     */
    private static void run(CommandState state) throws
        ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        MIDletSuite midletSuite;

        // Note: the install command creates the suite storage names

        state.status = ERROR;

        if (state.suiteStorageName == null) {
            throw new IllegalArgumentException("The storage name for the " +
                "MIDlet suite was not given");
        }

        if (state.midletName != null || state.midletNumber == null) {
            String temp = state.midletName;

            /*
             * When autotesting push, both the number and name may both be set
             * remove the launched suite name for the next test.
             */
            state.midletName = null;

            midletSuite = installer.getMIDletSuite(state.suiteStorageName,
                                                   temp);

        } else {
            int midletNumber;

            try {
                midletNumber = Integer.parseInt(state.midletNumber);
            } catch (NumberFormatException nfe) {
                throw new IllegalArgumentException("The value for " +
                    "MIDlet number was not formatted properly");
            }

            midletSuite = installer.getMIDletSuite(state.suiteStorageName,
                                                   midletNumber);
        }

        if (midletSuite == null) {
            state.status = MIDLET_SUITE_NOT_FOUND;
            return;
        }

        // remove any run once suites
        if (state.runOnce) {
            state.nextCommand = REMOVE;
        } else if (state.autotest) {
            state.nextCommand = INSTALL;
        }

        // run MIDlets til there are none
        if (!Scheduler.getScheduler().schedule(midletSuite)) {
            // The system is shutting down
            state.nextCommand = EXIT;
        }

        state.status = OK;
    }

    /**
     * Removes a MIDlet Suite.
     *
     * @param state command state containing the name of the suite to remove
     *
     * @exception IllegalArgumentException if storage name in the state is
     *    null
     */
    private static void remove(CommandState state) {
        state.status = ERROR;

        if (state.suiteStorageName == null) {
            throw new IllegalArgumentException("No suite specified");
        }
        
        if (state.suiteStorageName.equals("all")) {
            String suite[] = installer.list();
            for (int i = 0; i < suite.length; i++) {
                installer.remove(suite[i]);
            }
        } else {
            installer.remove(state.suiteStorageName);
        }

        state.status = OK;

        return;
    }

    /** This class is not meant to be instatiated */
    private CommandProcessor() {
    }
}