midletcontrollereventproducer.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 459 行 · 第 1/2 页

/*
 *
 *
 * Copyright  1990-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

package com.sun.midp.main;

import com.sun.midp.events.EventTypes;
import com.sun.midp.events.NativeEvent;
import com.sun.midp.events.EventQueue;


/**
 * This class provides methods to send events of types
 * handled by MIDletControllerEventConsumer I/F implementors.
 * This class completely hide event construction & sending in its methods.
 *
 * This class is intended to be used by MIDletStateHandler & MIDletPeer
 * classes in Allication Isolate.
 * So in some of its sendXXXEvent()methods we can change int IDs to
 * MIDletPeer references.
 *
 * Generic comments for all XXXEventProducers:
 *
 * For each supported event type there is a separate sendXXXEvent() method,
 * that gets all needed parameters to construct an event of an approprate class.
 * The method also performs event sending itself.
 *
 * If a given event type merges a set of logically different subtypes,
 * this class shall provide separate methods for these subtypes.
 *
 * It is assumed that only one object instance of this class
 * is initialized with the system event that is created at (isolate) startup. 
 *
 * This class only operates on the event queue given to it during
 * construction, the class does not obtain any restricted object itself,
 * so it does not need protection.
 *
 * All MIDP stack subsystems that need to send events of supported types,
 * must get a reference to an already created istance of this class.
 * Typically, this instance should be passed as a constructor parameter.
 *
 * Class is NOT final to allow debug/profile/test/automation subsystems
 * to change, substitute, complement default "event sending" functionality :
 * Ex.
 * class LogXXXEventProducer
 *      extends XXXEventProducer {
 *  ...
 *  void sendXXXEvent(parameters) {
 *      LOG("Event of type XXX is about to be sent ...")
 *      super.sendXXXEvent(parameters);
 *      LOG("Event of type XXX has been sent successfully !")
 *  }
 *  ...
 * }
 */
public class MIDletControllerEventProducer {

    /** Cached reference to the MIDP event queue. */
    protected EventQueue eventQueue;
    /** Cached reference to AMS isolate ID. */
    protected int amsIsolateId;
    /** Cached reference to current isolate ID. */
    protected int currentIsolateId;

    /** Preallocate start error event to work in case of out of memory */
    final NativeEvent startErrorEvent;
    /** Preallocate MIDlet created event to work in case of out of memory */
    final NativeEvent midletCreatedEvent;
    /** Preallocate MIDlet active event to work in case of out of memory */
    final NativeEvent midletActiveEvent;
    /** Preallocate MIDlet paused event to work in case of out of memory */
    final NativeEvent midletPausedEvent;
    /** Preallocate MIDlet destroyed event to work in case of out of memory */
    final NativeEvent midletDestroyedEvent;
    /**
     * Preallocate MIDlet resources paused event to work in case of out
     * of memory
     */
    final NativeEvent midletRsPausedEvent;

    /**
     * Construct a new MIDletControllerEventProducer.
     *
     * @param  theEventQueue An event queue where new events will be posted.
     * @param  theAmsIsolateId AMS Isolate Id
     * @param  theCurrentIsolateId Current Isolate Id
     */
    public MIDletControllerEventProducer(
        EventQueue theEventQueue,
        int theAmsIsolateId,
        int theCurrentIsolateId) {

        eventQueue = theEventQueue;
        amsIsolateId = theAmsIsolateId;
        currentIsolateId = theCurrentIsolateId;

        /* Cache all of the notification events. */
        startErrorEvent =
            new NativeEvent(EventTypes.MIDLET_START_ERROR_EVENT);
        midletCreatedEvent =
            new NativeEvent(EventTypes.MIDLET_CREATED_NOTIFICATION);
        midletActiveEvent =
            new NativeEvent(EventTypes.MIDLET_ACTIVE_NOTIFICATION);
        midletPausedEvent =
            new NativeEvent(EventTypes.MIDLET_PAUSED_NOTIFICATION);
        midletDestroyedEvent =
            new NativeEvent(EventTypes.MIDLET_DESTROYED_NOTIFICATION);
        midletRsPausedEvent =
            new NativeEvent(EventTypes.MIDLET_RS_PAUSED_NOTIFICATION);
    }

    /*
     * MIDlet Startup Events:
     *
     * MIDLET_START_ERROR
     * MIDLET_CREATED_NOTIFICATION
     */
    /**
     * Notifies AMS that MIDlet creation failed
     * NEW: earlier it has been explicitely generated by
     * void static AppIsolateMIDletSuiteLoader.main(...)
     *
     * @param midletExternalAppId ID of given by an external application
     *                            manager
     * @param midletSuiteId ID of the MIDlet suite
     * @param midletClassName Class name of the MIDlet
     * @param errorCode start error code
     */
    public void sendMIDletStartErrorEvent(
        int midletSuiteId,
        String midletClassName,
        int midletExternalAppId,
        int errorCode,
        String errorDetails) {

        synchronized (startErrorEvent) {
            // use pre-created event to work in case of handling out of memory
            startErrorEvent.intParam1 = midletSuiteId;
            startErrorEvent.intParam2 = midletExternalAppId;
            startErrorEvent.intParam3 = errorCode;

            startErrorEvent.stringParam1 = midletClassName;
            startErrorEvent.stringParam2 = errorDetails; 

            eventQueue.sendNativeEventToIsolate(startErrorEvent, amsIsolateId);
        }
    }

    /**
     * Called to send a MIDlet created notification to the AMS isolate.
     *
     * @param midletSuiteId ID of the MIDlet suite
     * @param midletClassName Class name of the MIDlet
     * @param midletExternalAppId ID of given by an external application
     *                            manager
     * @param midletDisplayName name to show the user
     */
    public void sendMIDletCreateNotifyEvent(
        int midletSuiteId,
        String midletClassName,
        int midletExternalAppId,
        String midletDisplayName) {

        synchronized (midletCreatedEvent) {
            midletCreatedEvent.intParam1 = midletSuiteId;
            midletCreatedEvent.intParam2 = currentIsolateId;
            midletCreatedEvent.intParam3 = midletExternalAppId;

            midletCreatedEvent.stringParam1 = midletClassName;
            midletCreatedEvent.stringParam2 = midletDisplayName;

            eventQueue.sendNativeEventToIsolate(midletCreatedEvent,
                                                amsIsolateId);
        }
    }

    /*
     * MIDlet State Management (Lifecycle) Events:
     *
     * MIDLET_ACTIVE_NOTIFICATION
     * MIDLET_PAUSE_NOTIFICATION
     * MIDLET_DESTROY_NOTIFICATION
     *
     * MIDLET_DESTROY_REQUEST
     *
     * ACTIVATE_ALL - produced by native code
     * PAUSE_ALL -produced by native code
     * SHUTDOWN/DESTROY_ALL - produced by native code
     *
     * FATAL_ERROR_NOTIFICATION - produced by native code
     *
     */
    /**
     * Called to send a MIDlet active notification to the AMS isolate.
     *
     * @param midletSuiteId ID of the MIDlet suite
     * @param midletClassName Class name of the MIDlet
     */
    public void sendMIDletActiveNotifyEvent(int midletSuiteId,
                                            String midletClassName) {
        sendEvent(midletActiveEvent, midletSuiteId, midletClassName);
    }
    /**
     * Called to send a MIDlet paused notification to the AMS isolate.
     *
     * @param midletSuiteId ID of the MIDlet suite
     * @param midletClassName Class name of the MIDlet
     */