001: /*
002: *
003: *
004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026:
027: package com.sun.midp.main;
028:
029: import com.sun.midp.events.EventQueue;
030: import com.sun.midp.events.EventTypes;
031: import com.sun.midp.events.Event;
032: import com.sun.midp.events.NativeEvent;
033: import com.sun.midp.events.EventListener;
034:
035: import com.sun.midp.log.Logging;
036: import com.sun.midp.log.LogChannels;
037: import com.sun.midp.configurator.Constants;
038:
039: /**
040: * Provides initial event processing for MIDletProxyList.
041: * This class is a listener that receives events and redirects them to
042: * an appropriate MIDletControllerEventConsumer I/F implementor
043: * (typically it is MIDletProxyList).
044: */
045: class MIDletControllerEventListener implements EventListener {
046:
047: /** Consumer that will process events */
048: private MIDletControllerEventConsumer midletControllerEventConsumer;
049:
050: /**
051: * Default package private constructor.
052: * Shall be called by MIDletProxyList.
053: * This object shall be instantiated in MIDletProxyList's constructor.
054: *
055: * @param eventQueue reference to the event queue
056: * @param theMIDletControllerEventConsumer comsumer that will process
057: * events received by this listener
058: */
059: MIDletControllerEventListener(
060: EventQueue eventQueue,
061: MIDletControllerEventConsumer theMIDletControllerEventConsumer) {
062:
063: midletControllerEventConsumer = theMIDletControllerEventConsumer;
064:
065: eventQueue.registerEventListener(
066: EventTypes.MIDLET_CREATED_NOTIFICATION, this );
067: eventQueue.registerEventListener(
068: EventTypes.MIDLET_ACTIVE_NOTIFICATION, this );
069: eventQueue.registerEventListener(
070: EventTypes.MIDLET_PAUSED_NOTIFICATION, this );
071: eventQueue.registerEventListener(
072: EventTypes.MIDLET_DESTROYED_NOTIFICATION, this );
073: eventQueue.registerEventListener(
074: EventTypes.MIDLET_RS_PAUSED_NOTIFICATION, this );
075: eventQueue.registerEventListener(
076: EventTypes.MIDLET_RESUME_REQUEST, this );
077: eventQueue.registerEventListener(
078: EventTypes.DISPLAY_CREATED_NOTIFICATION, this );
079: eventQueue.registerEventListener(
080: EventTypes.FOREGROUND_REQUEST_EVENT, this );
081: eventQueue.registerEventListener(
082: EventTypes.BACKGROUND_REQUEST_EVENT, this );
083: eventQueue.registerEventListener(EventTypes.SHUTDOWN_EVENT,
084: this );
085: eventQueue.registerEventListener(
086: EventTypes.SELECT_FOREGROUND_EVENT, this );
087: eventQueue.registerEventListener(
088: EventTypes.FOREGROUND_TRANSFER_EVENT, this );
089: eventQueue.registerEventListener(
090: EventTypes.SET_FOREGROUND_BY_NAME_REQUEST, this );
091: eventQueue
092: .registerEventListener(EventTypes.PREEMPT_EVENT, this );
093: eventQueue.registerEventListener(
094: EventTypes.MIDLET_START_ERROR_EVENT, this );
095: eventQueue.registerEventListener(
096: EventTypes.MIDLET_DESTROY_REQUEST_EVENT, this );
097: eventQueue.registerEventListener(EventTypes.ACTIVATE_ALL_EVENT,
098: this );
099: eventQueue.registerEventListener(EventTypes.PAUSE_ALL_EVENT,
100: this );
101: eventQueue.registerEventListener(
102: EventTypes.FATAL_ERROR_NOTIFICATION, this );
103: }
104:
105: /**
106: * Preprocess an event that is being posted to the event queue.
107: *
108: * @param event event being posted
109: *
110: * @param waitingEvent previous event of this type waiting in the
111: * queue to be processed
112: *
113: * @return true to allow the post to continue, false to not post the
114: * event to the queue
115: */
116: public boolean preprocess(Event event, Event waitingEvent) {
117: return true;
118: }
119:
120: /**
121: * Processes events.
122: * <p>
123: * Upon receiving a MIDlet created event a new MIDlet proxy will be
124: * added to the list and the midletAdded method of all listeners will be
125: * called with the new proxy.
126: * <p>
127: * Upon receiving a MIDlet destroyed event the MIDlet proxy corresponding
128: * to the destroyed MIDlet will be removed from the list and the
129: * midletRemoved method of all listeners
130: * will be called with the removed proxy.
131: * <p>
132: * Upon receiving a MIDlet paused event the MIDlet proxy corresponding
133: * to the paused MIDlet will have its midletState field set to
134: * PAUSED and the midletUpdated method of all listeners
135: * will be called with the updated proxy.
136: * <p>
137: * Upon receiving a foreground request event the MIDlet proxy corresponding
138: * to the MIDlet requesting to be moved to the foreground will have its
139: * wantsForeground field set to true and the midletUpdated method of all
140: * listeners will be called with the updated proxy.
141: * <p>
142: * Upon receiving a background request event the MIDlet proxy corresponding
143: * to the MIDlet requesting to be moved to the background will have its
144: * wantsForeground field set to false and the midletUpdated method of all
145: * listeners will be called with the updated proxy.
146: *
147: * @param event event to process
148: */
149: public void process(Event event) {
150: try {
151: NativeEvent nativeEvent = (NativeEvent) event;
152:
153: switch (nativeEvent.getType()) {
154:
155: case EventTypes.SHUTDOWN_EVENT:
156: midletControllerEventConsumer.handleDestroyAllEvent();
157: return;
158:
159: case EventTypes.SELECT_FOREGROUND_EVENT:
160:
161: if (Constants.MEASURE_STARTUP) {
162:
163: // IMPL_NOTE: Usually MIDlet is explicitly switched to
164: // background on a native event, e.g. HOME key pressing.
165: // The native event handling is correct place to count
166: // the time of background switching from. However, native
167: // events handling is platform dependent, and in this way
168: // we have to instrument lot of platform code. That's why
169: // we selected this place as the the first shared place
170: // to start the measuring from. The measured time is
171: // less than the time experienced by user by the time to
172: // map native event to MIDP SELECT_FOREGROUND_EVENT
173:
174: System.err
175: .println("Switch To Background Time: Begin at "
176: + System.currentTimeMillis());
177: }
178:
179: midletControllerEventConsumer
180: .handleMIDletForegroundSelectEvent(nativeEvent.intParam1);
181: return;
182:
183: case EventTypes.FOREGROUND_TRANSFER_EVENT:
184: midletControllerEventConsumer
185: .handleMIDletForegroundTransferEvent(
186: nativeEvent.intParam1,
187: nativeEvent.stringParam1,
188: nativeEvent.intParam2,
189: nativeEvent.stringParam2);
190: return;
191:
192: case EventTypes.SET_FOREGROUND_BY_NAME_REQUEST:
193: midletControllerEventConsumer
194: .handleSetForegroundByNameRequestEvent(
195: nativeEvent.intParam1,
196: nativeEvent.stringParam1);
197: return;
198:
199: case EventTypes.PREEMPT_EVENT:
200: if (nativeEvent.intParam2 != 0) {
201: midletControllerEventConsumer
202: .handleDisplayPreemptStartEvent(
203: nativeEvent.intParam1,
204: nativeEvent.intParam4);
205: } else {
206: midletControllerEventConsumer
207: .handleDisplayPreemptStopEvent(
208: nativeEvent.intParam1,
209: nativeEvent.intParam4);
210: }
211:
212: return;
213:
214: case EventTypes.MIDLET_CREATED_NOTIFICATION:
215: midletControllerEventConsumer
216: .handleMIDletCreateNotifyEvent(
217: nativeEvent.intParam1,
218: nativeEvent.stringParam1,
219: nativeEvent.intParam2,
220: nativeEvent.intParam3,
221: nativeEvent.stringParam2);
222: return;
223:
224: case EventTypes.MIDLET_ACTIVE_NOTIFICATION:
225: midletControllerEventConsumer
226: .handleMIDletActiveNotifyEvent(
227: nativeEvent.intParam1,
228: nativeEvent.stringParam1);
229: return;
230:
231: case EventTypes.MIDLET_PAUSED_NOTIFICATION:
232: midletControllerEventConsumer
233: .handleMIDletPauseNotifyEvent(
234: nativeEvent.intParam1,
235: nativeEvent.stringParam1);
236: return;
237:
238: case EventTypes.MIDLET_DESTROYED_NOTIFICATION:
239: midletControllerEventConsumer
240: .handleMIDletDestroyNotifyEvent(
241: nativeEvent.intParam1,
242: nativeEvent.stringParam1);
243: return;
244:
245: case EventTypes.MIDLET_RESUME_REQUEST:
246: midletControllerEventConsumer
247: .handleMIDletResumeRequestEvent(
248: nativeEvent.intParam1,
249: nativeEvent.stringParam1);
250:
251: case EventTypes.MIDLET_RS_PAUSED_NOTIFICATION:
252: midletControllerEventConsumer
253: .handleMIDletRsPauseNotifyEvent(
254: nativeEvent.intParam1,
255: nativeEvent.stringParam1);
256: return;
257:
258: case EventTypes.DISPLAY_CREATED_NOTIFICATION:
259: midletControllerEventConsumer
260: .handleDisplayCreateNotifyEvent(
261: nativeEvent.intParam1,
262: nativeEvent.intParam2,
263: nativeEvent.stringParam1);
264: return;
265:
266: case EventTypes.FOREGROUND_REQUEST_EVENT:
267: midletControllerEventConsumer
268: .handleDisplayForegroundRequestEvent(
269: nativeEvent.intParam1,
270: nativeEvent.intParam4,
271: (nativeEvent.intParam2 != 0));
272: return;
273:
274: case EventTypes.BACKGROUND_REQUEST_EVENT:
275: midletControllerEventConsumer
276: .handleDisplayBackgroundRequestEvent(
277: nativeEvent.intParam1,
278: nativeEvent.intParam4);
279: return;
280:
281: case EventTypes.MIDLET_START_ERROR_EVENT:
282: midletControllerEventConsumer
283: .handleMIDletStartErrorEvent(
284: nativeEvent.intParam1,
285: nativeEvent.stringParam1,
286: nativeEvent.intParam2,
287: nativeEvent.intParam3,
288: nativeEvent.stringParam2);
289: return;
290:
291: case EventTypes.MIDLET_DESTROY_REQUEST_EVENT:
292: midletControllerEventConsumer
293: .handleMIDletDestroyRequestEvent(
294: nativeEvent.intParam1,
295: nativeEvent.intParam4);
296: return;
297:
298: case EventTypes.ACTIVATE_ALL_EVENT:
299: midletControllerEventConsumer.handleActivateAllEvent();
300: return;
301:
302: case EventTypes.PAUSE_ALL_EVENT:
303: midletControllerEventConsumer.handlePauseAllEvent();
304: return;
305:
306: case EventTypes.FATAL_ERROR_NOTIFICATION:
307: midletControllerEventConsumer
308: .handleFatalErrorNotifyEvent(
309: nativeEvent.intParam1,
310: nativeEvent.intParam4);
311: return;
312:
313: default:
314: if (Logging.REPORT_LEVEL <= Logging.WARNING) {
315: Logging.report(Logging.WARNING,
316: LogChannels.LC_CORE, "unknown event ("
317: + event.getType() + ")");
318: }
319: return;
320: }
321: } catch (Throwable t) {
322: if (Logging.TRACE_ENABLED) {
323: Logging.trace(t,
324: "Error occurred processing MIDlet event "
325: + event.getType());
326: }
327: }
328: }
329: }
|