Simon Lessard said the following On 5/15/2009 12:35 PM PT:
Hi Blake,
I'm + 1 with the idea and the general API, but I have some concerns:
1. I don't really like the API to expose a read only map through
WindowManager.getWindows, I would prefer
WindowManager.getWindowIds(ExternalContext) and
WindowManager.getWindow(ExternalContext, String);
Is your worry over that the Map is read only? The two separate
methods prevent the developer from leveraging the Map interface.
1. WindowListener should be an interface extending EventListener
one of its subclasses;
Fair enough, the rationale for making this an abstract class was so we
could add more event types later. However, since the WindowManager
class is itself an abstract class we could add more event listener
interfaces later to the WindowManager later, so I agree that the
interface is fine
1. Either WindowListener or WindowLifecycleEvent is wrongly named
from a JSF point of view (althoguh it could be potentially
correctly named in Swing). All JSF Listener handle events with
the exact same name as the listener, but with Listener changed
to Event, so it should either be WindowLifecycleListener or
WindowEvent for the API to be coherent with the usual JSF
nomenclature.
See above. I agree that if we use an interface then the listener
class must be WindowLifecycleListener
1. WindowListener method is not properly named. Pretty much as
above, in JSF all listener methods are called process<evenType>
so it should either be public void processWindowEvent or
processWindowLifecycleEventdepending on the resolution of the
previous point;
2. The process method parameters do not match the usual listener
convention to receive a single event object. Would it be
possible to place the ExternalContext instance in the event?
I guess we could put the ExternalContext in the event, though the
field will need to be transient and getExternalContext() method on the
event would need to document that it might return null if the event
has been serialized. All of which is pretty gross. In this case the
extra parameter is much cleaner. I believe that the convention is
really to aid Java Beans design tools using introspection and would
prefer cleanliness in this case.
1. I would prefer to see WindowManager.isCurrentWindowNew as
Window.isNew, it's more OOP correct;
OK. The original implementation only tracked the new status of the
current window, which was tracked by the WindowManager (which is why
the WindowManager). However, due to the need to answer this question
in the face of redirects and other weirdness, the Windows in the
implementation I have been testing do maintain their "new" state, so I
agree that it makes more sense for the Window to answer this question.
1. Actually I would prefer the same for the
add/get/removeWindowListener
Prefer the same what? Are you talking about the ExternalContext?
Thanks for the helpful feedback.
--Blake Sullivan
Regards,
~ Simon
On Fri, May 15, 2009 at 3:09 PM, Blake Sullivan
<[email protected] <mailto:[email protected]>> wrote:
Here is the proposed api:
package org.apache.myfaces.trinidad.context;
/**
* Represents a Window in the current user's Session. Windows are
created and vended
* by the Session's WindowManager and the Window for the current
request is
* available from <code>WindowManager.getCurrentWindow</code>
* @see WindowManager#getCurrentWindow
*/
public abstract class Window implements Serializable
{
/**
* <p>
* Represents the current state of the Window. Windows start out
<code>OPEN</code>,
* when the current window's document is being unloaded, they
move to the <code>UNLOADING</code>
* state and then either move back to the <code>OPEN</code> state
if the Window's content
* is populated with a new document from the same application, or
to the <code>CLOSED</code>
* state if it is not.
* </p><p>
* This represents the framework's best guess at the current
status of the Window.
* </p>
*/
public enum LifecycleState
{
/** The Window is currently open */
OPEN,
/** The Window is being unloaded */
UNLOADING,
/** The Window is believed to be closed, either because the
window was explicitly closed
* or because the window is suspected to have been closed
*/
CLOSED
}
/**
* Represents how the window is used in the application
*/
public enum Usage
{
/** Used as a top-level application window */
FRAME,
/** Used as a dialog */
DIALOG
}
/**
* @return The unique identifier for this Window within the Session
*/
public abstract String getId();
/**
* @return The current state of the Window
*/
public abstract LifecycleState getLifecycleState();
/**
* Returns the Usage of the Window--either a top-level frame or a
dialog
* @return how the window is used
*/
public abstract Usage getUsage();
}
/**
* <p>
* Manages the set of Windows currently in the Session and allows
listeners on the Windows'
* lifecycles to be registered.
* </p>
* @see
org.apache.myfaces.trinidad.context.RequestContext#getWindowManager
*/
abstract public class WindowManager
{
/**
* @param extContext ExternalContext so that the WindowManager
may be called before the
* FacesContext is available
* @return The Window that contains the document making the
current request
*/
public abstract Window getCurrentWindow(ExternalContext extContext);
/**
* @param extContext ExternalContext so that the WindowManager
may be called before the
* FacesContext is available
* @return <code>true</code> if the Window making the current
request is newly created.
*/
public abstract boolean isCurrentWindowNew(ExternalContext
extContext);
/**
* @param extContext ExternalContext so that the WindowManager
may be called before the
* FacesContext is available
* @return The Unmodifiable Map of WindowIds to Windows
*/
public abstract Map<String, ? extends Window>
getWindows(ExternalContext extContext);
/**
* <p>
* Registers a listener that will be informed of changes to the
Lifecylce state of any of
* the known Windows.
* </p>
* <p>
* Window listeners may be registered automatically by adding a file
* containing the names of the classes implementing the
WindowListener in a file named
* <code>org.apache.myfaces.trinidad.event.WindowListener</code>
inside of
* the <code>META_INF/services</code> directory.
* </p>
* @param extContext ExternalContext so that the WindowManager
may be called before the
* FacesContext is available
* @param windowListener
*/
public abstract void addWindowListener(ExternalContext
extContext, WindowListener windowListener);
/**
* Removes a listener that will be informed of changes to the
Lifecylce state of any of
* the known Windows
* @param extContext ExternalContext so that the WindowManager
may be called before the
* FacesContext is available
* @param windowListener
*/
public abstract void removeWindowListener(ExternalContext
extContext, WindowListener windowListener);
/**
* Performs any necessary action to embed the current window
identifier into the output
* @param context FacesContext to use to write the output
* @throws IOException if an output exception occurs
*/
public abstract void writeState(FacesContext context) throws
IOException;
}
/**
* <p>
* Application-scoped factory for creating per-Session
WindowManager instances. It is the
* WindowManagerFactory implementation's responsibility to ensure
that only one
* WindowManager instance is created per-session. The
WindowManagerFactory is also responsible
* for ensuring that any mutable state in the WindowManager
instances will be successfully failed
* over.
* </p>
* <p>
* The factory is usually specified by placing the name of the
WindowManagerFactory
* implementation class in a file named
*
<code>org.apache.myfaces.trinidad.context.WindowManagerFactory</code>
* in the <code>META-INF/services</code> directory
* </p>
* @see org.apache.myfaces.trinidad.context.WindowManager
* @see
org.apache.myfaces.trinidad.context.RequestContext#getWindowManager
*/
abstract public class WindowManagerFactory
{
/**
* Returns the WindowManager to use for this session, creating a
new instance if one doesn't
* already exist.
* @param extContext ExternalContext
* @return WindowManager to use for this Session
*/
public abstract WindowManager getWindowManager(ExternalContext
extContext);
}
To RequestContext add;
/**
* <p>
* Returns the WindowManager for this request. A non-null
WindowManager
* will always be returned.
* </p><p>
* The default implementation uses the first WindowManagerFactory
specified
* implementation class in a file named
*
<code>org.apache.myfaces.trinidad.context.WindowManagerFactory</code>
* in the <code>META-INF/services</code> directory and uses the
WindowManagerFactory
* to create the WindowManager for this Session. If no
WindowManagerFactory is
* found, a default WindowManager that never returns any Windows
is used.
* </p>
* @return the WindowManager used for this Session.
*/
public WindowManager getWindowManager()
In package:
package org.apache.myfaces.trinidad.event;
/**
* Represents an event delivered with a Window as the source.
* @see org.apache.myfaces.trinidad.context.Window
* @see org.apache.myfaces.trinidad.event.WindowListener
*/
public abstract class WindowEvent extends EventObject
{ /**
* @return the Window that this event ocurred on.
*/
public Window getSource()
}
/**
* Event delivered when the LifecycleState of a Window changes.
The <code>cause</code>
* indicates the cause ot the state change. The state diagram for
theWindow LifecycleStates
* is
<pre>
+-----------load---------------+
| |
---expire---
V /---unload----\ | /
\
<start> ---open--->OPEN----- ----->UNLOADED--
-->CLOSED
| \--navigate---/ ^ \
/
| |
---close----
+---------closing--------------+
</pre>
* The new LifecycleStates can be retrieved by calling
<code>getLifecycleState</code> on the
* source Window or by calling the
<code>getNewLifecycleState</code> convenience function
* on the WindowLifecycleEvent
* @see org.apache.myfaces.trinidad.context.Window
* @see org.apache.myfaces.trinidad.context.Window.LifecycleState
*/
public class WindowLifecycleEvent extends WindowEvent
{
/**
* What caused the delivery of the WindowLifecycleEvent.
*/
public enum Cause
{
/**
* Delivered when a new Window is open
*/
OPEN,
/**
* Delivered when the content of a Window have been unloaded
but cause of the unloading
* isn't known.
*/
UNLOAD,
/**
* Delivered when the content of a Window have been unloaded as
a result of
* navigating within the application
*/
NAVIGATE,
/**
* Delivered when the content of a Window have been unloaded in
order to
* close the window
*/
CLOSING,
/**
* The contents of an existing Window are being reloaded
*/
RELOAD,
/**
* The Window is believed to have been closed by the user
*/
EXPIRE,
/**
* The Window is believed to have been closed by the user
*/
CLOSE
}
/**
* Creates a WindowOpenEvent event for the specified Window and
cause.
*/
public WindowLifecycleEvent(Window source, Cause cause)
/**
* @return the cause of the WindowOpen event.
*/
public Cause getCause()
/**
* Returns the new LifecycleState that the Window has moved to.
*/
public final LifecycleState getNewLifecycleState()
}
/**
* WindowLifecycleEvent delivered when the current window is being
unloaded
* in order to navigate to a new location
*/
public final class WindowNavigateEvent extends WindowLifecycleEvent
{
public WindowNavigateEvent(Window source, String destination)
/**
* Returns the URL to which the page is navigating.
* <p>
* The destination is not guaranteed to be normalized; it may
* be absolute, page-relative, or server-relative. It is also
* not guaranteed to be correct, as a browser
* may be redirected to an alternate destination.
*/
public String getDestination()
}
/**
* <p>
* A listener called when the Lifecyle of a Window changes.
* </p>
* <p>
* Window listeners may be registered automatically by adding a file
* containing the names of the classes implementing the
WindowListener in a file named
* <code>org.apache.myfaces.trinidad.event.WindowListener</code>
inside of
* the <code>META_INF/services</code> directory or manually by calling
* <code>WindowManager.addWindowListener</code>
* @see org.apache.myfaces.trinidad.context.WindowManager
*/
public abstract class WindowListener
{
/**
* <p>
* Called when the LifecycleState of a Window changes.
* </p>
* <p>
* The current lifecycle state of a Window is the framework's
best guess and may not be accurate.
* In particular, the last remaining open window may never move
into the <code>CLOSED</code> state
* once it has moved into the <code>UNLOADED</code> state. In
addition, no Window lifecycle events
* are delivered if the Session ceases to exist.
* </p>
* <p>
* The FacesContext may not be available at the time that this
event is delivered.
* </p>
* @param extContext ExternalContext available for this event
* @param event WindowLifecycleEvent indicating the cause of the
change to the Window's
* LifecycleState
*/
public abstract void processLifecylceEvent(ExternalContext
extContext, WindowLifecycleEvent event);
}
Blake Sullivan (JIRA) said the following On 5/15/2009 11:41 AM PT:
Add Window abstraction to Trinidad
----------------------------------
Key: TRINIDAD-1474
URL:
https://issues.apache.org/jira/browse/TRINIDAD-1474
Project: MyFaces Trinidad
Issue Type: New Feature
Components: Archetype
Affects Versions: 1.2.12-core
Environment: All
Reporter: Blake Sullivan
Add Window abstraction to Trinidad. Currently, Trinidad
knows nothing of the separate browser Windows that make up a
browser session. This causes weird problems. For example,
the state management token cache is shared across all of the
active windows with a simple LRU. If the user opens up two
windows and operates on one window long enough, he will cause
the token state for the original window to be purged. When
the user switches back to the original window and POSTs back,
the token won't be found, Trinidad will assume that this is
because the session expired, and the user will be given an error.
Adding the concept of a Window and a Window lifecyle opens up
the following capabilities:
1) Correct handling of per-window UI state by segregating
tokens by window
2) Early clean-up of UI state by aggressively purging state
for closed windows
3) Applications can manager per-window state by listening for
window lifecycle events
4) Sessions can be cleaned up earlier by terminating the
session when the last window in the session is closed
5) A window scope can be implemented to ease using per-window
state with EL
6) A window manager implementation can hide the details of
handling control-N in the browser
