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.automation;
028:
029: /**
030: * AutoMIDlet interface implementation
031: */
032: final class AutoMIDletImpl implements AutoMIDlet {
033: /** MIDlet descriptor for this MIDlet */
034: private AutoMIDletDescriptorImpl midletDescriptor;
035:
036: /** For tracking life cycle states */
037: private AutoStateTracker lifeCycleStateTracker;
038:
039: /** For tracking background/foreground states */
040: private AutoStateTracker foregroundStateTracker;
041:
042: /** For switching MIDlet state */
043: private static AutoMIDletStateController midletStateController = null;
044:
045: /** For switching MIDlet state */
046: private static AutoForegroundStateController foregroundStateController = null;
047:
048: /**
049: * Constructor.
050: *
051: * @param midletDescriptor MIDlet descriptor for this MIDlet
052: */
053: AutoMIDletImpl(AutoMIDletDescriptorImpl midletDescriptor) {
054: this .midletDescriptor = midletDescriptor;
055: this .lifeCycleStateTracker = new AutoStateTracker(
056: AutoMIDletLifeCycleState.PAUSED);
057:
058: this .foregroundStateTracker = new AutoStateTracker(
059: AutoMIDletForegroundState.BACKGROUND);
060:
061: if (midletStateController == null) {
062: midletStateController = AutoMIDletStateController
063: .getMIDletStateController();
064: }
065:
066: if (foregroundStateController == null) {
067: foregroundStateController = AutoForegroundStateController
068: .getForegroundStateController();
069: }
070: }
071:
072: /**
073: * To be called when MIDlet's life cycle state has changed.
074: *
075: * @param newState new life cycle state
076: */
077: void stateChanged(AutoMIDletLifeCycleState newState) {
078: boolean interruptWaiters = false;
079: if (newState == AutoMIDletLifeCycleState.DESTROYED) {
080: interruptWaiters = true;
081: }
082:
083: lifeCycleStateTracker.setCurrentState(newState,
084: interruptWaiters);
085:
086: if (newState == AutoMIDletLifeCycleState.DESTROYED) {
087: foregroundStateTracker.interruptWait();
088: midletDescriptor.midletDestroyed();
089: }
090: }
091:
092: /**
093: * To be called when MIDlet's foreground state has changed.
094: *
095: * @param newState new forgeround state
096: */
097: void stateChanged(AutoMIDletForegroundState newState) {
098: foregroundStateTracker.setCurrentState(newState, false);
099: }
100:
101: /**
102: * Guarantees that MIDlet is not destroyed: if MIDlet
103: * is destroyed, exception is thrown.
104: *
105: * @param s error string
106: */
107: private void guaranteeMIDletNotDestroyed(String s)
108: throws IllegalStateException {
109:
110: if (lifeCycleStateTracker.getCurrentState() == AutoMIDletLifeCycleState.DESTROYED) {
111: throw new IllegalStateException(s);
112: }
113: }
114:
115: /**
116: * Guarantees that state transition is valid (possible):
117: * if state is unreachable, exception is thrown.
118: *
119: * @param state state to check for
120: * @param s error string
121: */
122: private void guaranteeStateTransitionIsValid(
123: AutoMIDletLifeCycleState state, String s)
124: throws IllegalStateException {
125:
126: if (state != AutoMIDletLifeCycleState.DESTROYED) {
127: guaranteeMIDletNotDestroyed(s);
128: }
129: }
130:
131: /**
132: * Guarantees that waiting for state is valid:
133: * if state is unreachable, exception is thrown.
134: *
135: * @param state state to check for
136: * @param s error string
137: */
138: private void guaranteeStateTransitionIsValid(
139: AutoMIDletForegroundState state, String s)
140: throws IllegalStateException {
141:
142: guaranteeMIDletNotDestroyed(s);
143: }
144:
145: /**
146: * AutoMIDlet implementation
147: */
148:
149: /**
150: * Initiate a switch (transition) from current to specified
151: * lifecycle state.
152: *
153: * @param state state to switch to
154: * @param wait if true, wait (block) until transition to the
155: * specified state has been completed
156: * @throws IllegalStateException thrown when switching to specified
157: * state is invalid
158: */
159: public void switchTo(AutoMIDletLifeCycleState state, boolean wait)
160: throws IllegalStateException {
161:
162: synchronized (lifeCycleStateTracker) {
163: guaranteeStateTransitionIsValid(state, "switchTo");
164:
165: midletStateController.switchTo(this , state);
166: if (wait) {
167: waitFor(state);
168: }
169: }
170: }
171:
172: /**
173: * Initiate a switch (transition) from current to specified
174: * foreground state.
175: *
176: * @param state state to switch to
177: * @param wait if true, wait (block) until transition to the
178: * specified state has been completed
179: * @throws IllegalStateException thrown when switching to specified
180: * state is invalid
181: */
182: public void switchTo(AutoMIDletForegroundState state, boolean wait)
183: throws IllegalStateException {
184:
185: synchronized (foregroundStateTracker) {
186: guaranteeStateTransitionIsValid(state, "switchTo");
187:
188: foregroundStateController.switchTo(this , state);
189: if (wait) {
190: waitFor(state);
191: }
192: }
193: }
194:
195: /**
196: * Wait (block) until MIDlet reaches specified lifecycle state.
197: *
198: * @param state state to wait for
199: * @throws IlegalStateException thrown if state to wait for is invalid,
200: * or if during waiting MIDlet has reached the state where waiting for
201: * specified state is no longer valid
202: */
203: public void waitFor(AutoMIDletLifeCycleState state)
204: throws IllegalStateException {
205:
206: synchronized (lifeCycleStateTracker) {
207: guaranteeStateTransitionIsValid(state, "waitFor");
208:
209: // wait
210: lifeCycleStateTracker.waitFor(state);
211:
212: // wait might have been interrupted, so check again
213: // if waiting for this state is still valid
214: guaranteeStateTransitionIsValid(state, "waitFor");
215: }
216: }
217:
218: /**
219: * Wait (block) until MIDlet reaches specified foreground state.
220: *
221: * @param state state to wait for
222: * @throws IlegalStateException thrown if state to wait for is invalid,
223: * or if during waiting MIDlet has reached the state where waiting for
224: * specified state is no longer valid
225: */
226: public void waitFor(AutoMIDletForegroundState state)
227: throws IllegalStateException {
228:
229: synchronized (foregroundStateTracker) {
230: guaranteeStateTransitionIsValid(state, "waitFor");
231:
232: foregroundStateTracker.waitFor(state);
233:
234: // wait might have been interrupted, so check again
235: // if waiting for this state is still valid
236: guaranteeStateTransitionIsValid(state, "waitFor");
237: }
238: }
239:
240: /**
241: * Get current lifecycle state.
242: *
243: * @return AutoLifeCycleState representing current
244: * lifecycle state
245: */
246: public AutoMIDletLifeCycleState getLifeCycleState() {
247: synchronized (lifeCycleStateTracker) {
248: Object state = lifeCycleStateTracker.getCurrentState();
249: return (AutoMIDletLifeCycleState) state;
250: }
251: }
252:
253: /**
254: * Get current foreground state.
255: *
256: * @return AutoForegroundState representing current
257: * foreground state
258: */
259: public AutoMIDletForegroundState getForegroundState() {
260: synchronized (foregroundStateTracker) {
261: Object state = foregroundStateTracker.getCurrentState();
262: return (AutoMIDletForegroundState) state;
263: }
264: }
265:
266: /**
267: * Get MIDlet's event queue.
268: *
269: * @return AutoEventQueue representing event queue.
270: */
271: public AutoEventQueue getEventQueue() {
272: return null;
273: }
274:
275: /**
276: * Get MIDlet's descriptor.
277: *
278: * @return AutoMIDletDescriptor representing descriptor.
279: */
280: public AutoMIDletDescriptor getMIDletDescriptor() {
281: return midletDescriptor;
282: }
283: }
|